mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-13 21:30:09 +00:00
570 lines
16 KiB
C++
570 lines
16 KiB
C++
|
|
#include "SharedMemoryInProcessPhysicsC_API.h"
|
|
#include "../Utils/b3Clock.h"
|
|
|
|
#include "PhysicsClientSharedMemory.h"
|
|
#include "../ExampleBrowser/InProcessExampleBrowser.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "PhysicsServerExampleBullet2.h"
|
|
#include "../CommonInterfaces/CommonGUIHelperInterface.h"
|
|
#include "../CommonInterfaces/CommonExampleInterface.h"
|
|
#include "InProcessMemory.h"
|
|
#include "RemoteGUIHelper.h"
|
|
|
|
#include "Bullet3Common/b3Logging.h"
|
|
class InProcessPhysicsClientSharedMemoryMainThread : public PhysicsClientSharedMemory
|
|
{
|
|
btInProcessExampleBrowserMainThreadInternalData* m_data;
|
|
b3Clock m_clock;
|
|
|
|
public:
|
|
InProcessPhysicsClientSharedMemoryMainThread(int argc, char* argv[], bool useInProcessMemory)
|
|
{
|
|
int newargc = argc + 3;
|
|
char** newargv = (char**)malloc(sizeof(void*) * newargc);
|
|
char* t0 = (char*)"--unused";
|
|
newargv[0] = t0;
|
|
for (int i = 0; i < argc; i++)
|
|
newargv[i + 1] = argv[i];
|
|
newargv[argc + 1] = (char*)"--logtostderr";
|
|
newargv[argc + 2] = (char*)"--start_demo_name=Physics Server";
|
|
|
|
m_data = btCreateInProcessExampleBrowserMainThread(newargc, newargv, useInProcessMemory);
|
|
SharedMemoryInterface* shMem = btGetSharedMemoryInterfaceMainThread(m_data);
|
|
|
|
setSharedMemoryInterface(shMem);
|
|
}
|
|
|
|
virtual ~InProcessPhysicsClientSharedMemoryMainThread()
|
|
{
|
|
setSharedMemoryInterface(0);
|
|
btShutDownExampleBrowserMainThread(m_data);
|
|
}
|
|
|
|
// return non-null if there is a status, nullptr otherwise
|
|
virtual const struct SharedMemoryStatus* processServerStatus()
|
|
{
|
|
{
|
|
if (btIsExampleBrowserMainThreadTerminated(m_data))
|
|
{
|
|
PhysicsClientSharedMemory::disconnectSharedMemory();
|
|
}
|
|
}
|
|
{
|
|
unsigned long int ms = m_clock.getTimeMilliseconds();
|
|
if (ms > 2)
|
|
{
|
|
B3_PROFILE("m_clock.reset()");
|
|
|
|
btUpdateInProcessExampleBrowserMainThread(m_data);
|
|
m_clock.reset();
|
|
}
|
|
}
|
|
{
|
|
b3Clock::usleep(0);
|
|
}
|
|
const SharedMemoryStatus* stat = 0;
|
|
|
|
{
|
|
stat = PhysicsClientSharedMemory::processServerStatus();
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
virtual bool submitClientCommand(const struct SharedMemoryCommand& command)
|
|
{
|
|
// btUpdateInProcessExampleBrowserMainThread(m_data);
|
|
return PhysicsClientSharedMemory::submitClientCommand(command);
|
|
}
|
|
};
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectMainThread(int argc, char* argv[])
|
|
{
|
|
InProcessPhysicsClientSharedMemoryMainThread* cl = new InProcessPhysicsClientSharedMemoryMainThread(argc, argv, 1);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectMainThreadSharedMemory(int argc, char* argv[])
|
|
{
|
|
InProcessPhysicsClientSharedMemoryMainThread* cl = new InProcessPhysicsClientSharedMemoryMainThread(argc, argv, 0);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
|
|
|
|
class InProcessPhysicsClientSharedMemory : public PhysicsClientSharedMemory
|
|
{
|
|
btInProcessExampleBrowserInternalData* m_data;
|
|
char** m_newargv;
|
|
|
|
public:
|
|
InProcessPhysicsClientSharedMemory(int argc, char* argv[], bool useInProcessMemory)
|
|
{
|
|
int newargc = argc + 2;
|
|
m_newargv = (char**)malloc(sizeof(void*) * newargc);
|
|
char* t0 = (char*)"--unused";
|
|
m_newargv[0] = t0;
|
|
|
|
for (int i = 0; i < argc; i++)
|
|
m_newargv[i + 1] = argv[i];
|
|
|
|
char* t1 = (char*)"--start_demo_name=Physics Server";
|
|
m_newargv[argc + 1] = t1;
|
|
m_data = btCreateInProcessExampleBrowser(newargc, m_newargv, useInProcessMemory);
|
|
SharedMemoryInterface* shMem = btGetSharedMemoryInterface(m_data);
|
|
setSharedMemoryInterface(shMem);
|
|
}
|
|
|
|
virtual ~InProcessPhysicsClientSharedMemory()
|
|
{
|
|
setSharedMemoryInterface(0);
|
|
btShutDownExampleBrowser(m_data);
|
|
free(m_newargv);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnect(int argc, char* argv[])
|
|
{
|
|
InProcessPhysicsClientSharedMemory* cl = new InProcessPhysicsClientSharedMemory(argc, argv, 1);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectSharedMemory(int argc, char* argv[])
|
|
{
|
|
InProcessPhysicsClientSharedMemory* cl = new InProcessPhysicsClientSharedMemory(argc, argv, 0);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
class InProcessPhysicsClientExistingExampleBrowser : public PhysicsClientSharedMemory
|
|
{
|
|
CommonExampleInterface* m_physicsServerExample;
|
|
SharedMemoryInterface* m_sharedMem;
|
|
b3Clock m_clock;
|
|
unsigned long long int m_prevTime;
|
|
struct GUIHelperInterface* m_guiHelper;
|
|
|
|
public:
|
|
InProcessPhysicsClientExistingExampleBrowser(struct GUIHelperInterface* guiHelper, bool useInProcessMemory, bool skipGraphicsUpdate, bool ownsGuiHelper)
|
|
{
|
|
if (ownsGuiHelper)
|
|
{
|
|
m_guiHelper = guiHelper;
|
|
}
|
|
|
|
m_sharedMem = 0;
|
|
CommonExampleOptions options(guiHelper);
|
|
|
|
if (useInProcessMemory)
|
|
{
|
|
m_sharedMem = new InProcessMemory;
|
|
options.m_sharedMem = m_sharedMem;
|
|
}
|
|
|
|
options.m_skipGraphicsUpdate = skipGraphicsUpdate;
|
|
m_physicsServerExample = PhysicsServerCreateFuncBullet2(options);
|
|
m_physicsServerExample->initPhysics();
|
|
//m_physicsServerExample->resetCamera();
|
|
setSharedMemoryInterface(m_sharedMem);
|
|
m_clock.reset();
|
|
m_prevTime = m_clock.getTimeMicroseconds();
|
|
}
|
|
virtual ~InProcessPhysicsClientExistingExampleBrowser()
|
|
{
|
|
m_physicsServerExample->exitPhysics();
|
|
//s_instancingRenderer->removeAllInstances();
|
|
delete m_physicsServerExample;
|
|
delete m_sharedMem;
|
|
delete m_guiHelper;
|
|
}
|
|
|
|
// return non-null if there is a status, nullptr otherwise
|
|
virtual const struct SharedMemoryStatus* processServerStatus()
|
|
{
|
|
m_physicsServerExample->updateGraphics();
|
|
|
|
unsigned long long int curTime = m_clock.getTimeMicroseconds();
|
|
unsigned long long int dtMicro = curTime - m_prevTime;
|
|
m_prevTime = curTime;
|
|
|
|
double dt = double(dtMicro) / 1000000.;
|
|
|
|
m_physicsServerExample->stepSimulation(dt);
|
|
{
|
|
b3Clock::usleep(0);
|
|
}
|
|
const SharedMemoryStatus* stat = 0;
|
|
|
|
{
|
|
stat = PhysicsClientSharedMemory::processServerStatus();
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
virtual void renderScene()
|
|
{
|
|
m_physicsServerExample->renderScene();
|
|
}
|
|
virtual void debugDraw(int debugDrawMode)
|
|
{
|
|
m_physicsServerExample->physicsDebugDraw(debugDrawMode);
|
|
}
|
|
virtual bool mouseMoveCallback(float x, float y)
|
|
{
|
|
return m_physicsServerExample->mouseMoveCallback(x, y);
|
|
}
|
|
virtual bool mouseButtonCallback(int button, int state, float x, float y)
|
|
{
|
|
return m_physicsServerExample->mouseButtonCallback(button, state, x, y);
|
|
}
|
|
};
|
|
|
|
void b3InProcessDebugDrawInternal(b3PhysicsClientHandle clientHandle, int debugDrawMode)
|
|
{
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = (InProcessPhysicsClientExistingExampleBrowser*)clientHandle;
|
|
cl->debugDraw(debugDrawMode);
|
|
}
|
|
void b3InProcessRenderSceneInternal(b3PhysicsClientHandle clientHandle)
|
|
{
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = (InProcessPhysicsClientExistingExampleBrowser*)clientHandle;
|
|
cl->renderScene();
|
|
}
|
|
|
|
int b3InProcessMouseMoveCallback(b3PhysicsClientHandle clientHandle, float x, float y)
|
|
{
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = (InProcessPhysicsClientExistingExampleBrowser*)clientHandle;
|
|
return cl->mouseMoveCallback(x, y);
|
|
}
|
|
int b3InProcessMouseButtonCallback(b3PhysicsClientHandle clientHandle, int button, int state, float x, float y)
|
|
{
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = (InProcessPhysicsClientExistingExampleBrowser*)clientHandle;
|
|
return cl->mouseButtonCallback(button, state, x, y);
|
|
}
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect(void* guiHelperPtr)
|
|
{
|
|
static DummyGUIHelper noGfx;
|
|
|
|
GUIHelperInterface* guiHelper = (GUIHelperInterface*)guiHelperPtr;
|
|
if (!guiHelper)
|
|
{
|
|
guiHelper = &noGfx;
|
|
}
|
|
bool useInprocessMemory = true;
|
|
bool skipGraphicsUpdate = false;
|
|
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = new InProcessPhysicsClientExistingExampleBrowser(guiHelper, useInprocessMemory, skipGraphicsUpdate, false);
|
|
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
extern int gSharedMemoryKey;
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect3(void* guiHelperPtr, int sharedMemoryKey)
|
|
{
|
|
static DummyGUIHelper noGfx;
|
|
|
|
gSharedMemoryKey = sharedMemoryKey;
|
|
GUIHelperInterface* guiHelper = (GUIHelperInterface*)guiHelperPtr;
|
|
if (!guiHelper)
|
|
{
|
|
guiHelper = &noGfx;
|
|
}
|
|
bool useInprocessMemory = false;
|
|
bool skipGraphicsUpdate = true;
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = new InProcessPhysicsClientExistingExampleBrowser(guiHelper, useInprocessMemory, skipGraphicsUpdate, false);
|
|
|
|
cl->setSharedMemoryKey(sharedMemoryKey + 1);
|
|
cl->connect();
|
|
//backward compatiblity
|
|
gSharedMemoryKey = SHARED_MEMORY_KEY;
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect4(void* guiHelperPtr, int sharedMemoryKey)
|
|
{
|
|
gSharedMemoryKey = sharedMemoryKey;
|
|
GUIHelperInterface* guiHelper = (GUIHelperInterface*)guiHelperPtr;
|
|
bool ownsGuiHelper = false;
|
|
if (!guiHelper)
|
|
{
|
|
guiHelper = new RemoteGUIHelper();
|
|
ownsGuiHelper = true;
|
|
}
|
|
bool useInprocessMemory = false;
|
|
bool skipGraphicsUpdate = false;
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = new InProcessPhysicsClientExistingExampleBrowser(guiHelper, useInprocessMemory, skipGraphicsUpdate, ownsGuiHelper);
|
|
|
|
cl->setSharedMemoryKey(sharedMemoryKey + 1);
|
|
cl->connect();
|
|
//backward compatiblity
|
|
gSharedMemoryKey = SHARED_MEMORY_KEY;
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
#include "RemoteGUIHelperTCP.h"
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnectTCP(const char* hostName, int port)
|
|
{
|
|
bool ownsGuiHelper = true;
|
|
GUIHelperInterface* guiHelper = new RemoteGUIHelperTCP(hostName, port);
|
|
|
|
bool useInprocessMemory = true;
|
|
bool skipGraphicsUpdate = false;
|
|
InProcessPhysicsClientExistingExampleBrowser* cl = new InProcessPhysicsClientExistingExampleBrowser(guiHelper, useInprocessMemory, skipGraphicsUpdate, ownsGuiHelper);
|
|
|
|
//cl->setSharedMemoryKey(sharedMemoryKey + 1);
|
|
cl->connect();
|
|
//backward compatiblity
|
|
gSharedMemoryKey = SHARED_MEMORY_KEY;
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
|
|
|
|
//backward compatiblity
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect2(void* guiHelperPtr)
|
|
{
|
|
return b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect3(guiHelperPtr, SHARED_MEMORY_KEY);
|
|
}
|
|
|
|
|
|
|
|
#include "SharedMemoryCommands.h"
|
|
#include "PhysicsClientSharedMemory.h"
|
|
#include "GraphicsSharedMemoryBlock.h"
|
|
#include "PosixSharedMemory.h"
|
|
#include "Win32SharedMemory.h"
|
|
class InProcessGraphicsServerSharedMemory : public PhysicsClientSharedMemory
|
|
{
|
|
btInProcessExampleBrowserInternalData* m_data2;
|
|
char** m_newargv;
|
|
SharedMemoryCommand m_command;
|
|
|
|
GraphicsSharedMemoryBlock* m_testBlock1;
|
|
SharedMemoryInterface* m_sharedMemory;
|
|
|
|
public:
|
|
InProcessGraphicsServerSharedMemory(int port)
|
|
{
|
|
int newargc = 3;
|
|
m_newargv = (char**)malloc(sizeof(void*) * newargc);
|
|
char* t0 = (char*)"--unused";
|
|
m_newargv[0] = t0;
|
|
|
|
char* t1 = (char*)"--start_demo_name=Graphics Server";
|
|
char portArg[1024];
|
|
sprintf(portArg, "--port=%d", port);
|
|
|
|
m_newargv[1] = t1;
|
|
m_newargv[2] = portArg;
|
|
bool useInProcessMemory = false;
|
|
m_data2 = btCreateInProcessExampleBrowser(newargc, m_newargv, useInProcessMemory);
|
|
SharedMemoryInterface* shMem = btGetSharedMemoryInterface(m_data2);
|
|
|
|
setSharedMemoryInterface(shMem);
|
|
///////////////////
|
|
|
|
#ifdef _WIN32
|
|
m_sharedMemory = new Win32SharedMemoryServer();
|
|
#else
|
|
m_sharedMemory = new PosixSharedMemory();
|
|
#endif
|
|
|
|
/// server always has to create and initialize shared memory
|
|
bool allowCreation = false;
|
|
m_testBlock1 = (GraphicsSharedMemoryBlock*)m_sharedMemory->allocateSharedMemory(
|
|
GRAPHICS_SHARED_MEMORY_KEY, GRAPHICS_SHARED_MEMORY_SIZE, allowCreation);
|
|
|
|
}
|
|
|
|
virtual ~InProcessGraphicsServerSharedMemory()
|
|
{
|
|
m_sharedMemory->releaseSharedMemory(GRAPHICS_SHARED_MEMORY_KEY, GRAPHICS_SHARED_MEMORY_SIZE);
|
|
delete m_sharedMemory;
|
|
|
|
setSharedMemoryInterface(0);
|
|
btShutDownExampleBrowser(m_data2);
|
|
free(m_newargv);
|
|
}
|
|
virtual bool canSubmitCommand() const
|
|
{
|
|
if (m_testBlock1)
|
|
{
|
|
if (m_testBlock1->m_magicId != GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
virtual struct SharedMemoryCommand* getAvailableSharedMemoryCommand()
|
|
{
|
|
return &m_command;
|
|
}
|
|
|
|
virtual bool submitClientCommand(const struct SharedMemoryCommand& command)
|
|
{
|
|
switch (command.m_type)
|
|
{
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
class InProcessGraphicsServerSharedMemoryMainThread : public PhysicsClientSharedMemory
|
|
{
|
|
|
|
btInProcessExampleBrowserMainThreadInternalData* m_data2;
|
|
char** m_newargv;
|
|
SharedMemoryCommand m_command;
|
|
|
|
GraphicsSharedMemoryBlock* m_testBlock1;
|
|
SharedMemoryInterface* m_sharedMemory;
|
|
b3Clock m_clock;
|
|
|
|
public:
|
|
InProcessGraphicsServerSharedMemoryMainThread(int port)
|
|
{
|
|
int newargc = 3;
|
|
m_newargv = (char**)malloc(sizeof(void*) * newargc);
|
|
char* t0 = (char*)"--unused";
|
|
m_newargv[0] = t0;
|
|
|
|
|
|
char* t1 = (char*)"--start_demo_name=Graphics Server";
|
|
m_newargv[1] = t1;
|
|
char portArg[1024];
|
|
sprintf(portArg, "--port=%d", port);
|
|
m_newargv[2] = portArg;
|
|
|
|
bool useInProcessMemory = false;
|
|
m_data2 = btCreateInProcessExampleBrowserMainThread(newargc, m_newargv, useInProcessMemory);
|
|
SharedMemoryInterface* shMem = btGetSharedMemoryInterfaceMainThread(m_data2);
|
|
|
|
setSharedMemoryInterface(shMem);
|
|
///////////////////
|
|
|
|
#ifdef _WIN32
|
|
m_sharedMemory = new Win32SharedMemoryServer();
|
|
#else
|
|
m_sharedMemory = new PosixSharedMemory();
|
|
#endif
|
|
|
|
/// server always has to create and initialize shared memory
|
|
bool allowCreation = false;
|
|
m_testBlock1 = (GraphicsSharedMemoryBlock*)m_sharedMemory->allocateSharedMemory(
|
|
GRAPHICS_SHARED_MEMORY_KEY, GRAPHICS_SHARED_MEMORY_SIZE, allowCreation);
|
|
m_clock.reset();
|
|
}
|
|
|
|
virtual ~InProcessGraphicsServerSharedMemoryMainThread()
|
|
{
|
|
m_sharedMemory->releaseSharedMemory(GRAPHICS_SHARED_MEMORY_KEY, GRAPHICS_SHARED_MEMORY_SIZE);
|
|
delete m_sharedMemory;
|
|
|
|
setSharedMemoryInterface(0);
|
|
btShutDownExampleBrowserMainThread(m_data2);
|
|
free(m_newargv);
|
|
}
|
|
virtual bool canSubmitCommand() const
|
|
{
|
|
btUpdateInProcessExampleBrowserMainThread(m_data2);
|
|
if (m_testBlock1)
|
|
{
|
|
if (m_testBlock1->m_magicId != GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
virtual struct SharedMemoryCommand* getAvailableSharedMemoryCommand()
|
|
{
|
|
return &m_command;
|
|
}
|
|
|
|
virtual bool submitClientCommand(const struct SharedMemoryCommand& command)
|
|
{
|
|
switch (command.m_type)
|
|
{
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// return non-null if there is a status, nullptr otherwise
|
|
virtual const struct SharedMemoryStatus* processServerStatus()
|
|
{
|
|
{
|
|
if (btIsExampleBrowserMainThreadTerminated(m_data2))
|
|
{
|
|
PhysicsClientSharedMemory::disconnectSharedMemory();
|
|
}
|
|
}
|
|
{
|
|
unsigned long int ms = m_clock.getTimeMilliseconds();
|
|
if (ms > 2)
|
|
{
|
|
B3_PROFILE("m_clock.reset()");
|
|
|
|
btUpdateInProcessExampleBrowserMainThread(m_data2);
|
|
m_clock.reset();
|
|
}
|
|
}
|
|
{
|
|
b3Clock::usleep(0);
|
|
}
|
|
const SharedMemoryStatus* stat = 0;
|
|
|
|
{
|
|
stat = PhysicsClientSharedMemory::processServerStatus();
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessGraphicsServerAndConnectSharedMemory(int port)
|
|
{
|
|
InProcessGraphicsServerSharedMemory* cl = new InProcessGraphicsServerSharedMemory(port);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessGraphicsServerAndConnectMainThreadSharedMemory(int port)
|
|
{
|
|
InProcessGraphicsServerSharedMemoryMainThread* cl = new InProcessGraphicsServerSharedMemoryMainThread(port);
|
|
cl->setSharedMemoryKey(SHARED_MEMORY_KEY + 1);
|
|
cl->connect();
|
|
return (b3PhysicsClientHandle)cl;
|
|
}
|
|
|
|
|