// return true if connection succesfull, can also check 'isConnected' bool PhysicsDirect::connect() { bool connected = m_data->m_commandProcessor->connect(); m_data->m_commandProcessor->setGuiHelper(&m_data->m_noGfx); if (connected) //also request serialization data { SharedMemoryCommand command; command.m_type = CMD_REQUEST_INTERNAL_DATA; bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); if (hasStatus) { postProcessStatus(m_data->m_serverStatus); } else { b3Clock clock; double timeSec = clock.getTimeInSeconds(); while ((!hasStatus) && (clock.getTimeInSeconds() - timeSec < 10)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } } } return connected; }
bool PhysicsDirect::processContactPointData(const struct SharedMemoryCommand& orgCommand) { SharedMemoryCommand command = orgCommand; const SharedMemoryStatus& serverCmd = m_data->m_serverStatus; do { bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); b3Clock clock; double startTime = clock.getTimeInSeconds(); double timeOutInSeconds = m_data->m_timeOutInSeconds; while ((!hasStatus) && (clock.getTimeInSeconds() - startTime < timeOutInSeconds)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } m_data->m_hasStatus = hasStatus; if (hasStatus) { if (m_data->m_verboseOutput) { b3Printf("Contact Point Information Request OK\n"); } int startContactIndex = serverCmd.m_sendContactPointArgs.m_startingContactPointIndex; int numContactsCopied = serverCmd.m_sendContactPointArgs.m_numContactPointsCopied; m_data->m_cachedContactPoints.resize(startContactIndex + numContactsCopied); b3ContactPointData* contactData = (b3ContactPointData*)&m_data->m_bulletStreamDataServerToClient[0]; for (int i = 0; i < numContactsCopied; i++) { m_data->m_cachedContactPoints[startContactIndex + i] = contactData[i]; } if (serverCmd.m_sendContactPointArgs.m_numRemainingContactPoints > 0 && serverCmd.m_sendContactPointArgs.m_numContactPointsCopied) { m_data->m_hasStatus = false; command.m_type = CMD_REQUEST_CONTACT_POINT_INFORMATION; command.m_requestContactPointArguments.m_startingContactPointIndex = serverCmd.m_sendContactPointArgs.m_startingContactPointIndex + serverCmd.m_sendContactPointArgs.m_numContactPointsCopied; command.m_requestContactPointArguments.m_objectAIndexFilter = -1; command.m_requestContactPointArguments.m_objectBIndexFilter = -1; } } } while (serverCmd.m_sendContactPointArgs.m_numRemainingContactPoints > 0 && serverCmd.m_sendContactPointArgs.m_numContactPointsCopied); return m_data->m_hasStatus; }
bool PhysicsDirect::processOverlappingObjects(const struct SharedMemoryCommand& orgCommand) { SharedMemoryCommand command = orgCommand; const SharedMemoryStatus& serverCmd = m_data->m_serverStatus; do { bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); b3Clock clock; double startTime = clock.getTimeInSeconds(); double timeOutInSeconds = m_data->m_timeOutInSeconds; while ((!hasStatus) && (clock.getTimeInSeconds()-startTime < timeOutInSeconds)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } m_data->m_hasStatus = hasStatus; if (hasStatus) { if (m_data->m_verboseOutput) { b3Printf("Overlapping Objects Request OK\n"); } int startOverlapIndex = serverCmd.m_sendOverlappingObjectsArgs.m_startingOverlappingObjectIndex; int numOverlapCopied = serverCmd.m_sendOverlappingObjectsArgs.m_numOverlappingObjectsCopied; m_data->m_cachedOverlappingObjects.resize(startOverlapIndex + numOverlapCopied); b3OverlappingObject* objects = (b3OverlappingObject*)&m_data->m_bulletStreamDataServerToClient[0]; for (int i = 0; i < numOverlapCopied; i++) { m_data->m_cachedOverlappingObjects[startOverlapIndex + i] = objects[i]; } if (serverCmd.m_sendOverlappingObjectsArgs.m_numRemainingOverlappingObjects > 0 && serverCmd.m_sendOverlappingObjectsArgs.m_numOverlappingObjectsCopied) { m_data->m_hasStatus = false; command.m_type = CMD_REQUEST_AABB_OVERLAP; command.m_requestOverlappingObjectsArgs.m_startingOverlappingObjectIndex = serverCmd.m_sendOverlappingObjectsArgs.m_startingOverlappingObjectIndex + serverCmd.m_sendOverlappingObjectsArgs.m_numOverlappingObjectsCopied; } } } while (serverCmd.m_sendOverlappingObjectsArgs.m_numRemainingOverlappingObjects > 0 && serverCmd.m_sendOverlappingObjectsArgs.m_numOverlappingObjectsCopied); return m_data->m_hasStatus; }
bool PhysicsDirect::processVisualShapeData(const struct SharedMemoryCommand& orgCommand) { SharedMemoryCommand command = orgCommand; const SharedMemoryStatus& serverCmd = m_data->m_serverStatus; do { bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); b3Clock clock; double startTime = clock.getTimeInSeconds(); double timeOutInSeconds = m_data->m_timeOutInSeconds; while ((!hasStatus) && (clock.getTimeInSeconds()-startTime < timeOutInSeconds)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } m_data->m_hasStatus = hasStatus; if (hasStatus) { if (m_data->m_verboseOutput) { b3Printf("Visual Shape Information Request OK\n"); } int startVisualShapeIndex = serverCmd.m_sendVisualShapeArgs.m_startingVisualShapeIndex; int numVisualShapesCopied = serverCmd.m_sendVisualShapeArgs.m_numVisualShapesCopied; m_data->m_cachedVisualShapes.resize(startVisualShapeIndex + numVisualShapesCopied); b3VisualShapeData* shapeData = (b3VisualShapeData*)&m_data->m_bulletStreamDataServerToClient[0]; for (int i = 0; i < numVisualShapesCopied; i++) { m_data->m_cachedVisualShapes[startVisualShapeIndex + i] = shapeData[i]; } if (serverCmd.m_sendVisualShapeArgs.m_numRemainingVisualShapes >0 && serverCmd.m_sendVisualShapeArgs.m_numVisualShapesCopied) { m_data->m_hasStatus = false; command.m_type = CMD_REQUEST_VISUAL_SHAPE_INFO; command.m_requestVisualShapeDataArguments.m_startingVisualShapeIndex = serverCmd.m_sendVisualShapeArgs.m_startingVisualShapeIndex + serverCmd.m_sendVisualShapeArgs.m_numVisualShapesCopied; command.m_requestVisualShapeDataArguments.m_bodyUniqueId = serverCmd.m_sendVisualShapeArgs.m_bodyUniqueId; } } } while (serverCmd.m_sendVisualShapeArgs.m_numRemainingVisualShapes > 0 && serverCmd.m_sendVisualShapeArgs.m_numVisualShapesCopied); return m_data->m_hasStatus; }
bool PhysicsClientSharedMemory::connect() { /// server always has to create and initialize shared memory bool allowCreation = false; m_data->m_testBlock1 = (SharedMemoryBlock*)m_data->m_sharedMemory->allocateSharedMemory( m_data->m_sharedMemoryKey, SHARED_MEMORY_SIZE, allowCreation); if (m_data->m_testBlock1) { if (m_data->m_testBlock1->m_magicId != SHARED_MEMORY_MAGIC_NUMBER) { b3Error("Error: please start server before client\n"); m_data->m_sharedMemory->releaseSharedMemory(m_data->m_sharedMemoryKey, SHARED_MEMORY_SIZE); m_data->m_testBlock1 = 0; return false; } else { if (m_data->m_verboseOutput) { b3Printf("Connected to existing shared memory, status OK.\n"); } m_data->m_isConnected = true; } } else { b3Warning("Cannot connect to shared memory"); return false; } #if 0 if (m_data->m_isConnected) { //get all existing bodies and body info... SharedMemoryCommand& command = m_data->m_testBlock1->m_clientCommands[0]; //now transfer the information of the individual objects etc. command.m_type = CMD_REQUEST_BODY_INFO; command.m_sdfRequestInfoArgs.m_bodyUniqueId = 37; submitClientCommand(command); int timeout = 1024 * 1024 * 1024; const SharedMemoryStatus* status = 0; while ((status == 0) && (timeout-- > 0)) { status = processServerStatus(); } //submitClientCommand(command); } #endif return true; }
bool PhysicsDirect::processCamera(const struct SharedMemoryCommand& orgCommand) { SharedMemoryCommand command = orgCommand; const SharedMemoryStatus& serverCmd = m_data->m_serverStatus; do { bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); b3Clock clock; double startTime = clock.getTimeInSeconds(); double timeOutInSeconds = m_data->m_timeOutInSeconds; while ((!hasStatus) && (clock.getTimeInSeconds() - startTime < timeOutInSeconds)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } m_data->m_hasStatus = hasStatus; if (hasStatus) { btAssert(m_data->m_serverStatus.m_type == CMD_CAMERA_IMAGE_COMPLETED); if (m_data->m_verboseOutput) { b3Printf("Camera image OK\n"); } int numBytesPerPixel = 4; //RGBA int numTotalPixels = serverCmd.m_sendPixelDataArguments.m_startingPixelIndex + serverCmd.m_sendPixelDataArguments.m_numPixelsCopied + serverCmd.m_sendPixelDataArguments.m_numRemainingPixels; m_data->m_cachedCameraPixelsWidth = 0; m_data->m_cachedCameraPixelsHeight = 0; int numPixels = serverCmd.m_sendPixelDataArguments.m_imageWidth * serverCmd.m_sendPixelDataArguments.m_imageHeight; m_data->m_cachedCameraPixelsRGBA.reserve(numPixels * numBytesPerPixel); m_data->m_cachedCameraDepthBuffer.resize(numTotalPixels); m_data->m_cachedSegmentationMask.resize(numTotalPixels); m_data->m_cachedCameraPixelsRGBA.resize(numTotalPixels * numBytesPerPixel); unsigned char* rgbaPixelsReceived = (unsigned char*)&m_data->m_bulletStreamDataServerToClient[0]; float* depthBuffer = (float*)&(m_data->m_bulletStreamDataServerToClient[serverCmd.m_sendPixelDataArguments.m_numPixelsCopied * 4]); int* segmentationMaskBuffer = (int*)&(m_data->m_bulletStreamDataServerToClient[serverCmd.m_sendPixelDataArguments.m_numPixelsCopied * 8]); // printf("pixel = %d\n", rgbaPixelsReceived[0]); for (int i = 0; i < serverCmd.m_sendPixelDataArguments.m_numPixelsCopied; i++) { m_data->m_cachedCameraDepthBuffer[i + serverCmd.m_sendPixelDataArguments.m_startingPixelIndex] = depthBuffer[i]; } for (int i = 0; i < serverCmd.m_sendPixelDataArguments.m_numPixelsCopied; i++) { m_data->m_cachedSegmentationMask[i + serverCmd.m_sendPixelDataArguments.m_startingPixelIndex] = segmentationMaskBuffer[i]; } for (int i = 0; i < serverCmd.m_sendPixelDataArguments.m_numPixelsCopied * numBytesPerPixel; i++) { m_data->m_cachedCameraPixelsRGBA[i + serverCmd.m_sendPixelDataArguments.m_startingPixelIndex * numBytesPerPixel] = rgbaPixelsReceived[i]; } if (serverCmd.m_sendPixelDataArguments.m_numRemainingPixels > 0 && serverCmd.m_sendPixelDataArguments.m_numPixelsCopied) { m_data->m_hasStatus = false; // continue requesting remaining pixels command.m_type = CMD_REQUEST_CAMERA_IMAGE_DATA; command.m_requestPixelDataArguments.m_startPixelIndex = serverCmd.m_sendPixelDataArguments.m_startingPixelIndex + serverCmd.m_sendPixelDataArguments.m_numPixelsCopied; } else { m_data->m_cachedCameraPixelsWidth = serverCmd.m_sendPixelDataArguments.m_imageWidth; m_data->m_cachedCameraPixelsHeight = serverCmd.m_sendPixelDataArguments.m_imageHeight; } } } while (serverCmd.m_sendPixelDataArguments.m_numRemainingPixels > 0 && serverCmd.m_sendPixelDataArguments.m_numPixelsCopied); return m_data->m_hasStatus; }
bool PhysicsDirect::processDebugLines(const struct SharedMemoryCommand& orgCommand) { SharedMemoryCommand command = orgCommand; const SharedMemoryStatus& serverCmd = m_data->m_serverStatus; do { bool hasStatus = m_data->m_commandProcessor->processCommand(command, m_data->m_serverStatus, &m_data->m_bulletStreamDataServerToClient[0], SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); b3Clock clock; double startTime = clock.getTimeInSeconds(); double timeOutInSeconds = m_data->m_timeOutInSeconds; while ((!hasStatus) && (clock.getTimeInSeconds() - startTime < timeOutInSeconds)) { const SharedMemoryStatus* stat = processServerStatus(); if (stat) { hasStatus = true; } } m_data->m_hasStatus = hasStatus; if (hasStatus) { btAssert(m_data->m_serverStatus.m_type == CMD_DEBUG_LINES_COMPLETED); if (m_data->m_verboseOutput) { b3Printf("Success receiving %d debug lines", serverCmd.m_sendDebugLinesArgs.m_numDebugLines); } int numLines = serverCmd.m_sendDebugLinesArgs.m_numDebugLines; float* linesFrom = (float*)&m_data->m_bulletStreamDataServerToClient[0]; float* linesTo = (float*)(&m_data->m_bulletStreamDataServerToClient[0] + numLines * 3 * sizeof(float)); float* linesColor = (float*)(&m_data->m_bulletStreamDataServerToClient[0] + 2 * numLines * 3 * sizeof(float)); m_data->m_debugLinesFrom.resize(serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + numLines); m_data->m_debugLinesTo.resize(serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + numLines); m_data->m_debugLinesColor.resize( serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + numLines); for (int i = 0; i < numLines; i++) { TmpFloat3 from = CreateTmpFloat3(linesFrom[i * 3], linesFrom[i * 3 + 1], linesFrom[i * 3 + 2]); TmpFloat3 to = CreateTmpFloat3(linesTo[i * 3], linesTo[i * 3 + 1], linesTo[i * 3 + 2]); TmpFloat3 color = CreateTmpFloat3(linesColor[i * 3], linesColor[i * 3 + 1], linesColor[i * 3 + 2]); m_data ->m_debugLinesFrom[serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + i] = from; m_data->m_debugLinesTo[serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + i] = to; m_data->m_debugLinesColor[serverCmd.m_sendDebugLinesArgs.m_startingLineIndex + i] = color; } if (serverCmd.m_sendDebugLinesArgs.m_numRemainingDebugLines > 0) { m_data->m_hasStatus = false; command.m_type = CMD_REQUEST_DEBUG_LINES; command.m_requestDebugLinesArguments.m_startingLineIndex = serverCmd.m_sendDebugLinesArgs.m_numDebugLines + serverCmd.m_sendDebugLinesArgs.m_startingLineIndex; } } } while (serverCmd.m_sendDebugLinesArgs.m_numRemainingDebugLines > 0); return m_data->m_hasStatus; }