Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #495 from erwincoumans/master

Browse Source 
minor fix + merge
This commit is contained in:
erwincoumans
2015-10-19 18:52:32 -07:00
parent 324369fce6 abcaa19bc8
commit 61a5328985
16 changed files with 745 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
examples/Collision/CollisionSdkC_Api.cpp
View File

@@ -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);
}

43
examples/Collision/CollisionSdkC_Api.h
View File

@@ -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);

116
examples/Collision/CollisionTutorialBullet2.cpp
View File

@@ -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<plCollisionObjectHandle> 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;i<m_contactPoints.size();i++)
if (m_app && m_app->m_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;i<gTotalPoints;i++)
{
color.setValue(1,0,0);
const lwContactPoint& contact = pointsOut[i];
btVector3 color(1,1,0);
btScalar lineWidth=3;
if (contact.m_distance<0)
{
color.setValue(1,0,0);
}
m_app->m_renderer->drawLine(contact.m_ptOnAWorld,contact.m_ptOnBWorld,color,lineWidth);
}
m_app->m_renderer->drawLine(contact.m_ptOnAWorld,contact.m_ptOnBWorld,color,lineWidth);
}
*/
}

112
examples/Collision/Internal/Bullet2CollisionSdk.cpp
View File

@@ -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_numContacts<m_pointCapacity)
{
lwContactPoint& ptOut = m_pointsOut[m_numContacts];
ptOut.m_distance = cp.m_distance1;
ptOut.m_normalOnB[0] = cp.m_normalWorldOnB.getX();
ptOut.m_normalOnB[1] = cp.m_normalWorldOnB.getY();
ptOut.m_normalOnB[2] = cp.m_normalWorldOnB.getZ();
ptOut.m_ptOnAWorld[0] = cp.m_positionWorldOnA[0];
ptOut.m_ptOnAWorld[1] = cp.m_positionWorldOnA[1];
ptOut.m_ptOnAWorld[2] = cp.m_positionWorldOnA[2];
ptOut.m_ptOnBWorld[0] = cp.m_positionWorldOnB[0];
ptOut.m_ptOnBWorld[1] = cp.m_positionWorldOnB[1];
ptOut.m_ptOnBWorld[2] = cp.m_positionWorldOnB[2];
m_numContacts++;
}
return 1.f;
}
};
int Bullet2CollisionSdk::collide(plCollisionWorldHandle worldHandle,plCollisionObjectHandle colA, plCollisionObjectHandle colB,
lwContactPoint* pointsOut, int pointCapacity)
{
btCollisionWorld* world = (btCollisionWorld*) worldHandle;
btCollisionObject* colObjA = (btCollisionObject*) colA;
btCollisionObject* colObjB = (btCollisionObject*) colB;
btAssert(world && colObjA && colObjB);
if (world == m_internalData->m_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;

18
examples/Collision/Internal/Bullet2CollisionSdk.h
View File

@@ -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();
};

17
examples/Collision/Internal/CollisionSdkInterface.h
View File

@@ -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;
};

378
examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp Normal file
View File

@@ -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<void*> m_collidableUserPointers;
b3AlignedObjectArray<int> m_collidableUserIndices;
b3AlignedObjectArray<b3Float4> m_collidablePositions;
b3AlignedObjectArray<b3Quaternion> m_collidableOrientations;
b3AlignedObjectArray<b3Collidable> m_collidables;
b3AlignedObjectArray<b3GpuChildShape> m_childShapes;
b3AlignedObjectArray<b3GpuFace> m_planeFaces;
b3AlignedObjectArray<b3CompoundOverlappingPair> m_compoundOverlappingPairs;
int m_nextFreeShapeIndex;
int m_nextFreeCollidableIndex;
RTB3CollisionWorld()
:m_nextFreeCollidableIndex(START_COLLIDABLE_INDEX),
m_nextFreeShapeIndex(START_COLLIDABLE_INDEX)
{
}
};
struct RealTimeBullet3CollisionSdkInternalData
{
b3AlignedObjectArray<RTB3CollisionWorld*> 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 && loc<m_internalData->m_collisionWorlds.size());
if (loc >=0 && loc<m_internalData->m_collisionWorlds.size())
{
m_internalData->m_collisionWorlds.remove(world);
delete world;
}
}
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createSphereShape(plCollisionWorldHandle worldHandle, plReal radius)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
if (world->m_nextFreeShapeIndex<world->m_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;i<colA.m_numChildShapes;i++)
{
for (int j=0;j<colB.m_numChildShapes;j++)
{
if (contactCache.numAddedPoints<pointCapacity)
{
funcTbl_detectCollision[world->m_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;i<world->m_nextFreeCollidableIndex;i++)
{
for (int j=i+1;j<world->m_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();
}

42
examples/Collision/Internal/RealTimeBullet3CollisionSdk.h Normal file
View File

@@ -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

1
examples/CommonInterfaces/CommonRenderInterface.h
View File

@@ -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.

2
examples/ExampleBrowser/CMakeLists.txt
View File

@@ -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

5
examples/OpenGLWindow/GLInstancingRenderer.cpp
View File

@@ -1669,6 +1669,11 @@ void GLInstancingRenderer::enableShadowMap()
}
void GLInstancingRenderer::clearZBuffer()
{
glClear(GL_DEPTH_BUFFER_BIT);
}
int GLInstancingRenderer::getMaxShapeCapacity() const
{
return m_data->m_maxShapeCapacityInBytes;

1
examples/OpenGLWindow/GLInstancingRenderer.h
View File

@@ -127,6 +127,7 @@ public:
{
m_enableBlend = blend;
}
virtual void clearZBuffer();
};

5
examples/OpenGLWindow/SimpleOpenGL2Renderer.cpp
View File

@@ -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);
}

2
examples/OpenGLWindow/SimpleOpenGL2Renderer.h
View File

@@ -76,6 +76,8 @@ struct SimpleOpenGL2Renderer : public CommonRenderInterface
virtual void enableBlend(bool blend);
virtual void clearZBuffer();
virtual struct GLInstanceRendererInternalData* getInternalData()
{
return 0;

7
examples/Tutorial/Tutorial.cpp
View File

@@ -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;

24
src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h
View File

@@ -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