synchronized to latest version of Bullet. added btConeTwistConstraint (useful for ragdolls etc)

6 files changed, 88 insertions, 38 deletions

diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
index 198276d76df..b535fac6563 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
@@ -273,6 +273,8 @@ bool	btCollisionDispatcher::needsCollision(btCollisionObject* body0,btCollisionO
 		
 	if ((!body0->isActive()) && (!body1->isActive()))
 		needsCollision = false;
+	else if (!body0->checkCollideWith(body1))
+		needsCollision = false;
 	
 	return needsCollision ;
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
index 7b6f066275d..d4c0a4e8cb3 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
@@ -24,11 +24,15 @@ btCollisionObject::btCollisionObject()
 		m_userObjectPointer(0),
 		m_hitFraction(btScalar(1.)),
 		m_ccdSweptSphereRadius(btScalar(0.)),
-		m_ccdSquareMotionThreshold(btScalar(0.))
+		m_ccdSquareMotionThreshold(btScalar(0.)),
+		m_checkCollideWith(false)
 {
 	
 }
 
+btCollisionObject::~btCollisionObject()
+{
+}
 
 void btCollisionObject::setActivationState(int newState) 
 { 
diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h
index 93990235afe..9fb6a67c4a3 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h
@@ -69,15 +69,23 @@ protected:
 	void*			m_internalOwner;
 
 	///time of impact calculation
-	btScalar			m_hitFraction; 
+	btScalar		m_hitFraction; 
 	
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	btScalar			m_ccdSweptSphereRadius;
+	btScalar		m_ccdSweptSphereRadius;
 
 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
-	btScalar			m_ccdSquareMotionThreshold;
+	btScalar		m_ccdSquareMotionThreshold;
 	
-	char	m_pad[8];
+	/// If some object should have elaborate collision filtering by sub-classes
+	bool			m_checkCollideWith;
+
+	char	m_pad[7];
+
+	virtual bool	checkCollideWithOverride(btCollisionObject* co)
+	{
+		return true;
+	}
 
 public:
 
@@ -118,6 +126,7 @@ public:
 	
 	btCollisionObject();
 
+	virtual ~btCollisionObject();
 
 	void	setCollisionShape(btCollisionShape* collisionShape)
 	{
@@ -159,7 +168,7 @@ public:
 		return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
 	}
 
-		void	setRestitution(btScalar rest)
+	void	setRestitution(btScalar rest)
 	{
 		m_restitution = rest;
 	}
@@ -322,6 +331,15 @@ public:
 		m_userObjectPointer = userPointer;
 	}
 
+	inline bool checkCollideWith(btCollisionObject* co)
+	{
+		if (m_checkCollideWith)
+			return checkCollideWithOverride(co);
+
+		return true;
+	}
+
+
 }
 ;
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
index 49f35c2cc90..b49036a5b50 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
@@ -17,6 +17,8 @@ subject to the following restrictions:
 #include "btCollisionDispatcher.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletCollision/CollisionShapes/btConvexShape.h"
+
 #include "BulletCollision/CollisionShapes/btSphereShape.h" //for raycasting
 #include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" //for raycasting
 #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
@@ -179,12 +181,27 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 					  btCollisionObject* collisionObject,
 					  const btCollisionShape* collisionShape,
 					  const btTransform& colObjWorldTransform,
-					  RayResultCallback& resultCallback)
+					  RayResultCallback& resultCallback,short int collisionFilterMask)
 {
 	
 	btSphereShape pointShape(btScalar(0.0));
 	pointShape.setMargin(0.f);
 
+	objectQuerySingle(&pointShape,rayFromTrans,rayToTrans,
+					  collisionObject,
+					  collisionShape,
+					  colObjWorldTransform,
+					  resultCallback,collisionFilterMask);
+}
+
+void	btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const btTransform& rayFromTrans,const btTransform& rayToTrans,
+					  btCollisionObject* collisionObject,
+					  const btCollisionShape* collisionShape,
+					  const btTransform& colObjWorldTransform,
+					  RayResultCallback& resultCallback,short int collisionFilterMask)
+{
+	
+
 	if (collisionShape->isConvex())
 			{
 				btConvexCast::CastResult castResult;
@@ -192,9 +209,9 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 
 				btConvexShape* convexShape = (btConvexShape*) collisionShape;
 				btVoronoiSimplexSolver	simplexSolver;
-				btSubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
-				//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
-				//ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
+				btSubsimplexConvexCast convexCaster(castShape,convexShape,&simplexSolver);
+				//GjkConvexCast	convexCaster(castShape,convexShape,&simplexSolver);
+				//ContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0);
 				
 				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
 				{
@@ -292,11 +309,11 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 								btTransform childTrans = compoundShape->getChildTransform(i);
 								const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
 								btTransform childWorldTrans = colObjWorldTransform * childTrans;
-								rayTestSingle(rayFromTrans,rayToTrans,
+								objectQuerySingle(castShape, rayFromTrans,rayToTrans,
 									collisionObject,
 									childCollisionShape,
 									childWorldTrans,
-									resultCallback);
+									resultCallback, collisionFilterMask);
 
 							}
 
@@ -306,7 +323,7 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 			}
 }
 
-void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback)
+void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback,short int collisionFilterMask)
 {
 
 	
@@ -323,21 +340,22 @@ void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
 	for (i=0;i<m_collisionObjects.size();i++)
 	{
 		btCollisionObject*	collisionObject= m_collisionObjects[i];
-
-		//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
-		btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-		collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
-
-		btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
-		btVector3 hitNormal;
-		if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
-		{
-			rayTestSingle(rayFromTrans,rayToTrans,
-				collisionObject,
-					 collisionObject->getCollisionShape(),
-					  collisionObject->getWorldTransform(),
-					  resultCallback);
-			
+		//only perform raycast if filterMask matches
+		if(collisionObject->getBroadphaseHandle()->m_collisionFilterGroup & collisionFilterMask) { 
+			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
+			btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+
+			btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
+			btVector3 hitNormal;
+			if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
+			{
+				rayTestSingle(rayFromTrans,rayToTrans,
+					collisionObject,
+						collisionObject->getCollisionShape(),
+						collisionObject->getWorldTransform(),
+						resultCallback);
+			}	
 		}
 	}
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
index 0b0286c50f4..b6d80233ab7 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
@@ -53,9 +53,9 @@ subject to the following restrictions:
  * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector.
  *
  * @section copyright Copyright
- * Copyright (C) 2005-2006 Erwin Coumans, some contributions Copyright Gino van den Bergen, Christer Ericson, Simon Hobbs, Ricardo Padrela, F Richter(res), Stephane Redon
+ * Copyright (C) 2005-2007 Erwin Coumans, some contributions Copyright Gino van den Bergen, Christer Ericson, Simon Hobbs, Ricardo Padrela, F Richter(res), Stephane Redon
  * Special thanks to all visitors of the Bullet Physics forum, and in particular above contributors, Dave Eberle, Dirk Gregorius, Erin Catto, Dave Eberle, Adam Moravanszky,
- * Pierre Terdiman, Kenny Erleben, Russell Smith, Oliver Strunk, Jan Paul van Waveren.
+ * Pierre Terdiman, Kenny Erleben, Russell Smith, Oliver Strunk, Jan Paul van Waveren, Marten Svanfeldt.
  * 
  */
  
@@ -66,6 +66,7 @@ subject to the following restrictions:
 
 class btStackAlloc;
 class btCollisionShape;
+class btConvexShape;
 class btBroadphaseInterface;
 #include "../../LinearMath/btVector3.h"
 #include "../../LinearMath/btTransform.h"
@@ -208,7 +209,7 @@ public:
 
 	/// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback
 	/// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
-	void	rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback);
+	void	rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback, short int collisionFilterMask=-1);
 
 	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
 	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
@@ -217,7 +218,14 @@ public:
 					  btCollisionObject* collisionObject,
 					  const btCollisionShape* collisionShape,
 					  const btTransform& colObjWorldTransform,
-					  RayResultCallback& resultCallback);
+					  RayResultCallback& resultCallback, short int collisionFilterMask=-1);
+
+	/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
+	static void	objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
+					  btCollisionObject* collisionObject,
+					  const btCollisionShape* collisionShape,
+					  const btTransform& colObjWorldTransform,
+					  RayResultCallback& resultCallback, short int collisionFilterMask=-1);
 
 	void	addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1);
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
index 2f96c2e13c5..92f4c8b28a6 100644
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
@@ -77,9 +77,9 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 		btTransform	orgTrans = colObj->getWorldTransform();
 		btCollisionShape* orgShape = colObj->getCollisionShape();
 
-		btTransform childTrans = compoundShape->getChildTransform(i);
-		btTransform	newChildWorldTrans = orgTrans*childTrans ;
-		colObj->setWorldTransform( newChildWorldTrans );
+		const btTransform& childTrans = compoundShape->getChildTransform(i);
+		//btTransform	newChildWorldTrans = orgTrans*childTrans ;
+		colObj->setWorldTransform( orgTrans*childTrans );
 		//the contactpoint is still projected back using the original inverted worldtrans
 		colObj->setCollisionShape( childShape );
 		m_childCollisionAlgorithms[i]->processCollision(colObj,otherObj,dispatchInfo,resultOut);
@@ -119,9 +119,9 @@ btScalar	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject*
 		btTransform	orgTrans = colObj->getWorldTransform();
 		btCollisionShape* orgShape = colObj->getCollisionShape();
 
-		btTransform childTrans = compoundShape->getChildTransform(i);
-		btTransform	newChildWorldTrans = orgTrans*childTrans ;
-		colObj->setWorldTransform( newChildWorldTrans );
+		const btTransform& childTrans = compoundShape->getChildTransform(i);
+		//btTransform	newChildWorldTrans = orgTrans*childTrans ;
+		colObj->setWorldTransform( orgTrans*childTrans );
 
 		colObj->setCollisionShape( childShape );
 		btScalar frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);