mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-15 14:10:11 +00:00
957 lines
26 KiB
C++
957 lines
26 KiB
C++
|
|
#include "GraphicsServerExample.h"
|
|
#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
|
|
#include "../CommonInterfaces/CommonRenderInterface.h"
|
|
#include "PosixSharedMemory.h"
|
|
#include "Win32SharedMemory.h"
|
|
#include "../CommonInterfaces/CommonExampleInterface.h"
|
|
#include "LinearMath/btTransform.h"
|
|
#include "../CommonInterfaces/CommonGUIHelperInterface.h"
|
|
#include "Bullet3Common/b3AlignedObjectArray.h"
|
|
#include "GraphicsSharedMemoryBlock.h"
|
|
#include "../CommonInterfaces/CommonGUIHelperInterface.h"
|
|
#include "SharedMemoryPublic.h"
|
|
#include "../MultiThreading/b3ThreadSupportInterface.h"
|
|
#include "../Utils/b3Clock.h"
|
|
|
|
#ifdef BT_ENABLE_CLSOCKET
|
|
|
|
#include "PassiveSocket.h" // Include header for active socket object definition
|
|
#include <stdio.h>
|
|
#include "../CommonInterfaces/CommonGUIHelperInterface.h"
|
|
#include "Bullet3Common/b3CommandLineArgs.h"
|
|
#include "RemoteGUIHelper.h"
|
|
#include "GraphicsSharedMemoryPublic.h"
|
|
#include "GraphicsSharedMemoryCommands.h"
|
|
|
|
|
|
bool gVerboseNetworkMessagesServer = true;
|
|
|
|
void MySerializeInt(unsigned int sz, unsigned char* output)
|
|
{
|
|
unsigned int tmp = sz;
|
|
output[0] = tmp & 255;
|
|
tmp = tmp >> 8;
|
|
output[1] = tmp & 255;
|
|
tmp = tmp >> 8;
|
|
output[2] = tmp & 255;
|
|
tmp = tmp >> 8;
|
|
output[3] = tmp & 255;
|
|
}
|
|
|
|
void submitStatus(CActiveSocket* pClient, GraphicsSharedMemoryStatus& serverStatus, b3AlignedObjectArray<char>& buffer)
|
|
{
|
|
b3AlignedObjectArray<unsigned char> packetData;
|
|
unsigned char* statBytes = (unsigned char*)&serverStatus;
|
|
|
|
|
|
//create packetData with [int packetSizeInBytes, status, streamBytes)
|
|
packetData.resize(4 + sizeof(GraphicsSharedMemoryStatus) + serverStatus.m_numDataStreamBytes);
|
|
int sz = packetData.size();
|
|
int curPos = 0;
|
|
|
|
if (gVerboseNetworkMessagesServer)
|
|
{
|
|
printf("buffer.size = %d\n", buffer.size());
|
|
printf("serverStatus packed size = %d\n", sz);
|
|
}
|
|
|
|
MySerializeInt(sz, &packetData[curPos]);
|
|
curPos += 4;
|
|
for (int i = 0; i < sizeof(GraphicsSharedMemoryStatus); i++)
|
|
{
|
|
packetData[i + curPos] = statBytes[i];
|
|
}
|
|
curPos += sizeof(GraphicsSharedMemoryStatus);
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("serverStatus.m_numDataStreamBytes=%d\n", serverStatus.m_numDataStreamBytes);
|
|
for (int i = 0; i < serverStatus.m_numDataStreamBytes; i++)
|
|
{
|
|
packetData[i + curPos] = buffer[i];
|
|
}
|
|
|
|
pClient->Send(&packetData[0], packetData.size());
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("pClient->Send serverStatus: %d\n", packetData.size());
|
|
}
|
|
|
|
|
|
#endif //BT_ENABLE_CLSOCKET
|
|
|
|
|
|
#define MAX_GRAPHICS_SHARED_MEMORY_BLOCKS 1
|
|
|
|
|
|
struct TCPArgs
|
|
{
|
|
TCPArgs()
|
|
: m_cs(0),
|
|
m_port(6667),
|
|
m_numClientCommands(0),
|
|
m_numServerCommands(0),
|
|
m_cmdPtr(0)
|
|
{
|
|
m_dataSlots.resize(10);
|
|
}
|
|
|
|
void submitCommand()
|
|
{
|
|
m_cs->lock();
|
|
m_serverStatus.m_type = GFX_CMD_CLIENT_COMMAND_FAILED;
|
|
m_serverStatus.m_numDataStreamBytes = 0;
|
|
btAssert(m_numServerCommands == m_numClientCommands);
|
|
m_numClientCommands++;
|
|
m_cs->unlock();
|
|
}
|
|
void processCommand()
|
|
{
|
|
m_cs->lock();
|
|
btAssert(m_numServerCommands == (m_numClientCommands - 1));
|
|
m_numServerCommands++;
|
|
m_cs->unlock();
|
|
}
|
|
bool isCommandOutstanding()
|
|
{
|
|
m_cs->lock();
|
|
bool result = m_numClientCommands > m_numServerCommands;
|
|
m_cs->unlock();
|
|
return result;
|
|
}
|
|
|
|
|
|
b3CriticalSection* m_cs;
|
|
int m_port;
|
|
b3AlignedObjectArray< b3AlignedObjectArray<unsigned char> > m_dataSlots;
|
|
int m_numClientCommands;
|
|
int m_numServerCommands;
|
|
GraphicsSharedMemoryCommand* m_cmdPtr;
|
|
GraphicsSharedMemoryStatus m_serverStatus;
|
|
};
|
|
|
|
struct TCPThreadLocalStorage
|
|
{
|
|
int threadId;
|
|
};
|
|
|
|
|
|
enum TCPCommunicationEnums
|
|
{
|
|
eTCPRequestTerminate = 11,
|
|
eTCPIsUnInitialized,
|
|
eTCPIsInitialized,
|
|
eTCPInitializationFailed,
|
|
eTCPHasTerminated
|
|
};
|
|
|
|
void TCPThreadFunc(void* userPtr, void* lsMemory)
|
|
{
|
|
printf("TCPThreadFunc thread started\n");
|
|
|
|
TCPArgs* args = (TCPArgs*)userPtr;
|
|
//int workLeft = true;
|
|
b3Clock clock;
|
|
clock.reset();
|
|
b3Clock sleepClock;
|
|
bool init = true;
|
|
if (init)
|
|
{
|
|
unsigned int cachedSharedParam = eTCPIsInitialized;
|
|
|
|
args->m_cs->lock();
|
|
args->m_cs->setSharedParam(0, eTCPIsInitialized);
|
|
args->m_cs->unlock();
|
|
|
|
double deltaTimeInSeconds = 0;
|
|
int numCmdSinceSleep1ms = 0;
|
|
unsigned long long int prevTime = clock.getTimeMicroseconds();
|
|
|
|
#ifdef BT_ENABLE_CLSOCKET
|
|
b3Clock clock;
|
|
double timeOutInSeconds = 10;
|
|
|
|
|
|
bool isPhysicsClientConnected = true;
|
|
bool exitRequested = false;
|
|
|
|
|
|
if (!isPhysicsClientConnected)
|
|
{
|
|
printf("TCP thread error connecting to shared memory. Machine needs a reboot?\n");
|
|
}
|
|
btAssert(isPhysicsClientConnected);
|
|
|
|
printf("Starting TCP server using port %d\n", args->m_port);
|
|
|
|
CPassiveSocket socket;
|
|
CActiveSocket* pClient = NULL;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Initialize our socket object
|
|
//--------------------------------------------------------------------------
|
|
socket.Initialize();
|
|
|
|
socket.Listen("localhost", args->m_port);
|
|
|
|
socket.SetBlocking();
|
|
|
|
int curNumErr = 0;
|
|
|
|
#endif
|
|
|
|
do
|
|
{
|
|
|
|
{
|
|
b3Clock::usleep(0);
|
|
}
|
|
///////////////////////////////
|
|
|
|
#ifdef BT_ENABLE_CLSOCKET
|
|
|
|
{
|
|
b3Clock::usleep(0);
|
|
|
|
if ((pClient = socket.Accept()) != NULL)
|
|
{
|
|
socket.SetReceiveTimeout(60, 0);// (1, 0);
|
|
socket.SetSendTimeout(60, 0);
|
|
|
|
b3AlignedObjectArray<char> bytesReceived;
|
|
|
|
int clientPort = socket.GetClientPort();
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("connected from %s:%d\n", socket.GetClientAddr(), clientPort);
|
|
|
|
if (pClient->Receive(4))
|
|
{
|
|
int clientKey = *(int*)pClient->GetData();
|
|
|
|
if (clientKey == GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER)
|
|
{
|
|
printf("Client version OK %d\n", clientKey);
|
|
}
|
|
else
|
|
{
|
|
printf("Server version (%d) mismatches Client Version (%d)\n", GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER, clientKey);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Receive request from the client.
|
|
//----------------------------------------------------------------------
|
|
|
|
while (cachedSharedParam != eTCPRequestTerminate)
|
|
{
|
|
|
|
bool receivedData = false;
|
|
|
|
int maxLen = 4 + sizeof(GraphicsSharedMemoryCommand) + GRAPHICS_SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE;
|
|
|
|
|
|
if (pClient->Receive(maxLen))
|
|
{
|
|
|
|
//heuristic to detect disconnected clients
|
|
CSimpleSocket::CSocketError err = pClient->GetSocketError();
|
|
|
|
if (err != CSimpleSocket::SocketSuccess || !pClient->IsSocketValid())
|
|
{
|
|
b3Clock::usleep(100);
|
|
|
|
curNumErr++;
|
|
|
|
if (curNumErr > 100)
|
|
{
|
|
///printf("TCP Connection error = %d, curNumErr = %d\n", (int)err, curNumErr);
|
|
|
|
}
|
|
}
|
|
|
|
curNumErr = 0;
|
|
char* msg2 = (char*)pClient->GetData();
|
|
int numBytesRec2 = pClient->GetBytesReceived();
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("numBytesRec2=%d\n", numBytesRec2);
|
|
if (numBytesRec2 < 0)
|
|
{
|
|
numBytesRec2 = 0;
|
|
}
|
|
int curSize = bytesReceived.size();
|
|
bytesReceived.resize(bytesReceived.size() + numBytesRec2);
|
|
for (int i = 0; i < numBytesRec2; i++)
|
|
{
|
|
bytesReceived[curSize + i] = msg2[i];
|
|
}
|
|
|
|
if (bytesReceived.size() >= 4)
|
|
{
|
|
int numBytesRec = bytesReceived.size();
|
|
if (numBytesRec >= 10)
|
|
{
|
|
if (strncmp(&bytesReceived[0], "disconnect", 10) == 0)
|
|
{
|
|
printf("Disconnect request received\n");
|
|
bytesReceived.clear();
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if (gVerboseNetworkMessagesServer)
|
|
{
|
|
printf("received message length [%d]\n", numBytesRec);
|
|
}
|
|
|
|
receivedData = true;
|
|
|
|
|
|
args->m_cmdPtr = 0;
|
|
|
|
|
|
int type = *(int*)&bytesReceived[0];
|
|
|
|
|
|
if (numBytesRec == sizeof(GraphicsSharedMemoryCommand))
|
|
{
|
|
args->m_cmdPtr = (GraphicsSharedMemoryCommand*)&bytesReceived[0];
|
|
}
|
|
|
|
if (args->m_cmdPtr)
|
|
{
|
|
|
|
b3AlignedObjectArray<char> buffer;
|
|
buffer.resize(GRAPHICS_SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE);
|
|
bool hasStatus = true;
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("processing command:");
|
|
switch (args->m_cmdPtr->m_type)
|
|
{
|
|
case GFX_CMD_0:
|
|
{
|
|
int axis = args->m_cmdPtr->m_upAxisYCommand.m_enableUpAxisY ? 1 : 2;
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
bool done = false;
|
|
//guiHelper.setUpAxis(axis);
|
|
|
|
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_0\n");
|
|
break;
|
|
}
|
|
|
|
case GFX_CMD_SET_VISUALIZER_FLAG:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
//guiHelper.setVisualizerFlag(
|
|
// args->m_cmdPtr->m_visualizerFlagCommand.m_visualizerFlag,
|
|
// args->m_cmdPtr->m_visualizerFlagCommand.m_enable);
|
|
//serverStatus.m_type = GFX_CMD_CLIENT_COMMAND_COMPLETED;
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_SET_VISUALIZER_FLAG\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_UPLOAD_DATA:
|
|
{
|
|
int slot = args->m_cmdPtr->m_uploadDataCommand.m_dataSlot;
|
|
|
|
int numBytes = args->m_cmdPtr->m_uploadDataCommand.m_numBytes;
|
|
|
|
|
|
submitStatus(pClient, args->m_serverStatus, buffer);
|
|
|
|
//now receive numBytes
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_UPLOAD_DATA receiving data\n");
|
|
int received = 0;
|
|
int offset = 0;
|
|
args->m_dataSlots[slot].resize(numBytes);
|
|
while (received < numBytes)
|
|
{
|
|
if (pClient->Receive(args->m_cmdPtr->m_uploadDataCommand.m_numBytes))
|
|
{
|
|
//heuristic to detect disconnected clients
|
|
CSimpleSocket::CSocketError err = pClient->GetSocketError();
|
|
if (err != CSimpleSocket::SocketSuccess || !pClient->IsSocketValid())
|
|
{
|
|
curNumErr++;
|
|
//printf("TCP Connection error = %d, curNumErr = %d\n", (int)err, curNumErr);
|
|
}
|
|
char* msg2 = (char*)pClient->GetData();
|
|
int numBytesRec2 = pClient->GetBytesReceived();
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("received %d bytes (total=%d)\n", numBytesRec2, received);
|
|
|
|
for (int i = 0; i < numBytesRec2; i++)
|
|
{
|
|
args->m_dataSlots[slot][i+ offset] = msg2[i];
|
|
}
|
|
offset += numBytesRec2;
|
|
received += numBytesRec2;
|
|
}
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("received all bytes!\n");
|
|
args->m_serverStatus.m_type = GFX_CMD_CLIENT_COMMAND_COMPLETED;
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_UPLOAD_DATA\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_REGISTER_TEXTURE:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
//const unsigned char* texels = (const unsigned char*)&args->m_dataSlots[0][0];
|
|
//args->m_serverStatus.m_registerTextureStatus.m_textureId = guiHelper.registerTexture(texels, args->m_cmdPtr->m_registerTextureCommand.m_width,
|
|
// args->m_cmdPtr->m_registerTextureCommand.m_height);
|
|
//serverStatus.m_type = GFX_CMD_REGISTER_TEXTURE_COMPLETED;
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_REGISTER_TEXTURE\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_REGISTER_GRAPHICS_SHAPE:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_REGISTER_GRAPHICS_SHAPE\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_REGISTER_GRAPHICS_INSTANCE:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_REGISTER_GRAPHICS_INSTANCE\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_SYNCHRONIZE_TRANSFORMS:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_SYNCHRONIZE_TRANSFORMS\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_REMOVE_ALL_GRAPHICS_INSTANCES:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_REMOVE_ALL_GRAPHICS_INSTANCES\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_REMOVE_SINGLE_GRAPHICS_INSTANCE:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_REMOVE_SINGLE_GRAPHICS_INSTANCE\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_CHANGE_RGBA_COLOR:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_CHANGE_RGBA_COLOR\n");
|
|
break;
|
|
}
|
|
case GFX_CMD_GET_CAMERA_INFO:
|
|
{
|
|
args->submitCommand();
|
|
while (args->isCommandOutstanding())
|
|
{
|
|
clock.usleep(0);
|
|
}
|
|
//bool RemoteGUIHelper::getCameraInfo(int* width, int* height,
|
|
// float viewMatrix[16], float projectionMatrix[16],
|
|
// float camUp[3], float camForward[3], float hor[3], float vert[3],
|
|
// float* yaw, float* pitch, float* camDist, float camTarget[3]) const
|
|
#if 0
|
|
guiHelper.getCameraInfo(&serverStatus.m_getCameraInfoStatus.width,
|
|
&serverStatus.m_getCameraInfoStatus.height,
|
|
serverStatus.m_getCameraInfoStatus.viewMatrix,
|
|
serverStatus.m_getCameraInfoStatus.projectionMatrix,
|
|
serverStatus.m_getCameraInfoStatus.camUp,
|
|
serverStatus.m_getCameraInfoStatus.camForward,
|
|
serverStatus.m_getCameraInfoStatus.hor,
|
|
serverStatus.m_getCameraInfoStatus.vert,
|
|
&serverStatus.m_getCameraInfoStatus.yaw,
|
|
&serverStatus.m_getCameraInfoStatus.pitch,
|
|
&serverStatus.m_getCameraInfoStatus.camDist,
|
|
serverStatus.m_getCameraInfoStatus.camTarget);
|
|
serverStatus.m_type = GFX_CMD_GET_CAMERA_INFO_COMPLETED;
|
|
#endif
|
|
if (gVerboseNetworkMessagesServer)
|
|
printf("GFX_CMD_GET_CAMERA_INFO\n");
|
|
break;
|
|
}
|
|
|
|
case GFX_CMD_INVALID:
|
|
case GFX_CMD_MAX_CLIENT_COMMANDS:
|
|
default:
|
|
{
|
|
printf("UNKNOWN COMMAND!\n");
|
|
btAssert(0);
|
|
hasStatus = false;
|
|
}
|
|
}
|
|
|
|
|
|
double startTimeSeconds = clock.getTimeInSeconds();
|
|
double curTimeSeconds = clock.getTimeInSeconds();
|
|
|
|
if (gVerboseNetworkMessagesServer)
|
|
{
|
|
//printf("buffer.size = %d\n", buffer.size());
|
|
printf("serverStatus.m_numDataStreamBytes = %d\n", args->m_serverStatus.m_numDataStreamBytes);
|
|
}
|
|
if (hasStatus)
|
|
{
|
|
submitStatus(pClient, args->m_serverStatus, buffer);
|
|
}
|
|
|
|
bytesReceived.clear();
|
|
}
|
|
else
|
|
{
|
|
//likely an incomplete packet, let's append more bytes
|
|
//printf("received packet with unknown contents\n");
|
|
}
|
|
}
|
|
}
|
|
if (!receivedData)
|
|
{
|
|
//printf("Didn't receive data.\n");
|
|
}
|
|
}
|
|
|
|
printf("Disconnecting client.\n");
|
|
pClient->Close();
|
|
delete pClient;
|
|
}
|
|
}
|
|
|
|
#endif //BT_ENABLE_CLSOCKET
|
|
|
|
|
|
///////////////////////////////
|
|
args->m_cs->lock();
|
|
cachedSharedParam = args->m_cs->getSharedParam(0);
|
|
args->m_cs->unlock();
|
|
|
|
} while (cachedSharedParam != eTCPRequestTerminate);
|
|
#ifdef BT_ENABLE_CLSOCKET
|
|
socket.Close();
|
|
socket.Shutdown(CSimpleSocket::Both);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
args->m_cs->lock();
|
|
args->m_cs->setSharedParam(0, eTCPInitializationFailed);
|
|
args->m_cs->unlock();
|
|
}
|
|
|
|
printf("TCPThreadFunc thread exit\n");
|
|
//do nothing
|
|
}
|
|
|
|
void* TCPlsMemoryFunc()
|
|
{
|
|
//don't create local store memory, just return 0
|
|
return new TCPThreadLocalStorage;
|
|
}
|
|
|
|
void TCPlsMemoryReleaseFunc(void* ptr)
|
|
{
|
|
TCPThreadLocalStorage* p = (TCPThreadLocalStorage*)ptr;
|
|
delete p;
|
|
}
|
|
|
|
|
|
#ifndef _WIN32
|
|
#include "../MultiThreading/b3PosixThreadSupport.h"
|
|
|
|
b3ThreadSupportInterface* createTCPThreadSupport(int numThreads)
|
|
{
|
|
b3PosixThreadSupport::ThreadConstructionInfo constructionInfo("TCPThreads",
|
|
TCPThreadFunc,
|
|
TCPlsMemoryFunc,
|
|
TCPlsMemoryReleaseFunc,
|
|
numThreads);
|
|
b3ThreadSupportInterface* threadSupport = new b3PosixThreadSupport(constructionInfo);
|
|
|
|
return threadSupport;
|
|
}
|
|
|
|
#elif defined(_WIN32)
|
|
#include "../MultiThreading/b3Win32ThreadSupport.h"
|
|
|
|
b3ThreadSupportInterface* createTCPThreadSupport(int numThreads)
|
|
{
|
|
b3Win32ThreadSupport::Win32ThreadConstructionInfo threadConstructionInfo("TCPThreads", TCPThreadFunc, TCPlsMemoryFunc, TCPlsMemoryReleaseFunc, numThreads);
|
|
b3Win32ThreadSupport* threadSupport = new b3Win32ThreadSupport(threadConstructionInfo);
|
|
return threadSupport;
|
|
}
|
|
#endif
|
|
|
|
|
|
class GraphicsServerExample : public CommonExampleInterface
|
|
{
|
|
CommonGraphicsApp* m_app;
|
|
GUIHelperInterface* m_guiHelper;
|
|
|
|
bool m_verboseOutput;
|
|
|
|
float m_x;
|
|
float m_y;
|
|
float m_z;
|
|
|
|
b3ThreadSupportInterface* m_threadSupport;
|
|
TCPArgs m_args;
|
|
|
|
public:
|
|
GraphicsServerExample(GUIHelperInterface* guiHelper)
|
|
: m_guiHelper(guiHelper),
|
|
m_x(0),
|
|
m_y(0),
|
|
m_z(0)
|
|
{
|
|
m_verboseOutput = true;
|
|
|
|
m_app = guiHelper->getAppInterface();
|
|
m_app->setUpAxis(2);
|
|
|
|
m_threadSupport = createTCPThreadSupport(1);
|
|
m_args.m_cs = m_threadSupport->createCriticalSection();
|
|
m_args.m_cs->setSharedParam(0, eTCPIsUnInitialized);
|
|
m_threadSupport->runTask(B3_THREAD_SCHEDULE_TASK, (void*)&this->m_args, 0);
|
|
|
|
bool isUninitialized = true;
|
|
|
|
while (isUninitialized)
|
|
{
|
|
m_args.m_cs->lock();
|
|
isUninitialized = (m_args.m_cs->getSharedParam(0) == eTCPIsUnInitialized);
|
|
m_args.m_cs->unlock();
|
|
#ifdef _WIN32
|
|
b3Clock::usleep(1000);
|
|
#endif
|
|
}
|
|
|
|
}
|
|
virtual ~GraphicsServerExample()
|
|
{
|
|
|
|
m_args.m_cs->setSharedParam(0, eTCPRequestTerminate);
|
|
|
|
int numActiveThreads = 1;
|
|
while (numActiveThreads)
|
|
{
|
|
int arg0, arg1;
|
|
if (m_threadSupport->isTaskCompleted(&arg0, &arg1, 0))
|
|
{
|
|
numActiveThreads--;
|
|
printf("numActiveThreads = %d\n", numActiveThreads);
|
|
}
|
|
else
|
|
{
|
|
b3Clock::usleep(0);
|
|
}
|
|
};
|
|
|
|
m_threadSupport->deleteCriticalSection(m_args.m_cs);
|
|
|
|
delete m_threadSupport;
|
|
m_threadSupport = 0;
|
|
|
|
}
|
|
|
|
virtual void initPhysics()
|
|
{
|
|
}
|
|
virtual void exitPhysics()
|
|
{
|
|
}
|
|
|
|
void submitServerStatus(GraphicsSharedMemoryStatus& status, int blockIndex)
|
|
{
|
|
}
|
|
|
|
bool processCommand(const struct GraphicsSharedMemoryCommand& clientCmd, struct GraphicsSharedMemoryStatus& serverStatusOut)
|
|
{
|
|
//printf("processed command of type:%d\n", clientCmd.m_type);
|
|
B3_PROFILE("processCommand");
|
|
switch (clientCmd.m_type)
|
|
{
|
|
case GFX_CMD_0:
|
|
{
|
|
//either Y or Z can be up axis
|
|
int upAxis = (clientCmd.m_upAxisYCommand.m_enableUpAxisY) ? 1 : 2;
|
|
m_guiHelper->setUpAxis(upAxis);
|
|
serverStatusOut.m_type = GFX_CMD_CLIENT_COMMAND_COMPLETED;
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_SET_VISUALIZER_FLAG:
|
|
{
|
|
if (clientCmd.m_visualizerFlagCommand.m_visualizerFlag != COV_ENABLE_RENDERING)
|
|
{
|
|
//printf("clientCmd.m_visualizerFlag.m_visualizerFlag: %d, clientCmd.m_visualizerFlag.m_enable %d\n",
|
|
// clientCmd.m_visualizerFlagCommand.m_visualizerFlag, clientCmd.m_visualizerFlagCommand.m_enable);
|
|
|
|
this->m_guiHelper->setVisualizerFlag(clientCmd.m_visualizerFlagCommand.m_visualizerFlag, clientCmd.m_visualizerFlagCommand.m_enable);
|
|
}
|
|
m_args.processCommand();
|
|
break;
|
|
|
|
}
|
|
|
|
case GFX_CMD_UPLOAD_DATA:
|
|
{
|
|
#if 0
|
|
//printf("uploadData command: curSize=%d, offset=%d, slot=%d", clientCmd.m_uploadDataCommand.m_numBytes, clientCmd.m_uploadDataCommand.m_dataOffset, clientCmd.m_uploadDataCommand.m_dataSlot);
|
|
int dataSlot = clientCmd.m_uploadDataCommand.m_dataSlot;
|
|
int dataOffset = clientCmd.m_uploadDataCommand.m_dataOffset;
|
|
m_dataSlots.resize(dataSlot + 1);
|
|
btAssert(m_dataSlots[dataSlot].size() >= dataOffset);
|
|
m_dataSlots[dataSlot].resize(clientCmd.m_uploadDataCommand.m_numBytes + clientCmd.m_uploadDataCommand.m_dataOffset);
|
|
for (int i = 0; i < clientCmd.m_uploadDataCommand.m_numBytes; i++)
|
|
{
|
|
m_dataSlots[dataSlot][dataOffset + i] = bufferServerToClient[i];
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
case GFX_CMD_REGISTER_TEXTURE:
|
|
{
|
|
|
|
int dataSlot = 0;
|
|
int sizeData = m_args.m_dataSlots[dataSlot].size();
|
|
btAssert(sizeData > 0);
|
|
serverStatusOut.m_type = GFX_CMD_REGISTER_TEXTURE_FAILED;
|
|
if (sizeData)
|
|
{
|
|
unsigned char* texels = &m_args.m_dataSlots[dataSlot][0];
|
|
int textureId = this->m_guiHelper->registerTexture(texels, clientCmd.m_registerTextureCommand.m_width, clientCmd.m_registerTextureCommand.m_height);
|
|
serverStatusOut.m_type = GFX_CMD_REGISTER_TEXTURE_COMPLETED;
|
|
serverStatusOut.m_registerTextureStatus.m_textureId = textureId;
|
|
}
|
|
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
|
|
case GFX_CMD_REGISTER_GRAPHICS_SHAPE:
|
|
{
|
|
int verticesSlot = 0;
|
|
int indicesSlot = 1;
|
|
serverStatusOut.m_type = GFX_CMD_REGISTER_GRAPHICS_SHAPE_FAILED;
|
|
const float* vertices = (const float*)&m_args.m_dataSlots[verticesSlot][0];
|
|
const int* indices = (const int*)&m_args.m_dataSlots[indicesSlot][0];
|
|
int numVertices = clientCmd.m_registerGraphicsShapeCommand.m_numVertices;
|
|
int numIndices = clientCmd.m_registerGraphicsShapeCommand.m_numIndices;
|
|
int primitiveType = clientCmd.m_registerGraphicsShapeCommand.m_primitiveType;
|
|
int textureId = clientCmd.m_registerGraphicsShapeCommand.m_textureId;
|
|
int shapeId = this->m_guiHelper->registerGraphicsShape(vertices, numVertices, indices, numIndices, primitiveType, textureId);
|
|
serverStatusOut.m_registerGraphicsShapeStatus.m_shapeId = shapeId;
|
|
serverStatusOut.m_type = GFX_CMD_REGISTER_GRAPHICS_SHAPE_COMPLETED;
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
|
|
case GFX_CMD_REGISTER_GRAPHICS_INSTANCE:
|
|
{
|
|
int graphicsInstanceId = m_guiHelper->registerGraphicsInstance(clientCmd.m_registerGraphicsInstanceCommand.m_shapeIndex,
|
|
clientCmd.m_registerGraphicsInstanceCommand.m_position,
|
|
clientCmd.m_registerGraphicsInstanceCommand.m_quaternion,
|
|
clientCmd.m_registerGraphicsInstanceCommand.m_color,
|
|
clientCmd.m_registerGraphicsInstanceCommand.m_scaling);
|
|
serverStatusOut.m_registerGraphicsInstanceStatus.m_graphicsInstanceId = graphicsInstanceId;
|
|
serverStatusOut.m_type = GFX_CMD_REGISTER_GRAPHICS_INSTANCE_COMPLETED;
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_SYNCHRONIZE_TRANSFORMS:
|
|
{
|
|
GUISyncPosition* positions = (GUISyncPosition*)&m_args.m_dataSlots[0][0];
|
|
for (int i = 0; i < clientCmd.m_syncTransformsCommand.m_numPositions; i++)
|
|
{
|
|
m_app->m_renderer->writeSingleInstanceTransformToCPU(positions[i].m_pos, positions[i].m_orn, positions[i].m_graphicsInstanceId);
|
|
}
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_REMOVE_ALL_GRAPHICS_INSTANCES:
|
|
{
|
|
m_guiHelper->removeAllGraphicsInstances();
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_REMOVE_SINGLE_GRAPHICS_INSTANCE:
|
|
{
|
|
m_app->m_renderer->removeGraphicsInstance(clientCmd.m_removeGraphicsInstanceCommand.m_graphicsUid);
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_CHANGE_RGBA_COLOR:
|
|
{
|
|
m_guiHelper->changeRGBAColor(clientCmd.m_changeRGBAColorCommand.m_graphicsUid, clientCmd.m_changeRGBAColorCommand.m_rgbaColor);
|
|
m_args.processCommand();
|
|
break;
|
|
}
|
|
case GFX_CMD_GET_CAMERA_INFO:
|
|
{
|
|
serverStatusOut.m_type = GFX_CMD_GET_CAMERA_INFO_FAILED;
|
|
|
|
if (m_guiHelper->getCameraInfo(
|
|
&serverStatusOut.m_getCameraInfoStatus.width,
|
|
&serverStatusOut.m_getCameraInfoStatus.height,
|
|
serverStatusOut.m_getCameraInfoStatus.viewMatrix,
|
|
serverStatusOut.m_getCameraInfoStatus.projectionMatrix,
|
|
serverStatusOut.m_getCameraInfoStatus.camUp,
|
|
serverStatusOut.m_getCameraInfoStatus.camForward,
|
|
serverStatusOut.m_getCameraInfoStatus.hor,
|
|
serverStatusOut.m_getCameraInfoStatus.vert,
|
|
&serverStatusOut.m_getCameraInfoStatus.yaw,
|
|
&serverStatusOut.m_getCameraInfoStatus.pitch,
|
|
&serverStatusOut.m_getCameraInfoStatus.camDist,
|
|
serverStatusOut.m_getCameraInfoStatus.camTarget))
|
|
{
|
|
serverStatusOut.m_type = GFX_CMD_GET_CAMERA_INFO_COMPLETED;
|
|
}
|
|
m_args.processCommand();
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
printf("unsupported command:%d\n", clientCmd.m_type);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void processClientCommands()
|
|
{
|
|
int timeStamp = 0;
|
|
bool hasStatus = false;
|
|
if (m_args.isCommandOutstanding())
|
|
{
|
|
processCommand(*m_args.m_cmdPtr, m_args.m_serverStatus);
|
|
}
|
|
//serverStatusOut.m_type = GFX_CMD_CLIENT_COMMAND_FAILED;
|
|
//bool hasStatus = processCommand(clientCmd, serverStatusOut);
|
|
if (hasStatus)
|
|
{
|
|
//submitServerStatus(serverStatusOut);
|
|
}
|
|
}
|
|
|
|
virtual void stepSimulation(float deltaTime)
|
|
{
|
|
B3_PROFILE("stepSimulation");
|
|
processClientCommands();
|
|
m_x += 0.01f;
|
|
m_y += 0.01f;
|
|
m_z += 0.01f;
|
|
}
|
|
|
|
|
|
virtual void renderScene()
|
|
{
|
|
B3_PROFILE("renderScene");
|
|
{
|
|
|
|
B3_PROFILE("writeTransforms");
|
|
m_app->m_renderer->writeTransforms();
|
|
}
|
|
{
|
|
B3_PROFILE("m_renderer->renderScene");
|
|
m_app->m_renderer->renderScene();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void physicsDebugDraw(int debugDrawFlags)
|
|
{
|
|
|
|
}
|
|
|
|
virtual bool mouseMoveCallback(float x, float y)
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool mouseButtonCallback(int button, int state, float x, float y)
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool keyboardCallback(int key, int state)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual void resetCamera()
|
|
{
|
|
float dist = 3.5;
|
|
float pitch = -32;
|
|
float yaw = 136;
|
|
float targetPos[3] = {0, 0, 0};
|
|
if (m_app->m_renderer && m_app->m_renderer->getActiveCamera())
|
|
{
|
|
m_app->m_renderer->getActiveCamera()->setCameraDistance(dist);
|
|
m_app->m_renderer->getActiveCamera()->setCameraPitch(pitch);
|
|
m_app->m_renderer->getActiveCamera()->setCameraYaw(yaw);
|
|
m_app->m_renderer->getActiveCamera()->setCameraTargetPosition(targetPos[0], targetPos[1], targetPos[2]);
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CommonExampleInterface* GraphicsServerCreateFuncBullet(struct CommonExampleOptions& options)
|
|
{
|
|
return new GraphicsServerExample(options.m_guiHelper);
|
|
}
|