X11OpenGLWindow: create stencil buffer for shadows in OpenGL2 mode (OpenGL3 uses shadow maps)

Add 'createCollisionObjectGraphicsObject' API for CommonPhysicsSetup
Add 'pthread' dependency as workaround for NVIDIA graphics driver issue
(see //See https://bugs.launchpad.net/ubuntu/+source/nvidia-graphics-drivers-319/+bug/1248642
)

Demos/CommonMultiBodySetup.h

@@ -0,0 +1,247 @@
+
+#ifndef COMMON_MULTI_BODY_SETUP_H
+#define COMMON_MULTI_BODY_SETUP_H
+
+//todo: replace this 'btBulletDynamicsCommon.h' header with specific used header files
+#include "btBulletDynamicsCommon.h"
+#include "CommonPhysicsSetup.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+
+struct CommonMultiBodySetup : public CommonPhysicsSetup
+{
+		//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+	btBroadphaseInterface*	m_broadphase;
+	btCollisionDispatcher*	m_dispatcher;
+	btMultiBodyConstraintSolver*	m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btMultiBodyDynamicsWorld* m_dynamicsWorld;
+
+	//data for picking objects
+	class btRigidBody*	m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+
+	CommonMultiBodySetup()
+	:m_broadphase(0),
+		m_dispatcher(0),
+		m_solver(0),
+		m_collisionConfiguration(0),
+		m_dynamicsWorld(0),
+		m_pickedBody(0),
+		m_pickedConstraint(0)
+	{
+	}
+
+	virtual void createEmptyDynamicsWorld()
+	{
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);
+
+		m_broadphase = new btDbvtBroadphase();
+
+		m_solver = new btMultiBodyConstraintSolver;
+
+		m_dynamicsWorld = new btMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration);
+
+		m_dynamicsWorld->setGravity(btVector3(0, -10, 0));
+	}
+
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+
+		if (m_dynamicsWorld)
+		{
+
+            int i;
+            for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+            {
+                m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+            }
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j<m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+
+		delete m_solver;
+
+		delete m_broadphase;
+
+		delete m_dispatcher;
+
+		delete m_collisionConfiguration;
+	}
+
+	virtual void syncPhysicsToGraphics(GraphicsPhysicsBridge& gfxBridge)
+	{
+		if (m_dynamicsWorld)
+		{
+			gfxBridge.syncPhysicsToGraphics(m_dynamicsWorld);
+		}
+	}
+
+    virtual void    debugDraw()
+    {
+     	if (m_dynamicsWorld)
+        {
+            m_dynamicsWorld->debugDrawWorld();
+        }
+
+    }
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld==0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody  && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+
+				btVector3 newPivotB;
+
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+				return true;
+			}
+		}
+		return false;
+	}
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+	}
+
+
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	btRigidBody*	createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape,  const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif//
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+};
+
+#endif //COMMON_MULTI_BODY_SETUP_H
+

Demos/CommonPhysicsSetup.h

@@ -3,6 +3,7 @@
 #define COMMON_PHYSICS_SETUP_H
 
 class btRigidBody;
+class btCollisionObject;
 class btBoxShape;
 class btTransform;
 class btCollisionShape;
@@ -18,6 +19,10 @@ struct GraphicsPhysicsBridge
 	virtual void createRigidBodyGraphicsObject(btRigidBody* body,const btVector3& color)
 	{
 	}
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* obj,const btVector3& color)
+	{
+	}
 	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape)
 	{
 	}
@@ -32,11 +37,11 @@ struct GraphicsPhysicsBridge
 	{
 		return 0;
 	}
-	
+
 	virtual void setUpAxis(int axis)
 	{
 	}
-	
+
 };
 
 struct CommonPhysicsSetup

Demos/OpenGL/GL_ShapeDrawer.cpp

@@ -462,7 +462,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 				{
 					const int		s=x>>4;
 					const GLubyte	b=180;					
-					GLubyte			c=b+((s+t&1)&1)*(255-b);
+					GLubyte			c=b+((s+(t&1))&1)*(255-b);
 					pi[0]=pi[1]=pi[2]=pi[3]=c;pi+=3;
 				}
 			}
@@ -518,7 +518,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 
 		glColor3f(color.x(),color.y(), color.z());		
 
-		bool useWireframeFallback = true;
+		//bool useWireframeFallback = true;
 
 		if (!(debugMode & btIDebugDraw::DBG_DrawWireframe))
 		{
@@ -535,7 +535,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
 					float radius = sphereShape->getMargin();//radius doesn't include the margin, so draw with margin
 					drawSphere(radius,10,10);
-					useWireframeFallback = false;
+					//useWireframeFallback = false;
 					break;
 				}
 
@@ -586,7 +586,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					glEnd();
 #endif
 
-					useWireframeFallback = false;
+					//useWireframeFallback = false;
 					break;
 				}
 
@@ -617,7 +617,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 
 					glTranslatef(0.0, 0.0, -0.5*height);
 					glutSolidCone(radius,height,10,10);
-					useWireframeFallback = false;
+					//useWireframeFallback = false;
 					break;
 
 				}

Demos/OpenGL/GlutStuff.cpp

@@ -4,8 +4,8 @@ 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, 
+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.
@@ -17,6 +17,11 @@ subject to the following restrictions:
 
 #include "DemoApplication.h"
 
+#if !defined(_WIN32) && !defined(__APPLE__)
+//assume linux workaround
+#include <pthread.h>
+#endif
+
 //glut is C code, this global gDemoApplication links glut to the C++ demo
 static DemoApplication* gDemoApplication = 0;
 
@@ -74,9 +79,17 @@ static void glutDisplayCallback(void)
 //#include <GL/glut.h>
 
 int glutmain(int argc, char **argv,int width,int height,const char* title,DemoApplication* demoApp) {
-    
+
 	gDemoApplication = demoApp;
 
+#if !defined(_WIN32) && !defined(__APPLE__)
+//Access pthreads as a workaround for a bug in Linux/Ubuntu
+//See https://bugs.launchpad.net/ubuntu/+source/nvidia-graphics-drivers-319/+bug/1248642
+
+	int i=pthread_getconcurrency();
+        printf("pthread_getconcurrency()=%d\n",i);
+#endif
+
 	glutInit(&argc, argv);
     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
     glutInitWindowPosition(width/2, height/2);
@@ -112,7 +125,7 @@ CGLSetParameter(cgl_context, kCGLCPSwapInterval, &swap_interval);
 #endif
 
 
-	
+
     glutMainLoop();
     return 0;
 }

Demos/SerializeDemo/SerializeSetup.cpp

@@ -3,19 +3,59 @@
 
 SerializeSetup::SerializeSetup()
 {
-    
+
 }
 SerializeSetup::~SerializeSetup()
 {
-    
+
 }
-    
+
 void SerializeSetup::initPhysics(GraphicsPhysicsBridge& gfxBridge)
 {
     this->createEmptyDynamicsWorld();
     gfxBridge.createPhysicsDebugDrawer(m_dynamicsWorld);
     m_dynamicsWorld->getDebugDrawer()->setDebugMode(btIDebugDraw::DBG_DrawWireframe);
     btBulletWorldImporter* importer = new btBulletWorldImporter(m_dynamicsWorld);
-    const char* filename = "testFile.bullet";
-    importer->loadFile(filename);
-}
+	const char* someFileName="spider.bullet";
+
+    const char* prefix[]={"./","./data/","../data/","../../data/","../../../data/","../../../../data/"};
+        int numPrefixes = sizeof(prefix)/sizeof(const char*);
+        char relativeFileName[1024];
+        FILE* f=0;
+        bool fileFound = false;
+        int result = 0;
+
+        for (int i=0;!f && i<numPrefixes;i++)
+        {
+                sprintf(relativeFileName,"%s%s",prefix[i],someFileName);
+                f = fopen(relativeFileName,"rb");
+                if (f)
+                {
+                    fileFound = true;
+                    break;
+                }
+        }
+        if (f)
+        {
+                fclose(f);
+        }
+
+
+    importer->loadFile(relativeFileName);
+
+	//for now, guess the up axis from gravity
+	if (m_dynamicsWorld->getGravity()[1] == 0.f)
+	{
+		gfxBridge.setUpAxis(2);
+	} else
+	{
+		gfxBridge.setUpAxis(1);
+	}
+
+
+}
+
+void SerializeSetup::stepSimulation(float deltaTime)
+{
+    CommonRigidBodySetup::stepSimulation(deltaTime);
+}

Demos/SerializeDemo/SerializeSetup.h

@@ -7,8 +7,9 @@ class SerializeSetup : public CommonRigidBodySetup
 public:
     SerializeSetup();
     virtual ~SerializeSetup();
-    
+
 	virtual void initPhysics(GraphicsPhysicsBridge& gfxBridge);
+	virtual void stepSimulation(float deltaTime);
 };
 
 #endif //SERIALIZE_SETUP_H

Demos/premake4.lua

@@ -34,7 +34,7 @@ function createDemos( demos, incdirs, linknames)
 	 		linkoptions { "-framework Carbon -framework OpenGL -framework AGL -framework Glut" } 
 		
 		configuration {"not Windows", "not MacOSX"}
-			links {"GL","GLU","glut"}
+			links {"GL","GLU","glut","pthread"}
 		configuration{}