mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-07-15 00:24:40 +00:00
* Adjustment: Initial CMake reworking.
This commit is contained in:
Robert MacGregor
parent
516163fd5d
commit
d7cdf54661
5394 changed files with 2615532 additions and 8711 deletions
130
Engine/lib/bullet/examples/Collision/CollisionSdkC_Api.cpp
Normal file
130
Engine/lib/bullet/examples/Collision/CollisionSdkC_Api.cpp
Normal file
|
|
@ -0,0 +1,130 @@
|
|||
#include "CollisionSdkC_Api.h"
|
||||
#include "Internal/CollisionSdkInterface.h"
|
||||
#include "Internal/Bullet2CollisionSdk.h"
|
||||
#include "Internal/RealTimeBullet3CollisionSdk.h"
|
||||
|
||||
/* Collision World */
|
||||
|
||||
plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
return sdk->createCollisionWorld( maxNumObjsCapacity, maxNumShapesCapacity, maxNumPairsCapacity);
|
||||
}
|
||||
|
||||
void plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
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)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
delete sdk;
|
||||
}
|
||||
|
||||
plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plReal radius)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
return sdk->createSphereShape(worldHandle,radius);
|
||||
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
plCollisionObjectHandle plCreateCollisionObject( plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, void* userData, int userIndex, plCollisionShapeHandle cshape ,plVector3 childPos,plQuaternion childOrn)
|
||||
{
|
||||
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;
|
||||
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;
|
||||
sdk->addCollisionObject(world,object);
|
||||
}
|
||||
void plRemoveCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle 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)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
return sdk->collide(worldHandle, colA,colB,pointsOut,pointCapacity);
|
||||
}
|
||||
|
||||
void plWorldCollide(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle world,
|
||||
plNearCallback filter, void* userData)
|
||||
{
|
||||
CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
|
||||
sdk->collideWorld(world,filter,userData);
|
||||
}
|
||||
111
Engine/lib/bullet/examples/Collision/CollisionSdkC_Api.h
Normal file
111
Engine/lib/bullet/examples/Collision/CollisionSdkC_Api.h
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
#ifndef LW_COLLISION_C_API_H
|
||||
#define LW_COLLISION_C_API_H
|
||||
|
||||
|
||||
#define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
|
||||
|
||||
|
||||
#ifdef BT_USE_DOUBLE_PRECISION
|
||||
typedef double plReal;
|
||||
#else
|
||||
typedef float plReal;
|
||||
#endif
|
||||
|
||||
typedef plReal plVector3[3];
|
||||
typedef plReal plQuaternion[4];
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/** Particular collision SDK (C-API) */
|
||||
PL_DECLARE_HANDLE(plCollisionSdkHandle);
|
||||
|
||||
/** Collision world, belonging to some collision SDK (C-API)*/
|
||||
PL_DECLARE_HANDLE(plCollisionWorldHandle);
|
||||
|
||||
/** Collision object that can be part of a collision World (C-API)*/
|
||||
PL_DECLARE_HANDLE(plCollisionObjectHandle);
|
||||
|
||||
/** Collision Shape/Geometry, property of a collision object (C-API)*/
|
||||
PL_DECLARE_HANDLE(plCollisionShapeHandle);
|
||||
|
||||
/* Collision SDK */
|
||||
|
||||
extern plCollisionSdkHandle plCreateBullet2CollisionSdk();
|
||||
|
||||
#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
|
||||
extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk();
|
||||
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
|
||||
|
||||
// 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);
|
||||
|
||||
|
||||
/* 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);
|
||||
|
||||
/* 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);
|
||||
|
||||
|
||||
|
||||
/* Contact Results */
|
||||
|
||||
struct lwContactPoint
|
||||
{
|
||||
plVector3 m_ptOnAWorld;
|
||||
plVector3 m_ptOnBWorld;
|
||||
plVector3 m_normalOnB;
|
||||
plReal m_distance;
|
||||
};
|
||||
|
||||
/* Collision Filtering */
|
||||
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
|
||||
|
||||
|
|
@ -0,0 +1,391 @@
|
|||
|
||||
#include "CollisionTutorialBullet2.h"
|
||||
#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
|
||||
#include "../CommonInterfaces/CommonRenderInterface.h"
|
||||
|
||||
#include "../CommonInterfaces/CommonExampleInterface.h"
|
||||
#include "LinearMath/btTransform.h"
|
||||
|
||||
#include "../CommonInterfaces/CommonGUIHelperInterface.h"
|
||||
#include "../RenderingExamples/TimeSeriesCanvas.h"
|
||||
#include "stb_image/stb_image.h"
|
||||
#include "Bullet3Common/b3Quaternion.h"
|
||||
#include "Bullet3Common/b3Matrix3x3.h"
|
||||
#include "../CommonInterfaces/CommonParameterInterface.h"
|
||||
|
||||
#include "LinearMath/btAlignedObjectArray.h"
|
||||
#include "CollisionSdkC_Api.h"
|
||||
#include "LinearMath/btQuickprof.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;
|
||||
const int sPointCapacity = 10000;
|
||||
const int sNumCompounds = 10;
|
||||
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),
|
||||
};
|
||||
|
||||
void myNearCallback(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB)
|
||||
{
|
||||
numNearCallbacks++;
|
||||
int remainingCapacity = sPointCapacity-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;
|
||||
GUIHelperInterface* m_guiHelper;
|
||||
int m_tutorialIndex;
|
||||
|
||||
TimeSeriesCanvas* m_timeSeriesCanvas0;
|
||||
|
||||
plCollisionSdkHandle m_collisionSdkHandle;
|
||||
plCollisionWorldHandle m_collisionWorldHandle;
|
||||
|
||||
int m_stage;
|
||||
int m_counter;
|
||||
|
||||
public:
|
||||
|
||||
CollisionTutorialBullet2(GUIHelperInterface* guiHelper, int tutorialIndex)
|
||||
:m_app(guiHelper->getAppInterface()),
|
||||
m_guiHelper(guiHelper),
|
||||
m_tutorialIndex(tutorialIndex),
|
||||
m_collisionSdkHandle(0),
|
||||
m_collisionWorldHandle(0),
|
||||
m_stage(0),
|
||||
m_counter(0),
|
||||
m_timeSeriesCanvas0(0)
|
||||
{
|
||||
|
||||
gTotalPoints = 0;
|
||||
m_app->setUpAxis(1);
|
||||
m_app->m_renderer->enableBlend(true);
|
||||
|
||||
switch (m_tutorialIndex)
|
||||
{
|
||||
case TUT_SPHERE_PLANE_RTB3:
|
||||
case TUT_SPHERE_PLANE_BULLET2:
|
||||
{
|
||||
|
||||
if (m_tutorialIndex==TUT_SPHERE_PLANE_BULLET2)
|
||||
{
|
||||
m_collisionSdkHandle = plCreateBullet2CollisionSdk();
|
||||
} else
|
||||
{
|
||||
#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
|
||||
m_collisionSdkHandle = plCreateRealTimeBullet3CollisionSdk();
|
||||
#endif //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
|
||||
}
|
||||
if (m_collisionSdkHandle)
|
||||
{
|
||||
int maxNumObjsCapacity=1024;
|
||||
int maxNumShapesCapacity=1024;
|
||||
int maxNumPairsCapacity=16384;
|
||||
btAlignedObjectArray<plCollisionObjectHandle> colliders;
|
||||
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++)
|
||||
{
|
||||
plCollisionShapeHandle compoundShape = plCreateCompoundShape(m_collisionSdkHandle,m_collisionWorldHandle);
|
||||
|
||||
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);
|
||||
|
||||
|
||||
//m_guiHelper->createCollisionObjectGraphicsObject(colObj,color);
|
||||
|
||||
}
|
||||
if (m_tutorialIndex==TUT_SPHERE_PLANE_BULLET2)
|
||||
{
|
||||
btCollisionShape* colShape = (btCollisionShape*) compoundShape;
|
||||
m_guiHelper->createCollisionShapeGraphicsObject(colShape);
|
||||
} 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)
|
||||
{
|
||||
btCollisionObject* colObj = (btCollisionObject*) colObjHandle;
|
||||
btVector4 color=sColors[j&3];
|
||||
m_guiHelper->createCollisionObjectGraphicsObject(colObj,color);
|
||||
colliders.push_back(colObjHandle);
|
||||
plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObjHandle);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
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);
|
||||
colliders.push_back(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);
|
||||
//plDeleteCollisionObject(m_collisionSdkHandle,colObj);
|
||||
//plDeleteShape(m_collisionSdkHandle,colShape);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Constant Velocity");
|
||||
|
||||
m_timeSeriesCanvas0 ->setupTimeSeries(2,60, 0);
|
||||
m_timeSeriesCanvas0->addDataSource("X position (m)", 255,0,0);
|
||||
m_timeSeriesCanvas0->addDataSource("X velocity (m/s)", 0,0,255);
|
||||
m_timeSeriesCanvas0->addDataSource("dX/dt (m/s)", 0,0,0);
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
{
|
||||
|
||||
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 textureIndex = -1;
|
||||
|
||||
if (1)
|
||||
{
|
||||
int width,height,n;
|
||||
|
||||
const char* filename = "data/cube.png";
|
||||
const unsigned char* image=0;
|
||||
|
||||
const char* prefix[]={"./","../","../../","../../../","../../../../"};
|
||||
int numprefix = sizeof(prefix)/sizeof(const char*);
|
||||
|
||||
for (int i=0;!image && i<numprefix;i++)
|
||||
{
|
||||
char relativeFileName[1024];
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
m_app->m_renderer->writeTransforms();
|
||||
}
|
||||
virtual ~CollisionTutorialBullet2()
|
||||
{
|
||||
delete m_timeSeriesCanvas0;
|
||||
|
||||
plDeleteCollisionWorld(m_collisionSdkHandle,m_collisionWorldHandle);
|
||||
|
||||
plDeleteCollisionSdk(m_collisionSdkHandle);
|
||||
|
||||
m_timeSeriesCanvas0 = 0;
|
||||
|
||||
m_app->m_renderer->enableBlend(false);
|
||||
}
|
||||
|
||||
|
||||
virtual void initPhysics()
|
||||
{
|
||||
}
|
||||
virtual void exitPhysics()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
virtual void stepSimulation(float deltaTime)
|
||||
{
|
||||
#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);
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
switch (m_tutorialIndex)
|
||||
{
|
||||
case TUT_SPHERE_SPHERE:
|
||||
{
|
||||
if (m_timeSeriesCanvas0)
|
||||
{
|
||||
float xPos = 0.f;
|
||||
float xVel = 1.f;
|
||||
m_timeSeriesCanvas0->insertDataAtCurrentTime(xPos,0,true);
|
||||
m_timeSeriesCanvas0->insertDataAtCurrentTime(xVel,1,true);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
{
|
||||
}
|
||||
|
||||
};
|
||||
#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();
|
||||
#ifndef BT_NO_PROFILE
|
||||
CProfileManager::Increment_Frame_Counter();
|
||||
#endif
|
||||
}
|
||||
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);
|
||||
|
||||
|
||||
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)
|
||||
{
|
||||
color.setValue(1,0,0);
|
||||
}
|
||||
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 resetCamera()
|
||||
{
|
||||
float dist = 10.5;
|
||||
float pitch = 136;
|
||||
float yaw = 32;
|
||||
float targetPos[3]={0,0,0};
|
||||
if (m_app->m_renderer && m_app->m_renderer->getActiveCamera())
|
||||
{
|
||||
m_app->m_renderer->getActiveCamera()->setCameraDistance(dist);
|
||||
m_app->m_renderer->getActiveCamera()->setCameraPitch(pitch);
|
||||
m_app->m_renderer->getActiveCamera()->setCameraYaw(yaw);
|
||||
m_app->m_renderer->getActiveCamera()->setCameraTargetPosition(targetPos[0],targetPos[1],targetPos[2]);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options)
|
||||
{
|
||||
return new CollisionTutorialBullet2(options.m_guiHelper, options.m_option);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#ifndef COLLISION_TUTORIAL_H
|
||||
#define COLLISION_TUTORIAL_H
|
||||
|
||||
enum EnumCollisionTutorialTypes
|
||||
{
|
||||
TUT_SPHERE_PLANE_BULLET2=0,
|
||||
TUT_SPHERE_PLANE_RTB3,
|
||||
};
|
||||
|
||||
class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options);
|
||||
|
||||
#endif //COLLISION_TUTORIAL_H
|
||||
|
|
@ -0,0 +1,278 @@
|
|||
#include "Bullet2CollisionSdk.h"
|
||||
#include "btBulletCollisionCommon.h"
|
||||
|
||||
struct Bullet2CollisionSdkInternalData
|
||||
{
|
||||
btCollisionConfiguration* m_collisionConfig;
|
||||
btCollisionDispatcher* m_dispatcher;
|
||||
btBroadphaseInterface* m_aabbBroadphase;
|
||||
|
||||
btCollisionWorld* m_collisionWorld;
|
||||
|
||||
Bullet2CollisionSdkInternalData()
|
||||
:m_aabbBroadphase(0),
|
||||
m_dispatcher(0),
|
||||
m_collisionWorld(0)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
Bullet2CollisionSdk::Bullet2CollisionSdk()
|
||||
{
|
||||
m_internalData = new Bullet2CollisionSdkInternalData;
|
||||
}
|
||||
|
||||
Bullet2CollisionSdk::~Bullet2CollisionSdk()
|
||||
{
|
||||
delete m_internalData;
|
||||
m_internalData = 0;
|
||||
}
|
||||
|
||||
plCollisionWorldHandle Bullet2CollisionSdk::createCollisionWorld(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;
|
||||
}
|
||||
|
||||
void Bullet2CollisionSdk::deleteCollisionWorld(plCollisionWorldHandle worldHandle)
|
||||
{
|
||||
btCollisionWorld* world = (btCollisionWorld*) worldHandle;
|
||||
btAssert(m_internalData->m_collisionWorld == world);
|
||||
|
||||
if (m_internalData->m_collisionWorld == world)
|
||||
{
|
||||
delete m_internalData->m_collisionWorld;
|
||||
m_internalData->m_collisionWorld=0;
|
||||
delete m_internalData->m_aabbBroadphase;
|
||||
m_internalData->m_aabbBroadphase=0;
|
||||
delete m_internalData->m_dispatcher;
|
||||
m_internalData->m_dispatcher=0;
|
||||
delete m_internalData->m_collisionConfig;
|
||||
m_internalData->m_collisionConfig=0;
|
||||
}
|
||||
}
|
||||
|
||||
plCollisionShapeHandle Bullet2CollisionSdk::createSphereShape(plCollisionWorldHandle /*worldHandle*/, plReal radius)
|
||||
{
|
||||
btSphereShape* sphereShape = new btSphereShape(radius);
|
||||
return (plCollisionShapeHandle) sphereShape;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
return (plCollisionShapeHandle)capsule;
|
||||
}
|
||||
|
||||
plCollisionShapeHandle Bullet2CollisionSdk::createCompoundShape(plCollisionWorldHandle worldHandle)
|
||||
{
|
||||
return (plCollisionShapeHandle) new btCompoundShape();
|
||||
}
|
||||
void Bullet2CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShapeHandle, plCollisionShapeHandle childShapeHandle,plVector3 childPos,plQuaternion childOrn)
|
||||
{
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
void Bullet2CollisionSdk::deleteShape(plCollisionWorldHandle /*worldHandle*/, plCollisionShapeHandle shapeHandle)
|
||||
{
|
||||
btCollisionShape* shape = (btCollisionShape*) shapeHandle;
|
||||
delete shape;
|
||||
}
|
||||
|
||||
void Bullet2CollisionSdk::addCollisionObject(plCollisionWorldHandle worldHandle, plCollisionObjectHandle objectHandle)
|
||||
{
|
||||
btCollisionWorld* world = (btCollisionWorld*) worldHandle;
|
||||
btCollisionObject* colObj = (btCollisionObject*) objectHandle;
|
||||
btAssert(world && colObj);
|
||||
if (world == m_internalData->m_collisionWorld && colObj)
|
||||
{
|
||||
world->addCollisionObject(colObj);
|
||||
}
|
||||
}
|
||||
void Bullet2CollisionSdk::removeCollisionObject(plCollisionWorldHandle worldHandle, plCollisionObjectHandle objectHandle)
|
||||
{
|
||||
btCollisionWorld* world = (btCollisionWorld*) worldHandle;
|
||||
btCollisionObject* colObj = (btCollisionObject*) objectHandle;
|
||||
btAssert(world && colObj);
|
||||
if (world == m_internalData->m_collisionWorld && colObj)
|
||||
{
|
||||
world->removeCollisionObject(colObj);
|
||||
}
|
||||
}
|
||||
|
||||
plCollisionObjectHandle Bullet2CollisionSdk::createCollisionObject( 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);
|
||||
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;
|
||||
}
|
||||
|
||||
void Bullet2CollisionSdk::deleteCollisionObject(plCollisionObjectHandle bodyHandle)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#ifndef BULLET2_COLLISION_SDK_H
|
||||
#define BULLET2_COLLISION_SDK_H
|
||||
|
||||
#include "CollisionSdkInterface.h"
|
||||
|
||||
class Bullet2CollisionSdk : public CollisionSdkInterface
|
||||
{
|
||||
struct Bullet2CollisionSdkInternalData* m_internalData;
|
||||
|
||||
public:
|
||||
|
||||
Bullet2CollisionSdk();
|
||||
|
||||
virtual ~Bullet2CollisionSdk();
|
||||
|
||||
virtual plCollisionWorldHandle createCollisionWorld(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,
|
||||
plReal planeConstant);
|
||||
|
||||
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 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 createBullet2SdkHandle();
|
||||
};
|
||||
|
||||
#endif //BULLET2_COLLISION_SDK_H
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#ifndef COLLISION_SDK_INTERFACE_H
|
||||
#define COLLISION_SDK_INTERFACE_H
|
||||
|
||||
#include "../CollisionSdkC_Api.h"
|
||||
|
||||
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,
|
||||
plReal planeConstant) = 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 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;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif //COLLISION_SDK_INTERFACE_H
|
||||
|
||||
|
|
@ -0,0 +1,481 @@
|
|||
#define BLAAT
|
||||
#include "RealTimeBullet3CollisionSdk.h"
|
||||
#include "Bullet3Common/b3AlignedObjectArray.h"
|
||||
#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
|
||||
#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
|
||||
#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.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
|
||||
#define START_SHAPE_INDEX 1
|
||||
|
||||
struct RTB3CollisionWorld
|
||||
{
|
||||
b3AlignedObjectArray<void*> m_collidableUserPointers;
|
||||
b3AlignedObjectArray<int> m_collidableUserIndices;
|
||||
b3AlignedObjectArray<b3Float4> m_collidablePositions;
|
||||
b3AlignedObjectArray<b3Quaternion> m_collidableOrientations;
|
||||
b3AlignedObjectArray<b3Transform> m_collidableTransforms;
|
||||
|
||||
b3AlignedObjectArray<b3Collidable> m_collidables;
|
||||
|
||||
b3AlignedObjectArray<b3GpuChildShape> m_childShapes;
|
||||
b3AlignedObjectArray<b3Aabb> m_localSpaceAabbs;
|
||||
b3AlignedObjectArray<b3Aabb> m_worldSpaceAabbs;
|
||||
b3AlignedObjectArray<b3GpuFace> m_planeFaces;
|
||||
b3AlignedObjectArray<b3CompoundOverlappingPair> m_compoundOverlappingPairs;
|
||||
int m_nextFreeShapeIndex;
|
||||
int m_nextFreeCollidableIndex;
|
||||
int m_nextFreePlaneFaceIndex;
|
||||
|
||||
RTB3CollisionWorld()
|
||||
:m_nextFreeCollidableIndex(START_COLLIDABLE_INDEX),
|
||||
m_nextFreeShapeIndex(START_SHAPE_INDEX),
|
||||
m_nextFreePlaneFaceIndex(0)//this value is never exposed to the user, so we can start from 0
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
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+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;
|
||||
}
|
||||
|
||||
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;
|
||||
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_radius = radius;
|
||||
shape.m_shapeType = RTB3_SHAPE_SPHERE;
|
||||
return (plCollisionShapeHandle) world->m_nextFreeShapeIndex++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createPlaneShape(plCollisionWorldHandle worldHandle,
|
||||
plReal planeNormalX,
|
||||
plReal planeNormalY,
|
||||
plReal planeNormalZ,
|
||||
plReal planeConstant)
|
||||
{
|
||||
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_shapeIndex = world->m_nextFreePlaneFaceIndex++;
|
||||
shape.m_shapeType = RTB3_SHAPE_PLANE;
|
||||
return (plCollisionShapeHandle) world->m_nextFreeShapeIndex++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createCapsuleShape(plCollisionWorldHandle worldHandle,
|
||||
plReal radius,
|
||||
plReal height,
|
||||
int capsuleAxis)
|
||||
{
|
||||
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_radius = radius;
|
||||
shape.m_height = height;
|
||||
shape.m_shapeIndex = capsuleAxis;
|
||||
shape.m_shapeType = RTB3_SHAPE_CAPSULE;
|
||||
return (plCollisionShapeHandle) world->m_nextFreeShapeIndex++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
plCollisionShapeHandle RealTimeBullet3CollisionSdk::createCompoundShape(plCollisionWorldHandle 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_numChildShapes = 0;
|
||||
shape.m_shapeType = RTB3_SHAPE_COMPOUND_INTERNAL;
|
||||
return (plCollisionShapeHandle) world->m_nextFreeShapeIndex++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void RealTimeBullet3CollisionSdk::addChildShape(plCollisionWorldHandle worldHandle,plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape,plVector3 childPos,plQuaternion childOrn)
|
||||
{
|
||||
|
||||
}
|
||||
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;
|
||||
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_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;
|
||||
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:
|
||||
{
|
||||
break;
|
||||
}
|
||||
case RTB3_SHAPE_COMPOUND_INTERNAL:
|
||||
{
|
||||
|
||||
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++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
RTB3_ColliderOpaque2Int caster;
|
||||
plCollisionObjectHandle colA;
|
||||
plCollisionObjectHandle colB;
|
||||
for (int i=START_COLLIDABLE_INDEX;i<world->m_nextFreeCollidableIndex;i++)
|
||||
{
|
||||
|
||||
for (int j=i+1;j<world->m_nextFreeCollidableIndex;j++)
|
||||
{
|
||||
caster.m_intValue = i;
|
||||
colA = caster.m_ptrValue;
|
||||
caster.m_intValue = j;
|
||||
colB = caster.m_ptrValue;
|
||||
filter((plCollisionSdkHandle)this,worldHandle,userData,colA,colB);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
plCollisionSdkHandle RealTimeBullet3CollisionSdk::createRealTimeBullet3CollisionSdkHandle()
|
||||
{
|
||||
return (plCollisionSdkHandle) new RealTimeBullet3CollisionSdk();
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#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 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 createCompoundShape(plCollisionWorldHandle worldHandle);
|
||||
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 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
|
||||
Loading…
Add table
Add a link
Reference in a new issue