Some changes in rendering, to get shadows for trimeshes

Add dynamic aabb tree (btDbvt) optimization for btCompoundShape/btCompoundCollisionAlgorithm
Add btTransformAabb util, todo: deploy it throughout the codebase

Demos/ConvexDecompositionDemo/ConvexDecompositionDemo.cpp

@@ -45,7 +45,7 @@ subject to the following restrictions:
 #include "GlutStuff.h"
 
 
-btVector3	centroid;
+btVector3	centroid=btVector3(0,0,0);
 btVector3   convexDecompositionObjectOffset(10,0,0);
 
 #define CUBE_HALF_EXTENTS 4
@@ -100,6 +100,7 @@ void ConvexDecompositionDemo::initPhysics(const char* filename)
 #endif//USE_PARALLEL_DISPATCHER
 
 
+	convexDecompositionObjectOffset.setValue(10,0,0);
 
 	btVector3 worldAabbMin(-10000,-10000,-10000);
 	btVector3 worldAabbMax(10000,10000,10000);
@@ -124,10 +125,13 @@ void ConvexDecompositionDemo::initPhysics(const char* filename)
 
 	class MyConvexDecomposition : public ConvexDecomposition::ConvexDecompInterface
 	{
-
 		ConvexDecompositionDemo*	m_convexDemo;
+		
 		public:
 
+		btAlignedObjectArray<btConvexHullShape*> m_convexShapes;
+		btAlignedObjectArray<btVector3> m_convexCentroids;
+
 		MyConvexDecomposition (FILE* outputFile,ConvexDecompositionDemo* demo)
 			:m_convexDemo(demo),
 				mBaseCount(0),
@@ -162,6 +166,7 @@ void ConvexDecompositionDemo::initPhysics(const char* filename)
 
 					//calc centroid, to shift vertices around center of mass
 					centroid.setValue(0,0,0);
+
 					btAlignedObjectArray<btVector3> vertices;
 					if ( 1 )
 					{
@@ -245,29 +250,17 @@ void ConvexDecompositionDemo::initPhysics(const char* filename)
 					btGeometryUtil::getVerticesFromPlaneEquations(shiftedPlaneEquations,shiftedVertices);
 
 					
-					btCollisionShape* convexShape = new btConvexHullShape(&(shiftedVertices[0].getX()),shiftedVertices.size());
+					btConvexHullShape* convexShape = new btConvexHullShape(&(shiftedVertices[0].getX()),shiftedVertices.size());
 					
 #else //SHRINK_OBJECT_INWARDS
 					
-#ifdef USE_PARALLEL_DISPATCHER
+					btConvexHullShape* convexShape = new btConvexHullShape(&(vertices[0].getX()),vertices.size());
-					//SPU/multi threaded version only supports convex hull with contiguous vertices at the moment
-					btCollisionShape* convexShape = new btConvexHullShape(&(vertices[0].getX()),vertices.size());
-#else
-					btCollisionShape* convexShape = new btConvexTriangleMeshShape(trimesh);
-#endif //USE_PARALLEL_DISPATCHER
-
 #endif 
 
 					convexShape->setMargin(0.01);
-
+					m_convexShapes.push_back(convexShape);
+					m_convexCentroids.push_back(centroid);
 					m_convexDemo->m_collisionShapes.push_back(convexShape);
-
-					btTransform trans;
-					trans.setIdentity();
-					trans.setOrigin(centroid-convexDecompositionObjectOffset);
-					
-					//btRigidBody* body = m_convexDemo->localCreateRigidBody( mass, trans,convexShape);
-					m_convexDemo->localCreateRigidBody( mass, trans,convexShape);
 					mBaseCount+=result.mHullVcount; // advance the 'base index' counter.
 
 
@@ -394,6 +387,34 @@ void ConvexDecompositionDemo::initPhysics(const char* filename)
 
 		ConvexBuilder cb(desc.mCallback);
 		cb.process(desc);
+		//now create some bodies
+		
+		{
+			btCompoundShape* compound = new btCompoundShape();
+			m_collisionShapes.push_back (compound);
+
+			btTransform trans;
+			trans.setIdentity();
+			for (int i=0;i<convexDecomposition.m_convexShapes.size();i++)
+			{
+				
+				btVector3 centroid = convexDecomposition.m_convexCentroids[i];
+				trans.setOrigin(centroid);
+				btConvexHullShape* convexShape = convexDecomposition.m_convexShapes[i];
+				compound->addChildShape(trans,convexShape);
+			}
+			btScalar mass=10.f;
+			trans.setOrigin(-convexDecompositionObjectOffset);
+			localCreateRigidBody( mass, trans,compound);
+			convexDecompositionObjectOffset.setZ(6);
+			trans.setOrigin(-convexDecompositionObjectOffset);
+			localCreateRigidBody( mass, trans,compound);
+			convexDecompositionObjectOffset.setZ(-6);
+			trans.setOrigin(-convexDecompositionObjectOffset);
+			localCreateRigidBody( mass, trans,compound);
+			
+		}
+
 		
 		if (outputFile)
 			fclose(outputFile);

Demos/OpenGL/GL_ShapeDrawer.cpp

@@ -166,7 +166,7 @@ void OGL_displaylist_register_shape(btCollisionShape * shape)
 
 	glNewList(dlist.m_dlist,GL_COMPILE);
 
-	glEnable(GL_CULL_FACE);
+//	glEnable(GL_CULL_FACE);
 
 	glCullFace(GL_BACK);
 
@@ -177,7 +177,7 @@ void OGL_displaylist_register_shape(btCollisionShape * shape)
 		concaveMesh->processAllTriangles(&drawCallback,aabbMin,aabbMax);
 	}
 
-	glDisable(GL_CULL_FACE);	
+//	glDisable(GL_CULL_FACE);	
 
 	glEndList();
 }
@@ -237,12 +237,16 @@ public:
 		} else
 		{
 			glBegin(GL_TRIANGLES);
-			glColor3f(1, 1, 1);
+			//glColor3f(1, 1, 1);
+			
+			
 			glVertex3d(triangle[0].getX(), triangle[0].getY(), triangle[0].getZ());
-			//glColor3f(0, 1, 0);
 			glVertex3d(triangle[1].getX(), triangle[1].getY(), triangle[1].getZ());
-			//glColor3f(0, 0, 1);
 			glVertex3d(triangle[2].getX(), triangle[2].getY(), triangle[2].getZ());
+
+			glVertex3d(triangle[2].getX(), triangle[2].getY(), triangle[2].getZ());
+			glVertex3d(triangle[1].getX(), triangle[1].getY(), triangle[1].getZ());
+			glVertex3d(triangle[0].getX(), triangle[0].getY(), triangle[0].getZ());
 			glEnd();
 		}
 	}

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -16,12 +16,17 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
-
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btAabbUtil2.h"
 
 btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
 :btCollisionAlgorithm(ci),
-m_isSwapped(isSwapped)
+m_isSwapped(isSwapped),
+m_sharedManifold(ci.m_manifold)
 {
+	m_ownsManifold = false;
+
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
 	btCollisionObject* otherObj = m_isSwapped? body0 : body1;
 	assert (colObj->getCollisionShape()->isCompound());
@@ -33,11 +38,17 @@ m_isSwapped(isSwapped)
 	m_childCollisionAlgorithms.resize(numChildren);
 	for (i=0;i<numChildren;i++)
 	{
-		btCollisionShape* tmpShape = colObj->getCollisionShape();
+		if (compoundShape->getDynamicAabbTree())
-		btCollisionShape* childShape = compoundShape->getChildShape(i);
+		{
-		colObj->internalSetTemporaryCollisionShape( childShape );
+			m_childCollisionAlgorithms[i] = 0;
-		m_childCollisionAlgorithms[i] = ci.m_dispatcher1->findAlgorithm(colObj,otherObj);
+		} else
-		colObj->internalSetTemporaryCollisionShape( tmpShape );
+		{
+			btCollisionShape* tmpShape = colObj->getCollisionShape();
+			btCollisionShape* childShape = compoundShape->getChildShape(i);
+			colObj->internalSetTemporaryCollisionShape( childShape );
+			m_childCollisionAlgorithms[i] = ci.m_dispatcher1->findAlgorithm(colObj,otherObj,m_sharedManifold);
+			colObj->internalSetTemporaryCollisionShape( tmpShape );
+		}
 	}
 }
 
@@ -48,11 +59,109 @@ btCompoundCollisionAlgorithm::~btCompoundCollisionAlgorithm()
 	int i;
 	for (i=0;i<numChildren;i++)
 	{
-		m_childCollisionAlgorithms[i]->~btCollisionAlgorithm();
+		if (m_childCollisionAlgorithms[i])
-		m_dispatcher->freeCollisionAlgorithm(m_childCollisionAlgorithms[i]);
+		{
+			m_childCollisionAlgorithms[i]->~btCollisionAlgorithm();
+			m_dispatcher->freeCollisionAlgorithm(m_childCollisionAlgorithms[i]);
+		}
 	}
 }
 
+
+
+
+struct	btCompoundLeafCallback : btDbvt::ICollide
+{
+
+public:
+
+	btCollisionObject* m_compoundColObj;
+	btCollisionObject* m_otherObj;
+	btDispatcher* m_dispatcher;
+	const btDispatcherInfo& m_dispatchInfo;
+	btManifoldResult*	m_resultOut;
+	btCollisionAlgorithm**	m_childCollisionAlgorithms;
+	btPersistentManifold*	m_sharedManifold;
+
+
+
+
+	btCompoundLeafCallback (btCollisionObject* compoundObj,btCollisionObject* otherObj,btDispatcher* dispatcher,const btDispatcherInfo& dispatchInfo,btManifoldResult*	resultOut,btCollisionAlgorithm**	childCollisionAlgorithms,btPersistentManifold*	sharedManifold)
+		:m_compoundColObj(compoundObj),m_otherObj(otherObj),m_dispatcher(dispatcher),m_dispatchInfo(dispatchInfo),m_resultOut(resultOut),
+		m_childCollisionAlgorithms(childCollisionAlgorithms),
+		m_sharedManifold(sharedManifold)
+	{
+
+	}
+
+
+	void	ProcessChildShape(btCollisionShape* childShape,int index)
+	{
+		
+		btCompoundShape* compoundShape = static_cast<btCompoundShape*>(m_compoundColObj->getCollisionShape());
+
+
+		//backup
+		btTransform	orgTrans = m_compoundColObj->getWorldTransform();
+		btTransform	orgInterpolationTrans = m_compoundColObj->getInterpolationWorldTransform();
+		const btTransform& childTrans = compoundShape->getChildTransform(index);
+		btTransform	newChildWorldTrans = orgTrans*childTrans ;
+
+		//perform an AABB check first
+		btVector3 aabbMin0,aabbMax0,aabbMin1,aabbMax1;
+		childShape->getAabb(newChildWorldTrans,aabbMin0,aabbMax0);
+		m_otherObj->getCollisionShape()->getAabb(m_otherObj->getWorldTransform(),aabbMin1,aabbMax1);
+
+		if (TestAabbAgainstAabb2(aabbMin0,aabbMax0,aabbMin1,aabbMax1))
+		{
+
+			m_compoundColObj->setWorldTransform( newChildWorldTrans);
+			m_compoundColObj->setInterpolationWorldTransform(newChildWorldTrans);
+
+			//the contactpoint is still projected back using the original inverted worldtrans
+			btCollisionShape* tmpShape = m_compoundColObj->getCollisionShape();
+			m_compoundColObj->internalSetTemporaryCollisionShape( childShape );
+
+			if (!m_childCollisionAlgorithms[index])
+				m_childCollisionAlgorithms[index] = m_dispatcher->findAlgorithm(m_compoundColObj,m_otherObj,m_sharedManifold);
+
+			m_childCollisionAlgorithms[index]->processCollision(m_compoundColObj,m_otherObj,m_dispatchInfo,m_resultOut);
+			if (m_dispatchInfo.m_debugDraw && (m_dispatchInfo.m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
+			{
+				btVector3 worldAabbMin,worldAabbMax;
+				m_dispatchInfo.m_debugDraw->drawAabb(aabbMin0,aabbMax0,btVector3(1,1,1));
+				m_dispatchInfo.m_debugDraw->drawAabb(aabbMin1,aabbMax1,btVector3(1,1,1));
+			}
+			
+			//revert back transform
+			m_compoundColObj->internalSetTemporaryCollisionShape( tmpShape);
+			m_compoundColObj->setWorldTransform(  orgTrans );
+			m_compoundColObj->setInterpolationWorldTransform(orgInterpolationTrans);
+		}
+	}
+	void		Process(const btDbvtNode* leaf)
+	{
+		int index = int(leaf->data);
+
+		btCompoundShape* compoundShape = static_cast<btCompoundShape*>(m_compoundColObj->getCollisionShape());
+		btCollisionShape* childShape = compoundShape->getChildShape(index);
+		if (m_dispatchInfo.m_debugDraw && (m_dispatchInfo.m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
+		{
+			btVector3 worldAabbMin,worldAabbMax;
+			btTransform	orgTrans = m_compoundColObj->getWorldTransform();
+			btTransformAabb(leaf->volume.Mins(),leaf->volume.Maxs(),0.,orgTrans,worldAabbMin,worldAabbMax);
+			m_dispatchInfo.m_debugDraw->drawAabb(worldAabbMin,worldAabbMax,btVector3(1,0,0));
+		}
+		ProcessChildShape(childShape,index);
+
+	}
+};
+
+
+
+
+
+
 void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
@@ -61,37 +170,69 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 	assert (colObj->getCollisionShape()->isCompound());
 	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
 
-	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
+	btDbvt* tree = compoundShape->getDynamicAabbTree();
-	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
+	//use a dynamic aabb tree to cull potential child-overlaps
-	//given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
+	btCompoundLeafCallback  callback(colObj,otherObj,m_dispatcher,dispatchInfo,resultOut,&m_childCollisionAlgorithms[0],m_sharedManifold);
-	//determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
-	//then use each overlapping node AABB against Tree0
-	//and vise versa.
 
-	int numChildren = m_childCollisionAlgorithms.size();
+
-	int i;
+	if (tree)
-	for (i=0;i<numChildren;i++)
 	{
-		//temporarily exchange parent btCollisionShape with childShape, and recurse
-		btCollisionShape* childShape = compoundShape->getChildShape(i);
 
-		//backup
+		btVector3 localAabbMin,localAabbMax;
-		btTransform	orgTrans = colObj->getWorldTransform();
+		btTransform otherInCompoundSpace;
-		btTransform	orgInterpolationTrans = colObj->getInterpolationWorldTransform();
+		otherInCompoundSpace = colObj->getWorldTransform().inverse() * otherObj->getWorldTransform();
+		otherObj->getCollisionShape()->getAabb(otherInCompoundSpace,localAabbMin,localAabbMax);
 
-		const btTransform& childTrans = compoundShape->getChildTransform(i);
+		const btDbvtVolume	bounds=btDbvtVolume::FromMM(localAabbMin,localAabbMax);
-		btTransform	newChildWorldTrans = orgTrans*childTrans ;
+		//process all children, that overlap with  the given AABB bounds
-		colObj->setWorldTransform( newChildWorldTrans);
+		tree->collideTV(tree->m_root,bounds,callback);
-		colObj->setInterpolationWorldTransform(newChildWorldTrans);
+
+	} else
+	{
+		//iterate over all children, perform an AABB check inside ProcessChildShape
+		int numChildren = m_childCollisionAlgorithms.size();
+		int i;
+		for (i=0;i<numChildren;i++)
+		{
+			callback.ProcessChildShape(compoundShape->getChildShape(i),i);
+		}
+	}
+
+	{
+				//iterate over all children, perform an AABB check inside ProcessChildShape
+		int numChildren = m_childCollisionAlgorithms.size();
+		int i;
+		btManifoldArray	manifoldArray;
+
+		for (i=0;i<numChildren;i++)
+		{
+			if (m_childCollisionAlgorithms[i])
+			{
+				btCollisionShape* childShape = compoundShape->getChildShape(i);
+			//if not longer overlapping, remove the algorithm
+				btTransform	orgTrans = colObj->getWorldTransform();
+				btTransform	orgInterpolationTrans = colObj->getInterpolationWorldTransform();
+				const btTransform& childTrans = compoundShape->getChildTransform(i);
+				btTransform	newChildWorldTrans = orgTrans*childTrans ;
+
+				//perform an AABB check first
+				btVector3 aabbMin0,aabbMax0,aabbMin1,aabbMax1;
+				childShape->getAabb(newChildWorldTrans,aabbMin0,aabbMax0);
+				otherObj->getCollisionShape()->getAabb(otherObj->getWorldTransform(),aabbMin1,aabbMax1);
+
+				if (!TestAabbAgainstAabb2(aabbMin0,aabbMax0,aabbMin1,aabbMax1))
+				{
+					m_childCollisionAlgorithms[i]->~btCollisionAlgorithm();
+					m_dispatcher->freeCollisionAlgorithm(m_childCollisionAlgorithms[i]);
+					m_childCollisionAlgorithms[i] = 0;
+				}
+
+			}
+			
+		}
+
+		
 
-		//the contactpoint is still projected back using the original inverted worldtrans
-		btCollisionShape* tmpShape = colObj->getCollisionShape();
-		colObj->internalSetTemporaryCollisionShape( childShape );
-		m_childCollisionAlgorithms[i]->processCollision(colObj,otherObj,dispatchInfo,resultOut);
-		//revert back
-		colObj->internalSetTemporaryCollisionShape( tmpShape);
-		colObj->setWorldTransform(  orgTrans );
-		colObj->setInterpolationWorldTransform(orgInterpolationTrans);
 	}
 }
 

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -28,11 +28,13 @@ class btDispatcher;
 class btDispatcher;
 
 /// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
-/// Place holder, not fully implemented yet
 class btCompoundCollisionAlgorithm  : public btCollisionAlgorithm
 {
 	btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithms;
 	bool m_isSwapped;
+
+	class btPersistentManifold*	m_sharedManifold;
+	bool					m_ownsManifold;
 	
 public:
 

src/BulletCollision/CollisionShapes/btBoxShape.cpp

@@ -21,20 +21,7 @@ subject to the following restrictions:
 
 void btBoxShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	btVector3 halfExtents = getHalfExtentsWithoutMargin();
+	btTransformAabb(getHalfExtentsWithoutMargin(),getMargin(),t,aabbMin,aabbMax);
-	halfExtents += btVector3(getMargin(),getMargin(),getMargin());
-
-
-	btMatrix3x3 abs_b = t.getBasis().absolute();  
-	btPoint3 center = t.getOrigin();
-	btVector3 extent = btVector3(abs_b[0].dot(halfExtents),
-		   abs_b[1].dot(halfExtents),
-		  abs_b[2].dot(halfExtents));
-
-	aabbMin = center - extent;
-	aabbMax = center + extent;
-
-
 }
 
 

src/BulletCollision/CollisionShapes/btCompoundShape.cpp

@@ -14,23 +14,29 @@ subject to the following restrictions:
 */
 
 #include "btCompoundShape.h"
-
-
 #include "btCollisionShape.h"
-
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
 
 btCompoundShape::btCompoundShape()
 :m_localAabbMin(btScalar(1e30),btScalar(1e30),btScalar(1e30)),
 m_localAabbMax(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)),
-m_aabbTree(0),
 m_collisionMargin(btScalar(0.)),
-m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.))
+m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.)),
+m_dynamicAabbTree(0)
 {
+	void* mem = btAlignedAlloc(sizeof(btDbvt),16);
+	m_dynamicAabbTree = new(mem) btDbvt();
+	btAssert(mem==m_dynamicAabbTree);
 }
 
 
 btCompoundShape::~btCompoundShape()
 {
+	if (m_dynamicAabbTree)
+	{
+		m_dynamicAabbTree->~btDbvt();
+		btAlignedFree(m_dynamicAabbTree);
+	}
 }
 
 void	btCompoundShape::addChildShape(const btTransform& localTransform,btCollisionShape* shape)
@@ -60,68 +66,85 @@ void	btCompoundShape::addChildShape(const btTransform& localTransform,btCollisio
 		}
 
 	}
+	if (m_dynamicAabbTree)
+	{
+		const btDbvtVolume	bounds=btDbvtVolume::FromMM(localAabbMin,localAabbMax);
+		int index = m_children.size()-1;
+		child.m_node = m_dynamicAabbTree->insert(bounds,(void*)index);
+	}
+
+}
+
+void btCompoundShape::removeChildShapeByIndex(int childShapeIndex)
+{
+	btAssert(childShapeIndex >=0 && childShapeIndex < m_children.size());
+	if (m_dynamicAabbTree)
+	{
+		m_dynamicAabbTree->remove(m_children[childShapeIndex].m_node);
+	}
+	m_children.swap(childShapeIndex,m_children.size()-1);
+	m_children.pop_back();
+
 }
 
 void btCompoundShape::removeChildShape(btCollisionShape* shape)
 {
-   bool done_removing;
+	// Find the children containing the shape specified, and remove those children.
-   
+	//note: there might be multiple children using the same shape!
-   // Find the children containing the shape specified, and remove those children.
+	for(int i = m_children.size()-1; i >= 0 ; i--)
-   do
+	{
-   {
+		if(m_children[i].m_childShape == shape)
-      done_removing = true;
+		{
-      
+			m_children.swap(i,m_children.size()-1);
-      for(int i = 0; i < m_children.size(); i++)
+			m_children.pop_back();
-      {
+			//remove it from the m_dynamicAabbTree too
-         if(m_children[i].m_childShape == shape)
+			//m_dynamicAabbTree->remove(m_aabbProxies[i]);
-         {
+			//m_aabbProxies.swap(i,m_children.size()-1);
-            m_children.remove(m_children[i]);
+			//m_aabbProxies.pop_back();
-            done_removing = false;  // Do another iteration pass after removing from the vector
+		}
-            break;
+	}
-         }
+
-      }
+
-   }
+
-   while (!done_removing);
+	recalculateLocalAabb();
-   
-   recalculateLocalAabb();
 }
 
 void btCompoundShape::recalculateLocalAabb()
 {
-   // Recalculate the local aabb
+	// Recalculate the local aabb
-   // Brute force, it iterates over all the shapes left.
+	// Brute force, it iterates over all the shapes left.
-   m_localAabbMin = btVector3(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+	m_localAabbMin = btVector3(btScalar(1e30),btScalar(1e30),btScalar(1e30));
-   m_localAabbMax = btVector3(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	m_localAabbMax = btVector3(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
-   
+
-   //extend the local aabbMin/aabbMax
+	//extend the local aabbMin/aabbMax
-   for (int j = 0; j < m_children.size(); j++)
+	for (int j = 0; j < m_children.size(); j++)
-   {
+	{
-      btVector3 localAabbMin,localAabbMax;
+		btVector3 localAabbMin,localAabbMax;
-      m_children[j].m_childShape->getAabb(m_children[j].m_transform, localAabbMin, localAabbMax);
+		m_children[j].m_childShape->getAabb(m_children[j].m_transform, localAabbMin, localAabbMax);
-      for (int i=0;i<3;i++)
+		for (int i=0;i<3;i++)
-      {
+		{
-         if (m_localAabbMin[i] > localAabbMin[i])
+			if (m_localAabbMin[i] > localAabbMin[i])
-             m_localAabbMin[i] = localAabbMin[i];
+				m_localAabbMin[i] = localAabbMin[i];
-         if (m_localAabbMax[i] < localAabbMax[i])
+			if (m_localAabbMax[i] < localAabbMax[i])
-             m_localAabbMax[i] = localAabbMax[i];
+				m_localAabbMax[i] = localAabbMax[i];
-      }
+		}
-   }
+	}
 }
-	
+
-   ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
 void btCompoundShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {
 	btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
 	localHalfExtents += btVector3(getMargin(),getMargin(),getMargin());
 	btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
-	
+
 	btMatrix3x3 abs_b = trans.getBasis().absolute();  
 
 	btPoint3 center = trans(localCenter);
 
 	btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
-		   abs_b[1].dot(localHalfExtents),
+		abs_b[1].dot(localHalfExtents),
-		  abs_b[2].dot(localHalfExtents));
+		abs_b[2].dot(localHalfExtents));
 	aabbMin = center-extent;
 	aabbMax = center+extent;
 
@@ -134,9 +157,9 @@ void	btCompoundShape::calculateLocalInertia(btScalar mass,btVector3& inertia) co
 	ident.setIdentity();
 	btVector3 aabbMin,aabbMax;
 	getAabb(ident,aabbMin,aabbMax);
-	
+
 	btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);
-	
+
 	btScalar lx=btScalar(2.)*(halfExtents.x());
 	btScalar ly=btScalar(2.)*(halfExtents.y());
 	btScalar lz=btScalar(2.)*(halfExtents.z());
@@ -152,57 +175,57 @@ void	btCompoundShape::calculateLocalInertia(btScalar mass,btVector3& inertia) co
 
 void btCompoundShape::calculatePrincipalAxisTransform(btScalar* masses, btTransform& principal, btVector3& inertia) const
 {
-   int n = m_children.size();
+	int n = m_children.size();
 
-   btScalar totalMass = 0;
+	btScalar totalMass = 0;
-   btVector3 center(0, 0, 0);
+	btVector3 center(0, 0, 0);
-   for (int k = 0; k < n; k++)
+	for (int k = 0; k < n; k++)
-   {
+	{
-      center += m_children[k].m_transform.getOrigin() * masses[k];
+		center += m_children[k].m_transform.getOrigin() * masses[k];
-      totalMass += masses[k];
+		totalMass += masses[k];
-   }
+	}
-   center /= totalMass;
+	center /= totalMass;
-   principal.setOrigin(center);
+	principal.setOrigin(center);
 
-   btMatrix3x3 tensor(0, 0, 0, 0, 0, 0, 0, 0, 0);
+	btMatrix3x3 tensor(0, 0, 0, 0, 0, 0, 0, 0, 0);
-   for (int k = 0; k < n; k++)
+	for (int k = 0; k < n; k++)
-   {
+	{
-      btVector3 i;
+		btVector3 i;
-      m_children[k].m_childShape->calculateLocalInertia(masses[k], i);
+		m_children[k].m_childShape->calculateLocalInertia(masses[k], i);
 
-      const btTransform& t = m_children[k].m_transform;
+		const btTransform& t = m_children[k].m_transform;
-      btVector3 o = t.getOrigin() - center;
+		btVector3 o = t.getOrigin() - center;
-      
-      //compute inertia tensor in coordinate system of compound shape
-      btMatrix3x3 j = t.getBasis().transpose();
-      j[0] *= i[0];
-      j[1] *= i[1];
-      j[2] *= i[2];
-      j = t.getBasis() * j;
-      
-      //add inertia tensor
-      tensor[0] += j[0];
-      tensor[1] += j[1];
-      tensor[2] += j[2];
 
-      //compute inertia tensor of pointmass at o
+		//compute inertia tensor in coordinate system of compound shape
-      btScalar o2 = o.length2();
+		btMatrix3x3 j = t.getBasis().transpose();
-      j[0].setValue(o2, 0, 0);
+		j[0] *= i[0];
-      j[1].setValue(0, o2, 0);
+		j[1] *= i[1];
-      j[2].setValue(0, 0, o2);
+		j[2] *= i[2];
-      j[0] += o * -o.x(); 
+		j = t.getBasis() * j;
-      j[1] += o * -o.y(); 
-      j[2] += o * -o.z();
 
-      //add inertia tensor of pointmass
+		//add inertia tensor
-      tensor[0] += masses[k] * j[0];
+		tensor[0] += j[0];
-      tensor[1] += masses[k] * j[1];
+		tensor[1] += j[1];
-      tensor[2] += masses[k] * j[2];
+		tensor[2] += j[2];
-   }
 
-   tensor.diagonalize(principal.getBasis(), btScalar(0.00001), 20);
+		//compute inertia tensor of pointmass at o
-   inertia.setValue(tensor[0][0], tensor[1][1], tensor[2][2]);
+		btScalar o2 = o.length2();
+		j[0].setValue(o2, 0, 0);
+		j[1].setValue(0, o2, 0);
+		j[2].setValue(0, 0, o2);
+		j[0] += o * -o.x(); 
+		j[1] += o * -o.y(); 
+		j[2] += o * -o.z();
+
+		//add inertia tensor of pointmass
+		tensor[0] += masses[k] * j[0];
+		tensor[1] += masses[k] * j[1];
+		tensor[2] += masses[k] * j[2];
+	}
+
+	tensor.diagonalize(principal.getBasis(), btScalar(0.00001), 20);
+	inertia.setValue(tensor[0][0], tensor[1][1], tensor[2][2]);
 }
 
 
-	
+

src/BulletCollision/CollisionShapes/btCompoundShape.h

@@ -24,8 +24,8 @@ subject to the following restrictions:
 #include "btCollisionMargin.h"
 #include "LinearMath/btAlignedObjectArray.h"
 
-class btOptimizedBvh;
+//class btOptimizedBvh;
-
+struct btDbvt;
 
 ATTRIBUTE_ALIGNED16(struct) btCompoundShapeChild
 {
@@ -35,14 +35,15 @@ ATTRIBUTE_ALIGNED16(struct) btCompoundShapeChild
 	btCollisionShape*	m_childShape;
 	int					m_childShapeType;
 	btScalar			m_childMargin;
+	struct btDbvtNode*	m_node;
 };
 
 SIMD_FORCE_INLINE bool operator==(const btCompoundShapeChild& c1, const btCompoundShapeChild& c2)
 {
-   return  ( c1.m_transform      == c2.m_transform &&
+	return  ( c1.m_transform      == c2.m_transform &&
-             c1.m_childShape     == c2.m_childShape &&
+		c1.m_childShape     == c2.m_childShape &&
-             c1.m_childShapeType == c2.m_childShapeType &&
+		c1.m_childShapeType == c2.m_childShapeType &&
-             c1.m_childMargin    == c2.m_childMargin );
+		c1.m_childMargin    == c2.m_childMargin );
 }
 
 /// btCompoundShape allows to store multiple other btCollisionShapes
@@ -55,7 +56,8 @@ ATTRIBUTE_ALIGNED16(class) btCompoundShape	: public btCollisionShape
 	btVector3						m_localAabbMin;
 	btVector3						m_localAabbMax;
 
-	btOptimizedBvh*					m_aabbTree;
+	//btOptimizedBvh*					m_aabbTree;
+	btDbvt*							m_dynamicAabbTree;
 
 public:
 	BT_DECLARE_ALIGNED_ALLOCATOR();
@@ -66,11 +68,11 @@ public:
 
 	void	addChildShape(const btTransform& localTransform,btCollisionShape* shape);
 
-   /** Remove all children shapes that contain the specified shape. */
+	/// Remove all children shapes that contain the specified shape
 	virtual void removeChildShape(btCollisionShape* shape);
 
-	  
+	void removeChildShapeByIndex(int childShapeindex);
-	
+
 
 	int		getNumChildShapes() const
 	{
@@ -103,9 +105,9 @@ public:
 
 	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
 	virtual	void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;
-	
+
-   /** Re-calculate the local Aabb. Is called at the end of removeChildShapes. 
+	/** Re-calculate the local Aabb. Is called at the end of removeChildShapes. 
-       Use this yourself if you modify the children or their transforms. */
+	Use this yourself if you modify the children or their transforms. */
 	virtual void recalculateLocalAabb(); 
 
 	virtual void	setLocalScaling(const btVector3& scaling)
@@ -118,7 +120,7 @@ public:
 	}
 
 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia) const;
-	
+
 	virtual int	getShapeType() const { return COMPOUND_SHAPE_PROXYTYPE;}
 
 	virtual void	setMargin(btScalar margin)
@@ -137,9 +139,9 @@ public:
 	//this is optional, but should make collision queries faster, by culling non-overlapping nodes
 	void	createAabbTreeFromChildren();
 
-	const btOptimizedBvh*					getAabbTree() const
+	btDbvt*							getDynamicAabbTree()
 	{
-		return m_aabbTree;
+		return m_dynamicAabbTree;
 	}
 
 	///computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia

src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h

@@ -18,6 +18,7 @@ subject to the following restrictions:
 
 #include "LinearMath/btPoint3.h"
 #include "LinearMath/btMatrix3x3.h"
+#include "LinearMath/btAabbUtil2.h"
 #include "btConvexInternalShape.h"
 
 
@@ -46,28 +47,7 @@ public:
 
 		//lazy evaluation of local aabb
 		btAssert(m_isLocalAabbValid);
-
+		btTransformAabb(m_localAabbMin,m_localAabbMax,margin,trans,aabbMin,aabbMax);
-		btAssert(m_localAabbMin.getX() <= m_localAabbMax.getX());
-		btAssert(m_localAabbMin.getY() <= m_localAabbMax.getY());
-		btAssert(m_localAabbMin.getZ() <= m_localAabbMax.getZ());
-
-
-		btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
-		localHalfExtents+= btVector3(margin,margin,margin);
-		btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
-		
-		btMatrix3x3 abs_b = trans.getBasis().absolute();  
-
-		btPoint3 center = trans(localCenter);
-
-		btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
-			   abs_b[1].dot(localHalfExtents),
-			  abs_b[2].dot(localHalfExtents));
-
-		aabbMin = center-extent;
-		aabbMax = center+extent;
-
-		
 	}
 
 	

src/LinearMath/btAabbUtil2.h

@@ -17,6 +17,7 @@ subject to the following restrictions:
 #ifndef AABB_UTIL2
 #define AABB_UTIL2
 
+#include "btTransform.h"
 #include "btVector3.h"
 #include "btMinMax.h"
 
@@ -163,6 +164,38 @@ SIMD_FORCE_INLINE bool btRayAabb(const btVector3& rayFrom,
 }
 
 
+
+SIMD_FORCE_INLINE	void btTransformAabb(const btVector3& halfExtents, btScalar margin,const btTransform& t,btVector3& aabbMinOut,btVector3& aabbMaxOut)
+{
+	btVector3 halfExtentsWithMargin = halfExtents+btVector3(margin,margin,margin);
+	btMatrix3x3 abs_b = t.getBasis().absolute();  
+	btVector3 center = t.getOrigin();
+	btVector3 extent = btVector3(abs_b[0].dot(halfExtentsWithMargin),
+		   abs_b[1].dot(halfExtentsWithMargin),
+		  abs_b[2].dot(halfExtentsWithMargin));
+	aabbMinOut = center - extent;
+	aabbMaxOut = center + extent;
+};
+
+SIMD_FORCE_INLINE	void btTransformAabb(const btVector3& localAabbMin,const btVector3& localAabbMax, btScalar margin,const btTransform& trans,btVector3& aabbMinOut,btVector3& aabbMaxOut)
+{
+		btAssert(localAabbMin.getX() <= localAabbMax.getX());
+		btAssert(localAabbMin.getY() <= localAabbMax.getY());
+		btAssert(localAabbMin.getZ() <= localAabbMax.getZ());
+		btVector3 localHalfExtents = btScalar(0.5)*(localAabbMax-localAabbMin);
+		localHalfExtents+=btVector3(margin,margin,margin);
+
+		btVector3 localCenter = btScalar(0.5)*(localAabbMax+localAabbMin);
+		btMatrix3x3 abs_b = trans.getBasis().absolute();  
+		btVector3 center = trans(localCenter);
+		btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
+			   abs_b[1].dot(localHalfExtents),
+			  abs_b[2].dot(localHalfExtents));
+		aabbMinOut = center-extent;
+		aabbMaxOut = center+extent;
+}
+
+
 #endif