From 3d3830962a7576dcfb23225db6f8deeef81950dc Mon Sep 17 00:00:00 2001 From: Erwin Coumans Date: Sat, 17 Oct 2015 13:44:00 -0700 Subject: [PATCH] add a few collision examples to test a C API with various back-ends --- examples/Collision/CollisionSdkC_Api.cpp | 126 ++++++++ examples/Collision/CollisionSdkC_Api.h | 101 +++++++ .../Collision/CollisionTutorialBullet2.cpp | 270 ++++++++++++++++++ examples/Collision/CollisionTutorialBullet2.h | 12 + .../Internal/Bullet2CollisionSdk.cpp | 118 ++++++++ .../Collision/Internal/Bullet2CollisionSdk.h | 34 +++ .../Internal/CollisionSdkInterface.h | 32 +++ examples/ExampleBrowser/CMakeLists.txt | 7 + examples/ExampleBrowser/ExampleEntries.cpp | 11 +- examples/ExampleBrowser/premake4.lua | 2 + 10 files changed, 709 insertions(+), 4 deletions(-) create mode 100644 examples/Collision/CollisionSdkC_Api.cpp create mode 100644 examples/Collision/CollisionSdkC_Api.h create mode 100644 examples/Collision/CollisionTutorialBullet2.cpp create mode 100644 examples/Collision/CollisionTutorialBullet2.h create mode 100644 examples/Collision/Internal/Bullet2CollisionSdk.cpp create mode 100644 examples/Collision/Internal/Bullet2CollisionSdk.h create mode 100644 examples/Collision/Internal/CollisionSdkInterface.h diff --git a/examples/Collision/CollisionSdkC_Api.cpp b/examples/Collision/CollisionSdkC_Api.cpp new file mode 100644 index 000000000..b061da845 --- /dev/null +++ b/examples/Collision/CollisionSdkC_Api.cpp @@ -0,0 +1,126 @@ +#include "CollisionSdkC_Api.h" +#include "Internal/CollisionSdkInterface.h" +#include "Internal/Bullet2CollisionSdk.h" + + /* Collision World */ + +plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + return sdk->createCollisionWorld(); +} + +void plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->deleteCollisionWorld(worldHandle); +} + +plCollisionSdkHandle plCreateBullet2CollisionSdk() +{ + return Bullet2CollisionSdk::createBullet2SdkHandle(); +} + +void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + delete sdk; +} + +plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plReal radius) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + return sdk->createSphereShape(radius); + +} + +void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shapeHandle) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->deleteShape(shapeHandle); +} + +plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle collisionSdkHandle, void* user_data, plCollisionShapeHandle cshape ) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + return sdk->createCollisionObject(user_data, cshape); + +} + +void plDeleteCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionObjectHandle body) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->deleteCollisionObject(body); +} + +void plAddCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->addCollisionObject(world,object); +} +void plRemoveCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->removeCollisionObject(world,object); +} + + +//plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk(); +//plCollisionSdkHandle plCreateCustomCollisionSdk(); + + +#if 0 + extern void plDeleteCollisionWorld(plCollisionWorldHandle world); + + + extern void plAddCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + extern void plRemoveCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + + + /* Collision Object */ + + extern plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle sdk, void* user_data, plCollisionShapeHandle cshape ); + extern void plDeleteCollisionObject(plCollisionSdkHandle sdk, plCollisionObjectHandle body); + + + /* Collision Shape definition */ + + extern plCollisionShapeHandle plNewSphereShape(plCollisionSdkHandle sdk, plReal radius); + extern plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk, plReal radius, plReal height); + extern plCollisionShapeHandle plNewPlaneShape(plCollisionSdkHandle sdk, plReal planeNormalX, + plReal planeNormalY, + plReal planeNormalZ, + plReal planeConstant); + extern plCollisionShapeHandle plNewCompoundShape(plCollisionSdkHandle sdk); + extern void plAddChildShape(plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn); + + extern void plDeleteShape(plCollisionShapeHandle shape); + + + + /* Contact Results */ + + struct lwContactPoint + { + plVector3 m_ptOnAWorld; + plVector3 m_ptOnBWorld; + plVector3 m_normalOnB; + plReal m_distance; + }; + + /* Collision Filtering */ + typedef void(*plNearCallback)(plCollisionSdkHandle sdk, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB); + + + /* Collision Queries */ + extern int plCollide(plCollisionSdkHandle sdk, plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity); + + extern void plWorldCollide(plCollisionWorldHandle world, + plNearCallback filter, void* userData); + + + + +#endif + diff --git a/examples/Collision/CollisionSdkC_Api.h b/examples/Collision/CollisionSdkC_Api.h new file mode 100644 index 000000000..86bfb518c --- /dev/null +++ b/examples/Collision/CollisionSdkC_Api.h @@ -0,0 +1,101 @@ +#ifndef LW_COLLISION_C_API_H +#define LW_COLLISION_C_API_H + + +#define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name + +#ifdef BT_USE_DOUBLE_PRECISION +typedef double plReal; +#else +typedef float plReal; +#endif + +typedef plReal plVector3[3]; +typedef plReal plQuaternion[4]; + +#ifdef __cplusplus +extern "C" { +#endif + + + + /** Particular collision SDK (C-API) */ + PL_DECLARE_HANDLE(plCollisionSdkHandle); + + /** Collision world, belonging to some collision SDK (C-API)*/ + PL_DECLARE_HANDLE(plCollisionWorldHandle); + + /** Collision object that can be part of a collision World (C-API)*/ + PL_DECLARE_HANDLE(plCollisionObjectHandle); + + /** Collision Shape/Geometry, property of a collision object (C-API)*/ + PL_DECLARE_HANDLE(plCollisionShapeHandle); + + /* Collision SDK */ + + extern plCollisionSdkHandle plCreateBullet2CollisionSdk(); +// extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk(); +// extern plCollisionSdkHandle plCreateCustomCollisionSdk(); + + extern void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle); + + /* Collision World */ + + extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle); + extern void plDeleteCollisionWorld(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world); + + + extern void plAddCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object); + extern void plRemoveCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object); + + + /* Collision Object */ + + extern plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle sdkHandle, void* user_data, plCollisionShapeHandle cshape ); + extern void plDeleteCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionObjectHandle body); + + + /* Collision Shape definition */ + + extern plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plReal radius); + extern plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk, plReal radius, plReal height); + extern plCollisionShapeHandle plNewPlaneShape(plCollisionSdkHandle sdk, plReal planeNormalX, + plReal planeNormalY, + plReal planeNormalZ, + plReal planeConstant); + extern plCollisionShapeHandle plNewCompoundShape(plCollisionSdkHandle sdk); + extern void plAddChildShape(plCollisionSdkHandle sdk, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn); + + extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shape); + + + + /* Contact Results */ + + struct lwContactPoint + { + plVector3 m_ptOnAWorld; + plVector3 m_ptOnBWorld; + plVector3 m_normalOnB; + plReal m_distance; + }; + + /* Collision Filtering */ + typedef void(*plNearCallback)(plCollisionSdkHandle sdk, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB); + + + /* Collision Queries */ + extern int plCollide(plCollisionSdkHandle sdk, plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity); + + extern void plWorldCollide(plCollisionWorldHandle world, + plNearCallback filter, void* userData); + + +#ifdef __cplusplus +} +#endif + + +#endif //LW_COLLISION_C_API_H + diff --git a/examples/Collision/CollisionTutorialBullet2.cpp b/examples/Collision/CollisionTutorialBullet2.cpp new file mode 100644 index 000000000..3d913b4e3 --- /dev/null +++ b/examples/Collision/CollisionTutorialBullet2.cpp @@ -0,0 +1,270 @@ + +#include "CollisionTutorialBullet2.h" +#include "../CommonInterfaces/CommonGraphicsAppInterface.h" +#include "../CommonInterfaces/CommonRenderInterface.h" + +#include "../CommonInterfaces/CommonExampleInterface.h" +#include "LinearMath/btTransform.h" + +#include "../CommonInterfaces/CommonGUIHelperInterface.h" +#include "../RenderingExamples/TimeSeriesCanvas.h" +#include "stb_image/stb_image.h" +#include "Bullet3Common/b3Quaternion.h" +#include "Bullet3Common/b3Matrix3x3.h" +#include "../CommonInterfaces/CommonParameterInterface.h" + +#include "LinearMath/btAlignedObjectArray.h" +#include "CollisionSdkC_Api.h" + + +class CollisionTutorialBullet2 : public CommonExampleInterface +{ + CommonGraphicsApp* m_app; + GUIHelperInterface* m_guiHelper; + int m_tutorialIndex; + + TimeSeriesCanvas* m_timeSeriesCanvas0; + + plCollisionSdkHandle m_collisionSdkHandle; + plCollisionWorldHandle m_collisionWorldHandle; + + int m_stage; + int m_counter; +public: + + CollisionTutorialBullet2(GUIHelperInterface* guiHelper, int tutorialIndex) + :m_app(guiHelper->getAppInterface()), + m_guiHelper(guiHelper), + m_tutorialIndex(tutorialIndex), + m_collisionSdkHandle(0), + m_stage(0), + m_counter(0), + m_timeSeriesCanvas0(0) + { + int numBodies = 1; + + m_app->setUpAxis(1); + m_app->m_renderer->enableBlend(true); + + switch (m_tutorialIndex) + { + case TUT_SPHERE_SPHERE: + { + numBodies=10; + m_collisionSdkHandle = plCreateBullet2CollisionSdk(); + if (m_collisionSdkHandle) + { + m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle); + //create objects, do query etc + float radius = 1.f; + plCollisionShapeHandle colShape = plCreateSphereShape(m_collisionSdkHandle, radius); + void* userData = 0; + plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle,userData,colShape); + plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObj); + plRemoveCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,colObj); + plDeleteCollisionObject(m_collisionSdkHandle,colObj); + plDeleteShape(m_collisionSdkHandle,colShape); + } + + /* + m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Constant Velocity"); + + m_timeSeriesCanvas0 ->setupTimeSeries(2,60, 0); + m_timeSeriesCanvas0->addDataSource("X position (m)", 255,0,0); + m_timeSeriesCanvas0->addDataSource("X velocity (m/s)", 0,0,255); + m_timeSeriesCanvas0->addDataSource("dX/dt (m/s)", 0,0,0); + */ + break; + } + case TUT_SPHERE_PLANE: + { + break; + } + default: + { + + m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Unknown"); + m_timeSeriesCanvas0 ->setupTimeSeries(1,60, 0); + + } + }; + + + + if (m_tutorialIndex==TUT_SPHERE_SPHERE) + { + + int boxId = m_app->registerCubeShape(100,1,100); + b3Vector3 pos = b3MakeVector3(0,-3.5,0); + b3Quaternion orn(0,0,0,1); + b3Vector4 color = b3MakeVector4(1,1,1,1); + b3Vector3 scaling = b3MakeVector3(1,1,1); + m_app->m_renderer->registerGraphicsInstance(boxId,pos,orn,color,scaling); + } + + + { + int textureIndex = -1; + + if (1) + { + int width,height,n; + + const char* filename = "data/cube.png"; + const unsigned char* image=0; + + const char* prefix[]={"./","../","../../","../../../","../../../../"}; + int numprefix = sizeof(prefix)/sizeof(const char*); + + for (int i=0;!image && im_renderer->registerTexture(image,width,height); + } + } + + // int boxId = m_app->registerCubeShape(1,1,1,textureIndex); + int boxId = m_app->registerGraphicsUnitSphereShape(SPHERE_LOD_HIGH);//, textureIndex); + b3Vector4 color = b3MakeVector4(0,1,0,0.8); + b3Vector3 scaling = b3MakeVector3(1,1,1); + float pos[3] = {1,0,0}; + float orn[4] = {0,0,0,1}; + int gfxIndex = m_app->m_renderer->registerGraphicsInstance(boxId,pos, orn,color,scaling); + + + // m_bodies[i]->m_graphicsIndex = m_app->m_renderer->registerGraphicsInstance(boxId,m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation,color,scaling); + + + //m_app->m_renderer->writeSingleInstanceTransformToCPU(m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation, m_bodies[i]->m_graphicsIndex); + + } + + m_app->m_renderer->writeTransforms(); + } + virtual ~CollisionTutorialBullet2() + { + delete m_timeSeriesCanvas0; + + plDeleteCollisionWorld(m_collisionSdkHandle,m_collisionWorldHandle); + + plDeleteCollisionSdk(m_collisionSdkHandle); + + m_timeSeriesCanvas0 = 0; + + m_app->m_renderer->enableBlend(false); + } + + + virtual void initPhysics() + { + } + virtual void exitPhysics() + { + + } + + + virtual void stepSimulation(float deltaTime) + { + switch (m_tutorialIndex) + { + case TUT_SPHERE_SPHERE: + { + if (m_timeSeriesCanvas0) + { + float xPos = 0.f; + float xVel = 1.f; + m_timeSeriesCanvas0->insertDataAtCurrentTime(xPos,0,true); + m_timeSeriesCanvas0->insertDataAtCurrentTime(xVel,1,true); + } + break; + } + + + default: + { + } + + }; + + + if (m_timeSeriesCanvas0) + m_timeSeriesCanvas0->nextTick(); + + + + // m_app->m_renderer->writeSingleInstanceTransformToCPU(m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation, m_bodies[i]->m_graphicsIndex); + + + m_app->m_renderer->writeTransforms(); + } + virtual void renderScene() + { + m_app->m_renderer->renderScene(); + m_app->drawText3D("X",1,0,0,1); + m_app->drawText3D("Y",0,1,0,1); + m_app->drawText3D("Z",0,0,1,1); + + /*for (int i=0;im_renderer->drawLine(contact.m_ptOnAWorld,contact.m_ptOnBWorld,color,lineWidth); + } + */ + } + + + + 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 = 10.5; + float pitch = 136; + float yaw = 32; + 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]); + } + } +}; + +class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options) +{ + return new CollisionTutorialBullet2(options.m_guiHelper, options.m_option); +} + diff --git a/examples/Collision/CollisionTutorialBullet2.h b/examples/Collision/CollisionTutorialBullet2.h new file mode 100644 index 000000000..ee1650172 --- /dev/null +++ b/examples/Collision/CollisionTutorialBullet2.h @@ -0,0 +1,12 @@ +#ifndef COLLISION_TUTORIAL_H +#define COLLISION_TUTORIAL_H + +enum EnumCollisionTutorialTypes +{ + TUT_SPHERE_SPHERE=0, + TUT_SPHERE_PLANE, +}; + +class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options); + +#endif //COLLISION_TUTORIAL_H diff --git a/examples/Collision/Internal/Bullet2CollisionSdk.cpp b/examples/Collision/Internal/Bullet2CollisionSdk.cpp new file mode 100644 index 000000000..06b3a9b2b --- /dev/null +++ b/examples/Collision/Internal/Bullet2CollisionSdk.cpp @@ -0,0 +1,118 @@ +#include "Bullet2CollisionSdk.h" +#include "btBulletCollisionCommon.h" + +struct Bullet2CollisionSdkInternalData +{ + btCollisionConfiguration* m_collisionConfig; + btCollisionDispatcher* m_dispatcher; + btBroadphaseInterface* m_aabbBroadphase; + + btCollisionWorld* m_collisionWorld; + + Bullet2CollisionSdkInternalData() + :m_aabbBroadphase(0), + m_dispatcher(0), + m_collisionWorld(0) + { + } +}; + + +Bullet2CollisionSdk::Bullet2CollisionSdk() +{ + m_internalData = new Bullet2CollisionSdkInternalData; +} + +Bullet2CollisionSdk::~Bullet2CollisionSdk() +{ + delete m_internalData; + m_internalData = 0; +} + +plCollisionWorldHandle Bullet2CollisionSdk::createCollisionWorld() +{ + m_internalData->m_collisionConfig = new btDefaultCollisionConfiguration; + m_internalData->m_dispatcher = new btCollisionDispatcher(m_internalData->m_collisionConfig); + m_internalData->m_aabbBroadphase = new btDbvtBroadphase(); + m_internalData->m_collisionWorld = new btCollisionWorld(m_internalData->m_dispatcher, + m_internalData->m_aabbBroadphase, + m_internalData->m_collisionConfig); + return (plCollisionWorldHandle) m_internalData->m_collisionWorld; +} + +void Bullet2CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandle) +{ + btCollisionWorld* world = (btCollisionWorld*) worldHandle; + btAssert(m_internalData->m_collisionWorld == world); + + if (m_internalData->m_collisionWorld == world) + { + delete m_internalData->m_collisionWorld; + m_internalData->m_collisionWorld=0; + delete m_internalData->m_aabbBroadphase; + m_internalData->m_aabbBroadphase=0; + delete m_internalData->m_dispatcher; + m_internalData->m_dispatcher=0; + delete m_internalData->m_collisionConfig; + m_internalData->m_collisionConfig=0; + } +} + +plCollisionShapeHandle Bullet2CollisionSdk::createSphereShape(plReal radius) +{ + btSphereShape* sphereShape = new btSphereShape(radius); + return (plCollisionShapeHandle) sphereShape; +} + +void Bullet2CollisionSdk::deleteShape(plCollisionShapeHandle shapeHandle) +{ + btCollisionShape* shape = (btCollisionShape*) shapeHandle; + delete shape; +} + +void Bullet2CollisionSdk::addCollisionObject(plCollisionWorldHandle worldHandle, plCollisionObjectHandle objectHandle) +{ + btCollisionWorld* world = (btCollisionWorld*) worldHandle; + btCollisionObject* colObj = (btCollisionObject*) objectHandle; + btAssert(world && colObj); + if (world == m_internalData->m_collisionWorld && colObj) + { + world->addCollisionObject(colObj); + } +} +void Bullet2CollisionSdk::removeCollisionObject(plCollisionWorldHandle worldHandle, plCollisionObjectHandle objectHandle) +{ + btCollisionWorld* world = (btCollisionWorld*) worldHandle; + btCollisionObject* colObj = (btCollisionObject*) objectHandle; + btAssert(world && colObj); + if (world == m_internalData->m_collisionWorld && colObj) + { + world->removeCollisionObject(colObj); + } +} + +plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject( void* user_data, plCollisionShapeHandle shapeHandle ) +{ + btCollisionShape* colShape = (btCollisionShape*) shapeHandle; + btAssert(colShape); + if (colShape) + { + btCollisionObject* colObj= new btCollisionObject; + colObj->setCollisionShape(colShape); + colObj->setWorldTransform(btTransform::getIdentity()); + return (plCollisionObjectHandle) colObj; + } + return 0; +} + +void Bullet2CollisionSdk::deleteCollisionObject(plCollisionObjectHandle bodyHandle) +{ + btCollisionObject* colObj = (btCollisionObject*) bodyHandle; + delete colObj; +} + + +plCollisionSdkHandle Bullet2CollisionSdk::createBullet2SdkHandle() +{ + return (plCollisionSdkHandle) new Bullet2CollisionSdk; +} diff --git a/examples/Collision/Internal/Bullet2CollisionSdk.h b/examples/Collision/Internal/Bullet2CollisionSdk.h new file mode 100644 index 000000000..422c3622f --- /dev/null +++ b/examples/Collision/Internal/Bullet2CollisionSdk.h @@ -0,0 +1,34 @@ +#ifndef BULLET2_COLLISION_SDK_H +#define BULLET2_COLLISION_SDK_H + +#include "CollisionSdkInterface.h" + +class Bullet2CollisionSdk : public CollisionSdkInterface +{ + struct Bullet2CollisionSdkInternalData* m_internalData; + +public: + + Bullet2CollisionSdk(); + + virtual ~Bullet2CollisionSdk(); + + virtual plCollisionWorldHandle createCollisionWorld(); + + virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle); + + virtual plCollisionShapeHandle createSphereShape(plReal radius); + + virtual void deleteShape(plCollisionShapeHandle shape); + + virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + + virtual plCollisionObjectHandle createCollisionObject( void* user_data, plCollisionShapeHandle cshape ); + virtual void deleteCollisionObject(plCollisionObjectHandle body); + + + static plCollisionSdkHandle createBullet2SdkHandle(); +}; + +#endif //BULLET2_COLLISION_SDK_H diff --git a/examples/Collision/Internal/CollisionSdkInterface.h b/examples/Collision/Internal/CollisionSdkInterface.h new file mode 100644 index 000000000..b4cf425bf --- /dev/null +++ b/examples/Collision/Internal/CollisionSdkInterface.h @@ -0,0 +1,32 @@ +#ifndef COLLISION_SDK_INTERFACE_H +#define COLLISION_SDK_INTERFACE_H + +#include "../CollisionSdkC_Api.h" + +class CollisionSdkInterface +{ +public: + + virtual ~CollisionSdkInterface() + { + } + + virtual plCollisionWorldHandle createCollisionWorld() = 0; + + virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle) = 0; + + virtual plCollisionShapeHandle createSphereShape(plReal radius) = 0; + + virtual void deleteShape(plCollisionShapeHandle shape) = 0; + + virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object)=0; + virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object)=0; + + virtual plCollisionObjectHandle createCollisionObject( void* user_data, plCollisionShapeHandle cshape )=0; + virtual void deleteCollisionObject(plCollisionObjectHandle body)=0; + + +}; + +#endif //COLLISION_SDK_INTERFACE_H + diff --git a/examples/ExampleBrowser/CMakeLists.txt b/examples/ExampleBrowser/CMakeLists.txt index 3d40b8c81..df611f4b0 100644 --- a/examples/ExampleBrowser/CMakeLists.txt +++ b/examples/ExampleBrowser/CMakeLists.txt @@ -31,6 +31,13 @@ SET(App_ExampleBrowser_SRCS ../Tutorial/Tutorial.h ../Tutorial/Dof6ConstraintTutorial.cpp ../Tutorial/Dof6ConstraintTutorial.h + ../Collision/CollisionSdkC_Api.cpp + ../Collision/CollisionSdkC_Api.h + ../Collision/CollisionTutorialBullet2.cpp + ../Collision/CollisionTutorialBullet2.h + ../Collision/Internal/Bullet2CollisionSdk.cpp + ../Collision/Internal/Bullet2CollisionSdk.h + ../Collision/Internal/CollisionSdkInterface.h ../GyroscopicDemo/GyroscopicSetup.cpp ../GyroscopicDemo/GyroscopicSetup.h ../Planar2D/Planar2D.cpp diff --git a/examples/ExampleBrowser/ExampleEntries.cpp b/examples/ExampleBrowser/ExampleEntries.cpp index 28cf7c0a8..4f0f2d455 100644 --- a/examples/ExampleBrowser/ExampleEntries.cpp +++ b/examples/ExampleBrowser/ExampleEntries.cpp @@ -16,7 +16,7 @@ #include "../Importers/ImportColladaDemo/ImportColladaSetup.h" #include "../Importers/ImportSTLDemo/ImportSTLSetup.h" #include "../Importers/ImportURDFDemo/ImportURDFSetup.h" - +#include "../Collision/CollisionTutorialBullet2.h" #include "../GyroscopicDemo/GyroscopicSetup.h" #include "../Constraints/Dof6Spring2Setup.h" #include "../Constraints/ConstraintPhysicsSetup.h" @@ -114,11 +114,14 @@ static ExampleEntry gDefaultExamples[]= ExampleEntry(1,"Gravity Acceleration","Motion of a free falling rigid body under constant gravitational acceleration", TutorialCreateFunc,TUT_ACCELERATION), ExampleEntry(1,"Contact Computation","Discrete Collision Detection for sphere-sphere", TutorialCreateFunc,TUT_COLLISION), ExampleEntry(1,"Solve Contact Constraint","Compute and apply the impulses needed to satisfy non-penetrating contact constraints", TutorialCreateFunc,TUT_SOLVE_CONTACT_CONSTRAINT), - - - ExampleEntry(1,"Spring constraint","A rigid body with a spring constraint attached", Dof6ConstraintTutorialCreateFunc,0), + ExampleEntry(0,"Collision"), + ExampleEntry(1, "Sphere-Sphere C-API", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_SPHERE), + ExampleEntry(1, "Sphere-Plane C-API", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE), + + + #ifdef INCLUDE_CLOTH_DEMOS ExampleEntry(0,"Soft Body"), ExampleEntry(1,"Cloth","Simulate a patch of cloth.", SoftDemoCreateFunc,0), diff --git a/examples/ExampleBrowser/premake4.lua b/examples/ExampleBrowser/premake4.lua index 439b64670..d1503e05f 100644 --- a/examples/ExampleBrowser/premake4.lua +++ b/examples/ExampleBrowser/premake4.lua @@ -67,6 +67,8 @@ "../MultiThreading/b3ThreadSupportInterface.cpp", "../BasicDemo/BasicExample.*", "../Tutorial/*", + "../Collision/*", + "../Collision/Internal/*", "../Benchmarks/*", "../CommonInterfaces/*", "../ForkLift/ForkLiftDemo.*",