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

Also did some work on improving the constraint solver.

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();
-		collisionObject->m_broadphaseHandle = getBroadphase()->createProxy(
+		int type = collisionObject->getCollisionShape()->getShapeType();
+		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_broadphasePairCache->setAabb(m_collisionObjects[i]->m_broadphaseHandle,aabbMin,aabbMax);
+		m_collisionObjects[i]->getCollisionShape()->getAabb(m_collisionObjects[i]->getWorldTransform(),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->m_worldTransform,
+					 collisionObject->getCollisionShape(),
+					  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;
-		colObj->m_collisionShape = childShape;
+		btCollisionShape* orgShape = colObj->getCollisionShape();
+		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());
-	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
+	assert (colObj->getCollisionShape()->isCompound());
+	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;
-		btCollisionShape* orgShape = colObj->m_collisionShape;
+		btTransform	orgTrans = colObj->getWorldTransform();
+		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->m_worldTransform = orgTrans;
+		colObj->setCollisionShape( orgShape);
+		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;
-		btCollisionShape* orgShape = colObj->m_collisionShape;
+		btTransform	orgTrans = colObj->getWorldTransform();
+		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->m_worldTransform = orgTrans;
+		colObj->setCollisionShape( orgShape);
+		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;
-		ob->m_collisionShape = &tm;
+		btCollisionShape* tmpShape = ob->getCollisionShape();
+		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;
-	btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->m_collisionShape);
+	convexInTriangleSpace = m_triBody->getWorldTransform().inverse() * m_convexBody->getWorldTransform();
+	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();
-	if (squareMot0 < convexbody->m_ccdSquareMotionThreshold)
+	float squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
+	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 convexFromLocal = triInv * convexbody->m_worldTransform;
-	btTransform convexToLocal = triInv * convexbody->m_interpolationWorldTransform;
+	btTransform triInv = triBody->getWorldTransform().inverse();
+	btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
+	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);
-		rayAabbMax += btVector3(convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius);
+		float ccdRadius0 = convexbody->getCcdSweptSphereRadius();
+		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* min1 = static_cast<btConvexShape*>(body1->m_collisionShape);
+	btConvexShape* min0 = static_cast<btConvexShape*>(body0->getCollisionShape());
+	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_transformB = body1->m_worldTransform;
+	input.m_transformA = body0->getWorldTransform();
+	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 &&
-		squareMot0 < col0->m_ccdSquareMotionThreshold)
+	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
+		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,
-			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(),
+			col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result))
 		{
 		
 			//store result.m_fraction in both bodies
 		
-			if (col0->m_hitFraction	> result.m_fraction)
-				col0->m_hitFraction  = result.m_fraction;
+			if (col0->getHitFraction()> result.m_fraction)
+				col0->setHitFraction( result.m_fraction );
 
-			if (col1->m_hitFraction > result.m_fraction)
-				col1->m_hitFraction  = result.m_fraction;
+			if (col1->getHitFraction() > 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,
-			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(),
+			col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result))
 		{
 		
 			//store result.m_fraction in both bodies
 		
-			if (col0->m_hitFraction	> result.m_fraction)
-				col0->m_hitFraction  = result.m_fraction;
+			if (col0->getHitFraction()	> result.m_fraction)
+				col0->setHitFraction( result.m_fraction);
 
-			if (col1->m_hitFraction > result.m_fraction)
-				col1->m_hitFraction  = result.m_fraction;
+			if (col1->getHitFraction() > 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_rootTransB = body1->m_worldTransform;
+	m_rootTransA = body0->getWorldTransform();
+	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_body1->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)))
+		 ((m_body0->getCollisionFlags() & 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"
-struct btCollisionObject;
+class 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,
-					(colObj1)->m_islandTag1);
+				m_unionFind.unite((colObj0)->getIslandTag(),
+					(colObj1)->getIslandTag());
 			}
 		}
 	}
@@ -65,8 +65,8 @@ void	btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 		{
 			
 			btCollisionObject*	collisionObject= (*i);
-			collisionObject->m_islandTag1 = index;
-			collisionObject->m_hitFraction = 1.f;
+			collisionObject->setIslandTag(index);
+			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));
-			if (colObj0->m_islandTag1 == islandId)
+			assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+			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* sphere1 = (btSphereShape*)col1->m_collisionShape;
+	btSphereShape* sphere0 = (btSphereShape*)col0->getCollisionShape();
+	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;
-	btTriangleShape* triangle = (btTriangleShape*)col1->m_collisionShape;
+	btSphereShape* sphere = (btSphereShape*)col0->getCollisionShape();
+	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_transformB = col1->m_worldTransform;
+	input.m_transformA = col0->getWorldTransform();
+	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
-#define DISCRETE_COLLISION_DETECTOR_INTERFACE_H
+#ifndef DISCRETE_COLLISION_DETECTOR1_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;
-			GEN_set_min(total, limit);
-			GEN_set_max(total, -limit);
-			j1 = total - cpd->m_accumulatedTangentImpulse0;
-			cpd->m_accumulatedTangentImpulse0 = total;
+			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse0;
+			cpd->m_accumulatedTangentImpulse0 = oldTangentImpulse + j1;
+			GEN_set_min(cpd->m_accumulatedTangentImpulse0, limit);
+			GEN_set_max(cpd->m_accumulatedTangentImpulse0, -limit);
+			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;
-			GEN_set_min(total, limit);
-			GEN_set_max(total, -limit);
-			j2 = total - cpd->m_accumulatedTangentImpulse1;
-			cpd->m_accumulatedTangentImpulse1 = total;
+			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse1;
+			cpd->m_accumulatedTangentImpulse1 = oldTangentImpulse + j2;
+			GEN_set_min(cpd->m_accumulatedTangentImpulse1, limit);
+			GEN_set_max(cpd->m_accumulatedTangentImpulse1, -limit);
+			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;
-			prepareConstraints(manifoldPtr[k],info,debugDrawer);
-			solve(manifoldPtr[k],info,0,debugDrawer);
+			gOrder[j] = j;
+			prepareConstraints(manifoldPtr[j],info,debugDrawer);
 		}
 	}
 	
 	
 	//should traverse the contacts random order...
-	int i;
-	for ( i = 0;i<numiter-1;i++)
+	int iteration;
+	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;
-			if (i&1)
-				k=numManifolds-j-1;
-
-			solve(manifoldPtr[k],info,i,debugDrawer);
+			solve(manifoldPtr[gOrder[j]],info,iteration,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+
-					cp.m_frictionWorldTangential1*cp.m_accumulatedTangentImpulse1+
+					cpd->m_frictionWorldTangential0*cpd->m_accumulatedTangentImpulse0+
+					cpd->m_frictionWorldTangential1*cpd->m_accumulatedTangentImpulse1+
 	#endif //NO_FRICTION_WARMSTART
 					cp.m_normalWorldOnB*cpd->m_appliedImpulse;
 
@@ -320,11 +327,7 @@ 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,9 +370,7 @@ 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,
-					body->m_interpolationLinearVelocity,body->m_interpolationAngularVelocity,m_localTime,interpolatedTransform);
+				btTransformUtil::integrateTransform(body->getInterpolationWorldTransform(),
+					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,
-						(colObj1)->m_islandTag1);
+					getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(),
+						(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
-//doesn't work very well yet (value 0 only reduces performance a bit, no difference in functionality)
-float gClippedAngvelThresholdSqr = 0.f;
-float	gClippedLinearThresholdSqr = 0.f;
+//Bullet 2.20b has experimental damping code to reduce jitter just before objects fall asleep/deactivate
+//doesn't work very well yet (value 0 disabled this damping)
+//note there this influences deactivation thresholds!
+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 (m_angularVelocity.length2() < gClippedAngvelThresholdSqr)
+	if (wantsSleeping())
 	{
-		m_angularVelocity.setValue(0,0,0);
-		printf("clipped!\n");
+		//clip to avoid jitter
+//		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),