upload work-in-progress Collision example using C-API.

examples/Collision/CollisionSdkC_Api.cpp

@@ -61,6 +61,22 @@ plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle collisionSdkHandl
 	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)
 {

examples/Collision/CollisionSdkC_Api.h

@@ -36,7 +36,10 @@ extern "C" {
 	
 	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);
@@ -63,14 +66,14 @@ extern "C" {
 	/* Collision Shape definition */
 	
 	extern  plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius);
-	extern  plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk,  plCollisionWorldHandle worldHandle, plReal radius, plReal height);
+	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 plNewCompoundShape(plCollisionSdkHandle sdk,plCollisionWorldHandle worldHandle);
+	extern  plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle sdk,plCollisionWorldHandle worldHandle);
-	extern  void plAddChildShape(plCollisionSdkHandle sdk, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
+	extern  void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
 	
 	extern  void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
 	

examples/Collision/CollisionTutorialBullet2.cpp

@@ -22,11 +22,18 @@
 ///todo: use the 'userData' to prevent this use of global variables
 static int gTotalPoints = 0;
 const int sPointCapacity = 10000;
-const int sNumSpheres = 128;
+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)
 {
@@ -69,23 +76,25 @@ public:
 	m_counter(0),
 	m_timeSeriesCanvas0(0)
     {
-		int numBodies = 1;
+		
 		gTotalPoints = 0;
 		m_app->setUpAxis(1);
 		m_app->m_renderer->enableBlend(true);
 		
 		switch (m_tutorialIndex)
 		{
-			case TUT_SPHERE_SPHERE_RTB3:
+			case TUT_SPHERE_PLANE_RTB3:
-			case TUT_SPHERE_SPHERE_BULLET2:
+			case TUT_SPHERE_PLANE_BULLET2:
 			{
-				numBodies=10;
+				
-				if (m_tutorialIndex==TUT_SPHERE_SPHERE_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)
 				{
@@ -97,29 +106,54 @@ public:
 					//create objects, do query etc
 					{
 						float radius = 1.f;
-						plCollisionShapeHandle colShape = plCreateSphereShape(m_collisionSdkHandle, m_collisionWorldHandle,radius);
-						void* userPointer = 0;
 
-						int sphereGfxShapeId = m_app->registerGraphicsUnitSphereShape(SPHERE_LOD_HIGH);//, textureIndex);
+						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 pos(i*1.5,btScalar(0.8),0);
+									btVector3 childPos(i*1.5,0,0);
-							btQuaternion orn(0,0,0,1);
+									btQuaternion childOrn(0,0,0,1);
 								
-							btVector4 color(0,1,0,0.8);
 									btVector3 scaling(radius,radius,radius);
 						
-							int gfxIndex =  m_app->m_renderer->registerGraphicsInstance(sphereGfxShapeId,pos, orn,color,scaling);
+									plCollisionShapeHandle childShape = plCreateSphereShape(m_collisionSdkHandle, m_collisionWorldHandle,radius);
+									plAddChildShape(m_collisionSdkHandle,m_collisionWorldHandle,compoundShape, childShape,childPos,childOrn);
 						
-							plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,userPointer, gfxIndex,colShape,pos,orn);
+								
-							colliders.push_back(colObj);
+									//m_guiHelper->createCollisionObjectGraphicsObject(colObj,color);
-							plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObj);
+								
+								}
+								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,0);
+						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;
@@ -140,6 +174,7 @@ public:
 					//plDeleteShape(m_collisionSdkHandle,colShape);
 				}
 				
+
 				/*
 				m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Constant Velocity");
 				
@@ -151,11 +186,7 @@ public:
 				break;
 			}
 			
-			case TUT_SPHERE_PLANE_RTB3:
+			
-			case TUT_SPHERE_PLANE_BULLET2:
-			{
-				break;
-			}
 			default:
 			{
 				
@@ -169,7 +200,7 @@ public:
 		
 		{
 
-		 int boxId = m_app->registerCubeShape(100,1,100);
+		 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);

examples/Collision/CollisionTutorialBullet2.h

@@ -3,9 +3,7 @@
 
 enum EnumCollisionTutorialTypes
 {
-	TUT_SPHERE_SPHERE_BULLET2=0,
+	TUT_SPHERE_PLANE_BULLET2=0,
-	TUT_SPHERE_PLANE_BULLET2,
-	TUT_SPHERE_SPHERE_RTB3,
 	TUT_SPHERE_PLANE_RTB3,	
 };
 

examples/Collision/Internal/Bullet2CollisionSdk.cpp

@@ -75,6 +75,52 @@ plCollisionShapeHandle Bullet2CollisionSdk::createPlaneShape(plCollisionWorldHan
 	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)
 {

examples/Collision/Internal/Bullet2CollisionSdk.h

@@ -25,6 +25,14 @@ public:
 													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);

examples/Collision/Internal/CollisionSdkInterface.h

@@ -23,6 +23,14 @@ public:
 													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;

examples/Collision/Internal/RealTimeBullet3CollisionSdk.cpp

@@ -27,9 +27,9 @@ enum RTB3ShapeTypes
 {
 	RTB3_SHAPE_SPHERE=0,
 	RTB3_SHAPE_PLANE,
-//	RTB3_SHAPE_CAPSULE,
+	RTB3_SHAPE_CAPSULE,
 	MAX_NUM_SINGLE_SHAPE_TYPES,
-	RTB3_SHAPE_COMPOUND_INTERNAL
+	RTB3_SHAPE_COMPOUND_INTERNAL,
 
 	
 };
@@ -152,7 +152,49 @@ plCollisionShapeHandle RealTimeBullet3CollisionSdk::createPlaneShape(plCollision
 	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
@@ -206,7 +248,7 @@ plCollisionObjectHandle RealTimeBullet3CollisionSdk::createCollisionObject(  plC
 			}
 		case RTB3_SHAPE_COMPOUND_INTERNAL:
 			{
-				b3Assert(0);
+				
 				break;
 			}
 		default:
@@ -399,8 +441,8 @@ int RealTimeBullet3CollisionSdk::collide(plCollisionWorldHandle worldHandle,plCo
 		{
 			if (contactCache.numAddedPoints<pointCapacity)
 			{
-				funcTbl_detectCollision[world->m_childShapes[colA.m_shapeIndex+i].m_shapeType]
+				//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);
+				//					   [world->m_childShapes[colB.m_shapeIndex+j].m_shapeType](world,colAIndex,colA.m_shapeIndex+i,colBIndex,colB.m_shapeIndex+j,&contactCache);
 			}
 		}
 		return contactCache.numAddedPoints;

examples/Collision/Internal/RealTimeBullet3CollisionSdk.h

@@ -23,6 +23,13 @@ public:
 													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);
 	

examples/ExampleBrowser/ExampleEntries.cpp

@@ -117,10 +117,8 @@ static ExampleEntry gDefaultExamples[]=
 	ExampleEntry(1,"Spring constraint","A rigid body with a spring constraint attached", Dof6ConstraintTutorialCreateFunc,0),
 
 	ExampleEntry(0,"Collision"),
-	ExampleEntry(1, "Sphere-Sphere C-API (Bullet2)", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_SPHERE_BULLET2),
+	ExampleEntry(1, "Spheres & Plane C-API (Bullet2)", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE_BULLET2),
-	ExampleEntry(1, "Sphere-Plane C-API (Bullet2)", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE_BULLET2),
+	//ExampleEntry(1, "Spheres & Plane C-API (Bullet3)", "Collision C-API using Bullet 3.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE_RTB3),
-	ExampleEntry(1, "Sphere-Sphere C-API (Bullet3)", "Collision C-API using Bullet 3.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_SPHERE_RTB3),
-	ExampleEntry(1, "Sphere-Plane C-API (Bullet3)", "Collision C-API using Bullet 3.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE_RTB3),
 		
 	
 

src/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h

@@ -46,7 +46,11 @@ struct b3GpuChildShape
 {
 	b3Float4	m_childPosition;
 	b3Quat		m_childOrientation;
+	union
+	{
 		int			m_shapeIndex;//used for SHAPE_COMPOUND_OF_CONVEX_HULLS
+		int			m_capsuleAxis;
+	};
 	union 
 	{
 		float		m_radius;//used for childshape of SHAPE_COMPOUND_OF_SPHERES or SHAPE_COMPOUND_OF_CAPSULES