Added a very basic dynamics demo, only using spheres (and optionally boxes)

Demos/BasicDemo/BasicDemo.cpp

@@ -0,0 +1,164 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+//#define USE_GROUND_BOX 1
+#define PRINT_CONTACT_STATISTICS 1
+int gNumObjects = 120;
+#define HALF_EXTENTS 1.f
+#include "btBulletDynamicsCommon.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "GLDebugDrawer.h"
+#include "BMF_Api.h"
+#include <stdio.h> //printf debugging
+float deltaTime = 1.f/60.f;
+float	gCollisionMargin = 0.05f;
+#include "BasicDemo.h"
+#include "GL_ShapeDrawer.h"
+#include "GlutStuff.h"
+////////////////////////////////////
+
+GLDebugDrawer debugDrawer;
+
+int main(int argc,char** argv)
+{
+
+	BasicDemo* ccdDemo = new BasicDemo();
+	ccdDemo->initPhysics();
+	ccdDemo->setCameraDistance(50.f);
+	return glutmain(argc, argv,640,480,"Bullet Physics Demo. http://bullet.sf.net",ccdDemo);
+}
+
+
+
+extern int gNumManifold;
+extern int gOverlappingPairs;
+extern int gTotalContactPoints;
+
+void BasicDemo::clientMoveAndDisplay()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+
+	if (m_dynamicsWorld)
+		m_dynamicsWorld->stepSimulation(deltaTime);
+		
+	renderme(); 
+
+	glFlush();
+	//some additional debugging info
+#ifdef PRINT_CONTACT_STATISTICS
+	printf("num manifolds: %i\n",gNumManifold);
+	printf("num gOverlappingPairs: %i\n",gOverlappingPairs);
+	printf("num gTotalContactPoints : %i\n",gTotalContactPoints );
+#endif //PRINT_CONTACT_STATISTICS
+
+	gTotalContactPoints = 0;
+	glutSwapBuffers();
+
+}
+
+
+
+void BasicDemo::displayCallback(void) {
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+
+	m_dynamicsWorld->updateAabbs();
+	
+	renderme();
+
+	glFlush();
+	glutSwapBuffers();
+}
+
+
+
+///make this positive to show stack falling from a distance
+///this shows the penalty tresholds in action, springy/spungy look
+
+void BasicDemo::clientResetScene()
+{
+}
+
+
+void	BasicDemo::initPhysics()
+{
+
+	btCollisionDispatcher* dispatcher = new	btCollisionDispatcher(true);
+	
+#ifdef USE_SWEEP_AND_PRUNE
+	btVector3 worldAabbMin(-10000,-10000,-10000);
+	btVector3 worldAabbMax(10000,10000,10000);
+	btOverlappingPairCache* broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,maxProxies);
+#else
+	btOverlappingPairCache* broadphase = new btSimpleBroadphase;
+#endif //USE_SWEEP_AND_PRUNE
+	
+	dispatcher->registerCollisionCreateFunc(SPHERE_SHAPE_PROXYTYPE,SPHERE_SHAPE_PROXYTYPE,new btSphereSphereCollisionAlgorithm::CreateFunc);
+#ifdef USE_GROUND_BOX
+	dispatcher->registerCollisionCreateFunc(SPHERE_SHAPE_PROXYTYPE,BOX_SHAPE_PROXYTYPE,new btSphereBoxCollisionAlgorithm::CreateFunc);
+	btCollisionAlgorithmCreateFunc* swappedSphereBox = new btSphereBoxCollisionAlgorithm::CreateFunc;
+	swappedSphereBox->m_swapped = true;
+	dispatcher->registerCollisionCreateFunc(BOX_SHAPE_PROXYTYPE,SPHERE_SHAPE_PROXYTYPE,swappedSphereBox);
+#endif //USE_GROUND_BOX
+
+	btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;
+
+	m_dynamicsWorld = new btSimpleDynamicsWorld(dispatcher,broadphase,solver);
+	m_dynamicsWorld->setGravity(btVector3(0,-10,0));
+
+	m_dynamicsWorld->setDebugDrawer(&debugDrawer);
+
+	///create a few basic rigid bodies
+
+
+	//static ground
+#ifdef USE_GROUND_BOX
+	btCollisionShape* groundShape = new btBoxShape(btVector3(50.f,50.f,50.f));
+#else
+	btCollisionShape* groundShape = new btSphereShape(50.f);
+#endif//USE_GROUND_BOX
+
+	btTransform groundTransform;
+	groundTransform.setIdentity();
+	groundTransform.setOrigin(btVector3(0,-50,0));
+	localCreateRigidBody(0.f,groundTransform,groundShape);
+
+	//create a few dynamic sphere rigidbodies (re-using the same sphere shape)
+	btCollisionShape* sphereShape = new btSphereShape(1.f);
+	int i;
+	for (i=0;i<gNumObjects;i++)
+	{
+		
+		sphereShape->setMargin(gCollisionMargin);
+		btTransform trans;
+		trans.setIdentity();
+		//stack them
+		int colsize = 10;
+		int row = (i*HALF_EXTENTS*2)/(colsize*2*HALF_EXTENTS);
+		int row2 = row;
+		int col = (i)%(colsize)-colsize/2;
+		btVector3 pos(col*2*HALF_EXTENTS + (row2%2)*HALF_EXTENTS,
+			row*2*HALF_EXTENTS+HALF_EXTENTS,0);
+
+		trans.setOrigin(pos);
+		btRigidBody* body = localCreateRigidBody(1.f,trans,sphereShape);
+	}
+
+	clientResetScene();
+}
+	
+
+
+

Demos/BasicDemo/BasicDemo.h

@@ -0,0 +1,36 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BASIC_DEMO_H
+#define BASIC_DEMO_H
+
+#include "DemoApplication.h"
+
+///BasicDemo is good starting point for learning the code base and porting.
+class BasicDemo : public DemoApplication
+{
+	public:
+
+	void	initPhysics();
+
+	virtual void clientMoveAndDisplay();
+
+	virtual void displayCallback();
+	
+	virtual void	clientResetScene();
+	
+};
+
+#endif //BASIC_DEMO_H
+

Demos/BasicDemo/CMakeLists.txt

@@ -0,0 +1,61 @@
+# This is basically the overall name of the project in Visual Studio this is the name of the Solution File
+
+
+# For every executable you have with a main method you should have an add_executable line below.
+# For every add executable line you should list every .cpp and .h file you have associated with that executable.  
+
+
+# This is the variable for Windows.  I use this to define the root of my directory structure.
+SET(GLUT_ROOT ${BULLET_PHYSICS_SOURCE_DIR}/Glut)
+
+# You shouldn't have to modify anything below this line 
+########################################################
+
+
+# This is the shortcut to finding GLU, GLUT and OpenGL if they are properly installed on your system
+# This should be the case.
+INCLUDE (${CMAKE_ROOT}/Modules/FindGLU.cmake)
+INCLUDE (${CMAKE_ROOT}/Modules/FindGLUT.cmake) 
+INCLUDE (${CMAKE_ROOT}/Modules/FindOpenGL.cmake)
+
+
+IF (WIN32)
+  # This is the Windows code for which Opengl, and Glut are not properly installed
+  # since I can't install them I must cheat and copy libraries around
+  INCLUDE_DIRECTORIES(${GLUT_ROOT})
+ # LINK_DIRECTORIES(${GLUT_ROOT}\\lib)
+  IF (${GLUT_glut_LIBRARY} MATCHES "GLUT_glut_LIBRARY-NOTFOUND")
+  SET(GLUT_glut_LIBRARY ${BULLET_PHYSICS_SOURCE_DIR}/Glut/glut32.lib)
+ #   LINK_LIBRARIES(${GLUT_ROOT}\\lib\\glut32 ${OPENGL_gl_LIBRARY} ${OPENGL_glU_LIBRARY})
+ #   TARGET_LINK_LIBRARIES(table ${GLUT_ROOT}\\lib\\glut32)
+#
+#    ADD_CUSTOM_COMMAND(TARGET table POST_BUILD COMMAND copy ${GLUT_ROOT}\\lib\\glut32.dll ${GLUT_ROOT}\\bin\\vs2005\\Debug
+#                        COMMAND copy ${GLUT_ROOT}\\lib\\glut32.dll ${GLUT_ROOT}\\bin\\vs2003\\Debug 
+#            COMMAND copy ${GLUT_ROOT}\\lib\\glut32.dll ${GLUT_ROOT}\\bin\\vs6\\Debug)
+  ELSE (${GLUT_glut_LIBRARY} MATCHES "GLUT_glut_LIBRARY-NOTFOUND")
+#    LINK_LIBRARIES(${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glU_LIBRARY}) 
+#    TARGET_LINK_LIBRARIES(table ${GLUT_glut_LIBRARY})
+  ENDIF(${GLUT_glut_LIBRARY} MATCHES "GLUT_glut_LIBRARY-NOTFOUND")
+#  TARGET_LINK_LIBRARIES(table ${OPENGL_gl_LIBRARY})
+#  TARGET_LINK_LIBRARIES(table ${OPENGL_glu_LIBRARY}) 
+ELSE (WIN32)
+  # This is the lines for linux.  This should always work if everything is installed and working fine.
+#  SET(CMAKE_BUILD_TYPE Debug)
+#  SET(CMAKE_CXX_FLAGS_DEBUG "-g")
+  INCLUDE_DIRECTORIES(/usr/include /usr/local/include ${GLUT_INCLUDE_DIR}) 
+#  TARGET_LINK_LIBRARIES(table ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glU_LIBRARY})
+#  TARGET_LINK_LIBRARIES(checker ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glU_LIBRARY})
+ENDIF (WIN32)
+
+INCLUDE_DIRECTORIES(
+${BULLET_PHYSICS_SOURCE_DIR}/src ${BULLET_PHYSICS_SOURCE_DIR}/Demos/OpenGL }
+)
+
+LINK_LIBRARIES(
+LibOpenGLSupport  LibBulletDynamics  LibBulletCollision LibLinearMath    ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glU_LIBRARY}
+)
+
+ADD_EXECUTABLE(BasicDemo
+	BasicDemo.cpp
+)
+

Demos/BasicDemo/Jamfile

@@ -0,0 +1,3 @@
+SubDir TOP Demos BasicDemo ;
+
+BulletDemo BasicDemo : [ Wildcard *.h *.cpp  ] ;

Demos/CMakeLists.txt

@@ -1,2 +1,2 @@
-SUBDIRS( OpenGL CcdPhysicsDemo BspDemo ColladaDemo UserCollisionAlgorithm )
+SUBDIRS( OpenGL CcdPhysicsDemo BasicDemo BspDemo ColladaDemo UserCollisionAlgorithm )
 

Demos/Jamfile

@@ -63,10 +63,12 @@ else
         "../../src" ;
   }
 
+
 SubInclude TOP Demos CcdPhysicsDemo ;
 SubInclude TOP Demos UserCollisionAlgorithm ;
 #SubInclude TOP Demos ForkLiftDemo ;
 SubInclude TOP Demos BspDemo ;
+SubInclude TOP Demos BasicDemo ;
 SubInclude TOP Demos ConvexDecompositionDemo ;
 SubInclude TOP Demos ColladaDemo ;
 SubInclude TOP Demos BspDemo ;

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -32,6 +32,27 @@ int gNumManifold = 0;
 #include <stdio.h>
 
 	
+btCollisionDispatcher::btCollisionDispatcher(bool noDefaultAlgorithms)
+:m_useIslands(true),
+m_count(0),
+m_convexConvexCreateFunc(0),
+m_convexConcaveCreateFunc(0),
+m_swappedConvexConcaveCreateFunc(0),
+m_compoundCreateFunc(0),
+m_swappedCompoundCreateFunc(0),
+m_emptyCreateFunc(0)
+{
+	int i;
+
+	m_emptyCreateFunc = new btEmptyAlgorithm::CreateFunc;
+	for (i=0;i<MAX_BROADPHASE_COLLISION_TYPES;i++)
+	{
+		for (int j=0;j<MAX_BROADPHASE_COLLISION_TYPES;j++)
+		{
+			m_doubleDispatch[i][j] = m_emptyCreateFunc;
+		}
+	}
+}
 
 	
 btCollisionDispatcher::btCollisionDispatcher (): 

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h

@@ -56,8 +56,7 @@ class btCollisionDispatcher : public btDispatcher
 	btCollisionAlgorithmCreateFunc*	m_swappedCompoundCreateFunc;
 	btCollisionAlgorithmCreateFunc*   m_emptyCreateFunc;
 
-	
-
+	btCollisionAlgorithm* internalFindAlgorithm(btCollisionObject* body0,btCollisionObject* body1);
 
 public:
 
@@ -99,7 +98,12 @@ public:
 
 	int m_count;
 	
+	///the default constructor creates/register default collision algorithms, for convex, compound and concave shape support
 	btCollisionDispatcher ();
+
+	///a special constructor that doesn't create/register the default collision algorithms
+	btCollisionDispatcher(bool noDefaultAlgorithms);
+
 	virtual ~btCollisionDispatcher();
 
 	virtual btPersistentManifold*	getNewManifold(void* b0,void* b1);
@@ -111,9 +115,7 @@ public:
 
 			
 	btCollisionAlgorithm* findAlgorithm(btCollisionObject* body0,btCollisionObject* body1);
-	
-	btCollisionAlgorithm* internalFindAlgorithm(btCollisionObject* body0,btCollisionObject* body1);
-	
+		
 	virtual bool	needsCollision(btCollisionObject* body0,btCollisionObject* body1);
 	
 	virtual bool	needsResponse(btCollisionObject* body0,btCollisionObject* body1);

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -26,10 +26,12 @@ m_ownManifold(false),
 m_manifoldPtr(mf),
 m_isSwapped(isSwapped)
 {
+	btCollisionObject* sphereObj = m_isSwapped? col1 : col0;
+	btCollisionObject* boxObj = m_isSwapped? col0 : col1;
 	
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(col0,col1))
+	if (!m_manifoldPtr && m_dispatcher->needsCollision(sphereObj,boxObj))
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(col0,col1);
+		m_manifoldPtr = m_dispatcher->getNewManifold(sphereObj,boxObj);
 		m_ownManifold = true;
 	}
 }

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp

@@ -47,7 +47,7 @@ btSimpleDynamicsWorld::~btSimpleDynamicsWorld()
 		delete m_constraintSolver;
 }
 
-void	btSimpleDynamicsWorld::stepSimulation(float timeStep)
+void	btSimpleDynamicsWorld::stepSimulation(float timeStep,int numSubsteps)
 {
 	///apply gravity, predict motion
 	predictUnconstraintMotion(timeStep);
@@ -56,12 +56,16 @@ void	btSimpleDynamicsWorld::stepSimulation(float timeStep)
 	performDiscreteCollisionDetection();
 
 	///solve contact constraints
-	btPersistentManifold** manifoldPtr = ((btCollisionDispatcher*)m_dispatcher1)->getInternalManifoldPointer();
 	int numManifolds = m_dispatcher1->getNumManifolds();
-	btContactSolverInfo infoGlobal;
-	infoGlobal.m_timeStep = timeStep;
-	
-	m_constraintSolver->solveGroup(manifoldPtr, numManifolds,infoGlobal,m_debugDrawer);
+	if (numManifolds)
+	{
+		btPersistentManifold** manifoldPtr = ((btCollisionDispatcher*)m_dispatcher1)->getInternalManifoldPointer();
+		
+		btContactSolverInfo infoGlobal;
+		infoGlobal.m_timeStep = timeStep;
+		
+		m_constraintSolver->solveGroup(manifoldPtr, numManifolds,infoGlobal,m_debugDrawer);
+	}
 
 	///integrate transforms
 	integrateTransforms(timeStep);

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h

@@ -54,7 +54,7 @@ public:
 
 	virtual ~btSimpleDynamicsWorld();
 		
-	virtual void	stepSimulation( float timeStep);
+	virtual void	stepSimulation( float timeStep,int numSubsteps=1);
 
 	virtual void	setDebugDrawer(btIDebugDraw*	debugDrawer) 
 	{

src/btBulletCollisionCommon.h

@@ -41,7 +41,7 @@ subject to the following restrictions:
 
 ///Narrowphase Collision Detector
 #include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
-
+#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
 
 ///Dispatching and generation of collision pairs (broadphase)
 #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"