diff --git a/examples/Collision/CollisionSdkC_Api.cpp b/examples/Collision/CollisionSdkC_Api.cpp index b061da845..81e6fde0e 100644 --- a/examples/Collision/CollisionSdkC_Api.cpp +++ b/examples/Collision/CollisionSdkC_Api.cpp @@ -1,24 +1,41 @@ #include "CollisionSdkC_Api.h" #include "Internal/CollisionSdkInterface.h" #include "Internal/Bullet2CollisionSdk.h" +#include "Internal/RealTimeBullet3CollisionSdk.h" /* Collision World */ -plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle) +plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; - return sdk->createCollisionWorld(); + return sdk->createCollisionWorld( maxNumObjsCapacity, maxNumShapesCapacity, maxNumPairsCapacity); } void plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; - sdk->deleteCollisionWorld(worldHandle); + if (sdk && worldHandle) + { + sdk->deleteCollisionWorld(worldHandle); + } } plCollisionSdkHandle plCreateBullet2CollisionSdk() { +#ifndef DISABLE_BULLET2_COLLISION_SDK return Bullet2CollisionSdk::createBullet2SdkHandle(); +#else + return 0; +#endif //DISABLE_BULLET2_COLLISION_SDK +} + +plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk() +{ +#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK + return RealTimeBullet3CollisionSdk::createRealTimeBullet3CollisionSdkHandle(); +#else + return 0; +#endif } void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle) @@ -27,32 +44,38 @@ void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle) delete sdk; } -plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plReal radius) +plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plReal radius) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; - return sdk->createSphereShape(radius); + return sdk->createSphereShape(worldHandle,radius); } -void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shapeHandle) +void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shapeHandle) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; - sdk->deleteShape(shapeHandle); + sdk->deleteShape(worldHandle,shapeHandle); } -plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle collisionSdkHandle, void* user_data, plCollisionShapeHandle cshape ) +plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, void* userData, int userIndex, plCollisionShapeHandle cshape ,plVector3 childPos,plQuaternion childOrn) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; - return sdk->createCollisionObject(user_data, cshape); + return sdk->createCollisionObject(worldHandle, userData, userIndex, cshape, childPos, childOrn); } -void plDeleteCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionObjectHandle body) +void plDeleteCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle body) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; sdk->deleteCollisionObject(body); } +void plSetCollisionObjectTransform( plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle objHandle, plVector3 position,plQuaternion orientation) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->setCollisionObjectTransform(worldHandle,objHandle,position,orientation); +} + void plAddCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object) { CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; @@ -64,63 +87,17 @@ void plRemoveCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisio sdk->removeCollisionObject(world,object); } +/* Collision Queries */ +int plCollide(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + return sdk->collide(worldHandle, colA,colB,pointsOut,pointCapacity); +} -//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 - +void plWorldCollide(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, + plNearCallback filter, void* userData) +{ + CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle; + sdk->collideWorld(world,filter,userData); +} diff --git a/examples/Collision/CollisionSdkC_Api.h b/examples/Collision/CollisionSdkC_Api.h index 86bfb518c..dba4c146e 100644 --- a/examples/Collision/CollisionSdkC_Api.h +++ b/examples/Collision/CollisionSdkC_Api.h @@ -4,6 +4,7 @@ #define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name + #ifdef BT_USE_DOUBLE_PRECISION typedef double plReal; #else @@ -34,14 +35,18 @@ extern "C" { /* Collision SDK */ extern plCollisionSdkHandle plCreateBullet2CollisionSdk(); -// extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk(); + + extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk(); // extern plCollisionSdkHandle plCreateCustomCollisionSdk(); extern void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle); - + + //extern int plGetSdkWorldCreationIntParameter(); + //extern int plSetSdkWorldCreationIntParameter(int newValue); + /* Collision World */ - extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle); + extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity); extern void plDeleteCollisionWorld(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world); @@ -51,22 +56,23 @@ extern "C" { /* Collision Object */ - extern plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle sdkHandle, void* user_data, plCollisionShapeHandle cshape ); - extern void plDeleteCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionObjectHandle body); - + extern plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape , plVector3 startPosition,plQuaternion startOrientation); + extern void plDeleteCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle body); + extern void plSetCollisionObjectTransform( plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle objHandle, plVector3 startPosition,plQuaternion startOrientation); /* 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 plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius); + extern plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius, plReal height); + extern plCollisionShapeHandle plNewPlaneShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, + plReal planeNormalX, + plReal planeNormalY, + plReal planeNormalZ, + plReal planeConstant); + extern plCollisionShapeHandle plNewCompoundShape(plCollisionSdkHandle sdk,plCollisionWorldHandle worldHandle); + extern void plAddChildShape(plCollisionSdkHandle sdk, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn); - extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shape); + extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape); @@ -81,14 +87,15 @@ extern "C" { }; /* Collision Filtering */ - typedef void(*plNearCallback)(plCollisionSdkHandle sdk, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB); + typedef void(*plNearCallback)(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userData, + plCollisionObjectHandle objA, plCollisionObjectHandle objB); /* Collision Queries */ - extern int plCollide(plCollisionSdkHandle sdk, plCollisionObjectHandle colA, plCollisionObjectHandle colB, + extern int plCollide(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle colA, plCollisionObjectHandle colB, lwContactPoint* pointsOut, int pointCapacity); - extern void plWorldCollide(plCollisionWorldHandle world, + extern void plWorldCollide(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world, plNearCallback filter, void* userData); diff --git a/examples/Collision/CollisionTutorialBullet2.cpp b/examples/Collision/CollisionTutorialBullet2.cpp index 3d913b4e3..f32968cf8 100644 --- a/examples/Collision/CollisionTutorialBullet2.cpp +++ b/examples/Collision/CollisionTutorialBullet2.cpp @@ -17,6 +17,28 @@ #include "CollisionSdkC_Api.h" +///Not Invented Here link reminder http://www.joelonsoftware.com/articles/fog0000000007.html + +///todo: use the 'userData' to prevent this use of global variables +static int gTotalPoints = 0; +lwContactPoint pointsOut[10]; +int pointCapacity=2; + + +void myNearCallback(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB) +{ + int remainingCapacity = pointCapacity-gTotalPoints; + btAssert(remainingCapacity>=0); + + if (remainingCapacity>0) + { + lwContactPoint* pointPtr = &pointsOut[gTotalPoints]; + int numNewPoints = plCollide(sdkHandle, worldHandle, objA,objB,pointPtr,remainingCapacity); + btAssert(numNewPoints <= remainingCapacity); + gTotalPoints+=numNewPoints; + } +} + class CollisionTutorialBullet2 : public CommonExampleInterface { CommonGraphicsApp* m_app; @@ -37,6 +59,7 @@ public: m_guiHelper(guiHelper), m_tutorialIndex(tutorialIndex), m_collisionSdkHandle(0), + m_collisionWorldHandle(0), m_stage(0), m_counter(0), m_timeSeriesCanvas0(0) @@ -51,19 +74,47 @@ public: case TUT_SPHERE_SPHERE: { numBodies=10; - m_collisionSdkHandle = plCreateBullet2CollisionSdk(); + //m_collisionSdkHandle = plCreateBullet2CollisionSdk(); + m_collisionSdkHandle = plCreateRealTimeBullet3CollisionSdk(); if (m_collisionSdkHandle) { - m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle); + int maxNumObjsCapacity=32; + int maxNumShapesCapacity=1024; + int maxNumPairsCapacity=16384; + + m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle,maxNumObjsCapacity,maxNumShapesCapacity,maxNumPairsCapacity); //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); + plCollisionShapeHandle colShape = plCreateSphereShape(m_collisionSdkHandle, m_collisionWorldHandle,radius); + void* userPointer = 0; + btAlignedObjectArray colliders; + int sphereGfxShapeId = m_app->registerGraphicsUnitSphereShape(SPHERE_LOD_HIGH);//, textureIndex); + + for (int i=0;i<3;i++) + { + btVector3 pos(0,btScalar(i*1.5),0); + btQuaternion orn(0,0,0,1); + + btVector4 color(0,1,0,0.8); + btVector3 scaling(radius,radius,radius); + + int gfxIndex = m_app->m_renderer->registerGraphicsInstance(sphereGfxShapeId,pos, orn,color,scaling); + + plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,userPointer, gfxIndex,colShape,pos,orn); + colliders.push_back(colObj); + plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObj); + } + + int numContacts = plCollide(m_collisionSdkHandle,m_collisionWorldHandle,colliders[0],colliders[1],pointsOut,pointCapacity); + printf("numContacts = %d\n", numContacts); + void* myUserPtr = 0; + gTotalPoints = 0; + plWorldCollide(m_collisionSdkHandle,m_collisionWorldHandle,myNearCallback, myUserPtr); + printf("total points=%d\n",gTotalPoints); + + //plRemoveCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,colObj); + //plDeleteCollisionObject(m_collisionSdkHandle,colObj); + //plDeleteShape(m_collisionSdkHandle,colShape); } /* @@ -130,20 +181,6 @@ public: } } - // 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(); @@ -207,23 +244,30 @@ public: } 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) { - const LWContactPoint& contact = m_contactPoints[i]; - b3Vector3 color=b3MakeVector3(1,1,0); - float lineWidth=3; - if (contact.m_distance<0) + m_app->m_renderer->renderScene(); + + m_app->m_renderer->clearZBuffer(); + + 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); } - m_app->m_renderer->drawLine(contact.m_ptOnAWorld,contact.m_ptOnBWorld,color,lineWidth); } - */ + } diff --git a/examples/Collision/Internal/Bullet2CollisionSdk.cpp b/examples/Collision/Internal/Bullet2CollisionSdk.cpp index 06b3a9b2b..27d0da9bd 100644 --- a/examples/Collision/Internal/Bullet2CollisionSdk.cpp +++ b/examples/Collision/Internal/Bullet2CollisionSdk.cpp @@ -29,9 +29,10 @@ Bullet2CollisionSdk::~Bullet2CollisionSdk() m_internalData = 0; } -plCollisionWorldHandle Bullet2CollisionSdk::createCollisionWorld() +plCollisionWorldHandle Bullet2CollisionSdk::createCollisionWorld(int /*maxNumObjsCapacity*/, int /*maxNumShapesCapacity*/, int /*maxNumPairsCapacity*/) { 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, @@ -58,13 +59,13 @@ void Bullet2CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandl } } -plCollisionShapeHandle Bullet2CollisionSdk::createSphereShape(plReal radius) +plCollisionShapeHandle Bullet2CollisionSdk::createSphereShape(plCollisionWorldHandle /*worldHandle*/, plReal radius) { btSphereShape* sphereShape = new btSphereShape(radius); return (plCollisionShapeHandle) sphereShape; } -void Bullet2CollisionSdk::deleteShape(plCollisionShapeHandle shapeHandle) +void Bullet2CollisionSdk::deleteShape(plCollisionWorldHandle /*worldHandle*/, plCollisionShapeHandle shapeHandle) { btCollisionShape* shape = (btCollisionShape*) shapeHandle; delete shape; @@ -91,15 +92,22 @@ void Bullet2CollisionSdk::removeCollisionObject(plCollisionWorldHandle worldHand } } -plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject( void* user_data, plCollisionShapeHandle shapeHandle ) +plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle shapeHandle , + plVector3 startPosition,plQuaternion startOrientation ) + { btCollisionShape* colShape = (btCollisionShape*) shapeHandle; btAssert(colShape); if (colShape) { btCollisionObject* colObj= new btCollisionObject; + colObj->setUserIndex(userIndex); + colObj->setUserPointer(userPointer); colObj->setCollisionShape(colShape); - colObj->setWorldTransform(btTransform::getIdentity()); + btTransform tr; + tr.setOrigin(btVector3(startPosition[0],startPosition[1],startPosition[2])); + tr.setRotation(btQuaternion(startOrientation[0],startOrientation[1],startOrientation[2],startOrientation[3])); + colObj->setWorldTransform(tr); return (plCollisionObjectHandle) colObj; } return 0; @@ -110,8 +118,102 @@ void Bullet2CollisionSdk::deleteCollisionObject(plCollisionObjectHandle bodyHand btCollisionObject* colObj = (btCollisionObject*) bodyHandle; delete colObj; } +void Bullet2CollisionSdk::setCollisionObjectTransform(plCollisionWorldHandle /*worldHandle*/, plCollisionObjectHandle bodyHandle, + plVector3 position,plQuaternion orientation ) +{ + btCollisionObject* colObj = (btCollisionObject*) bodyHandle; + btTransform tr; + tr.setOrigin(btVector3(position[0],position[1],position[2])); + tr.setRotation(btQuaternion(orientation[0],orientation[1],orientation[2],orientation[3])); + colObj->setWorldTransform(tr); +} +struct Bullet2ContactResultCallback : public btCollisionWorld::ContactResultCallback +{ + int m_numContacts; + lwContactPoint* m_pointsOut; + int m_pointCapacity; + + Bullet2ContactResultCallback(lwContactPoint* pointsOut, int pointCapacity) : + m_numContacts(0), + m_pointsOut(pointsOut), + m_pointCapacity(pointCapacity) + { + } + virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) + { + if (m_numContactsm_collisionWorld && colObjA && colObjB) + { + Bullet2ContactResultCallback cb(pointsOut,pointCapacity); + world->contactPairTest(colObjA,colObjB,cb); + return cb.m_numContacts; + } + return 0; +} + +static plNearCallback gTmpFilter; +static int gNearCallbackCount = 0; +static plCollisionSdkHandle gCollisionSdk = 0; +static plCollisionWorldHandle gCollisionWorldHandle = 0; + +static void* gUserData = 0; + +void Bullet2NearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo) +{ + btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject; + btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject; + plCollisionObjectHandle obA =(plCollisionObjectHandle) colObj0; + plCollisionObjectHandle obB =(plCollisionObjectHandle) colObj1; + if(gTmpFilter) + { + gTmpFilter(gCollisionSdk,gCollisionWorldHandle, gUserData,obA,obB); + gNearCallbackCount++; + } +} + +void Bullet2CollisionSdk::collideWorld( plCollisionWorldHandle worldHandle, + plNearCallback filter, void* userData) +{ + btCollisionWorld* world = (btCollisionWorld*) worldHandle; + //chain the near-callback + gTmpFilter = filter; + gNearCallbackCount = 0; + gUserData = userData; + gCollisionSdk = (plCollisionSdkHandle)this; + gCollisionWorldHandle = worldHandle; + m_internalData->m_dispatcher->setNearCallback(Bullet2NearCallback); + world->performDiscreteCollisionDetection(); + gTmpFilter = 0; +} + plCollisionSdkHandle Bullet2CollisionSdk::createBullet2SdkHandle() { return (plCollisionSdkHandle) new Bullet2CollisionSdk; diff --git a/examples/Collision/Internal/Bullet2CollisionSdk.h b/examples/Collision/Internal/Bullet2CollisionSdk.h index 422c3622f..38418b54b 100644 --- a/examples/Collision/Internal/Bullet2CollisionSdk.h +++ b/examples/Collision/Internal/Bullet2CollisionSdk.h @@ -13,21 +13,29 @@ public: virtual ~Bullet2CollisionSdk(); - virtual plCollisionWorldHandle createCollisionWorld(); + virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity); virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle); - virtual plCollisionShapeHandle createSphereShape(plReal radius); + virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius); - virtual void deleteShape(plCollisionShapeHandle shape); + virtual void deleteShape(plCollisionWorldHandle worldHandle, 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); + virtual plCollisionObjectHandle createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape , + plVector3 startPosition,plQuaternion startOrientation ); + virtual void deleteCollisionObject(plCollisionObjectHandle body); + virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body, + plVector3 position,plQuaternion orientation ); + virtual int collide(plCollisionWorldHandle world,plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity); + virtual void collideWorld( plCollisionWorldHandle world, + plNearCallback filter, void* userData); + static plCollisionSdkHandle createBullet2SdkHandle(); }; diff --git a/examples/Collision/Internal/CollisionSdkInterface.h b/examples/Collision/Internal/CollisionSdkInterface.h index b4cf425bf..25f844ef5 100644 --- a/examples/Collision/Internal/CollisionSdkInterface.h +++ b/examples/Collision/Internal/CollisionSdkInterface.h @@ -11,19 +11,28 @@ public: { } - virtual plCollisionWorldHandle createCollisionWorld() = 0; + virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity) = 0; virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle) = 0; - virtual plCollisionShapeHandle createSphereShape(plReal radius) = 0; + virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius) = 0; - virtual void deleteShape(plCollisionShapeHandle shape) = 0; + virtual void deleteShape(plCollisionWorldHandle worldHandle, 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 plCollisionObjectHandle createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape , + plVector3 startPosition,plQuaternion startOrientation )=0; virtual void deleteCollisionObject(plCollisionObjectHandle body)=0; + virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body, + plVector3 position,plQuaternion orientation )=0; + + virtual int collide(plCollisionWorldHandle world,plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity)=0; + + virtual void collideWorld( plCollisionWorldHandle world, + plNearCallback filter, void* userData)=0; }; diff --git a/examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp b/examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp new file mode 100644 index 000000000..248f2ab9c --- /dev/null +++ b/examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp @@ -0,0 +1,378 @@ +#define BLAAT +#include "RealTimeBullet3CollisionSdk.h" +#include "Bullet3Common/b3AlignedObjectArray.h" +#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" +#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" + +//convert the opaque pointer to int +struct RTB3_ColliderOpaque2Int +{ + union + { + plCollisionObjectHandle m_ptrValue; + int m_intValue; + }; +}; +struct RTB3_ShapeOpaque2Int +{ + union + { + plCollisionShapeHandle m_ptrValue; + int m_intValue; + }; +}; + +enum RTB3ShapeTypes +{ + RTB3_SHAPE_SPHERE=0, + RTB3_SHAPE_PLANE, +// RTB3_SHAPE_CAPSULE, + MAX_NUM_SINGLE_SHAPE_TYPES, + RTB3_SHAPE_COMPOUND_INTERNAL + + +}; + +//we start at 1, so that the 0 index is 'invalid' just like a nullptr +#define START_COLLIDABLE_INDEX 1 + +struct RTB3CollisionWorld +{ + b3AlignedObjectArray m_collidableUserPointers; + b3AlignedObjectArray m_collidableUserIndices; + b3AlignedObjectArray m_collidablePositions; + b3AlignedObjectArray m_collidableOrientations; + b3AlignedObjectArray m_collidables; + b3AlignedObjectArray m_childShapes; + b3AlignedObjectArray m_planeFaces; + b3AlignedObjectArray m_compoundOverlappingPairs; + int m_nextFreeShapeIndex; + int m_nextFreeCollidableIndex; + + RTB3CollisionWorld() + :m_nextFreeCollidableIndex(START_COLLIDABLE_INDEX), + m_nextFreeShapeIndex(START_COLLIDABLE_INDEX) + { + } +}; + +struct RealTimeBullet3CollisionSdkInternalData +{ + b3AlignedObjectArray m_collisionWorlds; +}; + +RealTimeBullet3CollisionSdk::RealTimeBullet3CollisionSdk() +{ +// int szCol = sizeof(b3Collidable); +// int szShap = sizeof(b3GpuChildShape); +// int szComPair = sizeof(b3CompoundOverlappingPair); + m_internalData = new RealTimeBullet3CollisionSdkInternalData; +} + +RealTimeBullet3CollisionSdk::~RealTimeBullet3CollisionSdk() +{ + delete m_internalData; + m_internalData=0; +} + +plCollisionWorldHandle RealTimeBullet3CollisionSdk::createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity) +{ + RTB3CollisionWorld* world = new RTB3CollisionWorld(); + world->m_collidables.resize(maxNumObjsCapacity); + world->m_collidablePositions.resize(maxNumObjsCapacity); + world->m_collidableOrientations.resize(maxNumObjsCapacity); + world->m_collidableUserPointers.resize(maxNumObjsCapacity); + world->m_collidableUserIndices.resize(maxNumObjsCapacity); + world->m_childShapes.resize(maxNumShapesCapacity); + world->m_compoundOverlappingPairs.resize(maxNumPairsCapacity); + + m_internalData->m_collisionWorlds.push_back(world); + return (plCollisionWorldHandle) world; +} + +void RealTimeBullet3CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandle) +{ + RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle; + int loc = m_internalData->m_collisionWorlds.findLinearSearch(world); + b3Assert(loc >=0 && locm_collisionWorlds.size()); + if (loc >=0 && locm_collisionWorlds.size()) + { + m_internalData->m_collisionWorlds.remove(world); + delete world; + } +} + +plCollisionShapeHandle RealTimeBullet3CollisionSdk::createSphereShape(plCollisionWorldHandle worldHandle, plReal radius) +{ + RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle; + if (world->m_nextFreeShapeIndexm_childShapes.size()) + { + b3GpuChildShape& shape = world->m_childShapes[world->m_nextFreeShapeIndex]; + shape.m_childPosition.setZero(); + shape.m_childOrientation.setValue(0,0,0,1); + shape.m_radius = radius; + shape.m_shapeType = RTB3_SHAPE_SPHERE; + return (plCollisionShapeHandle) world->m_nextFreeShapeIndex++; + } + return 0; +} + +void RealTimeBullet3CollisionSdk::deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape) +{ + ///todo + //deleting shapes would involve a garbage collection phase, and mess up all user indices + //this would be solved by one more in-direction, at some performance penalty for certain operations + //for now, we don't delete and eventually run out-of-shapes +} + +void RealTimeBullet3CollisionSdk::addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) +{ + ///createCollisionObject already adds it to the world +} + +void RealTimeBullet3CollisionSdk::removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) +{ + ///todo, see deleteShape +} + +plCollisionObjectHandle RealTimeBullet3CollisionSdk::createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, + int userIndex, plCollisionShapeHandle shapeHandle , + plVector3 startPosition,plQuaternion startOrientation ) +{ + RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle; + if (world->m_nextFreeCollidableIndex < world->m_collidables.size()) + { + b3Collidable& collidable = world->m_collidables[world->m_nextFreeCollidableIndex]; + world->m_collidablePositions[world->m_nextFreeCollidableIndex].setValue(startPosition[0],startPosition[1],startPosition[2]); + world->m_collidableOrientations[world->m_nextFreeCollidableIndex].setValue(startOrientation[0],startOrientation[1],startOrientation[2],startOrientation[3]); + world->m_collidableUserPointers[world->m_nextFreeCollidableIndex] = userPointer; + world->m_collidableUserIndices[world->m_nextFreeCollidableIndex] = userIndex; + RTB3_ShapeOpaque2Int caster; + caster.m_ptrValue = shapeHandle; + int shapeIndex = caster.m_intValue; + collidable.m_shapeIndex = shapeIndex; + b3GpuChildShape& shape = world->m_childShapes[shapeIndex]; + collidable.m_shapeType = shape.m_shapeType; + collidable.m_numChildShapes = 1; + + switch (collidable.m_shapeType) + { + case RTB3_SHAPE_SPHERE: + { + break; + } + case RTB3_SHAPE_PLANE: + { + b3Assert(0); + break; + } + case RTB3_SHAPE_COMPOUND_INTERNAL: + { + b3Assert(0); + break; + } + default: + { + b3Assert(0); + } + } + + /*case SHAPE_COMPOUND_OF_CONVEX_HULLS: + case SHAPE_COMPOUND_OF_SPHERES: + case SHAPE_COMPOUND_OF_CAPSULES: + { + collidable.m_numChildShapes = shape.m_numChildShapes; + collidable.m_shapeIndex = shape.m_shapeIndex; + break; + */ + return (plCollisionObjectHandle)world->m_nextFreeCollidableIndex++; + } + return 0; +} + +void RealTimeBullet3CollisionSdk::deleteCollisionObject(plCollisionObjectHandle body) +{ + ///todo, see deleteShape +} + +void RealTimeBullet3CollisionSdk::setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body, + plVector3 position,plQuaternion orientation ) +{ +} + +struct plContactCache +{ + lwContactPoint* pointsOut; + int pointCapacity; + int numAddedPoints; +}; + +typedef void (*plDetectCollisionFunc)(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB, + plContactCache* contactCache); + +void detectCollisionDummy(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB, + plContactCache* contactCache) +{ + (void)world; + (void)colA,(void)colB; + (void)contactCache; +} + +void plVecCopy(float* dst,const b3Vector3& src) +{ + dst[0] = src.x; + dst[1] = src.y; + dst[2] = src.z; +} +void plVecCopy(double* dst,const b3Vector3& src) +{ + dst[0] = src.x; + dst[1] = src.y; + dst[2] = src.z; +} + +void ComputeClosestPointsPlaneSphere(const b3Vector3& planeNormalWorld, b3Scalar planeConstant, const b3Vector3& spherePosWorld,b3Scalar sphereRadius, plContactCache* contactCache) +{ + if (contactCache->numAddedPoints < contactCache->pointCapacity) + { + lwContactPoint& pointOut = contactCache->pointsOut[contactCache->numAddedPoints]; + b3Scalar t = -(spherePosWorld.dot(-planeNormalWorld)+planeConstant); + b3Vector3 intersectionPoint = spherePosWorld+t*-planeNormalWorld; + b3Scalar distance = t-sphereRadius; + if (distance<=0) + { + pointOut.m_distance = distance; + plVecCopy(pointOut.m_ptOnBWorld,intersectionPoint); + plVecCopy(pointOut.m_ptOnAWorld,spherePosWorld+sphereRadius*-planeNormalWorld); + plVecCopy(pointOut.m_normalOnB,planeNormalWorld); + contactCache->numAddedPoints++; + } + } +} + +void ComputeClosestPointsSphereSphere(b3Scalar sphereARadius, const b3Vector3& sphereAPosWorld, b3Scalar sphereBRadius, const b3Vector3& sphereBPosWorld, plContactCache* contactCache) { + + if (contactCache->numAddedPoints < contactCache->pointCapacity) + { + lwContactPoint& pointOut = contactCache->pointsOut[contactCache->numAddedPoints]; + b3Vector3 diff = sphereAPosWorld-sphereBPosWorld; + b3Scalar len = diff.length(); + pointOut.m_distance = len - (sphereARadius+sphereBRadius); + if (pointOut.m_distance<=0) + { + b3Vector3 normOnB = b3MakeVector3(1,0,0); + if (len > B3_EPSILON) { + normOnB = diff / len; + } + plVecCopy(pointOut.m_normalOnB,normOnB); + b3Vector3 ptAWorld = sphereAPosWorld - sphereARadius*normOnB; + plVecCopy(pointOut.m_ptOnAWorld,ptAWorld); + plVecCopy(pointOut.m_ptOnBWorld,ptAWorld-normOnB*pointOut.m_distance); + contactCache->numAddedPoints++; + } + } +} + +void detectCollisionSphereSphere(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB, + plContactCache* contactCache) +{ + b3Scalar radiusA = world->m_childShapes[shapeIndexA].m_radius; + b3Scalar radiusB = world->m_childShapes[shapeIndexB].m_radius; + b3Transform trA(world->m_collidableOrientations[colA],world->m_collidablePositions[colA]); + const b3Vector3& sphereALocalPos = world->m_childShapes[shapeIndexA].m_childPosition; + b3Vector3 spherePosAWorld = trA(sphereALocalPos); + b3Transform trB(world->m_collidableOrientations[colB],world->m_collidablePositions[colB]); + const b3Vector3& sphereBLocalPos = world->m_childShapes[shapeIndexB].m_childPosition; + b3Vector3 spherePosBWorld = trB(sphereBLocalPos); + ComputeClosestPointsSphereSphere(radiusA,spherePosAWorld,radiusB,spherePosBWorld,contactCache); +} + +void detectCollisionSpherePlane(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB, + plContactCache* contactCache) +{ + (void)world; + (void)colA,(void)shapeIndexA,(void)colB,(void)shapeIndexB; + (void)contactCache; +} + +void detectCollisionPlaneSphere(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB, + plContactCache* contactCache) +{ + (void)world; + (void)colA,(void)shapeIndexA,(void)colB,(void)shapeIndexB; + (void)contactCache; +} + + + +#ifdef RTB3_SHAPE_CAPSULE +plDetectCollisionFunc funcTbl_detectCollision[MAX_NUM_SINGLE_SHAPE_TYPES,][MAX_NUM_SINGLE_SHAPE_TYPES,] = { + {detectCollisionSphereSphere ,detectCollisionSpherePlane ,detectCollisionSphereCapsule}, + {detectCollisionPlaneSphere ,detectCollisionDummy ,detectCollisionPlaneCapsule}, + {detectCollisionCapsuleSphere ,detectCollisionCapsulePlane ,detectCollisionCapsuleCapsule}, +}; +#else +plDetectCollisionFunc funcTbl_detectCollision[MAX_NUM_SINGLE_SHAPE_TYPES][MAX_NUM_SINGLE_SHAPE_TYPES] = { + {detectCollisionSphereSphere ,detectCollisionSpherePlane}, + {detectCollisionPlaneSphere ,detectCollisionDummy }, +}; + +#endif + +int RealTimeBullet3CollisionSdk::collide(plCollisionWorldHandle worldHandle,plCollisionObjectHandle colAHandle, plCollisionObjectHandle colBHandle, + lwContactPoint* pointsOutOrg, int pointCapacity) +{ + RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle; + RTB3_ColliderOpaque2Int caster; + caster.m_ptrValue =colAHandle; + int colAIndex = caster.m_intValue; + caster.m_ptrValue = colBHandle; + int colBIndex = caster.m_intValue; + const b3Collidable& colA = world->m_collidables[colAIndex]; + const b3Collidable& colB = world->m_collidables[colBIndex]; + + plContactCache contactCache; + contactCache.pointCapacity = pointCapacity; + contactCache.pointsOut = pointsOutOrg; + contactCache.numAddedPoints = 0; + + for (int i=0;im_childShapes[colA.m_shapeIndex+i].m_shapeType] + [world->m_childShapes[colB.m_shapeIndex+j].m_shapeType](world,colAIndex,colA.m_shapeIndex+i,colBIndex,colB.m_shapeIndex+j,&contactCache); + } + } + return contactCache.numAddedPoints; + } + + return 0; +} + +void RealTimeBullet3CollisionSdk::collideWorld( plCollisionWorldHandle worldHandle, + plNearCallback filter, void* userData) +{ + RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle; + if (filter) + { + for (int i=START_COLLIDABLE_INDEX;im_nextFreeCollidableIndex;i++) + { + for (int j=i+1;jm_nextFreeCollidableIndex;j++) + { + RTB3_ColliderOpaque2Int caster; caster.m_intValue = i; + plCollisionObjectHandle colA = caster.m_ptrValue; + caster.m_intValue = j; + plCollisionObjectHandle colB = caster.m_ptrValue; + filter((plCollisionSdkHandle)this,worldHandle,userData,colA,colB); + } + } + } +} + +plCollisionSdkHandle RealTimeBullet3CollisionSdk::createRealTimeBullet3CollisionSdkHandle() +{ + return (plCollisionSdkHandle) new RealTimeBullet3CollisionSdk(); +} \ No newline at end of file diff --git a/examples/Collision/Internal/RealTimeBullet3CollisionSdk.h b/examples/Collision/Internal/RealTimeBullet3CollisionSdk.h new file mode 100644 index 000000000..b04f24d7b --- /dev/null +++ b/examples/Collision/Internal/RealTimeBullet3CollisionSdk.h @@ -0,0 +1,42 @@ +#ifndef REAL_TIME_COLLISION_SDK_H +#define REAL_TIME_COLLISION_SDK_H + +#include "CollisionSdkInterface.h" + +class RealTimeBullet3CollisionSdk : public CollisionSdkInterface +{ + struct RealTimeBullet3CollisionSdkInternalData* m_internalData; + +public: + + RealTimeBullet3CollisionSdk(); + + virtual ~RealTimeBullet3CollisionSdk(); + + virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity); + + virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle); + + virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius); + virtual void deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape); + + virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object); + + virtual plCollisionObjectHandle createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape , + plVector3 startPosition,plQuaternion startOrientation ); + virtual void deleteCollisionObject(plCollisionObjectHandle body); + virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body, + plVector3 position,plQuaternion orientation ); + + virtual int collide(plCollisionWorldHandle world,plCollisionObjectHandle colA, plCollisionObjectHandle colB, + lwContactPoint* pointsOut, int pointCapacity); + + virtual void collideWorld( plCollisionWorldHandle world, + plNearCallback filter, void* userData); + + static plCollisionSdkHandle createRealTimeBullet3CollisionSdkHandle(); +}; + + +#endif //REAL_TIME_COLLISION_SDK_H diff --git a/examples/CommonInterfaces/CommonRenderInterface.h b/examples/CommonInterfaces/CommonRenderInterface.h index 6e167c17a..a3d1d0f8b 100644 --- a/examples/CommonInterfaces/CommonRenderInterface.h +++ b/examples/CommonInterfaces/CommonRenderInterface.h @@ -51,6 +51,7 @@ struct CommonRenderInterface virtual void writeTransforms()=0; virtual void enableBlend(bool blend)=0; + virtual void clearZBuffer()=0; //This is internal access to OpenGL3+ features, mainly used for OpenCL-OpenGL interop //Only the GLInstancingRenderer supports it, just return 0 otherwise. diff --git a/examples/ExampleBrowser/CMakeLists.txt b/examples/ExampleBrowser/CMakeLists.txt index df611f4b0..3bbf75bdf 100644 --- a/examples/ExampleBrowser/CMakeLists.txt +++ b/examples/ExampleBrowser/CMakeLists.txt @@ -38,6 +38,8 @@ SET(App_ExampleBrowser_SRCS ../Collision/Internal/Bullet2CollisionSdk.cpp ../Collision/Internal/Bullet2CollisionSdk.h ../Collision/Internal/CollisionSdkInterface.h + ../Collision/Internal/RealTimeBullet3CollisionSdk.cpp + ../Collision/Internal/RealTimeBullet3CollisionSdk.h ../GyroscopicDemo/GyroscopicSetup.cpp ../GyroscopicDemo/GyroscopicSetup.h ../Planar2D/Planar2D.cpp diff --git a/examples/OpenGLWindow/GLInstancingRenderer.cpp b/examples/OpenGLWindow/GLInstancingRenderer.cpp index 5798c75ba..695f39e98 100644 --- a/examples/OpenGLWindow/GLInstancingRenderer.cpp +++ b/examples/OpenGLWindow/GLInstancingRenderer.cpp @@ -1669,6 +1669,11 @@ void GLInstancingRenderer::enableShadowMap() } +void GLInstancingRenderer::clearZBuffer() +{ + glClear(GL_DEPTH_BUFFER_BIT); +} + int GLInstancingRenderer::getMaxShapeCapacity() const { return m_data->m_maxShapeCapacityInBytes; diff --git a/examples/OpenGLWindow/GLInstancingRenderer.h b/examples/OpenGLWindow/GLInstancingRenderer.h index 2fd726409..abdadb9e9 100644 --- a/examples/OpenGLWindow/GLInstancingRenderer.h +++ b/examples/OpenGLWindow/GLInstancingRenderer.h @@ -127,6 +127,7 @@ public: { m_enableBlend = blend; } + virtual void clearZBuffer(); }; diff --git a/examples/OpenGLWindow/SimpleOpenGL2Renderer.cpp b/examples/OpenGLWindow/SimpleOpenGL2Renderer.cpp index a1108f8e4..74c701aad 100644 --- a/examples/OpenGLWindow/SimpleOpenGL2Renderer.cpp +++ b/examples/OpenGLWindow/SimpleOpenGL2Renderer.cpp @@ -160,3 +160,8 @@ void SimpleOpenGL2Renderer::updateShape(int shapeIndex, const float* vertices) void SimpleOpenGL2Renderer::enableBlend(bool blend) { } + +void SimpleOpenGL2Renderer::clearZBuffer() +{ + glClear(GL_DEPTH_BUFFER_BIT); +} \ No newline at end of file diff --git a/examples/OpenGLWindow/SimpleOpenGL2Renderer.h b/examples/OpenGLWindow/SimpleOpenGL2Renderer.h index 45c7809da..b1e64483c 100644 --- a/examples/OpenGLWindow/SimpleOpenGL2Renderer.h +++ b/examples/OpenGLWindow/SimpleOpenGL2Renderer.h @@ -76,6 +76,8 @@ struct SimpleOpenGL2Renderer : public CommonRenderInterface virtual void enableBlend(bool blend); + virtual void clearZBuffer(); + virtual struct GLInstanceRendererInternalData* getInternalData() { return 0; diff --git a/examples/Tutorial/Tutorial.cpp b/examples/Tutorial/Tutorial.cpp index c7564deae..8a2e0ca81 100644 --- a/examples/Tutorial/Tutorial.cpp +++ b/examples/Tutorial/Tutorial.cpp @@ -30,6 +30,8 @@ enum LWEnumCollisionTypes struct LWPlane { + BT_DECLARE_ALIGNED_ALLOCATOR(); + b3Vector3 m_normal; btScalar m_planeConstant; }; @@ -47,6 +49,7 @@ struct LWSphere struct LWBox { + BT_DECLARE_ALIGNED_ALLOCATOR(); b3Vector3 m_halfExtents; }; @@ -64,6 +67,8 @@ struct LWCollisionShape struct LWPose { + BT_DECLARE_ALIGNED_ALLOCATOR(); + b3Vector3 m_position; b3Quaternion m_orientation; LWPose() @@ -119,6 +124,8 @@ enum LWRIGIDBODY_FLAGS }; struct LWRigidBody { + BT_DECLARE_ALIGNED_ALLOCATOR(); + LWPose m_worldPose; b3Vector3 m_linearVelocity; b3Vector3 m_angularVelocity; diff --git a/src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h b/src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h index 50f835287..5808bdff0 100644 --- a/src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h +++ b/src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h @@ -34,19 +34,30 @@ struct b3Collidable }; int m_shapeType; - int m_shapeIndex; + union + { + int m_shapeIndex; + float m_height; + }; }; - typedef struct b3GpuChildShape b3GpuChildShape_t; struct b3GpuChildShape { b3Float4 m_childPosition; b3Quat m_childOrientation; - int m_shapeIndex; - int m_unused0; - int m_unused1; - int m_unused2; + int m_shapeIndex;//used for SHAPE_COMPOUND_OF_CONVEX_HULLS + union + { + float m_radius;//used for childshape of SHAPE_COMPOUND_OF_SPHERES or SHAPE_COMPOUND_OF_CAPSULES + int m_numChildShapes;//used for compound shape + }; + union + { + float m_height;//used for childshape of SHAPE_COMPOUND_OF_CAPSULES + int m_collidableShapeIndex; + }; + int m_shapeType; }; struct b3CompoundOverlappingPair @@ -57,4 +68,5 @@ struct b3CompoundOverlappingPair int m_childShapeIndexA; int m_childShapeIndexB; }; + #endif //B3_COLLIDABLE_H