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

Code-style consistency improvement:

Browse Source 
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files.
make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type.
This commit contains no other changes aside from adding and applying clang-format-all.sh
This commit is contained in:
erwincoumans
2018-09-23 14:17:31 -07:00
parent b73b05e9fb
commit ab8f16961e
1773 changed files with 1081087 additions and 474249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
examples/Collision/CollisionSdkC_Api.cpp
View File

@@ -3,17 +3,17 @@
#include "Internal/Bullet2CollisionSdk.h"
#include "Internal/RealTimeBullet3CollisionSdk.h"
/* Collision World */
/* Collision World */
plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
return sdk->createCollisionWorld( maxNumObjsCapacity, maxNumShapesCapacity, maxNumPairsCapacity);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createCollisionWorld(maxNumObjsCapacity, maxNumShapesCapacity, maxNumPairsCapacity);
}
void plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle)
void plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
if (sdk && worldHandle)
{
sdk->deleteCollisionWorld(worldHandle);
@@ -26,7 +26,7 @@ plCollisionSdkHandle plCreateBullet2CollisionSdk()
return Bullet2CollisionSdk::createBullet2SdkHandle();
#else
return 0;
#endif //DISABLE_BULLET2_COLLISION_SDK
#endif //DISABLE_BULLET2_COLLISION_SDK
}
plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk()
@@ -40,91 +40,89 @@ plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk()
void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
delete sdk;
}
plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plReal radius)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
return sdk->createSphereShape(worldHandle,radius);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createSphereShape(worldHandle, radius);
}
plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
return sdk->createPlaneShape(worldHandle,planeNormalX,planeNormalY,planeNormalZ,planeConstant);
}
plCollisionShapeHandle plCreateCapsuleShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plReal radius, plReal height, int capsuleAxis)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
return sdk->createCapsuleShape(worldHandle,radius,height,capsuleAxis);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createPlaneShape(worldHandle, planeNormalX, planeNormalY, planeNormalZ, planeConstant);
}
plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle collisionSdkHandle,plCollisionWorldHandle worldHandle)
plCollisionShapeHandle plCreateCapsuleShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plReal radius, plReal height, int capsuleAxis)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createCapsuleShape(worldHandle, radius, height, capsuleAxis);
}
plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createCompoundShape(worldHandle);
}
void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn)
void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
sdk->addChildShape(worldHandle,compoundShape,childShape,childPos,childOrn);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->addChildShape(worldHandle, compoundShape, childShape, childPos, childOrn);
}
void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shapeHandle)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
sdk->deleteShape(worldHandle,shapeHandle);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->deleteShape(worldHandle, shapeHandle);
}
plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, void* userData, int userIndex, plCollisionShapeHandle cshape ,plVector3 childPos,plQuaternion childOrn)
plCollisionObjectHandle plCreateCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, void* userData, int userIndex, plCollisionShapeHandle cshape, plVector3 childPos, plQuaternion childOrn)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->createCollisionObject(worldHandle, userData, userIndex, cshape, childPos, childOrn);
}
void plDeleteCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle body)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->deleteCollisionObject(body);
}
void plSetCollisionObjectTransform( plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle objHandle, plVector3 position,plQuaternion orientation)
void plSetCollisionObjectTransform(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle objHandle, plVector3 position, plQuaternion orientation)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
sdk->setCollisionObjectTransform(worldHandle,objHandle,position,orientation);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->setCollisionObjectTransform(worldHandle, objHandle, position, orientation);
}
void plAddCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
sdk->addCollisionObject(world,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);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->removeCollisionObject(world, object);
}
/* Collision Queries */
int plCollide(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
lwContactPoint* pointsOut, int pointCapacity)
lwContactPoint* pointsOut, int pointCapacity)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
return sdk->collide(worldHandle, colA,colB,pointsOut,pointCapacity);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
return sdk->collide(worldHandle, colA, colB, pointsOut, pointCapacity);
}
void plWorldCollide(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world,
plNearCallback filter, void* userData)
plNearCallback filter, void* userData)
{
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
sdk->collideWorld(world,filter,userData);
CollisionSdkInterface* sdk = (CollisionSdkInterface*)collisionSdkHandle;
sdk->collideWorld(world, filter, userData);
}

113
examples/Collision/CollisionSdkC_Api.h
View File

@@ -1,111 +1,104 @@
#ifndef LW_COLLISION_C_API_H
#define LW_COLLISION_C_API_H
#define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
#define PL_DECLARE_HANDLE(name) \
typedef struct name##__ \
{ \
int unused; \
} * name
#ifdef BT_USE_DOUBLE_PRECISION
typedef double plReal;
typedef double plReal;
#else
typedef float plReal;
typedef float plReal;
#endif
typedef plReal plVector3[3];
typedef plReal plQuaternion[4];
typedef plReal plVector3[3];
typedef plReal plQuaternion[4];
#ifdef __cplusplus
extern "C" {
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();
#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk();
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
// extern plCollisionSdkHandle plCreateCustomCollisionSdk();
// extern plCollisionSdkHandle plCreateCustomCollisionSdk();
extern void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle);
//extern int plGetSdkWorldCreationIntParameter();
//extern int plSetSdkWorldCreationIntParameter(int newValue);
/* Collision World */
extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
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);
extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
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, 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);
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, plCollisionWorldHandle worldHandle, plReal radius);
extern plCollisionShapeHandle plCreateCapsuleShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius, plReal height, int capsuleAxis);
extern plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant);
extern plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle sdk,plCollisionWorldHandle worldHandle);
extern void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
extern plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius);
extern plCollisionShapeHandle plCreateCapsuleShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius, plReal height, int capsuleAxis);
extern plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant);
extern plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle);
extern void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
/* Contact Results */
struct lwContactPoint
{
plVector3 m_ptOnAWorld;
plVector3 m_ptOnBWorld;
plVector3 m_normalOnB;
plReal m_distance;
plReal m_distance;
};
/* Collision Filtering */
typedef void(*plNearCallback)(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, 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 sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
lwContactPoint* pointsOut, int pointCapacity);
extern void plWorldCollide(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world,
plNearCallback filter, void* userData);
#ifdef __cplusplus
}
#endif
#endif //LW_COLLISION_C_API_H
#endif //LW_COLLISION_C_API_H

333
examples/Collision/CollisionTutorialBullet2.cpp
View File

@@ -27,124 +27,121 @@ const int sNumSpheres = 10;
lwContactPoint pointsOut[sPointCapacity];
int numNearCallbacks = 0;
static btVector4 sColors[4] =
{
btVector4(1,0.7,0.7,1),
btVector4(1,1,0.7,1),
btVector4(0.7,1,0.7,1),
btVector4(0.7,1,1,1),
static btVector4 sColors[4] =
{
btVector4(1, 0.7, 0.7, 1),
btVector4(1, 1, 0.7, 1),
btVector4(0.7, 1, 0.7, 1),
btVector4(0.7, 1, 1, 1),
};
void myNearCallback(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB)
{
numNearCallbacks++;
int remainingCapacity = sPointCapacity-gTotalPoints;
btAssert(remainingCapacity>0);
int remainingCapacity = sPointCapacity - gTotalPoints;
btAssert(remainingCapacity > 0);
if (remainingCapacity>0)
if (remainingCapacity > 0)
{
lwContactPoint* pointPtr = &pointsOut[gTotalPoints];
int numNewPoints = plCollide(sdkHandle, worldHandle, objA,objB,pointPtr,remainingCapacity);
int numNewPoints = plCollide(sdkHandle, worldHandle, objA, objB, pointPtr, remainingCapacity);
btAssert(numNewPoints <= remainingCapacity);
gTotalPoints+=numNewPoints;
gTotalPoints += numNewPoints;
}
}
class CollisionTutorialBullet2 : public CommonExampleInterface
{
CommonGraphicsApp* m_app;
CommonGraphicsApp* m_app;
GUIHelperInterface* m_guiHelper;
int m_tutorialIndex;
TimeSeriesCanvas* m_timeSeriesCanvas0;
int m_tutorialIndex;
TimeSeriesCanvas* m_timeSeriesCanvas0;
plCollisionSdkHandle m_collisionSdkHandle;
plCollisionWorldHandle m_collisionWorldHandle;
// int m_stage;
// int m_counter;
// int m_stage;
// int m_counter;
public:
CollisionTutorialBullet2(GUIHelperInterface* guiHelper, int tutorialIndex)
:m_app(guiHelper->getAppInterface()),
m_guiHelper(guiHelper),
m_tutorialIndex(tutorialIndex),
m_timeSeriesCanvas0(0),
m_collisionSdkHandle(0),
m_collisionWorldHandle(0)
// m_stage(0),
// m_counter(0)
{
CollisionTutorialBullet2(GUIHelperInterface* guiHelper, int tutorialIndex)
: m_app(guiHelper->getAppInterface()),
m_guiHelper(guiHelper),
m_tutorialIndex(tutorialIndex),
m_timeSeriesCanvas0(0),
m_collisionSdkHandle(0),
m_collisionWorldHandle(0)
// m_stage(0),
// m_counter(0)
{
gTotalPoints = 0;
m_app->setUpAxis(1);
switch (m_tutorialIndex)
{
case TUT_SPHERE_PLANE_RTB3:
case TUT_SPHERE_PLANE_BULLET2:
{
if (m_tutorialIndex==TUT_SPHERE_PLANE_BULLET2)
if (m_tutorialIndex == TUT_SPHERE_PLANE_BULLET2)
{
m_collisionSdkHandle = plCreateBullet2CollisionSdk();
} else
}
else
{
#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
m_collisionSdkHandle = plCreateRealTimeBullet3CollisionSdk();
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
}
if (m_collisionSdkHandle)
{
int maxNumObjsCapacity=1024;
int maxNumShapesCapacity=1024;
int maxNumPairsCapacity=16384;
int maxNumObjsCapacity = 1024;
int maxNumShapesCapacity = 1024;
int maxNumPairsCapacity = 16384;
btAlignedObjectArray<plCollisionObjectHandle> colliders;
m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle,maxNumObjsCapacity,maxNumShapesCapacity,maxNumPairsCapacity);
m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle, maxNumObjsCapacity, maxNumShapesCapacity, maxNumPairsCapacity);
//create objects, do query etc
{
float radius = 1.f;
void* userPointer = 0;
{
for (int j=0;j<sNumCompounds;j++)
for (int j = 0; j < sNumCompounds; j++)
{
plCollisionShapeHandle compoundShape = plCreateCompoundShape(m_collisionSdkHandle,m_collisionWorldHandle);
plCollisionShapeHandle compoundShape = plCreateCompoundShape(m_collisionSdkHandle, m_collisionWorldHandle);
for (int i=0;i<sNumSpheres;i++)
for (int i = 0; i < sNumSpheres; i++)
{
btVector3 childPos(i*1.5,0,0);
btQuaternion childOrn(0,0,0,1);
btVector3 scaling(radius,radius,radius);
plCollisionShapeHandle childShape = plCreateSphereShape(m_collisionSdkHandle, m_collisionWorldHandle,radius);
plAddChildShape(m_collisionSdkHandle,m_collisionWorldHandle,compoundShape, childShape,childPos,childOrn);
btVector3 childPos(i * 1.5, 0, 0);
btQuaternion childOrn(0, 0, 0, 1);
btVector3 scaling(radius, radius, radius);
plCollisionShapeHandle childShape = plCreateSphereShape(m_collisionSdkHandle, m_collisionWorldHandle, radius);
plAddChildShape(m_collisionSdkHandle, m_collisionWorldHandle, compoundShape, childShape, childPos, childOrn);
//m_guiHelper->createCollisionObjectGraphicsObject(colObj,color);
}
if (m_tutorialIndex==TUT_SPHERE_PLANE_BULLET2)
if (m_tutorialIndex == TUT_SPHERE_PLANE_BULLET2)
{
btCollisionShape* colShape = (btCollisionShape*) compoundShape;
btCollisionShape* colShape = (btCollisionShape*)compoundShape;
m_guiHelper->createCollisionShapeGraphicsObject(colShape);
} else
}
else
{
}
{
btVector3 pos(j*sNumSpheres*1.5,-2.4,0);
btQuaternion orn(0,0,0,1);
plCollisionObjectHandle colObjHandle = plCreateCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,userPointer, -1,compoundShape,pos,orn);
if (m_tutorialIndex==TUT_SPHERE_PLANE_BULLET2)
btVector3 pos(j * sNumSpheres * 1.5, -2.4, 0);
btQuaternion orn(0, 0, 0, 1);
plCollisionObjectHandle colObjHandle = plCreateCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle, userPointer, -1, compoundShape, pos, orn);
if (m_tutorialIndex == TUT_SPHERE_PLANE_BULLET2)
{
btCollisionObject* colObj = (btCollisionObject*) colObjHandle;
btVector4 color=sColors[j&3];
m_guiHelper->createCollisionObjectGraphicsObject(colObj,color);
btCollisionObject* colObj = (btCollisionObject*)colObjHandle;
btVector4 color = sColors[j & 3];
m_guiHelper->createCollisionObjectGraphicsObject(colObj, color);
colliders.push_back(colObjHandle);
plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObjHandle);
plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle, colObjHandle);
}
}
}
@@ -152,27 +149,26 @@ public:
}
{
plCollisionShapeHandle colShape = plCreatePlaneShape(m_collisionSdkHandle, m_collisionWorldHandle,0,1,0,-3.5);
btVector3 pos(0,0,0);
btQuaternion orn(0,0,0,1);
plCollisionShapeHandle colShape = plCreatePlaneShape(m_collisionSdkHandle, m_collisionWorldHandle, 0, 1, 0, -3.5);
btVector3 pos(0, 0, 0);
btQuaternion orn(0, 0, 0, 1);
void* userPointer = 0;
plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,userPointer, 0,colShape,pos,orn);
plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle, userPointer, 0, colShape, pos, orn);
colliders.push_back(colObj);
plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObj);
plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle, colObj);
}
int numContacts = plCollide(m_collisionSdkHandle,m_collisionWorldHandle,colliders[0],colliders[1],pointsOut,sPointCapacity);
printf("numContacts = %d\n", numContacts);
void* myUserPtr = 0;
plWorldCollide(m_collisionSdkHandle,m_collisionWorldHandle,myNearCallback, myUserPtr);
printf("total points=%d\n",gTotalPoints);
//plRemoveCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,colObj);
int numContacts = plCollide(m_collisionSdkHandle, m_collisionWorldHandle, colliders[0], colliders[1], pointsOut, sPointCapacity);
printf("numContacts = %d\n", numContacts);
void* myUserPtr = 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);
}
/*
m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Constant Velocity");
@@ -184,100 +180,86 @@ public:
*/
break;
}
default:
{
m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Unknown");
m_timeSeriesCanvas0 ->setupTimeSeries(1,60, 0);
m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface, 512, 256, "Unknown");
m_timeSeriesCanvas0->setupTimeSeries(1, 60, 0);
}
};
{
int boxId = m_app->registerCubeShape(100,0.01,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 boxId = m_app->registerCubeShape(100, 0.01, 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;
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 && i<numprefix;i++)
const unsigned char* image = 0;
const char* prefix[] = {"./", "../", "../../", "../../../", "../../../../"};
int numprefix = sizeof(prefix) / sizeof(const char*);
for (int i = 0; !image && i < numprefix; i++)
{
char relativeFileName[1024];
sprintf(relativeFileName,"%s%s",prefix[i],filename);
sprintf(relativeFileName, "%s%s", prefix[i], filename);
image = stbi_load(relativeFileName, &width, &height, &n, 3);
}
b3Assert(image);
if (image)
{
textureIndex = m_app->m_renderer->registerTexture(image,width,height);
textureIndex = m_app->m_renderer->registerTexture(image, width, height);
}
}
}
m_app->m_renderer->writeTransforms();
}
virtual ~CollisionTutorialBullet2()
{
}
virtual ~CollisionTutorialBullet2()
{
delete m_timeSeriesCanvas0;
plDeleteCollisionWorld(m_collisionSdkHandle,m_collisionWorldHandle);
plDeleteCollisionWorld(m_collisionSdkHandle, m_collisionWorldHandle);
plDeleteCollisionSdk(m_collisionSdkHandle);
m_timeSeriesCanvas0 = 0;
}
}
virtual void initPhysics()
{
}
virtual void exitPhysics()
{
}
virtual void stepSimulation(float deltaTime)
{
virtual void initPhysics()
{
}
virtual void exitPhysics()
{
}
virtual void stepSimulation(float deltaTime)
{
#ifndef BT_NO_PROFILE
CProfileManager::Reset();
#endif
void* myUserPtr = 0;
gTotalPoints = 0;
numNearCallbacks = 0;
{
BT_PROFILE("plWorldCollide");
if (m_collisionSdkHandle && m_collisionWorldHandle)
{
plWorldCollide(m_collisionSdkHandle,m_collisionWorldHandle,myNearCallback, myUserPtr);
plWorldCollide(m_collisionSdkHandle, m_collisionWorldHandle, myNearCallback, myUserPtr);
}
}
@@ -303,87 +285,76 @@ public:
};
#endif
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();
m_app->m_renderer->writeTransforms();
#ifndef BT_NO_PROFILE
CProfileManager::Increment_Frame_Counter();
CProfileManager::Increment_Frame_Counter();
#endif
}
virtual void renderScene()
{
}
virtual void renderScene()
{
if (m_app && m_app->m_renderer)
{
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);
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++)
for (int i = 0; i < gTotalPoints; i++)
{
const lwContactPoint& contact = pointsOut[i];
btVector3 color(1,1,0);
btScalar lineWidth=3;
if (contact.m_distance<0)
btVector3 color(1, 1, 0);
btScalar lineWidth = 3;
if (contact.m_distance < 0)
{
color.setValue(1,0,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);
}
}
}
}
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 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 = -32;
float yaw = 136;
float targetPos[3]={0,0,0};
if (m_app->m_renderer && m_app->m_renderer->getActiveCamera())
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]);
m_app->m_renderer->getActiveCamera()->setCameraTargetPosition(targetPos[0], targetPos[1], targetPos[2]);
}
}
};
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options)
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options)
{
return new CollisionTutorialBullet2(options.m_guiHelper, options.m_option);
}

10
examples/Collision/CollisionTutorialBullet2.h
View File

@@ -1,12 +1,12 @@
#ifndef COLLISION_TUTORIAL_H
#define COLLISION_TUTORIAL_H
#define COLLISION_TUTORIAL_H
enum EnumCollisionTutorialTypes
{
TUT_SPHERE_PLANE_BULLET2=0,
TUT_SPHERE_PLANE_RTB3,
TUT_SPHERE_PLANE_BULLET2 = 0,
TUT_SPHERE_PLANE_RTB3,
};
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options);
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options);
#endif //COLLISION_TUTORIAL_H
#endif //COLLISION_TUTORIAL_H

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

@@ -7,103 +7,101 @@ struct Bullet2CollisionSdkInternalData
btCollisionDispatcher* m_dispatcher;
btBroadphaseInterface* m_aabbBroadphase;
btCollisionWorld* m_collisionWorld;
Bullet2CollisionSdkInternalData()
:
m_collisionConfig(0),
m_dispatcher(0),
m_aabbBroadphase(0),
m_collisionWorld(0)
: m_collisionConfig(0),
m_dispatcher(0),
m_aabbBroadphase(0),
m_collisionWorld(0)
{
}
};
Bullet2CollisionSdk::Bullet2CollisionSdk()
{
m_internalData = new Bullet2CollisionSdkInternalData;
}
Bullet2CollisionSdk::~Bullet2CollisionSdk()
{
delete m_internalData;
m_internalData = 0;
}
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,
m_internalData->m_aabbBroadphase,
m_internalData->m_collisionConfig);
return (plCollisionWorldHandle) m_internalData->m_collisionWorld;
return (plCollisionWorldHandle)m_internalData->m_collisionWorld;
}
void Bullet2CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandle)
{
btCollisionWorld* world = (btCollisionWorld*) 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;
m_internalData->m_collisionWorld = 0;
delete m_internalData->m_aabbBroadphase;
m_internalData->m_aabbBroadphase=0;
m_internalData->m_aabbBroadphase = 0;
delete m_internalData->m_dispatcher;
m_internalData->m_dispatcher=0;
m_internalData->m_dispatcher = 0;
delete m_internalData->m_collisionConfig;
m_internalData->m_collisionConfig=0;
}
m_internalData->m_collisionConfig = 0;
}
}
plCollisionShapeHandle Bullet2CollisionSdk::createSphereShape(plCollisionWorldHandle /*worldHandle*/, plReal radius)
{
btSphereShape* sphereShape = new btSphereShape(radius);
return (plCollisionShapeHandle) sphereShape;
return (plCollisionShapeHandle)sphereShape;
}
plCollisionShapeHandle Bullet2CollisionSdk::createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
plCollisionShapeHandle Bullet2CollisionSdk::createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
{
btStaticPlaneShape* planeShape = new btStaticPlaneShape(btVector3(planeNormalX,planeNormalY,planeNormalZ),planeConstant);
return (plCollisionShapeHandle) planeShape;
btStaticPlaneShape* planeShape = new btStaticPlaneShape(btVector3(planeNormalX, planeNormalY, planeNormalZ), planeConstant);
return (plCollisionShapeHandle)planeShape;
}
plCollisionShapeHandle Bullet2CollisionSdk::createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis)
plCollisionShapeHandle Bullet2CollisionSdk::createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis)
{
btCapsuleShape* capsule = 0;
switch (capsuleAxis)
{
case 0:
{
capsule = new btCapsuleShapeX(radius,height);
break;
}
case 1:
{
capsule = new btCapsuleShape(radius,height);
break;
}
case 2:
{
capsule = new btCapsuleShapeZ(radius,height);
break;
}
default:
{
btAssert(0);
}
case 0:
{
capsule = new btCapsuleShapeX(radius, height);
break;
}
case 1:
{
capsule = new btCapsuleShape(radius, height);
break;
}
case 2:
{
capsule = new btCapsuleShapeZ(radius, height);
break;
}
default:
{
btAssert(0);
}
}
return (plCollisionShapeHandle)capsule;
}
@@ -112,28 +110,27 @@ plCollisionShapeHandle Bullet2CollisionSdk::createCompoundShape(plCollisionWorld
{
return (plCollisionShapeHandle) new btCompoundShape();
}
void Bullet2CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShapeHandle, plCollisionShapeHandle childShapeHandle,plVector3 childPos,plQuaternion childOrn)
void Bullet2CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShapeHandle, plCollisionShapeHandle childShapeHandle, plVector3 childPos, plQuaternion childOrn)
{
btCompoundShape* compound = (btCompoundShape*) compoundShapeHandle;
btCollisionShape* childShape = (btCollisionShape*) childShapeHandle;
btCompoundShape* compound = (btCompoundShape*)compoundShapeHandle;
btCollisionShape* childShape = (btCollisionShape*)childShapeHandle;
btTransform localTrans;
localTrans.setOrigin(btVector3(childPos[0],childPos[1],childPos[2]));
localTrans.setRotation(btQuaternion(childOrn[0],childOrn[1],childOrn[2],childOrn[3]));
compound->addChildShape(localTrans,childShape);
localTrans.setOrigin(btVector3(childPos[0], childPos[1], childPos[2]));
localTrans.setRotation(btQuaternion(childOrn[0], childOrn[1], childOrn[2], childOrn[3]));
compound->addChildShape(localTrans, childShape);
}
void Bullet2CollisionSdk::deleteShape(plCollisionWorldHandle /*worldHandle*/, plCollisionShapeHandle shapeHandle)
{
btCollisionShape* shape = (btCollisionShape*) 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);
btCollisionWorld* world = (btCollisionWorld*)worldHandle;
btCollisionObject* colObj = (btCollisionObject*)objectHandle;
btAssert(world && colObj);
if (world == m_internalData->m_collisionWorld && colObj)
{
world->addCollisionObject(colObj);
@@ -141,101 +138,98 @@ void Bullet2CollisionSdk::addCollisionObject(plCollisionWorldHandle worldHandle,
}
void Bullet2CollisionSdk::removeCollisionObject(plCollisionWorldHandle worldHandle, plCollisionObjectHandle objectHandle)
{
btCollisionWorld* world = (btCollisionWorld*) worldHandle;
btCollisionObject* colObj = (btCollisionObject*) objectHandle;
btAssert(world && colObj);
btCollisionWorld* world = (btCollisionWorld*)worldHandle;
btCollisionObject* colObj = (btCollisionObject*)objectHandle;
btAssert(world && colObj);
if (world == m_internalData->m_collisionWorld && colObj)
{
world->removeCollisionObject(colObj);
}
}
}
plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle shapeHandle ,
plVector3 startPosition,plQuaternion startOrientation )
plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject(plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle shapeHandle,
plVector3 startPosition, plQuaternion startOrientation)
{
btCollisionShape* colShape = (btCollisionShape*) shapeHandle;
btCollisionShape* colShape = (btCollisionShape*)shapeHandle;
btAssert(colShape);
if (colShape)
{
btCollisionObject* colObj= new btCollisionObject;
btCollisionObject* colObj = new btCollisionObject;
colObj->setUserIndex(userIndex);
colObj->setUserPointer(userPointer);
colObj->setCollisionShape(colShape);
btTransform tr;
tr.setOrigin(btVector3(startPosition[0],startPosition[1],startPosition[2]));
tr.setRotation(btQuaternion(startOrientation[0],startOrientation[1],startOrientation[2],startOrientation[3]));
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 (plCollisionObjectHandle)colObj;
}
return 0;
}
void Bullet2CollisionSdk::deleteCollisionObject(plCollisionObjectHandle bodyHandle)
{
btCollisionObject* colObj = (btCollisionObject*) bodyHandle;
btCollisionObject* colObj = (btCollisionObject*)bodyHandle;
delete colObj;
}
void Bullet2CollisionSdk::setCollisionObjectTransform(plCollisionWorldHandle /*worldHandle*/, plCollisionObjectHandle bodyHandle,
plVector3 position,plQuaternion orientation )
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]));
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
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 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)
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;
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;
@@ -247,30 +241,30 @@ 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++;
}
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)
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;
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()

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

@@ -6,51 +6,50 @@
class Bullet2CollisionSdk : public CollisionSdkInterface
{
struct Bullet2CollisionSdkInternalData* m_internalData;
public:
Bullet2CollisionSdk();
virtual ~Bullet2CollisionSdk();
virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle);
virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius);
virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant);
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis);
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis);
virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle);
virtual void addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape,plVector3 childPos,plQuaternion childOrn);
virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
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 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);
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();
};
#endif //BULLET2_COLLISION_SDK_H
#endif //BULLET2_COLLISION_SDK_H

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

@@ -6,50 +6,46 @@
class CollisionSdkInterface
{
public:
virtual ~CollisionSdkInterface()
{
}
virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity) = 0;
virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle) = 0;
virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius) = 0;
virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant) = 0;
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis) = 0;
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis) = 0;
virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle) = 0;
virtual void addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape,plVector3 childPos,plQuaternion childOrn)=0;
virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn) = 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( 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;
virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) = 0;
virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) = 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;
};
#endif //COLLISION_SDK_INTERFACE_H
#endif //COLLISION_SDK_INTERFACE_H

315
examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp
View File

@@ -8,30 +8,27 @@
//convert the opaque pointer to int
struct RTB3_ColliderOpaque2Int
{
union
{
plCollisionObjectHandle m_ptrValue;
int m_intValue;
};
union {
plCollisionObjectHandle m_ptrValue;
int m_intValue;
};
};
struct RTB3_ShapeOpaque2Int
{
union
{
plCollisionShapeHandle m_ptrValue;
int m_intValue;
};
union {
plCollisionShapeHandle m_ptrValue;
int m_intValue;
};
};
enum RTB3ShapeTypes
{
RTB3_SHAPE_SPHERE=0,
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
@@ -47,15 +44,14 @@ struct RTB3CollisionWorld
b3AlignedObjectArray<b3Transform> m_collidableTransforms;
b3AlignedObjectArray<b3Collidable> m_collidables;
b3AlignedObjectArray<b3GpuChildShape> m_childShapes;
b3AlignedObjectArray<b3Aabb> m_localSpaceAabbs;
b3AlignedObjectArray<b3Aabb> m_worldSpaceAabbs;
b3AlignedObjectArray<b3Aabb> m_localSpaceAabbs;
b3AlignedObjectArray<b3Aabb> m_worldSpaceAabbs;
b3AlignedObjectArray<b3GpuFace> m_planeFaces;
b3AlignedObjectArray<b3CompoundOverlappingPair> m_compoundOverlappingPairs;
union
{
union {
int m_nextFreeShapeIndex;
void* m_nextFreeShapePtr;
};
@@ -63,10 +59,9 @@ struct RTB3CollisionWorld
int m_nextFreePlaneFaceIndex;
RTB3CollisionWorld()
:
m_nextFreeShapeIndex(START_SHAPE_INDEX),
m_nextFreeCollidableIndex(START_COLLIDABLE_INDEX),
m_nextFreePlaneFaceIndex(0)//this value is never exposed to the user, so we can start from 0
: m_nextFreeShapeIndex(START_SHAPE_INDEX),
m_nextFreeCollidableIndex(START_COLLIDABLE_INDEX),
m_nextFreePlaneFaceIndex(0) //this value is never exposed to the user, so we can start from 0
{
}
};
@@ -78,42 +73,42 @@ struct RealTimeBullet3CollisionSdkInternalData
RealTimeBullet3CollisionSdk::RealTimeBullet3CollisionSdk()
{
// int szCol = sizeof(b3Collidable);
// int szShap = sizeof(b3GpuChildShape);
// int szComPair = sizeof(b3CompoundOverlappingPair);
// int szCol = sizeof(b3Collidable);
// int szShap = sizeof(b3GpuChildShape);
// int szComPair = sizeof(b3CompoundOverlappingPair);
m_internalData = new RealTimeBullet3CollisionSdkInternalData;
}
RealTimeBullet3CollisionSdk::~RealTimeBullet3CollisionSdk()
{
delete m_internalData;
m_internalData=0;
m_internalData = 0;
}
plCollisionWorldHandle RealTimeBullet3CollisionSdk::createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity)
{
RTB3CollisionWorld* world = new RTB3CollisionWorld();
world->m_collidables.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_collidablePositions.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_collidableOrientations.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_collidableTransforms.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_collidableUserPointers.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_collidableUserIndices.resize(maxNumObjsCapacity+START_COLLIDABLE_INDEX);
world->m_childShapes.resize(maxNumShapesCapacity+START_SHAPE_INDEX);
world->m_collidables.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_collidablePositions.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_collidableOrientations.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_collidableTransforms.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_collidableUserPointers.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_collidableUserIndices.resize(maxNumObjsCapacity + START_COLLIDABLE_INDEX);
world->m_childShapes.resize(maxNumShapesCapacity + START_SHAPE_INDEX);
world->m_planeFaces.resize(maxNumShapesCapacity);
world->m_compoundOverlappingPairs.resize(maxNumPairsCapacity);
m_internalData->m_collisionWorlds.push_back(world);
return (plCollisionWorldHandle) world;
return (plCollisionWorldHandle)world;
}
void RealTimeBullet3CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandle)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) 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())
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;
@@ -122,88 +117,87 @@ void RealTimeBullet3CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle wo
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createSphereShape(plCollisionWorldHandle worldHandle, plReal radius)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
b3Assert(world->m_nextFreeShapeIndex<world->m_childShapes.size());
if (world->m_nextFreeShapeIndex<world->m_childShapes.size())
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
b3Assert(world->m_nextFreeShapeIndex < world->m_childShapes.size());
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_childOrientation.setValue(0, 0, 0, 1);
shape.m_radius = radius;
shape.m_shapeType = RTB3_SHAPE_SPHERE;
world->m_nextFreeShapeIndex++;
return (plCollisionShapeHandle) world->m_nextFreeShapePtr;
return (plCollisionShapeHandle)world->m_nextFreeShapePtr;
}
return 0;
}
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
b3Assert(world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size());
if (world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size())
{
b3GpuChildShape& shape = world->m_childShapes[world->m_nextFreeShapeIndex];
shape.m_childPosition.setZero();
shape.m_childOrientation.setValue(0,0,0,1);
world->m_planeFaces[world->m_nextFreePlaneFaceIndex].m_plane = b3MakeVector4(planeNormalX,planeNormalY,planeNormalZ,planeConstant);
shape.m_childOrientation.setValue(0, 0, 0, 1);
world->m_planeFaces[world->m_nextFreePlaneFaceIndex].m_plane = b3MakeVector4(planeNormalX, planeNormalY, planeNormalZ, planeConstant);
shape.m_shapeIndex = world->m_nextFreePlaneFaceIndex++;
shape.m_shapeType = RTB3_SHAPE_PLANE;
world->m_nextFreeShapeIndex++;
return (plCollisionShapeHandle)world->m_nextFreeShapePtr ;
return (plCollisionShapeHandle)world->m_nextFreeShapePtr;
}
return 0;
}
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis)
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
b3Assert(world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size());
if (world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size())
{
b3GpuChildShape& shape = world->m_childShapes[world->m_nextFreeShapeIndex];
shape.m_childPosition.setZero();
shape.m_childOrientation.setValue(0,0,0,1);
shape.m_childOrientation.setValue(0, 0, 0, 1);
shape.m_radius = radius;
shape.m_height = height;
shape.m_shapeIndex = capsuleAxis;
shape.m_shapeType = RTB3_SHAPE_CAPSULE;
world->m_nextFreeShapeIndex++;
return (plCollisionShapeHandle) world->m_nextFreeShapePtr;
return (plCollisionShapeHandle)world->m_nextFreeShapePtr;
}
return 0;
}
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createCompoundShape(plCollisionWorldHandle worldHandle)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
b3Assert(world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size());
if (world->m_nextFreeShapeIndex < world->m_childShapes.size() && world->m_nextFreePlaneFaceIndex < world->m_planeFaces.size())
{
b3GpuChildShape& shape = world->m_childShapes[world->m_nextFreeShapeIndex];
shape.m_childPosition.setZero();
shape.m_childOrientation.setValue(0,0,0,1);
shape.m_childOrientation.setValue(0, 0, 0, 1);
shape.m_numChildShapes = 0;
shape.m_shapeType = RTB3_SHAPE_COMPOUND_INTERNAL;
world->m_nextFreeShapeIndex++;
return (plCollisionShapeHandle) world->m_nextFreeShapePtr;
return (plCollisionShapeHandle)world->m_nextFreeShapePtr;
}
return 0;
}
void RealTimeBullet3CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape,plVector3 childPos,plQuaternion childOrn)
void RealTimeBullet3CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn)
{
}
void RealTimeBullet3CollisionSdk::deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape)
{
@@ -212,7 +206,7 @@ void RealTimeBullet3CollisionSdk::deleteShape(plCollisionWorldHandle worldHandle
//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
@@ -222,46 +216,45 @@ void RealTimeBullet3CollisionSdk::removeCollisionObject(plCollisionWorldHandle w
{
///todo, see deleteShape
}
plCollisionObjectHandle RealTimeBullet3CollisionSdk::createCollisionObject( plCollisionWorldHandle worldHandle, void* userPointer,
int userIndex, plCollisionShapeHandle shapeHandle ,
plVector3 startPosition,plQuaternion startOrientation )
plCollisionObjectHandle RealTimeBullet3CollisionSdk::createCollisionObject(plCollisionWorldHandle worldHandle, void* userPointer,
int userIndex, plCollisionShapeHandle shapeHandle,
plVector3 startPosition, plQuaternion startOrientation)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
b3Assert(world->m_nextFreeCollidableIndex < world->m_collidables.size());
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_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_collidableTransforms[world->m_nextFreeCollidableIndex].setOrigin(world->m_collidablePositions[world->m_nextFreeCollidableIndex]);
world->m_collidableTransforms[world->m_nextFreeCollidableIndex].setRotation(world->m_collidableOrientations[world->m_nextFreeCollidableIndex]);
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;
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:
case RTB3_SHAPE_SPHERE:
{
break;
}
case RTB3_SHAPE_PLANE:
case RTB3_SHAPE_PLANE:
{
break;
}
case RTB3_SHAPE_COMPOUND_INTERNAL:
case RTB3_SHAPE_COMPOUND_INTERNAL:
{
break;
}
default:
default:
{
b3Assert(0);
}
@@ -280,14 +273,14 @@ plCollisionObjectHandle RealTimeBullet3CollisionSdk::createCollisionObject( plC
}
return 0;
}
void RealTimeBullet3CollisionSdk::deleteCollisionObject(plCollisionObjectHandle body)
{
///todo, see deleteShape
}
void RealTimeBullet3CollisionSdk::setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body,
plVector3 position,plQuaternion orientation )
plVector3 position, plQuaternion orientation)
{
}
@@ -298,159 +291,154 @@ struct plContactCache
int numAddedPoints;
};
typedef void (*plDetectCollisionFunc)(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache);
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 detectCollisionDummy(RTB3CollisionWorld* world, int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache)
{
(void)world;
(void)colA,(void)colB;
(void)colA, (void)colB;
(void)contactCache;
}
void plVecCopy(float* dst,const b3Vector3& src)
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)
void plVecCopy(double* dst, const b3Vector3& src)
{
dst[0] = src.x;
dst[1] = src.y;
dst[2] = src.z;
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)
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)
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);
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) {
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;
b3Vector3 diff = sphereAPosWorld - sphereBPosWorld;
b3Scalar len = diff.length();
pointOut.m_distance = len - (sphereARadius+sphereBRadius);
if (pointOut.m_distance<=0)
pointOut.m_distance = len - (sphereARadius + sphereBRadius);
if (pointOut.m_distance <= 0)
{
b3Vector3 normOnB = b3MakeVector3(1,0,0);
if (len > B3_EPSILON) {
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);
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++;
}
}
}
B3_FORCE_INLINE void detectCollisionSphereSphere(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache)
B3_FORCE_INLINE void detectCollisionSphereSphere(RTB3CollisionWorld* world, int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache)
{
const b3Scalar radiusA = world->m_childShapes[shapeIndexA].m_radius;
const b3Scalar radiusB = world->m_childShapes[shapeIndexB].m_radius;
const b3Transform& trA = world->m_collidableTransforms[colA];
const b3Vector3& sphereALocalPos = world->m_childShapes[shapeIndexA].m_childPosition;
b3Vector3 spherePosAWorld = trA(sphereALocalPos);
//b3Vector3 spherePosAWorld = b3QuatRotate( world->m_collidableOrientations[colA], sphereALocalPos ) + (world->m_collidablePositions[colA]);
const b3Transform& trB = world->m_collidableTransforms[colB];
const b3Vector3& sphereBLocalPos = world->m_childShapes[shapeIndexB].m_childPosition;
b3Vector3 spherePosBWorld = trB(sphereBLocalPos);
//b3Vector3 spherePosBWorld = b3QuatRotate( world->m_collidableOrientations[colB], sphereBLocalPos ) + (world->m_collidablePositions[colB]);
ComputeClosestPointsSphereSphere(radiusA,spherePosAWorld,radiusB,spherePosBWorld,contactCache);
ComputeClosestPointsSphereSphere(radiusA, spherePosAWorld, radiusB, spherePosBWorld, contactCache);
}
void detectCollisionSpherePlane(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache)
void detectCollisionSpherePlane(RTB3CollisionWorld* world, int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* contactCache)
{
const b3Transform& trA = world->m_collidableTransforms[colA];
const b3Vector3& sphereALocalPos = world->m_childShapes[shapeIndexA].m_childPosition;
b3Vector3 spherePosAWorld = trA(sphereALocalPos);
int planeFaceIndex = world->m_childShapes[shapeIndexB].m_shapeIndex;
b3Vector3 planeNormal = world->m_planeFaces[planeFaceIndex].m_plane;
b3Scalar planeConstant = planeNormal[3];
planeNormal[3] = 0.f;
ComputeClosestPointsPlaneSphere(planeNormal, planeConstant, spherePosAWorld,world->m_childShapes[shapeIndexA].m_radius, contactCache);
ComputeClosestPointsPlaneSphere(planeNormal, planeConstant, spherePosAWorld, world->m_childShapes[shapeIndexA].m_radius, contactCache);
}
void detectCollisionPlaneSphere(RTB3CollisionWorld* world,int colA, int shapeIndexA, int colB, int shapeIndexB,
plContactCache* 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)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},
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 },
{detectCollisionSphereSphere, detectCollisionSpherePlane},
{detectCollisionPlaneSphere, detectCollisionDummy},
};
#endif
int RealTimeBullet3CollisionSdk::collide(plCollisionWorldHandle worldHandle,plCollisionObjectHandle colAHandle, plCollisionObjectHandle colBHandle,
lwContactPoint* pointsOutOrg, int pointCapacity)
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];
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 i = 0; i < colA.m_numChildShapes; i++)
{
for (int j=0;j<colB.m_numChildShapes;j++)
for (int j = 0; j < colB.m_numChildShapes; j++)
{
if (contactCache.numAddedPoints<pointCapacity)
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);
@@ -462,25 +450,24 @@ int RealTimeBullet3CollisionSdk::collide(plCollisionWorldHandle worldHandle,plCo
return 0;
}
void RealTimeBullet3CollisionSdk::collideWorld( plCollisionWorldHandle worldHandle,
plNearCallback filter, void* userData)
void RealTimeBullet3CollisionSdk::collideWorld(plCollisionWorldHandle worldHandle,
plNearCallback filter, void* userData)
{
RTB3CollisionWorld* world = (RTB3CollisionWorld*) worldHandle;
RTB3CollisionWorld* world = (RTB3CollisionWorld*)worldHandle;
if (filter)
{
RTB3_ColliderOpaque2Int caster;
plCollisionObjectHandle colA;
plCollisionObjectHandle colB;
for (int i=START_COLLIDABLE_INDEX;i<world->m_nextFreeCollidableIndex;i++)
for (int i = START_COLLIDABLE_INDEX; i < world->m_nextFreeCollidableIndex; i++)
{
for (int j=i+1;j<world->m_nextFreeCollidableIndex;j++)
for (int j = i + 1; j < world->m_nextFreeCollidableIndex; j++)
{
caster.m_intValue = i;
colA = caster.m_ptrValue;
caster.m_intValue = j;
colA = caster.m_ptrValue;
caster.m_intValue = j;
colB = caster.m_ptrValue;
filter((plCollisionSdkHandle)this,worldHandle,userData,colA,colB);
filter((plCollisionSdkHandle)this, worldHandle, userData, colA, colB);
}
}
}

58
examples/Collision/Internal/RealTimeBullet3CollisionSdk.h
View File

@@ -6,50 +6,48 @@
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 plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
plReal planeNormalX,
plReal planeNormalY,
plReal planeNormalZ,
plReal planeConstant);
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis);
virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
plReal radius,
plReal height,
int capsuleAxis);
virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle);
virtual void addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape,plVector3 childPos,plQuaternion childOrn);
virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
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 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);
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
#endif //REAL_TIME_COLLISION_SDK_H