add a few collision examples to test a C API with various back-ends

examples/Collision/CollisionSdkC_Api.cpp

@@ -0,0 +1,126 @@
+#include "CollisionSdkC_Api.h"
+#include "Internal/CollisionSdkInterface.h"
+#include "Internal/Bullet2CollisionSdk.h"
+
+	/* Collision World */
+	
+plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	return sdk->createCollisionWorld();
+}
+
+void           plDeleteCollisionWorld(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	sdk->deleteCollisionWorld(worldHandle);
+}
+
+plCollisionSdkHandle plCreateBullet2CollisionSdk()
+{
+	return Bullet2CollisionSdk::createBullet2SdkHandle();
+}
+
+void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	delete sdk;
+}
+
+plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle collisionSdkHandle, plReal radius)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	return sdk->createSphereShape(radius);
+	
+}
+
+void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shapeHandle)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	sdk->deleteShape(shapeHandle);
+}
+
+plCollisionObjectHandle plCreateCollisionObject(  plCollisionSdkHandle collisionSdkHandle,  void* user_data,  plCollisionShapeHandle cshape )
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	return sdk->createCollisionObject(user_data, cshape);
+	
+}
+
+void plDeleteCollisionObject(plCollisionSdkHandle collisionSdkHandle, plCollisionObjectHandle body)
+{
+	CollisionSdkInterface* sdk = (CollisionSdkInterface*) collisionSdkHandle;
+	sdk->deleteCollisionObject(body);
+}
+
+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);
+}
+
+
+//plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk();
+//plCollisionSdkHandle plCreateCustomCollisionSdk();
+
+
+#if 0
+	extern  void           plDeleteCollisionWorld(plCollisionWorldHandle world);
+	
+	
+	extern  void plAddCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	extern  void plRemoveCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	
+	
+	/* Collision Object  */
+	
+	extern  plCollisionObjectHandle plCreateCollisionObject(  plCollisionSdkHandle sdk,  void* user_data,  plCollisionShapeHandle cshape );
+	extern  void plDeleteCollisionObject(plCollisionSdkHandle sdk, plCollisionObjectHandle body);
+	
+	
+	/* Collision Shape definition */
+	
+	extern  plCollisionShapeHandle plNewSphereShape(plCollisionSdkHandle sdk, plReal radius);
+	extern  plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk, plReal radius, plReal height);
+	extern  plCollisionShapeHandle plNewPlaneShape(plCollisionSdkHandle sdk, plReal planeNormalX, 
+												   plReal planeNormalY, 
+												   plReal planeNormalZ, 
+												   plReal planeConstant);
+	extern  plCollisionShapeHandle plNewCompoundShape(plCollisionSdkHandle sdk);
+	extern  void    plAddChildShape(plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
+	
+	extern  void plDeleteShape(plCollisionShapeHandle shape);
+	
+	
+	
+	/* Contact Results */
+	
+	struct lwContactPoint
+	{
+		plVector3 m_ptOnAWorld;
+		plVector3 m_ptOnBWorld;
+		plVector3 m_normalOnB;
+		plReal  m_distance;
+	};
+	
+	/* Collision Filtering */
+	typedef void(*plNearCallback)(plCollisionSdkHandle sdk, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB);
+	
+	
+	/* Collision Queries */
+	extern int plCollide(plCollisionSdkHandle sdk, plCollisionObjectHandle colA, plCollisionObjectHandle colB, 
+						 lwContactPoint* pointsOut, int pointCapacity);
+	
+	extern void plWorldCollide(plCollisionWorldHandle world,
+							   plNearCallback filter, void* userData);
+	
+	
+
+
+#endif
+

examples/Collision/CollisionSdkC_Api.h

@@ -0,0 +1,101 @@
+#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();
+//	extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk();
+//	extern plCollisionSdkHandle plCreateCustomCollisionSdk();
+	
+	extern void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle);
+	
+	/* Collision World */
+	
+	extern  plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle);
+	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,  void* user_data,  plCollisionShapeHandle cshape );
+	extern  void plDeleteCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionObjectHandle body);
+	
+	
+	/* Collision Shape definition */
+	
+	extern  plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plReal radius);
+	extern  plCollisionShapeHandle plNewCapsuleShape(plCollisionSdkHandle sdk, plReal radius, plReal height);
+	extern  plCollisionShapeHandle plNewPlaneShape(plCollisionSdkHandle sdk, plReal planeNormalX, 
+												   plReal planeNormalY, 
+												   plReal planeNormalZ, 
+												   plReal planeConstant);
+	extern  plCollisionShapeHandle plNewCompoundShape(plCollisionSdkHandle sdk);
+	extern  void    plAddChildShape(plCollisionSdkHandle sdk, plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
+	
+	extern  void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionShapeHandle shape);
+	
+	
+	
+	/* Contact Results */
+	
+	struct lwContactPoint
+	{
+		plVector3 m_ptOnAWorld;
+		plVector3 m_ptOnBWorld;
+		plVector3 m_normalOnB;
+		plReal  m_distance;
+	};
+	
+	/* Collision Filtering */
+	typedef void(*plNearCallback)(plCollisionSdkHandle sdk, void* userData, plCollisionObjectHandle objA, plCollisionObjectHandle objB);
+	
+	
+	/* Collision Queries */
+	extern int plCollide(plCollisionSdkHandle sdk, plCollisionObjectHandle colA, plCollisionObjectHandle colB, 
+						 lwContactPoint* pointsOut, int pointCapacity);
+	
+	extern void plWorldCollide(plCollisionWorldHandle world,
+							   plNearCallback filter, void* userData);
+	
+	
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //LW_COLLISION_C_API_H
+

examples/Collision/CollisionTutorialBullet2.cpp

@@ -0,0 +1,270 @@
+
+#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"
+
+
+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_stage(0),
+	m_counter(0),
+	m_timeSeriesCanvas0(0)
+    {
+		int numBodies = 1;
+		
+		m_app->setUpAxis(1);
+		m_app->m_renderer->enableBlend(true);
+		
+		switch (m_tutorialIndex)
+		{
+			case TUT_SPHERE_SPHERE:
+			{
+				numBodies=10;
+				m_collisionSdkHandle = plCreateBullet2CollisionSdk();
+				if (m_collisionSdkHandle)
+				{
+					m_collisionWorldHandle = plCreateCollisionWorld(m_collisionSdkHandle);
+					//create objects, do query etc
+					float radius = 1.f;
+					plCollisionShapeHandle colShape = plCreateSphereShape(m_collisionSdkHandle, radius);
+					void* userData = 0;
+					plCollisionObjectHandle colObj = plCreateCollisionObject(m_collisionSdkHandle,userData,colShape);
+					plAddCollisionObject(m_collisionSdkHandle, m_collisionWorldHandle,colObj);
+					plRemoveCollisionObject(m_collisionSdkHandle,m_collisionWorldHandle,colObj);
+					plDeleteCollisionObject(m_collisionSdkHandle,colObj);
+					plDeleteShape(m_collisionSdkHandle,colShape);
+				}
+				
+				/*
+				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;
+			}
+			case TUT_SPHERE_PLANE:
+			{
+				break;
+			}
+			default:
+			{
+				
+				m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Unknown");
+				m_timeSeriesCanvas0 ->setupTimeSeries(1,60, 0);
+				
+			}
+		};
+
+		
+		
+		if (m_tutorialIndex==TUT_SPHERE_SPHERE)
+		{
+
+		 int boxId = m_app->registerCubeShape(100,1,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, 0);
+				}
+				
+				b3Assert(image);
+				if (image)
+				{
+					textureIndex = m_app->m_renderer->registerTexture(image,width,height);
+				}
+			}
+			
+			//            int boxId = m_app->registerCubeShape(1,1,1,textureIndex);
+			int boxId = m_app->registerGraphicsUnitSphereShape(SPHERE_LOD_HIGH);//, textureIndex);
+			b3Vector4 color = b3MakeVector4(0,1,0,0.8);
+			b3Vector3 scaling = b3MakeVector3(1,1,1);
+			float pos[3] = {1,0,0};
+			float orn[4] = {0,0,0,1};
+			int gfxIndex =  m_app->m_renderer->registerGraphicsInstance(boxId,pos, orn,color,scaling);
+			
+			
+			//	m_bodies[i]->m_graphicsIndex = m_app->m_renderer->registerGraphicsInstance(boxId,m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation,color,scaling);
+			
+				
+				//m_app->m_renderer->writeSingleInstanceTransformToCPU(m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation, m_bodies[i]->m_graphicsIndex);
+		
+		}
+		
+		m_app->m_renderer->writeTransforms();
+    }
+    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)
+    {
+		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:
+			{
+			}
+			
+		};
+		
+		
+		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();
+    }
+    virtual void	renderScene()
+    {
+		m_app->m_renderer->renderScene();
+		m_app->drawText3D("X",1,0,0,1);
+		m_app->drawText3D("Y",0,1,0,1);
+		m_app->drawText3D("Z",0,0,1,1);
+
+		/*for (int i=0;i<m_contactPoints.size();i++)
+		{
+			const LWContactPoint& contact = m_contactPoints[i];
+			b3Vector3 color=b3MakeVector3(1,1,0);
+			float 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);
+}
+

examples/Collision/CollisionTutorialBullet2.h

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

examples/Collision/Internal/Bullet2CollisionSdk.cpp

@@ -0,0 +1,118 @@
+#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()
+{
+	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(plReal radius)
+{
+	btSphereShape* sphereShape = new btSphereShape(radius);
+	return (plCollisionShapeHandle) sphereShape;
+}
+
+void Bullet2CollisionSdk::deleteShape(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(  void* user_data,  plCollisionShapeHandle shapeHandle )
+{
+	btCollisionShape* colShape =  (btCollisionShape*) shapeHandle;
+	btAssert(colShape);
+	if (colShape)
+	{
+		btCollisionObject* colObj= new btCollisionObject;
+		colObj->setCollisionShape(colShape);
+		colObj->setWorldTransform(btTransform::getIdentity());
+		return (plCollisionObjectHandle) colObj;
+	}
+	return 0;
+}
+
+void Bullet2CollisionSdk::deleteCollisionObject(plCollisionObjectHandle bodyHandle)
+{
+	btCollisionObject* colObj = (btCollisionObject*) bodyHandle;
+	delete colObj;
+}
+
+
+plCollisionSdkHandle Bullet2CollisionSdk::createBullet2SdkHandle()
+{
+	return (plCollisionSdkHandle) new Bullet2CollisionSdk;
+}

examples/Collision/Internal/Bullet2CollisionSdk.h

@@ -0,0 +1,34 @@
+#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();
+	
+	virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle);
+
+	virtual plCollisionShapeHandle createSphereShape(plReal radius);
+	
+	virtual void deleteShape(plCollisionShapeHandle shape);
+	
+	virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	virtual  void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	
+	virtual  plCollisionObjectHandle createCollisionObject(  void* user_data,  plCollisionShapeHandle cshape );
+	virtual  void deleteCollisionObject(plCollisionObjectHandle body);
+	
+	
+	static plCollisionSdkHandle createBullet2SdkHandle();
+};
+
+#endif //BULLET2_COLLISION_SDK_H

examples/Collision/Internal/CollisionSdkInterface.h

@@ -0,0 +1,32 @@
+#ifndef COLLISION_SDK_INTERFACE_H
+#define COLLISION_SDK_INTERFACE_H
+
+#include "../CollisionSdkC_Api.h"
+
+class CollisionSdkInterface
+{
+public:
+	
+	virtual ~CollisionSdkInterface()
+	{
+	}
+	
+	virtual plCollisionWorldHandle createCollisionWorld() = 0;
+	
+	virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle) = 0;
+	
+	virtual plCollisionShapeHandle createSphereShape(plReal radius) = 0;
+	
+	virtual void deleteShape(plCollisionShapeHandle shape) = 0;
+	
+	virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object)=0;
+	virtual  void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object)=0;
+	
+	virtual  plCollisionObjectHandle createCollisionObject(  void* user_data,  plCollisionShapeHandle cshape )=0;
+	virtual  void deleteCollisionObject(plCollisionObjectHandle body)=0;
+	
+
+};
+
+#endif //COLLISION_SDK_INTERFACE_H
+

examples/ExampleBrowser/CMakeLists.txt

@@ -31,6 +31,13 @@ SET(App_ExampleBrowser_SRCS
 	../Tutorial/Tutorial.h
 	../Tutorial/Dof6ConstraintTutorial.cpp
 	../Tutorial/Dof6ConstraintTutorial.h
+	../Collision/CollisionSdkC_Api.cpp
+	../Collision/CollisionSdkC_Api.h
+	../Collision/CollisionTutorialBullet2.cpp
+	../Collision/CollisionTutorialBullet2.h
+	../Collision/Internal/Bullet2CollisionSdk.cpp
+	../Collision/Internal/Bullet2CollisionSdk.h
+	../Collision/Internal/CollisionSdkInterface.h
 	../GyroscopicDemo/GyroscopicSetup.cpp
 	../GyroscopicDemo/GyroscopicSetup.h
 	../Planar2D/Planar2D.cpp

examples/ExampleBrowser/ExampleEntries.cpp

@@ -16,7 +16,7 @@
 #include "../Importers/ImportColladaDemo/ImportColladaSetup.h"
 #include "../Importers/ImportSTLDemo/ImportSTLSetup.h"
 #include "../Importers/ImportURDFDemo/ImportURDFSetup.h"
-
+#include "../Collision/CollisionTutorialBullet2.h"
 #include "../GyroscopicDemo/GyroscopicSetup.h"
 #include "../Constraints/Dof6Spring2Setup.h"
 #include "../Constraints/ConstraintPhysicsSetup.h"
@@ -114,11 +114,14 @@ static ExampleEntry gDefaultExamples[]=
 	ExampleEntry(1,"Gravity Acceleration","Motion of a free falling rigid body under constant gravitational acceleration", TutorialCreateFunc,TUT_ACCELERATION),
 	ExampleEntry(1,"Contact Computation","Discrete Collision Detection for sphere-sphere", TutorialCreateFunc,TUT_COLLISION),
 	ExampleEntry(1,"Solve Contact Constraint","Compute and apply the impulses needed to satisfy non-penetrating contact constraints", TutorialCreateFunc,TUT_SOLVE_CONTACT_CONSTRAINT),
-
-	
-	
 	ExampleEntry(1,"Spring constraint","A rigid body with a spring constraint attached", Dof6ConstraintTutorialCreateFunc,0),
 
+	ExampleEntry(0,"Collision"),
+	ExampleEntry(1, "Sphere-Sphere C-API", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_SPHERE),
+	ExampleEntry(1, "Sphere-Plane C-API", "Collision C-API using Bullet 2.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE),
+	
+	
+
 #ifdef INCLUDE_CLOTH_DEMOS
 	ExampleEntry(0,"Soft Body"),
 	ExampleEntry(1,"Cloth","Simulate a patch of cloth.", SoftDemoCreateFunc,0),

examples/ExampleBrowser/premake4.lua

@@ -67,6 +67,8 @@
 		"../MultiThreading/b3ThreadSupportInterface.cpp",
 		"../BasicDemo/BasicExample.*",
 		"../Tutorial/*",
+		"../Collision/*",
+		"../Collision/Internal/*",
 		"../Benchmarks/*",
 		"../CommonInterfaces/*",
 		"../ForkLift/ForkLiftDemo.*",