One of the last parts of the refactoring (hopefully), made most members of btCollisionObject protected.

Also did some work on improving the constraint solver.

Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp

@@ -12,7 +12,6 @@ subject to the following restrictions:
 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_KINEMATIC_GROUND 1
 //#define PRINT_CONTACT_STATISTICS 1
 //#define REGISTER_CUSTOM_COLLISION_ALGORITHM 1
@@ -82,7 +81,7 @@ btCollisionShape* shapePtr[numShapes] =
 	///Please don't make the box sizes larger then 1000: the collision detection will be inaccurate.
 	///See http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=346
 
-#define USE_GROUND_PLANE 1
+//#define USE_GROUND_PLANE 1
 #ifdef USE_GROUND_PLANE
 	new btStaticPlaneShape(btVector3(0,1,0),10),
 #else
@@ -164,6 +163,19 @@ void CcdPhysicsDemo::clientMoveAndDisplay()
 	
 	if (m_dynamicsWorld)
 	{
+
+		//swap solver
+#ifdef COMPARE_WITH_QUICKSTEP
+	   if (m_debugMode & btIDebugDraw::DBG_DisableBulletLCP)
+	   {
+		   m_dynamicsWorld->setConstraintSolver( new OdeConstraintSolver());
+	   } else
+	   {
+		   m_dynamicsWorld->setConstraintSolver( new btSequentialImpulseConstraintSolver());
+	   }
+#endif //COMPARE_WITH_QUICKSTEP
+
+
 		//during idle mode, just run 1 simulation step maximum
 		int maxSimSubSteps = m_idle ? 1 : 1;
 		if (m_idle)
@@ -356,10 +368,10 @@ void	CcdPhysicsDemo::initPhysics()
 		
 		
 		// Only do CCD if  motion in one timestep (1.f/60.f) exceeds CUBE_HALF_EXTENTS
-		body->m_ccdSquareMotionThreshold = CUBE_HALF_EXTENTS;
+		body->setCcdSquareMotionThreshold( CUBE_HALF_EXTENTS );
 		
 		//Experimental: better estimation of CCD Time of Impact:
-		body->m_ccdSweptSphereRadius = 0.2*CUBE_HALF_EXTENTS;
+		body->setCcdSweptSphereRadius( 0.2*CUBE_HALF_EXTENTS );
 
 #ifdef USER_DEFINED_FRICTION_MODEL	
 		///Advanced use: override the friction solver

Demos/ColladaDemo/ColladaConverter.cpp

@@ -543,9 +543,9 @@ void	ColladaConverter::prepareConstraints(ConstraintInput& input)
 					
 					for (int i=0;i<m_numObjects;i++)
 					{
-						if (m_rigidBodies[i]->m_userObjectPointer)
+						if (m_rigidBodies[i]->getUserPointer())
 						{
-							char* bodyName = (char*)m_rigidBodies[i]->m_userObjectPointer;
+							char* bodyName = (char*)m_rigidBodies[i]->getUserPointer();
 							if (!strcmp(bodyName,orgUri0))
 							{
 								body0=m_rigidBodies[i];
@@ -707,7 +707,7 @@ void	ColladaConverter::PreparePhysicsObject(struct btRigidBodyInput& input, bool
 	if (body)
 	{
 		//bodyName is used as identifier for constraints
-		body->m_userObjectPointer = (void*)input.m_bodyName;
+		body->setUserPointer((void*)input.m_bodyName);
 		m_rigidBodies[m_numObjects] = body;
 		m_numObjects++;
 	}
@@ -737,7 +737,7 @@ bool ColladaConverter::saveAs(const char* filename)
 
 				{
 
-					btVector3 np = m_rigidBodies[i]->m_worldTransform.getOrigin();
+					btVector3 np = m_rigidBodies[i]->getWorldTransform().getOrigin();
 					domFloat3 newPos = m_colladadomNodes[i]->getTranslate_array().get(0)->getValue();
 					newPos.set(0,np[0]);
 					newPos.set(1,np[1]);

Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp

@@ -65,8 +65,8 @@ void	CollisionInterfaceDemo::initPhysics()
 	btMatrix3x3 basisB;
 	basisB.setIdentity();
 
-	objects[0].m_worldTransform.setBasis(basisA);
+	objects[0].getWorldTransform().setBasis(basisA);
-	objects[1].m_worldTransform.setBasis(basisB);
+	objects[1].getWorldTransform().setBasis(basisB);
 
 	//btPoint3	points0[3]={btPoint3(1,0,0),btPoint3(0,1,0),btPoint3(0,0,1)};
 	//btPoint3	points1[5]={btPoint3(1,0,0),btPoint3(0,1,0),btPoint3(0,0,1),btPoint3(0,0,-1),btPoint3(-1,-1,0)};
@@ -78,8 +78,8 @@ void	CollisionInterfaceDemo::initPhysics()
 	//ConvexHullShape	hullB(points1,4);
 	//hullB.setLocalScaling(btVector3(4,4,4));
 
-	objects[0].m_collisionShape = boxA;//&hullA;
+	objects[0].setCollisionShape(boxA);//&hullA;
-	objects[1].m_collisionShape = boxB;//&hullB;
+	objects[1].setCollisionShape(boxB);//&hullB;
 
 	btCollisionDispatcher* dispatcher = new btCollisionDispatcher;
 	btVector3	worldAabbMin(-1000,-1000,-1000);
@@ -130,7 +130,7 @@ void CollisionInterfaceDemo::displayCallback(void) {
 		btPersistentManifold* contactManifold = collisionWorld->getDispatcher()->getManifoldByIndexInternal(i);
 		btCollisionObject* obA = static_cast<btCollisionObject*>(contactManifold->getBody0());
 		btCollisionObject* obB = static_cast<btCollisionObject*>(contactManifold->getBody1());
-		contactManifold->refreshContactPoints(obA->m_worldTransform,obB->m_worldTransform);
+		contactManifold->refreshContactPoints(obA->getWorldTransform(),obB->getWorldTransform());
 
 		int numContacts = contactManifold->getNumContacts();
 		for (int j=0;j<numContacts;j++)
@@ -161,17 +161,17 @@ void CollisionInterfaceDemo::displayCallback(void) {
 	for (i=0;i<numObjects;i++)
 	{
 		
-		objects[i].m_worldTransform.getOpenGLMatrix( m );
+		objects[i].getWorldTransform().getOpenGLMatrix( m );
-		GL_ShapeDrawer::drawOpenGL(m,objects[i].m_collisionShape,btVector3(1,1,1),getDebugMode());
+		GL_ShapeDrawer::drawOpenGL(m,objects[i].getCollisionShape(),btVector3(1,1,1),getDebugMode());
 
 	}
 
 
 	btQuaternion orn;
 	orn.setEuler(yaw,pitch,roll);
-	objects[1].m_worldTransform.setOrigin(objects[1].m_worldTransform.getOrigin()+btVector3(0,-0.01,0));
+	objects[1].getWorldTransform().setOrigin(objects[1].getWorldTransform().getOrigin()+btVector3(0,-0.01,0));
 
-	objects[0].m_worldTransform.setRotation(orn);
+	objects[0].getWorldTransform().setRotation(orn);
 
 	pitch += 0.005f;
 	yaw += 0.01f;
@@ -182,8 +182,8 @@ void CollisionInterfaceDemo::displayCallback(void) {
 
 void CollisionInterfaceDemo::clientResetScene()
 {
-	objects[0].m_worldTransform.setOrigin(btVector3(0.0f,3.f,0.f));
+	objects[0].getWorldTransform().setOrigin(btVector3(0.0f,3.f,0.f));
-	objects[1].m_worldTransform.setOrigin(btVector3(0.0f,9.f,0.f));
+	objects[1].getWorldTransform().setOrigin(btVector3(0.0f,9.f,0.f));
 }
 
 

Demos/ConcaveDemo/ConcavePhysicsDemo.cpp

@@ -60,12 +60,12 @@ bool CustomMaterialCombinerCallback(btManifoldPoint& cp,	const btCollisionObject
 	float restitution0 = colObj0->getRestitution();
 	float restitution1 = colObj1->getRestitution();
 
-	if (colObj0->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)
+	if (colObj0->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)
 	{
 		friction0 = 1.0;//partId0,index0
 		restitution0 = 0.f;
 	}
-	if (colObj1->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)
+	if (colObj1->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)
 	{
 		if (index1&1)
 		{
@@ -161,10 +161,10 @@ void	ConcaveDemo::initPhysics()
 
 	btRigidBody* staticBody = localCreateRigidBody(mass, startTransform,trimeshShape);
 
-	staticBody->m_collisionFlags |=btCollisionObject::CF_STATIC_OBJECT;
+	staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT);
 
 	//enable custom material callback
-	staticBody->m_collisionFlags |= btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK;
+	staticBody->setCollisionFlags(staticBody->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
 
 	{
 		for (int i=0;i<10;i++)

Demos/OpenGL/DemoApplication.cpp

@@ -435,8 +435,8 @@ void	DemoApplication::shootBox(const btVector3& destination)
 		linVel.normalize();
 		linVel*=m_ShootBoxInitialSpeed;
 
-		body->m_worldTransform.setOrigin(camPos);
+		body->getWorldTransform().setOrigin(camPos);
-		body->m_worldTransform.setRotation(btQuaternion(0,0,0,1));
+		body->getWorldTransform().setRotation(btQuaternion(0,0,0,1));
 		body->setLinearVelocity(linVel);
 		body->setAngularVelocity(btVector3(0,0,0));
 	}
@@ -597,7 +597,7 @@ void DemoApplication::mouseFunc(int button, int state, int x, int y)
 					//printf("removed constraint %i",gPickingConstraintId);
 					m_pickConstraint = 0;
 					pickedBody->ForceActivationState(ACTIVE_TAG);
-					pickedBody->m_deactivationTime = 0.f;
+					pickedBody->setDeactivationTime( 0.f );
 					pickedBody = 0;
 				}
 
@@ -690,7 +690,7 @@ void DemoApplication::renderme()
 				myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(m);
 			} else
 			{
-				colObj->m_worldTransform.getOpenGLMatrix(m);
+				colObj->getWorldTransform().getOpenGLMatrix(m);
 			}
 
 			btVector3 wireColor(1.f,1.0f,0.5f); //wants deactivation
@@ -720,7 +720,7 @@ void DemoApplication::renderme()
 				}
 			}
 
-			GL_ShapeDrawer::drawOpenGL(m,colObj->m_collisionShape,wireColor,getDebugMode());
+			GL_ShapeDrawer::drawOpenGL(m,colObj->getCollisionShape(),wireColor,getDebugMode());
 		}
 
 
@@ -832,8 +832,8 @@ void	DemoApplication::clientResetScene()
 		{
 			btDefaultMotionState* myMotionState = (btDefaultMotionState*)body->getMotionState();
 			myMotionState->m_graphicsWorldTrans = myMotionState->m_startWorldTrans;
-			colObj->m_worldTransform = myMotionState->m_graphicsWorldTrans;
+			colObj->setWorldTransform( myMotionState->m_graphicsWorldTrans );
-			colObj->m_interpolationWorldTransform = myMotionState->m_startWorldTrans;
+			colObj->setInterpolationWorldTransform( myMotionState->m_startWorldTrans );
 			btRigidBody* body = btRigidBody::upcast(colObj);
 			if (body && !body->isStaticObject())
 			{

Demos/UserCollisionAlgorithm/UserCollisionAlgorithm.cpp

@@ -123,7 +123,7 @@ void	UserCollisionAlgorithm::initPhysics()
 
 	btRigidBody* staticBody= localCreateRigidBody(mass, startTransform,trimeshShape);
 	//enable custom material callback
-	staticBody->m_collisionFlags |= btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK;
+	staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
 
 	{
 		for (int i=0;i<10;i++)

src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h

@@ -19,7 +19,7 @@ subject to the following restrictions:
 struct btBroadphaseProxy;
 class btDispatcher;
 class btManifoldResult;
-struct btCollisionObject;
+class btCollisionObject;
 struct btDispatcherInfo;
 class	btPersistentManifold;
 

src/BulletCollision/BroadphaseCollision/btDispatcher.h

@@ -19,7 +19,7 @@ subject to the following restrictions:
 class btCollisionAlgorithm;
 struct btBroadphaseProxy;
 class btRigidBody;
-struct	btCollisionObject;
+class	btCollisionObject;
 class btOverlappingPairCache;
 
 enum btCollisionDispatcherId

src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h

@@ -18,9 +18,9 @@ subject to the following restrictions:
 
 #include <vector>
 
-typedef std::vector<struct btCollisionObject*> btCollisionObjectArray;
+typedef std::vector<class btCollisionObject*> btCollisionObjectArray;
 class btCollisionAlgorithm;
-struct btCollisionObject;
+class btCollisionObject;
 
 struct btCollisionAlgorithmConstructionInfo;
 

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -150,7 +150,7 @@ btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(btCollisionObject* bo
 	btCollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = this;
 	ci.m_manifold = sharedManifold;
-	btCollisionAlgorithm* algo = m_doubleDispatch[body0->m_collisionShape->getShapeType()][body1->m_collisionShape->getShapeType()]
+	btCollisionAlgorithm* algo = m_doubleDispatch[body0->getCollisionShape()->getShapeType()][body1->getCollisionShape()->getShapeType()]
 	->CreateCollisionAlgorithm(ci,body0,body1);
 #else
 	btCollisionAlgorithm* algo = internalFindAlgorithm(body0,body1);
@@ -201,27 +201,27 @@ btCollisionAlgorithm* btCollisionDispatcher::internalFindAlgorithm(btCollisionOb
 	btCollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = this;
 	
-	if (body0->m_collisionShape->isConvex() && body1->m_collisionShape->isConvex() )
+	if (body0->getCollisionShape()->isConvex() && body1->getCollisionShape()->isConvex() )
 	{
 		return new btConvexConvexAlgorithm(sharedManifold,ci,body0,body1);
 	}
 
-	if (body0->m_collisionShape->isConvex() && body1->m_collisionShape->isConcave())
+	if (body0->getCollisionShape()->isConvex() && body1->getCollisionShape()->isConcave())
 	{
 		return new btConvexConcaveCollisionAlgorithm(ci,body0,body1,false);
 	}
 
-	if (body1->m_collisionShape->isConvex() && body0->m_collisionShape->isConcave())
+	if (body1->getCollisionShape()->isConvex() && body0->getCollisionShape()->isConcave())
 	{
 		return new btConvexConcaveCollisionAlgorithm(ci,body0,body1,true);
 	}
 
-	if (body0->m_collisionShape->isCompound())
+	if (body0->getCollisionShape()->isCompound())
 	{
 		return new btCompoundCollisionAlgorithm(ci,body0,body1,false);
 	} else
 	{
-		if (body1->m_collisionShape->isCompound())
+		if (body1->getCollisionShape()->isCompound())
 		{
 			return new btCompoundCollisionAlgorithm(ci,body0,body1,true);
 		}

src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -34,8 +34,11 @@ class	btCollisionShape;
 /// btCollisionObject can be used to manage collision detection objects. 
 /// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
 /// They can be added to the btCollisionWorld.
-struct	btCollisionObject
+class	btCollisionObject
 {
+
+protected:
+
 	btTransform	m_worldTransform;
 	btBroadphaseProxy*	m_broadphaseHandle;
 	btCollisionShape*		m_collisionShape;
@@ -48,15 +51,6 @@ struct	btCollisionObject
 	btVector3	m_interpolationLinearVelocity;
 	btVector3	m_interpolationAngularVelocity;
 
-
-	enum CollisionFlags
-	{
-		CF_STATIC_OBJECT= 1,
-		CF_KINEMATIC_OJBECT= 2,
-		CF_NO_CONTACT_RESPONSE = 4,
-		CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
-	};
-
 	int				m_collisionFlags;
 
 	int				m_islandTag1;
@@ -66,7 +60,7 @@ struct	btCollisionObject
 	btScalar		m_friction;
 	btScalar		m_restitution;
 
-	///users can point to their objects, m_userPointer is not used by Bullet
+	///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer
 	void*			m_userObjectPointer;
 
 	///m_internalOwner is reserved to point to Bullet's btRigidBody. Don't use this, use m_userObjectPointer instead.
@@ -81,6 +75,17 @@ struct	btCollisionObject
 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
 	float			m_ccdSquareMotionThreshold;
 
+public:
+
+	enum CollisionFlags
+	{
+		CF_STATIC_OBJECT= 1,
+		CF_KINEMATIC_OJBECT= 2,
+		CF_NO_CONTACT_RESPONSE = 4,
+		CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
+	};
+
+
 	inline bool mergesSimulationIslands() const
 	{
 		///static objects, kinematic and object without contact response don't merge islands
@@ -107,20 +112,40 @@ struct	btCollisionObject
 	}
 
 	
-
-
 	btCollisionObject();
 
 
-	void	SetCollisionShape(btCollisionShape* collisionShape)
+	void	setCollisionShape(btCollisionShape* collisionShape)
 	{
 		m_collisionShape = collisionShape;
 	}
 
+	const btCollisionShape*	getCollisionShape() const
+	{
+		return m_collisionShape;
+	}
+
+	btCollisionShape*	getCollisionShape()
+	{
+		return m_collisionShape;
+	}
+
+	
+
+
 	int	GetActivationState() const { return m_activationState1;}
 	
 	void SetActivationState(int newState);
 
+	void	setDeactivationTime(float time)
+	{
+		m_deactivationTime = time;
+	}
+	float	getDeactivationTime() const
+	{
+		return m_deactivationTime;
+	}
+
 	void ForceActivationState(int newState);
 
 	void	activate();
@@ -147,6 +172,141 @@ struct	btCollisionObject
 		return m_friction;
 	}
 
+	///reserved for Bullet internal usage
+	void*	getInternalOwner()
+	{
+		return m_internalOwner;
+	}
+
+	const void*	getInternalOwner() const
+	{
+		return m_internalOwner;
+	}
+
+	btTransform&	getWorldTransform()
+	{
+		return m_worldTransform;
+	}
+
+	const btTransform&	getWorldTransform() const
+	{
+		return m_worldTransform;
+	}
+
+	void	setWorldTransform(const btTransform& worldTrans)
+	{
+		m_worldTransform = worldTrans;
+	}
+
+
+	btBroadphaseProxy*	getBroadphaseHandle()
+	{
+		return m_broadphaseHandle;
+	}
+
+	const btBroadphaseProxy*	getBroadphaseHandle() const
+	{
+		return m_broadphaseHandle;
+	}
+
+	void	setBroadphaseHandle(btBroadphaseProxy* handle)
+	{
+		m_broadphaseHandle = handle;
+	}
+
+
+	const btTransform&	getInterpolationWorldTransform() const
+	{
+		return m_interpolationWorldTransform;
+	}
+
+	btTransform&	getInterpolationWorldTransform()
+	{
+		return m_interpolationWorldTransform;
+	}
+
+	void	setInterpolationWorldTransform(const btTransform&	trans)
+	{
+		m_interpolationWorldTransform = trans;
+	}
+
+
+	const btVector3&	getInterpolationLinearVelocity() const
+	{
+		return m_interpolationLinearVelocity;
+	}
+
+	const btVector3&	getInterpolationAngularVelocity() const
+	{
+		return m_interpolationAngularVelocity;
+	}
+
+	const int getIslandTag() const
+	{
+		return	m_islandTag1;
+	}
+
+	void	setIslandTag(int tag)
+	{
+		m_islandTag1 = tag;
+	}
+
+	const float			getHitFraction() const
+	{
+		return m_hitFraction; 
+	}
+
+	void	setHitFraction(float hitFraction)
+	{
+		m_hitFraction = hitFraction;
+	}
+
+	
+	const int	getCollisionFlags() const
+	{
+		return m_collisionFlags;
+	}
+
+	void	setCollisionFlags(int flags)
+	{
+		m_collisionFlags = flags;
+	}
+	
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
+	float			getCcdSweptSphereRadius() const
+	{
+		return m_ccdSweptSphereRadius;
+	}
+
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
+	void	setCcdSweptSphereRadius(float radius)
+	{
+		m_ccdSweptSphereRadius = radius;
+	}
+
+	float 	getCcdSquareMotionThreshold() const
+	{
+		return m_ccdSquareMotionThreshold;
+	}
+
+
+	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
+	void	setCcdSquareMotionThreshold(float ccdSquareMotionThreshold)
+	{
+		m_ccdSquareMotionThreshold = ccdSquareMotionThreshold;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void*	getUserPointer()
+	{
+		return m_userObjectPointer;
+	}
+	
+	///users can point to their objects, userPointer is not used by Bullet
+	void	setUserPointer(void* userPointer)
+	{
+		m_userObjectPointer = userPointer;
+	}
 
 };
 

src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -60,7 +60,7 @@ btCollisionWorld::~btCollisionWorld()
 	{
 		btCollisionObject* collisionObject= (*i);
 		
-		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
 		if (bp)
 		{
 			//
@@ -98,21 +98,22 @@ void	btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject,sho
 		m_collisionObjects.push_back(collisionObject);
 
 		//calculate new AABB
-		btTransform trans = collisionObject->m_worldTransform;
+		btTransform trans = collisionObject->getWorldTransform();
 
 		btVector3	minAabb;
 		btVector3	maxAabb;
-		collisionObject->m_collisionShape->getAabb(trans,minAabb,maxAabb);
+		collisionObject->getCollisionShape()->getAabb(trans,minAabb,maxAabb);
 
-		int type = collisionObject->m_collisionShape->getShapeType();
+		int type = collisionObject->getCollisionShape()->getShapeType();
-		collisionObject->m_broadphaseHandle = getBroadphase()->createProxy(
+		collisionObject->setBroadphaseHandle( getBroadphase()->createProxy(
 			minAabb,
 			maxAabb,
 			type,
 			collisionObject,
 			collisionFilterGroup,
 			collisionFilterMask
-			);
+			))	;
+
 		
 
 
@@ -132,8 +133,8 @@ void	btCollisionWorld::performDiscreteCollisionDetection()
 	btVector3 aabbMin,aabbMax;
 	for (size_t i=0;i<m_collisionObjects.size();i++)
 	{
-		m_collisionObjects[i]->m_collisionShape->getAabb(m_collisionObjects[i]->m_worldTransform,aabbMin,aabbMax);
+		m_collisionObjects[i]->getCollisionShape()->getAabb(m_collisionObjects[i]->getWorldTransform(),aabbMin,aabbMax);
-		m_broadphasePairCache->setAabb(m_collisionObjects[i]->m_broadphaseHandle,aabbMin,aabbMax);
+		m_broadphasePairCache->setAabb(m_collisionObjects[i]->getBroadphaseHandle(),aabbMin,aabbMax);
 	}
 
 	m_broadphasePairCache->refreshOverlappingPairs();
@@ -155,7 +156,7 @@ void	btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 	
 	{
 		
-		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
 		if (bp)
 		{
 			//
@@ -163,7 +164,7 @@ void	btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 			//
 			getBroadphase()->cleanProxyFromPairs(bp);
 			getBroadphase()->destroyProxy(bp);
-			collisionObject->m_broadphaseHandle = 0;
+			collisionObject->setBroadphaseHandle(0);
 		}
 	}
 
@@ -338,7 +339,7 @@ void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
 
 		//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 		btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-		collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
+		collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
 
 		//check aabb overlap
 
@@ -346,8 +347,8 @@ void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
 		{
 			rayTestSingle(rayFromTrans,rayToTrans,
 				collisionObject,
-					 collisionObject->m_collisionShape,
+					 collisionObject->getCollisionShape(),
-					  collisionObject->m_worldTransform,
+					  collisionObject->getWorldTransform(),
 					  resultCallback);
 			
 		}

src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -194,7 +194,7 @@ public:
 			
 			m_closestHitFraction = rayResult.m_hitFraction;
 			m_collisionObject = rayResult.m_collisionObject;
-			m_hitNormalWorld = m_collisionObject->m_worldTransform.getBasis()*rayResult.m_hitNormalLocal;
+			m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
 			m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
 			return rayResult.m_hitFraction;
 		}

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -23,9 +23,9 @@ btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlg
 {
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
 	btCollisionObject* otherObj = m_isSwapped? body0 : body1;
-	assert (colObj->m_collisionShape->isCompound());
+	assert (colObj->getCollisionShape()->isCompound());
 	
-	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
 	int numChildren = compoundShape->getNumChildShapes();
 	int i;
 	
@@ -33,10 +33,10 @@ btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlg
 	for (i=0;i<numChildren;i++)
 	{
 		btCollisionShape* childShape = compoundShape->getChildShape(i);
-		btCollisionShape* orgShape = colObj->m_collisionShape;
+		btCollisionShape* orgShape = colObj->getCollisionShape();
-		colObj->m_collisionShape = childShape;
+		colObj->setCollisionShape( childShape );
 		m_childCollisionAlgorithms[i] = ci.m_dispatcher->findAlgorithm(colObj,otherObj);
-		colObj->m_collisionShape =orgShape;
+		colObj->setCollisionShape( orgShape );
 	}
 }
 
@@ -56,8 +56,8 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
 	btCollisionObject* otherObj = m_isSwapped? body0 : body1;
 
-	assert (colObj->m_collisionShape->isCompound());
+	assert (colObj->getCollisionShape()->isCompound());
-	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
 
 	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
 	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
@@ -74,18 +74,18 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 		btCollisionShape* childShape = compoundShape->getChildShape(i);
 
 		//backup
-		btTransform	orgTrans = colObj->m_worldTransform;
+		btTransform	orgTrans = colObj->getWorldTransform();
-		btCollisionShape* orgShape = colObj->m_collisionShape;
+		btCollisionShape* orgShape = colObj->getCollisionShape();
 
 		btTransform childTrans = compoundShape->getChildTransform(i);
 		btTransform	newChildWorldTrans = orgTrans*childTrans ;
-		colObj->m_worldTransform = newChildWorldTrans;
+		colObj->setWorldTransform( newChildWorldTrans );
 		//the contactpoint is still projected back using the original inverted worldtrans
-		colObj->m_collisionShape = childShape;
+		colObj->setCollisionShape( childShape );
 		m_childCollisionAlgorithms[i]->processCollision(colObj,otherObj,dispatchInfo,resultOut);
 		//revert back
-		colObj->m_collisionShape =orgShape;
+		colObj->setCollisionShape( orgShape);
-		colObj->m_worldTransform = orgTrans;
+		colObj->setWorldTransform(  orgTrans );
 	}
 }
 
@@ -95,9 +95,9 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
 	btCollisionObject* otherObj = m_isSwapped? body0 : body1;
 
-	assert (colObj->m_collisionShape->isCompound());
+	assert (colObj->getCollisionShape()->isCompound());
 	
-	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
 
 	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
 	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
@@ -116,22 +116,22 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 		btCollisionShape* childShape = compoundShape->getChildShape(i);
 
 		//backup
-		btTransform	orgTrans = colObj->m_worldTransform;
+		btTransform	orgTrans = colObj->getWorldTransform();
-		btCollisionShape* orgShape = colObj->m_collisionShape;
+		btCollisionShape* orgShape = colObj->getCollisionShape();
 
 		btTransform childTrans = compoundShape->getChildTransform(i);
 		btTransform	newChildWorldTrans = orgTrans*childTrans ;
-		colObj->m_worldTransform = newChildWorldTrans;
+		colObj->setWorldTransform( newChildWorldTrans );
 
-		colObj->m_collisionShape = childShape;
+		colObj->setCollisionShape( childShape );
 		float frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);
 		if (frac<hitFraction)
 		{
 			hitFraction = frac;
 		}
 		//revert back
-		colObj->m_collisionShape =orgShape;
+		colObj->setCollisionShape( orgShape);
-		colObj->m_worldTransform = orgTrans;
+		colObj->setWorldTransform( orgTrans);
 	}
 	return hitFraction;
 

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -89,7 +89,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 	if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && m_dispatchInfoPtr->m_debugDraw->getDebugMode() > 0)
 	{
 		btVector3 color(255,255,0);
-		btTransform& tr = ob->m_worldTransform;
+		btTransform& tr = ob->getWorldTransform();
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);
@@ -105,14 +105,14 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 
 	//btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
 	
-	if (m_convexBody->m_collisionShape->isConvex())
+	if (m_convexBody->getCollisionShape()->isConvex())
 	{
 		btTriangleShape tm(triangle[0],triangle[1],triangle[2]);	
 		tm.setMargin(m_collisionMarginTriangle);
 	
 		
-		btCollisionShape* tmpShape = ob->m_collisionShape;
+		btCollisionShape* tmpShape = ob->getCollisionShape();
-		ob->m_collisionShape = &tm;
+		ob->setCollisionShape( &tm );
 		
 
 		btCollisionAlgorithm* colAlgo = ci.m_dispatcher->findAlgorithm(m_convexBody,m_triBody,m_manifoldPtr);
@@ -124,7 +124,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 //		cvxcvxalgo.processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut);
 		colAlgo->processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut);
 		delete colAlgo;
-		ob->m_collisionShape = tmpShape;
+		ob->setCollisionShape( tmpShape );
 
 	}
 
@@ -142,8 +142,8 @@ void	btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTrian
 
 	//recalc aabbs
 	btTransform convexInTriangleSpace;
-	convexInTriangleSpace = m_triBody->m_worldTransform.inverse() * m_convexBody->m_worldTransform;
+	convexInTriangleSpace = m_triBody->getWorldTransform().inverse() * m_convexBody->getWorldTransform();
-	btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->m_collisionShape);
+	btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->getCollisionShape());
 	//CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
 	convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
 	float extraMargin = collisionMarginTriangle;
@@ -167,14 +167,14 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod
 	btCollisionObject* convexBody = m_isSwapped ? body1 : body0;
 	btCollisionObject* triBody = m_isSwapped ? body0 : body1;
 
-	if (triBody->m_collisionShape->isConcave())
+	if (triBody->getCollisionShape()->isConcave())
 	{
 
 
 		btCollisionObject*	triOb = triBody;
-		ConcaveShape* concaveShape = static_cast<ConcaveShape*>( triOb->m_collisionShape);
+		ConcaveShape* concaveShape = static_cast<ConcaveShape*>( triOb->getCollisionShape());
 		
-		if (convexBody->m_collisionShape->isConvex())
+		if (convexBody->getCollisionShape()->isConvex())
 		{
 			float collisionMarginTriangle = concaveShape->getMargin();
 					
@@ -207,8 +207,8 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 
 	//only perform CCD above a certain threshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
-	float squareMot0 = (convexbody->m_interpolationWorldTransform.getOrigin() - convexbody->m_worldTransform.getOrigin()).length2();
+	float squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
-	if (squareMot0 < convexbody->m_ccdSquareMotionThreshold)
+	if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
 	{
 		return 1.f;
 	}
@@ -217,9 +217,9 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 	//btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
 	//todo: only do if the motion exceeds the 'radius'
 
-	btTransform triInv = triBody->m_worldTransform.inverse();
+	btTransform triInv = triBody->getWorldTransform().inverse();
-	btTransform convexFromLocal = triInv * convexbody->m_worldTransform;
+	btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
-	btTransform convexToLocal = triInv * convexbody->m_interpolationWorldTransform;
+	btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform();
 
 	struct LocalTriangleSphereCastCallback	: public btTriangleCallback
 	{
@@ -270,24 +270,25 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 	
 
 	
-	if (triBody->m_collisionShape->isConcave())
+	if (triBody->getCollisionShape()->isConcave())
 	{
 		btVector3 rayAabbMin = convexFromLocal.getOrigin();
 		rayAabbMin.setMin(convexToLocal.getOrigin());
 		btVector3 rayAabbMax = convexFromLocal.getOrigin();
 		rayAabbMax.setMax(convexToLocal.getOrigin());
-		rayAabbMin -= btVector3(convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius);
+		float ccdRadius0 = convexbody->getCcdSweptSphereRadius();
-		rayAabbMax += btVector3(convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius);
+		rayAabbMin -= btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
+		rayAabbMax += btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
 
 		float curHitFraction = 1.f; //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
-		convexbody->m_ccdSweptSphereRadius,curHitFraction);
+			convexbody->getCcdSweptSphereRadius(),curHitFraction);
 
-		raycastCallback.m_hitFraction = convexbody->m_hitFraction;
+		raycastCallback.m_hitFraction = convexbody->getHitFraction();
 
 		btCollisionObject* concavebody = triBody;
 
-		ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->m_collisionShape;
+		ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->getCollisionShape();
 		
 		if (triangleMesh)
 		{
@@ -296,9 +297,9 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 	
 
 
-		if (raycastCallback.m_hitFraction < convexbody->m_hitFraction)
+		if (raycastCallback.m_hitFraction < convexbody->getHitFraction())
 		{
-			convexbody->m_hitFraction = raycastCallback.m_hitFraction;
+			convexbody->setHitFraction( raycastCallback.m_hitFraction);
 			return raycastCallback.m_hitFraction;
 		}
 	}

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -157,8 +157,8 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
 
 	checkPenetrationDepthSolver();
 
-	btConvexShape* min0 = static_cast<btConvexShape*>(body0->m_collisionShape);
+	btConvexShape* min0 = static_cast<btConvexShape*>(body0->getCollisionShape());
-	btConvexShape* min1 = static_cast<btConvexShape*>(body1->m_collisionShape);
+	btConvexShape* min1 = static_cast<btConvexShape*>(body1->getCollisionShape());
 	
 	btGjkPairDetector::ClosestPointInput input;
 
@@ -170,8 +170,8 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
 	
 //	input.m_maximumDistanceSquared = 1e30f;
 	
-	input.m_transformA = body0->m_worldTransform;
+	input.m_transformA = body0->getWorldTransform();
-	input.m_transformB = body1->m_worldTransform;
+	input.m_transformB = body1->getWorldTransform();
 	
 	resultOut->setPersistentManifold(m_manifoldPtr);
 	m_gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
@@ -190,14 +190,13 @@ float	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC
 	float resultFraction = 1.f;
 
 
-	float squareMot0 = (col0->m_interpolationWorldTransform.getOrigin() - col0->m_worldTransform.getOrigin()).length2();
+	float squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2();
+	float squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2();
     
-	if (squareMot0 < col0->m_ccdSquareMotionThreshold &&
+	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
-		squareMot0 < col0->m_ccdSquareMotionThreshold)
+		squareMot1 < col1->getCcdSquareMotionThreshold())
 		return resultFraction;
 
-
-
 	if (disableCcd)
 		return 1.f;
 
@@ -212,26 +211,26 @@ float	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC
 		
 	/// Convex0 against sphere for Convex1
 	{
-		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->m_collisionShape);
+		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->getCollisionShape());
 
-		btSphereShape	sphere1(col1->m_ccdSweptSphereRadius); //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape	sphere1(col1->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1( convex0 ,&sphere1,&voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform,
+		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(),
-			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+			col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result))
 		{
 		
 			//store result.m_fraction in both bodies
 		
-			if (col0->m_hitFraction	> result.m_fraction)
+			if (col0->getHitFraction()> result.m_fraction)
-				col0->m_hitFraction  = result.m_fraction;
+				col0->setHitFraction( result.m_fraction );
 
-			if (col1->m_hitFraction > result.m_fraction)
+			if (col1->getHitFraction() > result.m_fraction)
-				col1->m_hitFraction  = result.m_fraction;
+				col1->setHitFraction( result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;
@@ -245,26 +244,26 @@ float	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC
 
 	/// Sphere (for convex0) against Convex1
 	{
-		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->m_collisionShape);
+		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->getCollisionShape());
 
-		btSphereShape	sphere0(col0->m_ccdSweptSphereRadius); //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape	sphere0(col0->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1(&sphere0,convex1,&voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform,
+		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(),
-			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+			col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result))
 		{
 		
 			//store result.m_fraction in both bodies
 		
-			if (col0->m_hitFraction	> result.m_fraction)
+			if (col0->getHitFraction()	> result.m_fraction)
-				col0->m_hitFraction  = result.m_fraction;
+				col0->setHitFraction( result.m_fraction);
 
-			if (col1->m_hitFraction > result.m_fraction)
+			if (col1->getHitFraction() > result.m_fraction)
-				col1->m_hitFraction  = result.m_fraction;
+				col1->setHitFraction( result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;

src/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -48,8 +48,8 @@ btManifoldResult::btManifoldResult(btCollisionObject* body0,btCollisionObject* b
 		m_body0(body0),
 		m_body1(body1)
 {
-	m_rootTransA = body0->m_worldTransform;
+	m_rootTransA = body0->getWorldTransform();
-	m_rootTransB = body1->m_worldTransform;
+	m_rootTransB = body1->getWorldTransform();
 }
 
 
@@ -81,8 +81,8 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const b
 	//User can override friction and/or restitution
 	if (gContactAddedCallback &&
 		//and if either of the two bodies requires custom material
-		 ((m_body0->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) ||
+		 ((m_body0->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) ||
-		   (m_body1->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)))
+		   (m_body1->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)))
 	{
 		//experimental feature info, for per-triangle material etc.
 		btCollisionObject* obj0 = isSwapped? m_body1 : m_body0;

src/BulletCollision/CollisionDispatch/btManifoldResult.h

@@ -17,10 +17,12 @@ subject to the following restrictions:
 #ifndef MANIFOLD_RESULT_H
 #define MANIFOLD_RESULT_H
 
-#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+class btCollisionObject;
-struct btCollisionObject;
 class btPersistentManifold;
 class btManifoldPoint;
+
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+
 #include "LinearMath/btTransform.h"
 
 typedef bool (*ContactAddedCallback)(btManifoldPoint& cp,	const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1);

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -42,8 +42,8 @@ void btSimulationIslandManager::findUnions(btDispatcher* dispatcher)
 				((colObj1) && ((colObj1)->mergesSimulationIslands())))
 			{
 
-				m_unionFind.unite((colObj0)->m_islandTag1,
+				m_unionFind.unite((colObj0)->getIslandTag(),
-					(colObj1)->m_islandTag1);
+					(colObj1)->getIslandTag());
 			}
 		}
 	}
@@ -65,8 +65,8 @@ void	btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 		{
 			
 			btCollisionObject*	collisionObject= (*i);
-			collisionObject->m_islandTag1 = index;
+			collisionObject->setIslandTag(index);
-			collisionObject->m_hitFraction = 1.f;
+			collisionObject->setHitFraction(1.f);
 			index++;
 			
 		}
@@ -98,10 +98,10 @@ void	btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* col
 			
 			if (collisionObject->mergesSimulationIslands())
 			{
-				collisionObject->m_islandTag1 = m_unionFind.find(index);
+				collisionObject->setIslandTag( m_unionFind.find(index) );
 			} else
 			{
-				collisionObject->m_islandTag1 = -1;
+				collisionObject->setIslandTag(-1);
 			}
 			index++;
 		}
@@ -113,7 +113,7 @@ inline	int	getIslandId(const btPersistentManifold* lhs)
 	int islandId;
 	const btCollisionObject* rcolObj0 = static_cast<const btCollisionObject*>(lhs->getBody0());
 	const btCollisionObject* rcolObj1 = static_cast<const btCollisionObject*>(lhs->getBody1());
-	islandId= rcolObj0->m_islandTag1>=0?rcolObj0->m_islandTag1:rcolObj1->m_islandTag1;
+	islandId= rcolObj0->getIslandTag()>=0?rcolObj0->getIslandTag():rcolObj1->getIslandTag();
 	return islandId;
 
 }
@@ -158,13 +158,13 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 			int i = getUnionFind().getElement(idx).m_sz;
 
 			btCollisionObject* colObj0 = collisionObjects[i];
-			if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+			if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
 			{
 				printf("error in island management\n");
 			}
 
-			assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+			assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
-			if (colObj0->m_islandTag1 == islandId)
+			if (colObj0->getIslandTag() == islandId)
 			{
 				if (colObj0->GetActivationState()== ACTIVE_TAG)
 				{
@@ -184,14 +184,14 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 			{
 				int i = getUnionFind().getElement(idx).m_sz;
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
 				{
 					printf("error in island management\n");
 				}
 
-				assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+				assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
 
-				if (colObj0->m_islandTag1 == islandId)
+				if (colObj0->getIslandTag() == islandId)
 				{
 					colObj0->SetActivationState( ISLAND_SLEEPING );
 				}
@@ -205,14 +205,14 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 				int i = getUnionFind().getElement(idx).m_sz;
 
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
 				{
 					printf("error in island management\n");
 				}
 
-				assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+				assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
 
-				if (colObj0->m_islandTag1 == islandId)
+				if (colObj0->getIslandTag() == islandId)
 				{
 					if ( colObj0->GetActivationState() == ISLAND_SLEEPING)
 					{

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -57,11 +57,11 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b
 	btCollisionObject* boxObj = m_isSwapped? body0 : body1;
 
 
-	btSphereShape* sphere0 = (btSphereShape*)sphereObj ->m_collisionShape;
+	btSphereShape* sphere0 = (btSphereShape*)sphereObj->getCollisionShape();
 
 	btVector3 normalOnSurfaceB;
 	btVector3 pOnBox,pOnSphere;
-	btVector3 sphereCenter = sphereObj->m_worldTransform.getOrigin();
+	btVector3 sphereCenter = sphereObj->getWorldTransform().getOrigin();
 	btScalar radius = sphere0->getRadius();
 	
 	float dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);
@@ -93,14 +93,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 
 	btScalar margins;
 	btVector3 bounds[2];
-	btBoxShape* boxShape= (btBoxShape*)boxObj->m_collisionShape;
+	btBoxShape* boxShape= (btBoxShape*)boxObj->getCollisionShape();
 	
 	bounds[0] = -boxShape->getHalfExtents();
 	bounds[1] = boxShape->getHalfExtents();
 
 	margins = boxShape->getMargin();//also add sphereShape margin?
 
-	const btTransform&	m44T = boxObj->m_worldTransform;
+	const btTransform&	m44T = boxObj->getWorldTransform();
 
 	btVector3	boundsVec[2];
 	btScalar	fPenetration;
@@ -209,7 +209,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject*
 	n[4].setValue(  0.0f,  1.0f,  0.0f );
 	n[5].setValue(  0.0f,  0.0f,  1.0f );
 
-	const btTransform&	m44T = boxObj->m_worldTransform;
+	const btTransform&	m44T = boxObj->getWorldTransform();
 
 	// convert  point in local space
 	prel = m44T.invXform( sphereCenter);

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -44,10 +44,10 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0
 	if (!m_manifoldPtr)
 		return;
 
-	btSphereShape* sphere0 = (btSphereShape*)col0->m_collisionShape;
+	btSphereShape* sphere0 = (btSphereShape*)col0->getCollisionShape();
-	btSphereShape* sphere1 = (btSphereShape*)col1->m_collisionShape;
+	btSphereShape* sphere1 = (btSphereShape*)col1->getCollisionShape();
 
-	btVector3 diff = col0->m_worldTransform.getOrigin()-  col1->m_worldTransform.getOrigin();
+	btVector3 diff = col0->getWorldTransform().getOrigin()-  col1->getWorldTransform().getOrigin();
 	float len = diff.length();
 	btScalar radius0 = sphere0->getRadius();
 	btScalar radius1 = sphere1->getRadius();
@@ -61,9 +61,9 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0
 
 	btVector3 normalOnSurfaceB = diff / len;
 	///point on A (worldspace)
-	btVector3 pos0 = col0->m_worldTransform.getOrigin() - radius0 * normalOnSurfaceB;
+	btVector3 pos0 = col0->getWorldTransform().getOrigin() - radius0 * normalOnSurfaceB;
 	///point on B (worldspace)
-	btVector3 pos1 = col1->m_worldTransform.getOrigin() + radius1* normalOnSurfaceB;
+	btVector3 pos1 = col1->getWorldTransform().getOrigin() + radius1* normalOnSurfaceB;
 
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
 	resultOut->setPersistentManifold(m_manifoldPtr);

src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp

@@ -48,8 +48,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co
 	if (!m_manifoldPtr)
 		return;
 
-	btSphereShape* sphere = (btSphereShape*)col0->m_collisionShape;
+	btSphereShape* sphere = (btSphereShape*)col0->getCollisionShape();
-	btTriangleShape* triangle = (btTriangleShape*)col1->m_collisionShape;
+	btTriangleShape* triangle = (btTriangleShape*)col1->getCollisionShape();
 	
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
 	resultOut->setPersistentManifold(m_manifoldPtr);
@@ -57,8 +57,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co
 	
 	btDiscreteCollisionDetectorInterface::ClosestPointInput input;
 	input.m_maximumDistanceSquared = 1e30f;//todo: tighter bounds
-	input.m_transformA = col0->m_worldTransform;
+	input.m_transformA = col0->getWorldTransform();
-	input.m_transformB = col1->m_worldTransform;
+	input.m_transformB = col1->getWorldTransform();
 
 	detector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
 

src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h

@@ -14,8 +14,8 @@ subject to the following restrictions:
 */
 
 
-#ifndef DISCRETE_COLLISION_DETECTOR_INTERFACE_H
+#ifndef DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
-#define DISCRETE_COLLISION_DETECTOR_INTERFACE_H
+#define DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
 #include "LinearMath/btTransform.h"
 #include "LinearMath/btVector3.h"
 
@@ -84,4 +84,4 @@ struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
 		}
 };
 
-#endif //DISCRETE_COLLISION_DETECTOR_INTERFACE_H
+#endif //DISCRETE_COLLISION_DETECTOR_INTERFACE1_H

src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp

@@ -164,7 +164,8 @@ float resolveSingleFriction(
 	float combinedFriction = cpd->m_friction;
 	
 	btScalar limit = cpd->m_appliedImpulse * combinedFriction;
-	//if (contactPoint.m_appliedImpulse>0.f)
+	
+	if (cpd->m_appliedImpulse>0.f)
 	//friction
 	{
 		//apply friction in the 2 tangential directions
@@ -182,11 +183,12 @@ float resolveSingleFriction(
 
 			// calculate j that moves us to zero relative velocity
 			j1 = -vrel * cpd->m_jacDiagABInvTangent0;
-			float total = cpd->m_accumulatedTangentImpulse0 + j1;
+			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse0;
-			GEN_set_min(total, limit);
+			cpd->m_accumulatedTangentImpulse0 = oldTangentImpulse + j1;
-			GEN_set_max(total, -limit);
+			GEN_set_min(cpd->m_accumulatedTangentImpulse0, limit);
-			j1 = total - cpd->m_accumulatedTangentImpulse0;
+			GEN_set_max(cpd->m_accumulatedTangentImpulse0, -limit);
-			cpd->m_accumulatedTangentImpulse0 = total;
+			j1 = cpd->m_accumulatedTangentImpulse0 - oldTangentImpulse;
+
 		}
 		{
 			// 2nd tangent
@@ -195,11 +197,11 @@ float resolveSingleFriction(
 			
 			// calculate j that moves us to zero relative velocity
 			j2 = -vrel * cpd->m_jacDiagABInvTangent1;
-			float total = cpd->m_accumulatedTangentImpulse1 + j2;
+			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse1;
-			GEN_set_min(total, limit);
+			cpd->m_accumulatedTangentImpulse1 = oldTangentImpulse + j2;
-			GEN_set_max(total, -limit);
+			GEN_set_min(cpd->m_accumulatedTangentImpulse1, limit);
-			j2 = total - cpd->m_accumulatedTangentImpulse1;
+			GEN_set_max(cpd->m_accumulatedTangentImpulse1, -limit);
-			cpd->m_accumulatedTangentImpulse1 = total;
+			j2 = cpd->m_accumulatedTangentImpulse1 - oldTangentImpulse;
 		}
 
 #ifdef USE_INTERNAL_APPLY_IMPULSE

src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp

@@ -32,6 +32,21 @@ int totalCpd = 0;
 
 int	gTotalContactPoints = 0;
 
+#define SEQUENTIAL_IMPULSE_MAX_SOLVER_BODIES 16384
+static int	gOrder[SEQUENTIAL_IMPULSE_MAX_SOLVER_BODIES];
+static unsigned long btSeed2 = 0;
+unsigned long btRand2()
+{
+  btSeed2 = (1664525L*btSeed2 + 1013904223L) & 0xffffffff;
+  return btSeed2;
+}
+
+int btRandInt2 (int n)
+{
+  float a = float(n) / 4294967296.0f;
+  return (int) (float(btRand2()) * a);
+}
+
 bool  MyContactDestroyedCallback(void* userPersistentData)
 {
 	assert (userPersistentData);
@@ -73,48 +88,40 @@ float btSequentialImpulseConstraintSolver::solveGroup(btPersistentManifold** man
 		int j;
 		for (j=0;j<numManifolds;j++)
 		{
-			int k=j;
+			gOrder[j] = j;
-			prepareConstraints(manifoldPtr[k],info,debugDrawer);
+			prepareConstraints(manifoldPtr[j],info,debugDrawer);
-			solve(manifoldPtr[k],info,0,debugDrawer);
 		}
 	}
 	
 	
 	//should traverse the contacts random order...
-	int i;
+	int iteration;
-	for ( i = 0;i<numiter-1;i++)
+	for ( iteration = 0;iteration<numiter-1;iteration++)
 	{
 		int j;
+		if ((iteration & 7) == 0) {
+			for (j=0; j<numManifolds; ++j) {
+				int tmp = gOrder[j];
+				int swapi = btRandInt2(j+1);
+				gOrder[j] = gOrder[swapi];
+				gOrder[swapi] = tmp;
+			}
+		}
+
 		for (j=0;j<numManifolds;j++)
 		{
-			int k=j;
+			solve(manifoldPtr[gOrder[j]],info,iteration,debugDrawer);
-			if (i&1)
-				k=numManifolds-j-1;
-
-			solve(manifoldPtr[k],info,i,debugDrawer);
 		}
 
+	
+		for (j=0;j<numManifolds;j++)
+		{
+			solveFriction(manifoldPtr[gOrder[j]],info,iteration,debugDrawer);
+		}
 	}
+		
 #ifdef USE_PROFILE
 	btProfiler::endBlock("solve");
-
-	btProfiler::beginBlock("solveFriction");
-#endif //USE_PROFILE
-
-	//now solve the friction		
-	for (i = 0;i<numiter-1;i++)
-	{
-		int j;
-	for (j=0;j<numManifolds;j++)
-		{
-			int k = j;
-			if (i&1)
-				k=numManifolds-j-1;
-			solveFriction(manifoldPtr[k],info,i,debugDrawer);
-		}
-	}
-#ifdef USE_PROFILE
-	btProfiler::endBlock("solveFriction");
 #endif //USE_PROFILE
 
 	return 0.f;
@@ -225,7 +232,7 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 				
 				btScalar penVel = -cpd->m_penetration/info.m_timeStep;
 
-				if (cpd->m_restitution >= penVel)
+				if (cpd->m_restitution > penVel)
 				{
 					cpd->m_penetration = 0.f;
 				} 				
@@ -233,7 +240,7 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 				
 
 				float relaxation = info.m_damping;
-				cpd->m_appliedImpulse *= relaxation;
+				cpd->m_appliedImpulse =0.f;//*= relaxation;
 				//for friction
 				cpd->m_prevAppliedImpulse = cpd->m_appliedImpulse;
 				
@@ -260,8 +267,8 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 
 				btVector3 totalImpulse = 
 	#ifndef NO_FRICTION_WARMSTART
-					cp.m_frictionWorldTangential0*cp.m_accumulatedTangentImpulse0+
+					cpd->m_frictionWorldTangential0*cpd->m_accumulatedTangentImpulse0+
-					cp.m_frictionWorldTangential1*cp.m_accumulatedTangentImpulse1+
+					cpd->m_frictionWorldTangential1*cpd->m_accumulatedTangentImpulse1+
 	#endif //NO_FRICTION_WARMSTART
 					cp.m_normalWorldOnB*cpd->m_appliedImpulse;
 
@@ -320,10 +327,6 @@ float btSequentialImpulseConstraintSolver::solve(btPersistentManifold* manifoldP
 		{
 
 			int j=i;
-			if (iter % 2)
-				j = numpoints-1-i;
-			else
-				j=i;
 		
 			btManifoldPoint& cp = manifoldPtr->getContactPoint(j);
 				if (cp.getDistance() <= 0.f)
@@ -367,8 +370,6 @@ float btSequentialImpulseConstraintSolver::solveFriction(btPersistentManifold* m
 		{
 
 			int j=i;
-			//if (iter % 2)
-			//	j = numpoints-1-i;
 		
 			btManifoldPoint& cp = manifoldPtr->getContactPoint(j);
 			if (cp.getDistance() <= 0.f)

src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp

@@ -17,7 +17,7 @@ subject to the following restrictions:
 #include "btTypedConstraint.h"
 #include "BulletDynamics/Dynamics/btRigidBody.h"
 
-static btRigidBody s_fixed(0, btTransform::getIdentity(),0);
+static btRigidBody s_fixed(0, 0,0);
 
 btTypedConstraint::btTypedConstraint()
 : m_userConstraintType(-1),

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp

@@ -56,9 +56,9 @@ subject to the following restrictions:
 
 #include <algorithm>
 
-btDiscreteDynamicsWorld::btDiscreteDynamicsWorld()
+btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btConstraintSolver* constraintSolver)
 :btDynamicsWorld(),
-m_constraintSolver(new btSequentialImpulseConstraintSolver),
+m_constraintSolver(constraintSolver? constraintSolver: new btSequentialImpulseConstraintSolver),
 m_debugDrawer(0),
 m_gravity(0,-10,0),
 m_localTime(1.f/60.f),
@@ -66,8 +66,7 @@ m_profileTimings(0)
 {
 	m_islandManager = new btSimulationIslandManager();
 	m_ownsIslandManager = true;
-	m_ownsConstraintSolver = true;
+	m_ownsConstraintSolver = (constraintSolver==0);
-
 }
 
 btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache,btConstraintSolver* constraintSolver)
@@ -142,7 +141,7 @@ void	btDiscreteDynamicsWorld::synchronizeMotionStates()
 				}
 			};
 
-			debugDrawObject(colObj->m_worldTransform,colObj->m_collisionShape,color);
+			debugDrawObject(colObj->getWorldTransform(),colObj->getCollisionShape(),color);
 		}
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body && body->getMotionState() && !body->isStaticOrKinematicObject())
@@ -150,8 +149,8 @@ void	btDiscreteDynamicsWorld::synchronizeMotionStates()
 			if (body->GetActivationState() != ISLAND_SLEEPING)
 			{
 				btTransform interpolatedTransform;
-				btTransformUtil::integrateTransform(body->m_interpolationWorldTransform,
+				btTransformUtil::integrateTransform(body->getInterpolationWorldTransform(),
-					body->m_interpolationLinearVelocity,body->m_interpolationAngularVelocity,m_localTime,interpolatedTransform);
+					body->getInterpolationLinearVelocity(),body->getInterpolationAngularVelocity(),m_localTime,interpolatedTransform);
 				body->getMotionState()->setWorldTransform(interpolatedTransform);
 			}
 		}
@@ -439,8 +438,8 @@ void	btDiscreteDynamicsWorld::calculateSimulationIslands()
 				if (colObj0->IsActive() || colObj1->IsActive())
 				{
 
-					getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1,
+					getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(),
-						(colObj1)->m_islandTag1);
+						(colObj1)->getIslandTag());
 				}
 			}
 		}
@@ -501,13 +500,13 @@ void	btDiscreteDynamicsWorld::updateAabbs()
 		//	if (body->IsActive() && (!body->IsStatic()))
 			{
 				btPoint3 minAabb,maxAabb;
-				colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb,maxAabb);
+				colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
 				btSimpleBroadphase* bp = (btSimpleBroadphase*)m_broadphasePairCache;
 
 				//moving objects should be moderately sized, probably something wrong if not
 				if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < 1e12f))
 				{
-					bp->setAabb(body->m_broadphaseHandle,minAabb,maxAabb);
+					bp->setAabb(body->getBroadphaseHandle(),minAabb,maxAabb);
 				} else
 				{
 					//something went wrong, investigate
@@ -575,7 +574,7 @@ void	btDiscreteDynamicsWorld::predictUnconstraintMotion(float timeStep)
 				{
 					body->applyForces( timeStep);
 					body->integrateVelocities( timeStep);
-					body->predictIntegratedTransform(timeStep,body->m_interpolationWorldTransform);
+					body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform());
 				}
 			}
 		}
@@ -768,3 +767,13 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 		}
 	}
 }
+
+void	btDiscreteDynamicsWorld::setConstraintSolver(btConstraintSolver* solver)
+{
+	if (m_ownsConstraintSolver)
+	{
+		delete m_constraintSolver;
+	}
+	m_ownsConstraintSolver = false;
+	m_constraintSolver = solver;
+}

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h

@@ -86,7 +86,7 @@ public:
 	btDiscreteDynamicsWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache,btConstraintSolver* constraintSolver=0);
 
 	///this btDiscreteDynamicsWorld will create and own dispatcher, pairCache and constraintSolver, and deletes it in the destructor.
-	btDiscreteDynamicsWorld();
+	btDiscreteDynamicsWorld(btConstraintSolver* constraintSolver = 0);
 		
 	virtual ~btDiscreteDynamicsWorld();
 
@@ -136,6 +136,7 @@ public:
 
 	void	debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
 
+	virtual void	setConstraintSolver(btConstraintSolver* solver);
 
 };
 

src/BulletDynamics/Dynamics/btDynamicsWorld.h

@@ -19,6 +19,8 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
 class btTypedConstraint;
 class btRaycastVehicle;
+class btConstraintSolver;
+
 
 ///btDynamicsWorld is the baseclass for several dynamics implementation, basic, discrete, parallel, and continuous
 class btDynamicsWorld : public btCollisionWorld
@@ -65,6 +67,8 @@ class btDynamicsWorld : public btCollisionWorld
 
 		virtual void	removeRigidBody(btRigidBody* body) = 0;
 
+		virtual void	setConstraintSolver(btConstraintSolver* solver) = 0;
+
 };
 
 #endif //BT_DYNAMICS_WORLD_H

src/BulletDynamics/Dynamics/btRigidBody.cpp

@@ -42,7 +42,13 @@ btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShap
 	m_frictionSolverType(0)
 {
 
-	motionState->getWorldTransform(m_worldTransform);
+	if (motionState)
+	{
+		motionState->getWorldTransform(m_worldTransform);
+	} else
+	{
+		m_worldTransform = btTransform::getIdentity();
+	}
 
 	m_interpolationWorldTransform = m_worldTransform;
 	m_interpolationLinearVelocity.setValue(0,0,0);
@@ -64,7 +70,7 @@ btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShap
 
 }
 
-
+#ifdef OBSOLETE_MOTIONSTATE_LESS
 btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisionShape* collisionShape,const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution)
 : 
 	m_gravity(0.0f, 0.0f, 0.0f),
@@ -100,30 +106,34 @@ btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisi
 
 }
 
+#endif //OBSOLETE_MOTIONSTATE_LESS
+
+
 #define EXPERIMENTAL_JITTER_REMOVAL 1
 #ifdef EXPERIMENTAL_JITTER_REMOVAL
-//Bullet 2.20b has experimental code to reduce jitter just before objects fall asleep/deactivate
+//Bullet 2.20b has experimental damping code to reduce jitter just before objects fall asleep/deactivate
-//doesn't work very well yet (value 0 only reduces performance a bit, no difference in functionality)
+//doesn't work very well yet (value 0 disabled this damping)
-float gClippedAngvelThresholdSqr = 0.f;
+//note there this influences deactivation thresholds!
-float	gClippedLinearThresholdSqr = 0.f;
+float gClippedAngvelThresholdSqr = 0.01f;
+float	gClippedLinearThresholdSqr = 0.01f;
+float	gJitterVelocityDampingFactor = 1.0f;
 #endif //EXPERIMENTAL_JITTER_REMOVAL
 
 void btRigidBody::predictIntegratedTransform(btScalar timeStep,btTransform& predictedTransform) 
 {
 
 #ifdef EXPERIMENTAL_JITTER_REMOVAL
-	//clip to avoid jitter
+	if (wantsSleeping())
-	if (m_angularVelocity.length2() < gClippedAngvelThresholdSqr)
 	{
-		m_angularVelocity.setValue(0,0,0);
+		//clip to avoid jitter
-		printf("clipped!\n");
+//		if ((m_angularVelocity.length2() < gClippedAngvelThresholdSqr) &&
+//			(m_linearVelocity.length2() < gClippedLinearThresholdSqr))
+		{
+			m_angularVelocity *= gJitterVelocityDampingFactor;
+			m_linearVelocity *= gJitterVelocityDampingFactor;
+		}
 	}
 	
-	if (m_linearVelocity.length2() < gClippedLinearThresholdSqr)
-	{
-		m_linearVelocity.setValue(0,0,0);
-		printf("clipped!\n");
-	}
 #endif //EXPERIMENTAL_JITTER_REMOVAL
 
 	btTransformUtil::integrateTransform(m_worldTransform,m_linearVelocity,m_angularVelocity,timeStep,predictedTransform);

src/BulletDynamics/Dynamics/btRigidBody.h

@@ -62,7 +62,11 @@ class btRigidBody  : public btCollisionObject
 
 public:
 
+#ifdef OBSOLETE_MOTIONSTATE_LESS
+	//not supported, please use btMotionState
 	btRigidBody(float mass, const btTransform& worldTransform, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f);
+#endif //OBSOLETE_MOTIONSTATE_LESS
+
 	btRigidBody(float mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f);
 
 	void			proceedToTransform(const btTransform& newTrans); 
@@ -71,11 +75,11 @@ public:
 	///but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast
 	static const btRigidBody*	upcast(const btCollisionObject* colObj)
 	{
-		return (const btRigidBody*)colObj->m_internalOwner;
+		return (const btRigidBody*)colObj->getInternalOwner();
 	}
 	static btRigidBody*	upcast(btCollisionObject* colObj)
 	{
-		return (btRigidBody*)colObj->m_internalOwner;
+		return (btRigidBody*)colObj->getInternalOwner();
 	}
 	
 	/// continuous collision detection needs prediction

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp

@@ -117,9 +117,9 @@ void	btSimpleDynamicsWorld::updateAabbs()
 			if (body->IsActive() && (!body->isStaticObject()))
 			{
 				btPoint3 minAabb,maxAabb;
-				colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb,maxAabb);
+				colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
 				btBroadphaseInterface* bp = getBroadphase();
-				bp->setAabb(body->m_broadphaseHandle,minAabb,maxAabb);
+				bp->setAabb(body->getBroadphaseHandle(),minAabb,maxAabb);
 			}
 		}
 	}
@@ -159,7 +159,7 @@ void	btSimpleDynamicsWorld::predictUnconstraintMotion(float timeStep)
 				{
 					body->applyForces( timeStep);
 					body->integrateVelocities( timeStep);
-					body->predictIntegratedTransform(timeStep,body->m_interpolationWorldTransform);
+					body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform());
 				}
 			}
 		}
@@ -178,9 +178,20 @@ void	btSimpleDynamicsWorld::synchronizeMotionStates()
 		{
 			if (body->GetActivationState() != ISLAND_SLEEPING)
 			{
-				body->getMotionState()->setWorldTransform(body->m_worldTransform);
+				body->getMotionState()->setWorldTransform(body->getWorldTransform());
 			}
 		}
 	}
 
 }
+
+
+void	btSimpleDynamicsWorld::setConstraintSolver(btConstraintSolver* solver)
+{
+	if (m_ownsConstraintSolver)
+	{
+		delete m_constraintSolver;
+	}
+	m_ownsConstraintSolver = false;
+	m_constraintSolver = solver;
+}

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h

@@ -77,6 +77,8 @@ public:
 
 	void	synchronizeMotionStates();
 
+	virtual void	setConstraintSolver(btConstraintSolver* solver);
+
 };
 
 #endif //BT_SIMPLE_DYNAMICS_WORLD_H

src/BulletDynamics/Vehicle/btRaycastVehicle.cpp

@@ -11,6 +11,7 @@
 
 #include "LinearMath/btVector3.h"
 #include "btRaycastVehicle.h"
+
 #include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h"
 #include "BulletDynamics/ConstraintSolver/btJacobianEntry.h"
 #include "LinearMath/btQuaternion.h"
@@ -23,7 +24,7 @@
 
 
 
-static btRigidBody s_fixedObject( 0,btTransform(btQuaternion(0,0,0,1)),0);
+static btRigidBody s_fixedObject( 0,0,0);
 
 btRaycastVehicle::btRaycastVehicle(const btVehicleTuning& tuning,btRigidBody* chassis,	btVehicleRaycaster* raycaster )
 :m_vehicleRaycaster(raycaster),