merged most of the changes from the branch into trunk, except for COLLADA, libxml and glut glitches.

Still need to verify to make sure no unwanted renaming is introduced.

src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h

@@ -18,23 +18,23 @@ subject to the following restrictions:
 
 #include <vector>
 
-typedef std::vector<struct CollisionObject*> CollisionObjectArray;
-class CollisionAlgorithm;
-struct BroadphaseProxy;
-struct CollisionAlgorithmConstructionInfo;
+typedef std::vector<struct btCollisionObject*> btCollisionObjectArray;
+class btCollisionAlgorithm;
+struct btBroadphaseProxy;
+struct btCollisionAlgorithmConstructionInfo;
 
 
-struct CollisionAlgorithmCreateFunc
+struct btCollisionAlgorithmCreateFunc
 {
 	bool m_swapped;
 	
-	CollisionAlgorithmCreateFunc()
+	btCollisionAlgorithmCreateFunc()
 		:m_swapped(false)
 	{
 	}
-	virtual ~CollisionAlgorithmCreateFunc(){};
+	virtual ~btCollisionAlgorithmCreateFunc(){};
 
-	virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+	virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 	{
 		return 0;
 	}

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -33,7 +33,7 @@ int gNumManifold = 0;
 	
 
 	
-CollisionDispatcher::CollisionDispatcher (): 
+btCollisionDispatcher::btCollisionDispatcher (): 
 	m_useIslands(true),
 		m_defaultManifoldResult(0,0,0),
 		m_count(0)
@@ -41,12 +41,12 @@ CollisionDispatcher::CollisionDispatcher ():
 	int i;
 	
 	//default CreationFunctions, filling the m_doubleDispatch table
-	m_convexConvexCreateFunc = new ConvexConvexAlgorithm::CreateFunc;
-	m_convexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::CreateFunc;
-	m_swappedConvexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
-	m_compoundCreateFunc = new CompoundCollisionAlgorithm::CreateFunc;
-	m_swappedCompoundCreateFunc = new CompoundCollisionAlgorithm::SwappedCreateFunc;
-	m_emptyCreateFunc = new EmptyAlgorithm::CreateFunc;
+	m_convexConvexCreateFunc = new btConvexConvexAlgorithm::CreateFunc;
+	m_convexConcaveCreateFunc = new btConvexConcaveCollisionAlgorithm::CreateFunc;
+	m_swappedConvexConcaveCreateFunc = new btConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
+	m_compoundCreateFunc = new btCompoundCollisionAlgorithm::CreateFunc;
+	m_swappedCompoundCreateFunc = new btCompoundCollisionAlgorithm::SwappedCreateFunc;
+	m_emptyCreateFunc = new btEmptyAlgorithm::CreateFunc;
 
 	for (i=0;i<MAX_BROADPHASE_COLLISION_TYPES;i++)
 	{
@@ -60,12 +60,12 @@ CollisionDispatcher::CollisionDispatcher ():
 	
 };
 
-void CollisionDispatcher::RegisterCollisionCreateFunc(int proxyType0, int proxyType1, CollisionAlgorithmCreateFunc *createFunc)
+void btCollisionDispatcher::RegisterCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
 {
 	m_doubleDispatch[proxyType0][proxyType1] = createFunc;
 }
 
-CollisionDispatcher::~CollisionDispatcher()
+btCollisionDispatcher::~btCollisionDispatcher()
 {
 	delete m_convexConvexCreateFunc;
 	delete m_convexConcaveCreateFunc;
@@ -75,29 +75,29 @@ CollisionDispatcher::~CollisionDispatcher()
 	delete m_emptyCreateFunc;
 }
 
-PersistentManifold*	CollisionDispatcher::GetNewManifold(void* b0,void* b1) 
+btPersistentManifold*	btCollisionDispatcher::GetNewManifold(void* b0,void* b1) 
 { 
 	gNumManifold++;
 	
 	//ASSERT(gNumManifold < 65535);
 	
 
-	CollisionObject* body0 = (CollisionObject*)b0;
-	CollisionObject* body1 = (CollisionObject*)b1;
+	btCollisionObject* body0 = (btCollisionObject*)b0;
+	btCollisionObject* body1 = (btCollisionObject*)b1;
 	
-	PersistentManifold* manifold = new PersistentManifold (body0,body1);
+	btPersistentManifold* manifold = new btPersistentManifold (body0,body1);
 	m_manifoldsPtr.push_back(manifold);
 
 	return manifold;
 }
 
-void CollisionDispatcher::ClearManifold(PersistentManifold* manifold)
+void btCollisionDispatcher::ClearManifold(btPersistentManifold* manifold)
 {
 	manifold->ClearManifold();
 }
 
 	
-void CollisionDispatcher::ReleaseManifold(PersistentManifold* manifold)
+void btCollisionDispatcher::ReleaseManifold(btPersistentManifold* manifold)
 {
 	
 	gNumManifold--;
@@ -106,7 +106,7 @@ void CollisionDispatcher::ReleaseManifold(PersistentManifold* manifold)
 
 	ClearManifold(manifold);
 
-	std::vector<PersistentManifold*>::iterator i =
+	std::vector<btPersistentManifold*>::iterator i =
 		std::find(m_manifoldsPtr.begin(), m_manifoldsPtr.end(), manifold);
 	if (!(i == m_manifoldsPtr.end()))
 	{
@@ -121,47 +121,47 @@ void CollisionDispatcher::ReleaseManifold(PersistentManifold* manifold)
 
 	
 
-CollisionAlgorithm* CollisionDispatcher::FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+btCollisionAlgorithm* btCollisionDispatcher::FindAlgorithm(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
 {
 #define USE_DISPATCH_REGISTRY_ARRAY 1
 #ifdef USE_DISPATCH_REGISTRY_ARRAY
-	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
-	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
-	CollisionAlgorithmConstructionInfo ci;
+	btCollisionObject* body0 = (btCollisionObject*)proxy0.m_clientObject;
+	btCollisionObject* body1 = (btCollisionObject*)proxy1.m_clientObject;
+	btCollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = this;
-	CollisionAlgorithm* algo = m_doubleDispatch[body0->m_collisionShape->GetShapeType()][body1->m_collisionShape->GetShapeType()]
+	btCollisionAlgorithm* algo = m_doubleDispatch[body0->m_collisionShape->GetShapeType()][body1->m_collisionShape->GetShapeType()]
 	->CreateCollisionAlgorithm(ci,&proxy0,&proxy1);
 #else
-	CollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1);
+	btCollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1);
 #endif //USE_DISPATCH_REGISTRY_ARRAY
 	return algo;
 }
 
 
-CollisionAlgorithmCreateFunc* CollisionDispatcher::InternalFindCreateFunc(int proxyType0,int proxyType1)
+btCollisionAlgorithmCreateFunc* btCollisionDispatcher::InternalFindCreateFunc(int proxyType0,int proxyType1)
 {
 	
-	if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConvex(proxyType1))
+	if (btBroadphaseProxy::IsConvex(proxyType0) && btBroadphaseProxy::IsConvex(proxyType1))
 	{
 		return m_convexConvexCreateFunc;
 	}
 
-	if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConcave(proxyType1))
+	if (btBroadphaseProxy::IsConvex(proxyType0) && btBroadphaseProxy::IsConcave(proxyType1))
 	{
 		return m_convexConcaveCreateFunc;
 	}
 
-	if (BroadphaseProxy::IsConvex(proxyType1) && BroadphaseProxy::IsConcave(proxyType0))
+	if (btBroadphaseProxy::IsConvex(proxyType1) && btBroadphaseProxy::IsConcave(proxyType0))
 	{
 		return m_swappedConvexConcaveCreateFunc;
 	}
 
-	if (BroadphaseProxy::IsCompound(proxyType0))
+	if (btBroadphaseProxy::IsCompound(proxyType0))
 	{
 		return m_compoundCreateFunc;
 	} else
 	{
-		if (BroadphaseProxy::IsCompound(proxyType1))
+		if (btBroadphaseProxy::IsCompound(proxyType1))
 		{
 			return m_swappedCompoundCreateFunc;
 		}
@@ -173,72 +173,72 @@ CollisionAlgorithmCreateFunc* CollisionDispatcher::InternalFindCreateFunc(int pr
 
 
 
-CollisionAlgorithm* CollisionDispatcher::InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+btCollisionAlgorithm* btCollisionDispatcher::InternalFindAlgorithm(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
 {
 	m_count++;
-	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
-	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
+	btCollisionObject* body0 = (btCollisionObject*)proxy0.m_clientObject;
+	btCollisionObject* body1 = (btCollisionObject*)proxy1.m_clientObject;
 
-	CollisionAlgorithmConstructionInfo ci;
+	btCollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = this;
 	
 	if (body0->m_collisionShape->IsConvex() && body1->m_collisionShape->IsConvex() )
 	{
-		return new ConvexConvexAlgorithm(0,ci,&proxy0,&proxy1);			
+		return new btConvexConvexAlgorithm(0,ci,&proxy0,&proxy1);			
 	}
 
 	if (body0->m_collisionShape->IsConvex() && body1->m_collisionShape->IsConcave())
 	{
-		return new ConvexConcaveCollisionAlgorithm(ci,&proxy0,&proxy1);
+		return new btConvexConcaveCollisionAlgorithm(ci,&proxy0,&proxy1);
 	}
 
 	if (body1->m_collisionShape->IsConvex() && body0->m_collisionShape->IsConcave())
 	{
-		return new ConvexConcaveCollisionAlgorithm(ci,&proxy1,&proxy0);
+		return new btConvexConcaveCollisionAlgorithm(ci,&proxy1,&proxy0);
 	}
 
 	if (body0->m_collisionShape->IsCompound())
 	{
-		return new CompoundCollisionAlgorithm(ci,&proxy0,&proxy1);
+		return new btCompoundCollisionAlgorithm(ci,&proxy0,&proxy1);
 	} else
 	{
 		if (body1->m_collisionShape->IsCompound())
 		{
-			return new CompoundCollisionAlgorithm(ci,&proxy1,&proxy0);
+			return new btCompoundCollisionAlgorithm(ci,&proxy1,&proxy0);
 		}
 	}
 
 	//failed to find an algorithm
-	return new EmptyAlgorithm(ci);
+	return new btEmptyAlgorithm(ci);
 	
 }
 
-bool	CollisionDispatcher::NeedsResponse(const  CollisionObject& colObj0,const CollisionObject& colObj1)
+bool	btCollisionDispatcher::NeedsResponse(const  btCollisionObject& colObj0,const btCollisionObject& colObj1)
 {
 
 	
 	//here you can do filtering
 	bool hasResponse = 
-		(!(colObj0.m_collisionFlags & CollisionObject::noContactResponse)) &&
-		(!(colObj1.m_collisionFlags & CollisionObject::noContactResponse));
+		(!(colObj0.m_collisionFlags & btCollisionObject::noContactResponse)) &&
+		(!(colObj1.m_collisionFlags & btCollisionObject::noContactResponse));
 	hasResponse = hasResponse &&
 		(colObj0.IsActive() || colObj1.IsActive());
 	return hasResponse;
 }
 
-bool	CollisionDispatcher::NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+bool	btCollisionDispatcher::NeedsCollision(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
 {
 
-	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
-	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
+	btCollisionObject* body0 = (btCollisionObject*)proxy0.m_clientObject;
+	btCollisionObject* body1 = (btCollisionObject*)proxy1.m_clientObject;
 
 	assert(body0);
 	assert(body1);
 
 	bool needsCollision = true;
 
-	if ((body0->m_collisionFlags & CollisionObject::isStatic) && 
-		(body1->m_collisionFlags & CollisionObject::isStatic))
+	if ((body0->m_collisionFlags & btCollisionObject::isStatic) && 
+		(body1->m_collisionFlags & btCollisionObject::isStatic))
 		needsCollision = false;
 		
 	if ((!body0->IsActive()) && (!body1->IsActive()))
@@ -249,37 +249,37 @@ bool	CollisionDispatcher::NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy
 }
 
 ///allows the user to get contact point callbacks 
-ManifoldResult*	CollisionDispatcher::GetNewManifoldResult(CollisionObject* obj0,CollisionObject* obj1,PersistentManifold* manifold)
+btManifoldResult*	btCollisionDispatcher::GetNewManifoldResult(btCollisionObject* obj0,btCollisionObject* obj1,btPersistentManifold* manifold)
 {
 
 
 	//in-place, this prevents parallel dispatching, but just adding a list would fix that.
-	ManifoldResult* manifoldResult = new (&m_defaultManifoldResult)	ManifoldResult(obj0,obj1,manifold);
+	btManifoldResult* manifoldResult = new (&m_defaultManifoldResult)	btManifoldResult(obj0,obj1,manifold);
 	return manifoldResult;
 }
 	
 ///allows the user to get contact point callbacks 
-void	CollisionDispatcher::ReleaseManifoldResult(ManifoldResult*)
+void	btCollisionDispatcher::ReleaseManifoldResult(btManifoldResult*)
 {
 
 }
 
 
-class CollisionPairCallback : public OverlapCallback
+class CollisionPairCallback : public btOverlapCallback
 {
-	DispatcherInfo& m_dispatchInfo;
-	CollisionDispatcher*	m_dispatcher;
+	btDispatcherInfo& m_dispatchInfo;
+	btCollisionDispatcher*	m_dispatcher;
 	int		m_dispatcherId;
 public:
 
-	CollisionPairCallback(DispatcherInfo& dispatchInfo,CollisionDispatcher*	dispatcher,int		dispatcherId)
+	CollisionPairCallback(btDispatcherInfo& dispatchInfo,btCollisionDispatcher*	dispatcher,int		dispatcherId)
 	:m_dispatchInfo(dispatchInfo),
 	m_dispatcher(dispatcher),
 	m_dispatcherId(dispatcherId)
 	{
 	}
 
-	virtual bool	ProcessOverlap(BroadphasePair& pair)
+	virtual bool	ProcessOverlap(btBroadphasePair& pair)
 	{
 		if (m_dispatcherId>= 0)
 		{
@@ -293,7 +293,7 @@ public:
 
 			if (pair.m_algorithms[m_dispatcherId])
 			{
-				if (m_dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
+				if (m_dispatchInfo.m_dispatchFunc == 		btDispatcherInfo::DISPATCH_DISCRETE)
 				{
 					pair.m_algorithms[m_dispatcherId]->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
 				} else
@@ -307,13 +307,13 @@ public:
 		} else
 		{
 			//non-persistent algorithm dispatcher
-			CollisionAlgorithm* algo = m_dispatcher->FindAlgorithm(
+			btCollisionAlgorithm* algo = m_dispatcher->FindAlgorithm(
 				*pair.m_pProxy0,
 				*pair.m_pProxy1);
 
 			if (algo)
 			{
-				if (m_dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
+				if (m_dispatchInfo.m_dispatchFunc == 		btDispatcherInfo::DISPATCH_DISCRETE)
 				{
 					algo->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
 				} else
@@ -330,7 +330,7 @@ public:
 };
 
 
-void	CollisionDispatcher::DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo)
+void	btCollisionDispatcher::DispatchAllCollisionPairs(btOverlappingPairCache* pairCache,btDispatcherInfo& dispatchInfo)
 {
 	//m_blockedForChanges = true;
 

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h

@@ -24,8 +24,8 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 
 
-class IDebugDraw;
-class OverlappingPairCache;
+class btIDebugDraw;
+class btOverlappingPairCache;
 
 
 #include "btCollisionCreateFunc.h"
@@ -35,77 +35,82 @@ class OverlappingPairCache;
 
 ///CollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
 ///Time of Impact, Closest Points and Penetration Depth.
-class CollisionDispatcher : public Dispatcher
+class btCollisionDispatcher : public btDispatcher
 {
 	
-	std::vector<PersistentManifold*>	m_manifoldsPtr;
+	std::vector<btPersistentManifold*>	m_manifoldsPtr;
 
 	bool m_useIslands;
 	
-	ManifoldResult	m_defaultManifoldResult;
+	btManifoldResult	m_defaultManifoldResult;
 	
-	CollisionAlgorithmCreateFunc* m_doubleDispatch[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
+	btCollisionAlgorithmCreateFunc* m_doubleDispatch[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
 	
-	CollisionAlgorithmCreateFunc* InternalFindCreateFunc(int proxyType0,int proxyType1);
+	btCollisionAlgorithmCreateFunc* InternalFindCreateFunc(int proxyType0,int proxyType1);
 
 	//default CreationFunctions, filling the m_doubleDispatch table
-	CollisionAlgorithmCreateFunc*	m_convexConvexCreateFunc;
-	CollisionAlgorithmCreateFunc*	m_convexConcaveCreateFunc;
-	CollisionAlgorithmCreateFunc*	m_swappedConvexConcaveCreateFunc;
-	CollisionAlgorithmCreateFunc*	m_compoundCreateFunc;
-	CollisionAlgorithmCreateFunc*	m_swappedCompoundCreateFunc;
-	CollisionAlgorithmCreateFunc*   m_emptyCreateFunc;
+	btCollisionAlgorithmCreateFunc*	m_convexConvexCreateFunc;
+	btCollisionAlgorithmCreateFunc*	m_convexConcaveCreateFunc;
+	btCollisionAlgorithmCreateFunc*	m_swappedConvexConcaveCreateFunc;
+	btCollisionAlgorithmCreateFunc*	m_compoundCreateFunc;
+	btCollisionAlgorithmCreateFunc*	m_swappedCompoundCreateFunc;
+	btCollisionAlgorithmCreateFunc*   m_emptyCreateFunc;
 
 public:
 
 	///RegisterCollisionCreateFunc allows registration of custom/alternative collision create functions
-	void	RegisterCollisionCreateFunc(int proxyType0,int proxyType1, CollisionAlgorithmCreateFunc* createFunc);
+	void	RegisterCollisionCreateFunc(int proxyType0,int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);
 
 	int	GetNumManifolds() const
 	{ 
 		return m_manifoldsPtr.size();
 	}
 
-	 PersistentManifold* GetManifoldByIndexInternal(int index)
+	btPersistentManifold**	getInternalManifoldPointer()
+	{
+		return &m_manifoldsPtr[0];
+	}
+
+	 btPersistentManifold* GetManifoldByIndexInternal(int index)
 	{
 		return m_manifoldsPtr[index];
 	}
 
-	 const PersistentManifold* GetManifoldByIndexInternal(int index) const
+	 const btPersistentManifold* GetManifoldByIndexInternal(int index) const
 	{
 		return m_manifoldsPtr[index];
 	}
 
 	int m_count;
 	
-	CollisionDispatcher ();
-	virtual ~CollisionDispatcher();
+	btCollisionDispatcher ();
+	virtual ~btCollisionDispatcher();
 
-	virtual PersistentManifold*	GetNewManifold(void* b0,void* b1);
+	virtual btPersistentManifold*	GetNewManifold(void* b0,void* b1);
 	
-	virtual void ReleaseManifold(PersistentManifold* manifold);
+	virtual void ReleaseManifold(btPersistentManifold* manifold);
 
 	
 	///allows the user to get contact point callbacks 
-	virtual	ManifoldResult*	GetNewManifoldResult(CollisionObject* obj0,CollisionObject* obj1,PersistentManifold* manifold);
+	virtual	btManifoldResult*	GetNewManifoldResult(btCollisionObject* obj0,btCollisionObject* obj1,btPersistentManifold* manifold);
 
 	///allows the user to get contact point callbacks 
-	virtual	void	ReleaseManifoldResult(ManifoldResult*);
+	virtual	void	ReleaseManifoldResult(btManifoldResult*);
 
-	virtual void ClearManifold(PersistentManifold* manifold);
+	virtual void ClearManifold(btPersistentManifold* manifold);
 
 			
-	CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	btCollisionAlgorithm* FindAlgorithm(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1);
 	
-	CollisionAlgorithm* InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	btCollisionAlgorithm* InternalFindAlgorithm(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1);
 	
-	virtual bool	NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	virtual bool	NeedsCollision(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1);
 	
-	virtual bool	NeedsResponse(const CollisionObject& colObj0,const CollisionObject& colObj1);
+	virtual bool	NeedsResponse(const btCollisionObject& colObj0,const btCollisionObject& colObj1);
 
 	virtual int GetUniqueId() { return RIGIDBODY_DISPATCHER;}
 	
-	virtual void	DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo);
+	virtual void	DispatchAllCollisionPairs(btOverlappingPairCache* pairCache,btDispatcherInfo& dispatchInfo);
 
 	
 

src/BulletCollision/CollisionDispatch/btCollisionObject.cpp

@@ -15,7 +15,7 @@ subject to the following restrictions:
 
 #include "btCollisionObject.h"
 
-CollisionObject::CollisionObject()
+btCollisionObject::btCollisionObject()
 	:	m_collisionFlags(0),
 		m_activationState1(1),
 		m_deactivationTime(0.f),
@@ -30,18 +30,18 @@ CollisionObject::CollisionObject()
 }
 
 
-void CollisionObject::SetActivationState(int newState) 
+void btCollisionObject::SetActivationState(int newState) 
 { 
 	if ( (m_activationState1 != DISABLE_DEACTIVATION) && (m_activationState1 != DISABLE_SIMULATION))
 		m_activationState1 = newState;
 }
 
-void CollisionObject::ForceActivationState(int newState)
+void btCollisionObject::ForceActivationState(int newState)
 {
 	m_activationState1 = newState;
 }
 
-void CollisionObject::activate()
+void btCollisionObject::activate()
 {
 	if (!(m_collisionFlags & isStatic))
 	{
@@ -50,8 +50,8 @@ void CollisionObject::activate()
 	}
 }
 
-bool CollisionObject::mergesSimulationIslands() const
+bool btCollisionObject::mergesSimulationIslands() const
 {
 	//static objects, and object without contact response don't merge islands
-	return ( !(m_collisionFlags & (isStatic |noContactResponse )));
+	return ( !(m_collisionFlags & (isStatic | noContactResponse)));
 }

src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef COLLISION_OBJECT_H
 #define COLLISION_OBJECT_H
 
-#include "LinearMath/SimdTransform.h"
+#include "LinearMath/btTransform.h"
 
 //island management, m_activationState1
 #define ACTIVE_TAG 1
@@ -25,23 +25,23 @@ subject to the following restrictions:
 #define DISABLE_DEACTIVATION 4
 #define DISABLE_SIMULATION 5
 
-struct	BroadphaseProxy;
-class	CollisionShape;
+struct	btBroadphaseProxy;
+class	btCollisionShape;
 
-/// CollisionObject can be used to manage collision detection objects. 
-/// CollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
-/// They can be added to the CollisionWorld.
-struct	CollisionObject
+/// 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
 {
-	SimdTransform	m_worldTransform;
+	btTransform	m_worldTransform;
 	BroadphaseProxy*	m_broadphaseHandle;
 	CollisionShape*		m_collisionShape;
 
 	//m_interpolationWorldTransform is used for CCD and interpolation
 	//it can be either previous or future (predicted) transform
-	SimdTransform	m_interpolationWorldTransform;
+	btTransform	m_interpolationWorldTransform;
 
-	SimdTransform	m_cachedInvertedWorldTransform;
+	btTransform	m_cachedInvertedWorldTransform;
 
 	enum CollisionFlags
 	{
@@ -56,10 +56,8 @@ struct	CollisionObject
 	int				m_activationState1;
 	float			m_deactivationTime;
 
-	SimdScalar		m_friction;
-	SimdScalar		m_restitution;
-
-	
+	btScalar		m_friction;
+	btScalar		m_restitution;
 
 	//users can point to their objects, m_userPointer is not used by Bullet
 	void*			m_userObjectPointer;
@@ -70,7 +68,7 @@ struct	CollisionObject
 	///time of impact calculation
 	float			m_hitFraction; 
 	
-	///Swept sphere radius (0.0 by default), see ConvexConvexAlgorithm::
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
 	float			m_ccdSweptShereRadius;
 
 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionTreshold
@@ -89,10 +87,10 @@ struct	CollisionObject
 	
 
 
-	CollisionObject();
+	btCollisionObject();
 
 
-	void	SetCollisionShape(CollisionShape* collisionShape)
+	void	SetCollisionShape(btCollisionShape* collisionShape)
 	{
 		m_collisionShape = collisionShape;
 	}

src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -24,22 +24,22 @@ subject to the following restrictions:
 
 #include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
-#include "LinearMath/GenAabbUtil2.h"
+#include "LinearMath/btAabbUtil2.h"
 
 #include <algorithm>
 
-CollisionWorld::~CollisionWorld()
+btCollisionWorld::~btCollisionWorld()
 {
 	//clean up remaining objects
-	std::vector<CollisionObject*>::iterator i;
+	std::vector<btCollisionObject*>::iterator i;
 
 	for (i=m_collisionObjects.begin();
 	!(i==m_collisionObjects.end()); i++)
 
 	{
-		CollisionObject* collisionObject= (*i);
+		btCollisionObject* collisionObject= (*i);
 		
-		BroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
 		if (bp)
 		{
 			//
@@ -61,15 +61,15 @@ CollisionWorld::~CollisionWorld()
 
 
 
-void	CollisionWorld::AddCollisionObject(CollisionObject* collisionObject,short int collisionFilterGroup,short int collisionFilterMask)
+void	btCollisionWorld::AddCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup,short int collisionFilterMask)
 {
 		m_collisionObjects.push_back(collisionObject);
 
 		//calculate new AABB
-		SimdTransform trans = collisionObject->m_worldTransform;
+		btTransform trans = collisionObject->m_worldTransform;
 
-		SimdVector3	minAabb;
-		SimdVector3	maxAabb;
+		btVector3	minAabb;
+		btVector3	maxAabb;
 		collisionObject->m_collisionShape->GetAabb(trans,minAabb,maxAabb);
 
 		int type = collisionObject->m_collisionShape->GetShapeType();
@@ -87,15 +87,15 @@ void	CollisionWorld::AddCollisionObject(CollisionObject* collisionObject,short i
 
 }
 
-void	CollisionWorld::PerformDiscreteCollisionDetection()
+void	btCollisionWorld::PerformDiscreteCollisionDetection()
 {
-	DispatcherInfo	dispatchInfo;
+	btDispatcherInfo	dispatchInfo;
 	dispatchInfo.m_timeStep = 0.f;
 	dispatchInfo.m_stepCount = 0;
 
 	//update aabb (of all moved objects)
 
-	SimdVector3 aabbMin,aabbMax;
+	btVector3 aabbMin,aabbMax;
 	for (size_t i=0;i<m_collisionObjects.size();i++)
 	{
 		m_collisionObjects[i]->m_cachedInvertedWorldTransform = m_collisionObjects[i]->m_worldTransform.inverse();
@@ -105,14 +105,14 @@ void	CollisionWorld::PerformDiscreteCollisionDetection()
 
 	m_pairCache->RefreshOverlappingPairs();
 
-	Dispatcher* dispatcher = GetDispatcher();
+	btDispatcher* dispatcher = GetDispatcher();
 	if (dispatcher)
 		dispatcher->DispatchAllCollisionPairs(m_pairCache,dispatchInfo);
 
 }
 
 
-void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
+void	btCollisionWorld::RemoveCollisionObject(btCollisionObject* collisionObject)
 {
 	
 	
@@ -120,7 +120,7 @@ void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
 	
 	{
 		
-		BroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
 		if (bp)
 		{
 			//
@@ -133,7 +133,7 @@ void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
 	}
 
 
-	std::vector<CollisionObject*>::iterator i =	std::find(m_collisionObjects.begin(), m_collisionObjects.end(), collisionObject);
+	std::vector<btCollisionObject*>::iterator i =	std::find(m_collisionObjects.begin(), m_collisionObjects.end(), collisionObject);
 		
 	if (!(i == m_collisionObjects.end()))
 		{
@@ -142,23 +142,23 @@ void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
 		}
 }
 
-void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdTransform& rayToTrans,
-					  CollisionObject* collisionObject,
-					  const CollisionShape* collisionShape,
-					  const SimdTransform& colObjWorldTransform,
+void	btCollisionWorld::RayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
+					  btCollisionObject* collisionObject,
+					  const btCollisionShape* collisionShape,
+					  const btTransform& colObjWorldTransform,
 					  RayResultCallback& resultCallback)
 {
 	
-	SphereShape pointShape(0.0f);
+	btSphereShape pointShape(0.0f);
 
 	if (collisionShape->IsConvex())
 			{
-				ConvexCast::CastResult castResult;
+				btConvexCast::CastResult castResult;
 				castResult.m_fraction = 1.f;//??
 
-				ConvexShape* convexShape = (ConvexShape*) collisionShape;
-				VoronoiSimplexSolver	simplexSolver;
-				SubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
+				btConvexShape* convexShape = (btConvexShape*) collisionShape;
+				btVoronoiSimplexSolver	simplexSolver;
+				btSubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
 				//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
 				//ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
 				
@@ -172,7 +172,7 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 						{
 							
 
-							CollisionWorld::LocalRayResult localRayResult
+							btCollisionWorld::LocalRayResult localRayResult
 								(
 									collisionObject, 
 									0,
@@ -192,24 +192,24 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 				if (collisionShape->IsConcave())
 					{
 
-						TriangleMeshShape* triangleMesh = (TriangleMeshShape*)collisionShape;
+						btTriangleMeshShape* triangleMesh = (btTriangleMeshShape*)collisionShape;
 						
-						SimdTransform worldTocollisionObject = colObjWorldTransform.inverse();
+						btTransform worldTocollisionObject = colObjWorldTransform.inverse();
 
-						SimdVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
-						SimdVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();
+						btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
+						btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();
 
 						//ConvexCast::CastResult
 
-						struct BridgeTriangleRaycastCallback : public TriangleRaycastCallback 
+						struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback 
 						{
-							CollisionWorld::RayResultCallback* m_resultCallback;
-							CollisionObject*	m_collisionObject;
-							TriangleMeshShape*	m_triangleMesh;
+							btCollisionWorld::RayResultCallback* m_resultCallback;
+							btCollisionObject*	m_collisionObject;
+							btTriangleMeshShape*	m_triangleMesh;
 
-							BridgeTriangleRaycastCallback( const SimdVector3& from,const SimdVector3& to,
-								CollisionWorld::RayResultCallback* resultCallback, CollisionObject* collisionObject,TriangleMeshShape*	triangleMesh):
-								TriangleRaycastCallback(from,to),
+							BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
+								btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape*	triangleMesh):
+								btTriangleRaycastCallback(from,to),
 									m_resultCallback(resultCallback),
 									m_collisionObject(collisionObject),
 									m_triangleMesh(triangleMesh)
@@ -217,13 +217,13 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 								}
 
 
-							virtual float ReportHit(const SimdVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex )
+							virtual float ReportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex )
 							{
-								CollisionWorld::LocalShapeInfo	shapeInfo;
+								btCollisionWorld::LocalShapeInfo	shapeInfo;
 								shapeInfo.m_shapePart = partId;
 								shapeInfo.m_triangleIndex = triangleIndex;
 								
-								CollisionWorld::LocalRayResult rayResult
+								btCollisionWorld::LocalRayResult rayResult
 								(m_collisionObject, 
 									&shapeInfo,
 									hitNormalLocal,
@@ -240,9 +240,9 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 						BridgeTriangleRaycastCallback	rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,triangleMesh);
 						rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 
-						SimdVector3 rayAabbMinLocal = rayFromLocal;
+						btVector3 rayAabbMinLocal = rayFromLocal;
 						rayAabbMinLocal.setMin(rayToLocal);
-						SimdVector3 rayAabbMaxLocal = rayFromLocal;
+						btVector3 rayAabbMaxLocal = rayFromLocal;
 						rayAabbMaxLocal.setMax(rayToLocal);
 
 						triangleMesh->ProcessAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
@@ -252,13 +252,13 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 						//todo: use AABB tree or other BVH acceleration structure!
 						if (collisionShape->IsCompound())
 						{
-							const CompoundShape* compoundShape = static_cast<const CompoundShape*>(collisionShape);
+							const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
 							int i=0;
 							for (i=0;i<compoundShape->GetNumChildShapes();i++)
 							{
-								SimdTransform childTrans = compoundShape->GetChildTransform(i);
-								const CollisionShape* childCollisionShape = compoundShape->GetChildShape(i);
-								SimdTransform childWorldTrans = colObjWorldTransform * childTrans;
+								btTransform childTrans = compoundShape->GetChildTransform(i);
+								const btCollisionShape* childCollisionShape = compoundShape->GetChildShape(i);
+								btTransform childWorldTrans = colObjWorldTransform * childTrans;
 								RayTestSingle(rayFromTrans,rayToTrans,
 									collisionObject,
 									childCollisionShape,
@@ -273,11 +273,11 @@ void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdT
 			}
 }
 
-void	CollisionWorld::RayTest(const SimdVector3& rayFromWorld, const SimdVector3& rayToWorld, RayResultCallback& resultCallback)
+void	btCollisionWorld::RayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback)
 {
 
 	
-	SimdTransform	rayFromTrans,rayToTrans;
+	btTransform	rayFromTrans,rayToTrans;
 	rayFromTrans.setIdentity();
 	rayFromTrans.setOrigin(rayFromWorld);
 	rayToTrans.setIdentity();
@@ -285,8 +285,8 @@ void	CollisionWorld::RayTest(const SimdVector3& rayFromWorld, const SimdVector3&
 	rayToTrans.setOrigin(rayToWorld);
 
 	//do culling based on aabb (rayFrom/rayTo)
-	SimdVector3 rayAabbMin = rayFromWorld;
-	SimdVector3 rayAabbMax = rayFromWorld;
+	btVector3 rayAabbMin = rayFromWorld;
+	btVector3 rayAabbMax = rayFromWorld;
 	rayAabbMin.setMin(rayToWorld);
 	rayAabbMax.setMax(rayToWorld);
 
@@ -294,16 +294,16 @@ void	CollisionWorld::RayTest(const SimdVector3& rayFromWorld, const SimdVector3&
 	/// brute force go over all objects. Once there is a broadphase, use that, or
 	/// add a raycast against aabb first.
 	
-	std::vector<CollisionObject*>::iterator iter;
+	std::vector<btCollisionObject*>::iterator iter;
 	
 	for (iter=m_collisionObjects.begin();
 	!(iter==m_collisionObjects.end()); iter++)
 	{
 		
-		CollisionObject*	collisionObject= (*iter);
+		btCollisionObject*	collisionObject= (*iter);
 
 		//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
-		SimdVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+		btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 		collisionObject->m_collisionShape->GetAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
 
 		//check aabb overlap

src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -22,7 +22,7 @@ subject to the following restrictions:
  *
  * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ).
  *
- * There is the Physics Forum for Feedback and General Collision Detection and Physics discussions.
+ * There is the Physics Forum for Feedback and bteral Collision Detection and Physics discussions.
  * Please visit http://www.continuousphysics.com/Bullet/phpBB2/index.php
  *
  * @section install_sec Installation
@@ -44,12 +44,12 @@ subject to the following restrictions:
  * The Dependencies can be seen in this documentation under Directories
  * 
  * @subsection step4 Step 4: Integrating in your application, Full Rigid Body Simulation
- * Check out CcdPhysicsDemo how to create a CcdPhysicsEnvironment , CollisionShape and RigidBody, Stepping the simulation and synchronizing your derived version of the PHY_IMotionState class.
+ * Check out CcdPhysicsDemo how to create a CcdPhysicsEnvironment , btCollisionShape and btRigidBody, Stepping the simulation and synchronizing your derived version of the PHY_IMotionState class.
  * @subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras)
  * Bullet Collision Detection can also be used without the Dynamics/Extras.
- * Check out CollisionWorld and CollisionObject, and the CollisionInterfaceDemo. Also in Extras/test_BulletOde.cpp there is a sample Collision Detection integration with Open Dynamics Engine, ODE, http://www.ode.org
+ * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. Also in Extras/test_BulletOde.cpp there is a sample Collision Detection integration with Open Dynamics Engine, ODE, http://www.ode.org
  * @subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation.
- * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of GjkPairDetector.
+ * 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
@@ -64,12 +64,12 @@ subject to the following restrictions:
 #define COLLISION_WORLD_H
 
 
-class CollisionShape;
-class BroadphaseInterface;
-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
+class btCollisionShape;
+class btBroadphaseInterface;
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
 #include "btCollisionObject.h"
-#include "btCollisionDispatcher.h" //for definition of CollisionObjectArray
+#include "btCollisionDispatcher.h" //for definition of btCollisionObjectArray
 #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
 
 #include <vector>
@@ -77,61 +77,62 @@ class BroadphaseInterface;
 
 
 ///CollisionWorld is interface and container for the collision detection
-class CollisionWorld
+class btCollisionWorld
 {
 
 	
+protected:
 
-	std::vector<CollisionObject*>	m_collisionObjects;
+	std::vector<btCollisionObject*>	m_collisionObjects;
 	
-	Dispatcher*	m_dispatcher1;
+	btDispatcher*	m_dispatcher1;
 
-	OverlappingPairCache*	m_pairCache;
+	btOverlappingPairCache*	m_pairCache;
 	
 
 public:
 
-	CollisionWorld(Dispatcher* dispatcher,OverlappingPairCache* pairCache)
+	btCollisionWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache)
 		:m_dispatcher1(dispatcher),
 		m_pairCache(pairCache)
 	{
 
 	}
-	virtual ~CollisionWorld();
+	virtual ~btCollisionWorld();
 
 
-	BroadphaseInterface*	GetBroadphase()
+	btBroadphaseInterface*	GetBroadphase()
 	{
 		return m_pairCache;
 	}
 
-	OverlappingPairCache*	GetPairCache()
+	btOverlappingPairCache*	GetPairCache()
 	{
 		return m_pairCache;
 	}
 
 
-	Dispatcher*	GetDispatcher()
+	btDispatcher*	GetDispatcher()
 	{
 		return m_dispatcher1;
 	}
 
 	///LocalShapeInfo gives extra information for complex shapes
-	///Currently, only TriangleMeshShape is available, so it just contains triangleIndex and subpart
+	///Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
 	struct	LocalShapeInfo
 	{
 		int	m_shapePart;
 		int	m_triangleIndex;
 		
-		//const CollisionShape*	m_shapeTemp;
-		//const SimdTransform*	m_shapeLocalTransform;
+		//const btCollisionShape*	m_shapeTemp;
+		//const btTransform*	m_shapeLocalTransform;
 	};
 
 	struct	LocalRayResult
 	{
-		LocalRayResult(const CollisionObject*	collisionObject, 
+		LocalRayResult(const btCollisionObject*	collisionObject, 
 			LocalShapeInfo*	localShapeInfo,
-			const SimdVector3&		hitNormalLocal,
+			const btVector3&		hitNormalLocal,
 			float hitFraction)
 		:m_collisionObject(collisionObject),
 		m_localShapeInfo(m_localShapeInfo),
@@ -140,9 +141,9 @@ public:
 		{
 		}
 
-		const CollisionObject*	m_collisionObject;
+		const btCollisionObject*	m_collisionObject;
 		LocalShapeInfo*			m_localShapeInfo;
-		const SimdVector3&		m_hitNormalLocal;
+		const btVector3&		m_hitNormalLocal;
 		float					m_hitFraction;
 
 	};
@@ -168,19 +169,19 @@ public:
 
 	struct	ClosestRayResultCallback : public RayResultCallback
 	{
-		ClosestRayResultCallback(SimdVector3	rayFromWorld,SimdVector3	rayToWorld)
+		ClosestRayResultCallback(btVector3	rayFromWorld,btVector3	rayToWorld)
 		:m_rayFromWorld(rayFromWorld),
 		m_rayToWorld(rayToWorld),
 		m_collisionObject(0)
 		{
 		}
 
-		SimdVector3	m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
-		SimdVector3	m_rayToWorld;
+		btVector3	m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
+		btVector3	m_rayToWorld;
 
-		SimdVector3	m_hitNormalWorld;
-		SimdVector3	m_hitPointWorld;
-		const CollisionObject*	m_collisionObject;
+		btVector3	m_hitNormalWorld;
+		btVector3	m_hitPointWorld;
+		const btCollisionObject*	m_collisionObject;
 		
 		virtual	float	AddSingleResult(const LocalRayResult& rayResult)
 		{
@@ -204,33 +205,33 @@ public:
 		return m_collisionObjects.size();
 	}
 
-	/// RayTest performs a raycast on all objects in the CollisionWorld, and calls the resultCallback
+	/// 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 SimdVector3& rayFromWorld, const SimdVector3& rayToWorld, RayResultCallback& resultCallback);
+	void	RayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback);
 
 	/// 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 CollisionShape.
+	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
 	/// This allows more customization.
-	void	RayTestSingle(const SimdTransform& rayFromTrans,const SimdTransform& rayToTrans,
-					  CollisionObject* collisionObject,
-					  const CollisionShape* collisionShape,
-					  const SimdTransform& colObjWorldTransform,
+	void	RayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
+					  btCollisionObject* collisionObject,
+					  const btCollisionShape* collisionShape,
+					  const btTransform& colObjWorldTransform,
 					  RayResultCallback& resultCallback);
 
-	void	AddCollisionObject(CollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1);
+	void	AddCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1);
 
-	CollisionObjectArray& GetCollisionObjectArray()
+	btCollisionObjectArray& GetCollisionObjectArray()
 	{
 		return m_collisionObjects;
 	}
 
-	const CollisionObjectArray& GetCollisionObjectArray() const
+	const btCollisionObjectArray& GetCollisionObjectArray() const
 	{
 		return m_collisionObjects;
 	}
 
 
-	void	RemoveCollisionObject(CollisionObject* collisionObject);
+	void	RemoveCollisionObject(btCollisionObject* collisionObject);
 
 	virtual void	PerformDiscreteCollisionDetection();
 

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -18,29 +18,29 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
 
 
-CompoundCollisionAlgorithm::CompoundCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 :m_dispatcher(ci.m_dispatcher),
 m_compoundProxy(*proxy0),
 m_otherProxy(*proxy1)
 {
-	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	btCollisionObject* colObj = static_cast<btCollisionObject*>(m_compoundProxy.m_clientObject);
 	assert (colObj->m_collisionShape->IsCompound());
 	
-	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
 	int numChildren = compoundShape->GetNumChildShapes();
 	m_childProxies.resize( numChildren );
 	int i;
 	for (i=0;i<numChildren;i++)
 	{
-		m_childProxies[i] = BroadphaseProxy(*proxy0);
+		m_childProxies[i] = btBroadphaseProxy(*proxy0);
 	}
 
 	m_childCollisionAlgorithms.resize(numChildren);
 	for (i=0;i<numChildren;i++)
 	{
-		CollisionShape* childShape = compoundShape->GetChildShape(i);
-		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
-		CollisionShape* orgShape = colObj->m_collisionShape;
+		btCollisionShape* childShape = compoundShape->GetChildShape(i);
+		btCollisionObject* colObj = static_cast<btCollisionObject*>(m_childProxies[i].m_clientObject);
+		btCollisionShape* orgShape = colObj->m_collisionShape;
 		colObj->m_collisionShape = childShape;
 		m_childCollisionAlgorithms[i] = m_dispatcher->FindAlgorithm(m_childProxies[i],m_otherProxy);
 		colObj->m_collisionShape =orgShape;
@@ -48,7 +48,7 @@ m_otherProxy(*proxy1)
 }
 
 
-CompoundCollisionAlgorithm::~CompoundCollisionAlgorithm()
+btCompoundCollisionAlgorithm::~btCompoundCollisionAlgorithm()
 {
 	int numChildren = m_childCollisionAlgorithms.size();
 	int i;
@@ -58,12 +58,12 @@ CompoundCollisionAlgorithm::~CompoundCollisionAlgorithm()
 	}
 }
 
-void CompoundCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+void btCompoundCollisionAlgorithm::ProcessCollision (btBroadphaseProxy* ,btBroadphaseProxy* ,const btDispatcherInfo& dispatchInfo)
 {
-	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	btCollisionObject* colObj = static_cast<btCollisionObject*>(m_compoundProxy.m_clientObject);
 	assert (colObj->m_collisionShape->IsCompound());
 	
-	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
 
 	//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
@@ -77,16 +77,16 @@ void CompoundCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseP
 	int i;
 	for (i=0;i<numChildren;i++)
 	{
-		//temporarily exchange parent CollisionShape with childShape, and recurse
-		CollisionShape* childShape = compoundShape->GetChildShape(i);
-		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
+		//temporarily exchange parent btCollisionShape with childShape, and recurse
+		btCollisionShape* childShape = compoundShape->GetChildShape(i);
+		btCollisionObject* colObj = static_cast<btCollisionObject*>(m_childProxies[i].m_clientObject);
 
 		//backup
-		SimdTransform	orgTrans = colObj->m_worldTransform;
-		CollisionShape* orgShape = colObj->m_collisionShape;
+		btTransform	orgTrans = colObj->m_worldTransform;
+		btCollisionShape* orgShape = colObj->m_collisionShape;
 
-		SimdTransform childTrans = compoundShape->GetChildTransform(i);
-		SimdTransform	newChildWorldTrans = orgTrans*childTrans ;
+		btTransform childTrans = compoundShape->GetChildTransform(i);
+		btTransform	newChildWorldTrans = orgTrans*childTrans ;
 		colObj->m_worldTransform = newChildWorldTrans;
 
 		colObj->m_collisionShape = childShape;
@@ -97,12 +97,12 @@ void CompoundCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseP
 	}
 }
 
-float	CompoundCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+float	btCompoundCollisionAlgorithm::CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
-	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	btCollisionObject* colObj = static_cast<btCollisionObject*>(m_compoundProxy.m_clientObject);
 	assert (colObj->m_collisionShape->IsCompound());
 	
-	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
 
 	//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
@@ -117,16 +117,16 @@ float	CompoundCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,
 	int i;
 	for (i=0;i<numChildren;i++)
 	{
-		//temporarily exchange parent CollisionShape with childShape, and recurse
-		CollisionShape* childShape = compoundShape->GetChildShape(i);
-		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
+		//temporarily exchange parent btCollisionShape with childShape, and recurse
+		btCollisionShape* childShape = compoundShape->GetChildShape(i);
+		btCollisionObject* colObj = static_cast<btCollisionObject*>(m_childProxies[i].m_clientObject);
 
 		//backup
-		SimdTransform	orgTrans = colObj->m_worldTransform;
-		CollisionShape* orgShape = colObj->m_collisionShape;
+		btTransform	orgTrans = colObj->m_worldTransform;
+		btCollisionShape* orgShape = colObj->m_collisionShape;
 
-		SimdTransform childTrans = compoundShape->GetChildTransform(i);
-		SimdTransform	newChildWorldTrans = orgTrans*childTrans ;
+		btTransform childTrans = compoundShape->GetChildTransform(i);
+		btTransform	newChildWorldTrans = orgTrans*childTrans ;
 		colObj->m_worldTransform = newChildWorldTrans;
 
 		colObj->m_collisionShape = childShape;

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -21,49 +21,49 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
 
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
-class Dispatcher;
+class btDispatcher;
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include <vector>
 #include "btCollisionCreateFunc.h"
 
-/// CompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
+/// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
 /// Place holder, not fully implemented yet
-class CompoundCollisionAlgorithm  : public CollisionAlgorithm
+class btCompoundCollisionAlgorithm  : public btCollisionAlgorithm
 {
-	Dispatcher*	m_dispatcher;
-	BroadphaseProxy	m_compoundProxy;
-	BroadphaseProxy	m_otherProxy;
-	std::vector<BroadphaseProxy> m_childProxies;
-	std::vector<CollisionAlgorithm*> m_childCollisionAlgorithms;
+	btDispatcher*	m_dispatcher;
+	btBroadphaseProxy	m_compoundProxy;
+	btBroadphaseProxy	m_otherProxy;
+	std::vector<btBroadphaseProxy> m_childProxies;
+	std::vector<btCollisionAlgorithm*> m_childCollisionAlgorithms;
 
-	BroadphaseProxy m_compound;
+	btBroadphaseProxy m_compound;
 
-	BroadphaseProxy m_other;
+	btBroadphaseProxy m_other;
 
 	
 public:
 
-	CompoundCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 
-	virtual ~CompoundCollisionAlgorithm();
+	virtual ~btCompoundCollisionAlgorithm();
 
-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	float	CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	float	CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new CompoundCollisionAlgorithm(ci,proxy0,proxy1);
+			return new btCompoundCollisionAlgorithm(ci,proxy0,proxy1);
 		}
 	};
 
-	struct SwappedCreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct SwappedCreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new CompoundCollisionAlgorithm(ci,proxy1,proxy0);
+			return new btCompoundCollisionAlgorithm(ci,proxy1,proxy0);
 		}
 	};
 

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -24,23 +24,23 @@ subject to the following restrictions:
 #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
 #include "BulletCollision/CollisionShapes/btSphereShape.h"
-#include "LinearMath/GenIDebugDraw.h"
+#include "LinearMath/btIDebugDraw.h"
 #include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
 
-ConvexConcaveCollisionAlgorithm::ConvexConcaveCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
-: CollisionAlgorithm(ci),m_convex(*proxy0),m_concave(*proxy1),
-m_ConvexTriangleCallback(ci.m_dispatcher,proxy0,proxy1)
+btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+: btCollisionAlgorithm(ci),m_convex(*proxy0),m_concave(*proxy1),
+m_btConvexTriangleCallback(ci.m_dispatcher,proxy0,proxy1)
 
 {
 }
 
-ConvexConcaveCollisionAlgorithm::~ConvexConcaveCollisionAlgorithm()
+btConvexConcaveCollisionAlgorithm::~btConvexConcaveCollisionAlgorithm()
 {
 }
 
 
 
-ConvexTriangleCallback::ConvexTriangleCallback(Dispatcher*  dispatcher,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1):
+btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher*  dispatcher,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1):
   m_convexProxy(proxy0),m_triangleProxy(*proxy1),m_dispatcher(dispatcher),
 	m_dispatchInfoPtr(0)
 {
@@ -53,7 +53,7 @@ ConvexTriangleCallback::ConvexTriangleCallback(Dispatcher*  dispatcher,Broadphas
   	  ClearCache();
 }
 
-ConvexTriangleCallback::~ConvexTriangleCallback()
+btConvexTriangleCallback::~btConvexTriangleCallback()
 {
 	ClearCache();
 	m_dispatcher->ReleaseManifold( m_manifoldPtr );
@@ -61,14 +61,14 @@ ConvexTriangleCallback::~ConvexTriangleCallback()
 }
   
 
-void	ConvexTriangleCallback::ClearCache()
+void	btConvexTriangleCallback::ClearCache()
 {
 	m_dispatcher->ClearManifold(m_manifoldPtr);
 };
 
 
 
-void ConvexTriangleCallback::ProcessTriangle(SimdVector3* triangle,int partId, int triangleIndex)
+void btConvexTriangleCallback::ProcessTriangle(btVector3* triangle,int partId, int triangleIndex)
 {
  
 	//just for debugging purposes
@@ -77,23 +77,23 @@ void ConvexTriangleCallback::ProcessTriangle(SimdVector3* triangle,int partId, i
 
 	//aabb filter is already applied!	
 
-	CollisionAlgorithmConstructionInfo ci;
+	btCollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = m_dispatcher;
 
-	CollisionObject* ob = static_cast<CollisionObject*>(m_triangleProxy.m_clientObject);
+	btCollisionObject* ob = static_cast<btCollisionObject*>(m_triangleProxy.m_clientObject);
 
 
 	
 	///debug drawing of the overlapping triangles
 	if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && m_dispatchInfoPtr->m_debugDraw->GetDebugMode() > 0)
 	{
-		SimdVector3 color(255,255,0);
-		SimdTransform& tr = ob->m_worldTransform;
+		btVector3 color(255,255,0);
+		btTransform& tr = ob->m_worldTransform;
 		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);
 
-		//SimdVector3 center = triangle[0] + triangle[1]+triangle[2];
+		//btVector3 center = triangle[0] + triangle[1]+triangle[2];
 		//center *= 0.333333f;
 		//m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[0]),tr(center),color);
 		//m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[1]),tr(center),color);
@@ -102,19 +102,19 @@ void ConvexTriangleCallback::ProcessTriangle(SimdVector3* triangle,int partId, i
 	}
 
 
-	CollisionObject* colObj = static_cast<CollisionObject*>(m_convexProxy->m_clientObject);
+	btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
 	
 	if (colObj->m_collisionShape->IsConvex())
 	{
-		TriangleShape tm(triangle[0],triangle[1],triangle[2]);	
+		btTriangleShape tm(triangle[0],triangle[1],triangle[2]);	
 		tm.SetMargin(m_collisionMarginTriangle);
 	
 		
-		CollisionShape* tmpShape = ob->m_collisionShape;
+		btCollisionShape* tmpShape = ob->m_collisionShape;
 		ob->m_collisionShape = &tm;
 		
-		///this should use the Dispatcher, so the actual registered algorithm is used
-		ConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexProxy,&m_triangleProxy);
+		///this should use the btDispatcher, so the actual registered algorithm is used
+		btConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexProxy,&m_triangleProxy);
 		cvxcvxalgo.SetShapeIdentifiers(-1,-1,partId,triangleIndex);
 		cvxcvxalgo.ProcessCollision(m_convexProxy,&m_triangleProxy,*m_dispatchInfoPtr);
 		ob->m_collisionShape = tmpShape;
@@ -127,43 +127,43 @@ void ConvexTriangleCallback::ProcessTriangle(SimdVector3* triangle,int partId, i
 
 
 
-void	ConvexTriangleCallback::SetTimeStepAndCounters(float collisionMarginTriangle,const DispatcherInfo& dispatchInfo)
+void	btConvexTriangleCallback::SetTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo)
 {
 	m_dispatchInfoPtr = &dispatchInfo;
 	m_collisionMarginTriangle = collisionMarginTriangle;
 
 	//recalc aabbs
-	CollisionObject* convexBody = (CollisionObject* )m_convexProxy->m_clientObject;
-	CollisionObject* triBody = (CollisionObject* )m_triangleProxy.m_clientObject;
+	btCollisionObject* convexBody = (btCollisionObject* )m_convexProxy->m_clientObject;
+	btCollisionObject* triBody = (btCollisionObject* )m_triangleProxy.m_clientObject;
 
-	SimdTransform convexInTriangleSpace;
+	btTransform convexInTriangleSpace;
 	convexInTriangleSpace = triBody->m_worldTransform.inverse() * convexBody->m_worldTransform;
 
-	CollisionShape* convexShape = static_cast<CollisionShape*>(convexBody->m_collisionShape);
-	//CollisionShape* triangleShape = static_cast<CollisionShape*>(triBody->m_collisionShape);
+	btCollisionShape* convexShape = static_cast<btCollisionShape*>(convexBody->m_collisionShape);
+	//CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
 
 	convexShape->GetAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
 
 	float extraMargin = collisionMarginTriangle;//CONVEX_DISTANCE_MARGIN;//+0.1f;
 
-	SimdVector3 extra(extraMargin,extraMargin,extraMargin);
+	btVector3 extra(extraMargin,extraMargin,extraMargin);
 
 	m_aabbMax += extra;
 	m_aabbMin -= extra;
 	
 }
 
-void ConvexConcaveCollisionAlgorithm::ClearCache()
+void btConvexConcaveCollisionAlgorithm::ClearCache()
 {
-	m_ConvexTriangleCallback.ClearCache();
+	m_btConvexTriangleCallback.ClearCache();
 
 }
 
-void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+void btConvexConcaveCollisionAlgorithm::ProcessCollision (btBroadphaseProxy* ,btBroadphaseProxy* ,const btDispatcherInfo& dispatchInfo)
 {
 	
-	CollisionObject* convexBody = static_cast<CollisionObject* >(m_convex.m_clientObject);
-	CollisionObject* triBody = static_cast<CollisionObject* >(m_concave.m_clientObject);
+	btCollisionObject* convexBody = static_cast<btCollisionObject* >(m_convex.m_clientObject);
+	btCollisionObject* triBody = static_cast<btCollisionObject* >(m_concave.m_clientObject);
 
 	if (triBody->m_collisionShape->IsConcave())
 	{
@@ -173,22 +173,22 @@ void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,Broadp
 
 		
 
-		CollisionObject*	triOb = static_cast<CollisionObject*>(m_concave.m_clientObject);
+		btCollisionObject*	triOb = static_cast<btCollisionObject*>(m_concave.m_clientObject);
 		ConcaveShape* concaveShape = static_cast<ConcaveShape*>( triOb->m_collisionShape);
 		
 		if (convexBody->m_collisionShape->IsConvex())
 		{
 			float collisionMarginTriangle = concaveShape->GetMargin();
 					
-			m_ConvexTriangleCallback.SetTimeStepAndCounters(collisionMarginTriangle,dispatchInfo);
+			m_btConvexTriangleCallback.SetTimeStepAndCounters(collisionMarginTriangle,dispatchInfo);
 
 			//Disable persistency. previously, some older algorithm calculated all contacts in one go, so you can clear it here.
-			//m_dispatcher->ClearManifold(m_ConvexTriangleCallback.m_manifoldPtr);
+			//m_dispatcher->ClearManifold(m_btConvexTriangleCallback.m_manifoldPtr);
 
 
-			m_ConvexTriangleCallback.m_manifoldPtr->SetBodies(m_convex.m_clientObject,m_concave.m_clientObject);
+			m_btConvexTriangleCallback.m_manifoldPtr->SetBodies(m_convex.m_clientObject,m_concave.m_clientObject);
 
-			concaveShape->ProcessAllTriangles( &m_ConvexTriangleCallback,m_ConvexTriangleCallback.GetAabbMin(),m_ConvexTriangleCallback.GetAabbMax());
+			concaveShape->ProcessAllTriangles( &m_btConvexTriangleCallback,m_btConvexTriangleCallback.GetAabbMin(),m_btConvexTriangleCallback.GetAabbMax());
 			
 	
 		}
@@ -198,12 +198,12 @@ void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,Broadp
 }
 
 
-float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+float btConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(btBroadphaseProxy* ,btBroadphaseProxy* ,const btDispatcherInfo& dispatchInfo)
 {
 
-	//quick approximation using raycast, todo: hook up to the continuous collision detection (one of the ConvexCast)
-	CollisionObject* convexbody = (CollisionObject* )m_convex.m_clientObject;
-	CollisionObject* triBody = static_cast<CollisionObject* >(m_concave.m_clientObject);
+	//quick approximation using raycast, todo: hook up to the continuous collision detection (one of the btConvexCast)
+	btCollisionObject* convexbody = (btCollisionObject* )m_convex.m_clientObject;
+	btCollisionObject* triBody = static_cast<btCollisionObject* >(m_concave.m_clientObject);
 
 	//only perform CCD above a certain treshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
@@ -213,24 +213,24 @@ float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,B
 		return 1.f;
 	}
 
-	//const SimdVector3& from = convexbody->m_worldTransform.getOrigin();
-	//SimdVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
+	//const btVector3& from = convexbody->m_worldTransform.getOrigin();
+	//btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
 	//todo: only do if the motion exceeds the 'radius'
 
-	SimdTransform convexFromLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_worldTransform;
-	SimdTransform convexToLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_interpolationWorldTransform;
+	btTransform convexFromLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_worldTransform;
+	btTransform convexToLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_interpolationWorldTransform;
 
-	struct LocalTriangleSphereCastCallback	: public TriangleCallback
+	struct LocalTriangleSphereCastCallback	: public btTriangleCallback
 	{
-		SimdTransform m_ccdSphereFromTrans;
-		SimdTransform m_ccdSphereToTrans;
-		SimdTransform	m_meshTransform;
+		btTransform m_ccdSphereFromTrans;
+		btTransform m_ccdSphereToTrans;
+		btTransform	m_meshTransform;
 
 		float	m_ccdSphereRadius;
 		float	m_hitFraction;
 	
 
-		LocalTriangleSphereCastCallback(const SimdTransform& from,const SimdTransform& to,float ccdSphereRadius,float hitFraction)
+		LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,float ccdSphereRadius,float hitFraction)
 			:m_ccdSphereFromTrans(from),
 			m_ccdSphereToTrans(to),
 			m_ccdSphereRadius(ccdSphereRadius),
@@ -239,17 +239,17 @@ float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,B
 		}
 		
 		
-		virtual void ProcessTriangle(SimdVector3* triangle, int partId, int triangleIndex)
+		virtual void ProcessTriangle(btVector3* triangle, int partId, int triangleIndex)
 		{
 			//do a swept sphere for now
-			SimdTransform ident;
+			btTransform ident;
 			ident.setIdentity();
-			ConvexCast::CastResult castResult;
+			btConvexCast::CastResult castResult;
 			castResult.m_fraction = m_hitFraction;
-			SphereShape	pointShape(m_ccdSphereRadius);
-			TriangleShape	triShape(triangle[0],triangle[1],triangle[2]);
-			VoronoiSimplexSolver	simplexSolver;
-			SubsimplexConvexCast convexCaster(&pointShape,&triShape,&simplexSolver);
+			btSphereShape	pointShape(m_ccdSphereRadius);
+			btTriangleShape	triShape(triangle[0],triangle[1],triangle[2]);
+			btVoronoiSimplexSolver	simplexSolver;
+			btSubsimplexConvexCast convexCaster(&pointShape,&triShape,&simplexSolver);
 			//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
 			//ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
 			//local space?
@@ -271,12 +271,12 @@ float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,B
 	
 	if (triBody->m_collisionShape->IsConcave())
 	{
-		SimdVector3 rayAabbMin = convexFromLocal.getOrigin();
+		btVector3 rayAabbMin = convexFromLocal.getOrigin();
 		rayAabbMin.setMin(convexToLocal.getOrigin());
-		SimdVector3 rayAabbMax = convexFromLocal.getOrigin();
+		btVector3 rayAabbMax = convexFromLocal.getOrigin();
 		rayAabbMax.setMax(convexToLocal.getOrigin());
-		rayAabbMin -= SimdVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
-		rayAabbMax += SimdVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
+		rayAabbMin -= btVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
+		rayAabbMax += btVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
 
 		float curHitFraction = 1.f; //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
@@ -284,7 +284,7 @@ float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,B
 
 		raycastCallback.m_hitFraction = convexbody->m_hitFraction;
 
-		CollisionObject* concavebody = (CollisionObject* )m_concave.m_clientObject;
+		btCollisionObject* concavebody = (btCollisionObject* )m_concave.m_clientObject;
 
 		ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->m_collisionShape;
 		

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

@@ -21,43 +21,43 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
 #include "BulletCollision/CollisionShapes/btTriangleCallback.h"
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
-class Dispatcher;
+class btDispatcher;
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "btCollisionCreateFunc.h"
 
 ///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), ProcessTriangle is called.
-class ConvexTriangleCallback : public TriangleCallback
+class btConvexTriangleCallback : public btTriangleCallback
 {
-	BroadphaseProxy* m_convexProxy;
-	BroadphaseProxy m_triangleProxy;
+	btBroadphaseProxy* m_convexProxy;
+	btBroadphaseProxy m_triangleProxy;
 
-	SimdVector3	m_aabbMin;
-	SimdVector3	m_aabbMax ;
+	btVector3	m_aabbMin;
+	btVector3	m_aabbMax ;
 
-	Dispatcher*	m_dispatcher;
-	const DispatcherInfo* m_dispatchInfoPtr;
+	btDispatcher*	m_dispatcher;
+	const btDispatcherInfo* m_dispatchInfoPtr;
 	float m_collisionMarginTriangle;
 	
 public:
 int	m_triangleCount;
 	
-	PersistentManifold*	m_manifoldPtr;
+	btPersistentManifold*	m_manifoldPtr;
 
-	ConvexTriangleCallback(Dispatcher* dispatcher,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btConvexTriangleCallback(btDispatcher* dispatcher,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 
-	void	SetTimeStepAndCounters(float collisionMarginTriangle,const DispatcherInfo& dispatchInfo);
+	void	SetTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo);
 
-	virtual ~ConvexTriangleCallback();
+	virtual ~btConvexTriangleCallback();
 
-	virtual void ProcessTriangle(SimdVector3* triangle, int partId, int triangleIndex);
+	virtual void ProcessTriangle(btVector3* triangle, int partId, int triangleIndex);
 	
 	void ClearCache();
 
-	inline const SimdVector3& GetAabbMin() const
+	inline const btVector3& GetAabbMin() const
 	{
 		return m_aabbMin;
 	}
-	inline const SimdVector3& GetAabbMax() const
+	inline const btVector3& GetAabbMax() const
 	{
 		return m_aabbMax;
 	}
@@ -67,42 +67,42 @@ int	m_triangleCount;
 
 
 
-/// ConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
-class ConvexConcaveCollisionAlgorithm  : public CollisionAlgorithm
+/// btConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
+class btConvexConcaveCollisionAlgorithm  : public btCollisionAlgorithm
 {
 
-	BroadphaseProxy m_convex;
+	btBroadphaseProxy m_convex;
 
-	BroadphaseProxy m_concave;
+	btBroadphaseProxy m_concave;
 
-	ConvexTriangleCallback m_ConvexTriangleCallback;
+	btConvexTriangleCallback m_btConvexTriangleCallback;
 
 
 public:
 
-	ConvexConcaveCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 
-	virtual ~ConvexConcaveCollisionAlgorithm();
+	virtual ~btConvexConcaveCollisionAlgorithm();
 
-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	float	CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	float	CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
 	void	ClearCache();
 
-	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new ConvexConcaveCollisionAlgorithm(ci,proxy0,proxy1);
+			return new btConvexConcaveCollisionAlgorithm(ci,proxy0,proxy1);
 		}
 	};
 
-	struct SwappedCreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct SwappedCreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new ConvexConcaveCollisionAlgorithm(ci,proxy1,proxy0);
+			return new btConvexConcaveCollisionAlgorithm(ci,proxy1,proxy0);
 		}
 	};
 

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -81,8 +81,8 @@ bool gDisableConvexCollision = false;
 
 
 
-ConvexConvexAlgorithm::ConvexConvexAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
-: CollisionAlgorithm(ci),
+btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+: btCollisionAlgorithm(ci),
 m_gjkPairDetector(0,0,&m_simplexSolver,0),
 m_useEpa(!gUseEpa),
 m_box0(*proxy0),
@@ -105,7 +105,7 @@ m_lowLevelOfDetail(false)
 
 
 
-ConvexConvexAlgorithm::~ConvexConvexAlgorithm()
+btConvexConvexAlgorithm::~btConvexConvexAlgorithm()
 {
 	if (m_ownManifold)
 	{
@@ -114,35 +114,35 @@ ConvexConvexAlgorithm::~ConvexConvexAlgorithm()
 	}
 }
 
-void	ConvexConvexAlgorithm ::SetLowLevelOfDetail(bool useLowLevel)
+void	btConvexConvexAlgorithm ::SetLowLevelOfDetail(bool useLowLevel)
 {
 	m_lowLevelOfDetail = useLowLevel;
 }
 
 
 
-class FlippedContactResult : public DiscreteCollisionDetectorInterface::Result
+class FlippedContactResult : public btDiscreteCollisionDetectorInterface::Result
 {
-	DiscreteCollisionDetectorInterface::Result* m_org;
+	btDiscreteCollisionDetectorInterface::Result* m_org;
 
 public:
 
-	FlippedContactResult(DiscreteCollisionDetectorInterface::Result* org)
+	FlippedContactResult(btDiscreteCollisionDetectorInterface::Result* org)
 		: m_org(org)
 	{
 
 	}
 
-	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+	virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 	{
-		SimdVector3 flippedNormal = -normalOnBInWorld;
+		btVector3 flippedNormal = -normalOnBInWorld;
 
 		m_org->AddContactPoint(flippedNormal,pointInWorld,depth);
 	}
 
 };
 
-static MinkowskiPenetrationDepthSolver	gPenetrationDepthSolver;
+static btMinkowskiPenetrationDepthSolver	gPenetrationDepthSolver;
 
 //static EpaPenetrationDepthSolver	gEpaPenetrationDepthSolver;
 
@@ -150,7 +150,7 @@ static MinkowskiPenetrationDepthSolver	gPenetrationDepthSolver;
 Solid3EpaPenetrationDepth	gSolidEpaPenetrationSolver;
 #endif //USE_EPA
 
-void	ConvexConvexAlgorithm::CheckPenetrationDepthSolver()
+void	btConvexConvexAlgorithm::CheckPenetrationDepthSolver()
 {
 	if (m_useEpa != gUseEpa)
 	{
@@ -171,15 +171,15 @@ void	ConvexConvexAlgorithm::CheckPenetrationDepthSolver()
 
 #ifdef USE_HULL
 
-Transform	GetTransformFromSimdTransform(const SimdTransform& trans)
+Transform	GetTransformFrombtTransform(const btTransform& trans)
 {
-			//const SimdVector3& rowA0 = trans.getBasis().getRow(0);
-			////const SimdVector3& rowA1 = trans.getBasis().getRow(1);
-			//const SimdVector3& rowA2 = trans.getBasis().getRow(2);
+			//const btVector3& rowA0 = trans.getBasis().getRow(0);
+			////const btVector3& rowA1 = trans.getBasis().getRow(1);
+			//const btVector3& rowA2 = trans.getBasis().getRow(2);
 
-			SimdVector3 rowA0 = trans.getBasis().getColumn(0);
-			SimdVector3 rowA1 = trans.getBasis().getColumn(1);
-			SimdVector3 rowA2 = trans.getBasis().getColumn(2);
+			btVector3 rowA0 = trans.getBasis().getColumn(0);
+			btVector3 rowA1 = trans.getBasis().getColumn(1);
+			btVector3 rowA2 = trans.getBasis().getColumn(2);
 
 
 			Vector3	x(rowA0.getX(),rowA0.getY(),rowA0.getZ());
@@ -196,28 +196,28 @@ Transform	GetTransformFromSimdTransform(const SimdTransform& trans)
 			return Transform(ornA,transA);
 }
 
-class ManifoldResultCollector : public HullContactCollector
+class btManifoldResultCollector : public HullContactCollector
 {
 public:
-	ManifoldResult& m_manifoldResult;
+	btManifoldResult& m_manifoldResult;
 
-	ManifoldResultCollector(ManifoldResult& manifoldResult)
+	btManifoldResultCollector(btManifoldResult& manifoldResult)
 		:m_manifoldResult(manifoldResult)
 	{
 
 	}
 	
 
-	virtual ~ManifoldResultCollector() {};
+	virtual ~btManifoldResultCollector() {};
 
-	virtual int	BatchAddContactGroup(const Separation& sep,int numContacts,const Vector3& normalWorld,const Vector3& tangent,const Point3* positionsWorld,const float* depths)
+	virtual int	BatchAddContactGroup(const btSeparation& sep,int numContacts,const Vector3& normalWorld,const Vector3& tangent,const Point3* positionsWorld,const float* depths)
 	{
 		for (int i=0;i<numContacts;i++)
 		{
 			//printf("numContacts = %i\n",numContacts);
-			SimdVector3 normalOnBInWorld(sep.m_axis.GetX(),sep.m_axis.GetY(),sep.m_axis.GetZ());
+			btVector3 normalOnBInWorld(sep.m_axis.GetX(),sep.m_axis.GetY(),sep.m_axis.GetZ());
 			//normalOnBInWorld.normalize();
-			SimdVector3 pointInWorld(positionsWorld[i].GetX(),positionsWorld[i].GetY(),positionsWorld[i].GetZ());
+			btVector3 pointInWorld(positionsWorld[i].GetX(),positionsWorld[i].GetY(),positionsWorld[i].GetZ());
 			float depth = -depths[i];
 			m_manifoldResult.AddContactPoint(normalOnBInWorld,pointInWorld,depth);
 
@@ -237,7 +237,7 @@ public:
 //
 // Convex-Convex collision algorithm
 //
-void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+void btConvexConvexAlgorithm ::ProcessCollision (btBroadphaseProxy* ,btBroadphaseProxy* ,const btDispatcherInfo& dispatchInfo)
 {
 
 	if (!m_manifoldPtr)
@@ -245,14 +245,14 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 
 	CheckPenetrationDepthSolver();
 
-//	printf("ConvexConvexAlgorithm::ProcessCollision\n");
+//	printf("btConvexConvexAlgorithm::ProcessCollision\n");
 
 	bool needsCollision = m_dispatcher->NeedsCollision(m_box0,m_box1);
 	if (!needsCollision)
 		return;
 	
-	CollisionObject*	col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
-	CollisionObject*	col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
+	btCollisionObject*	col0 = static_cast<btCollisionObject*>(m_box0.m_clientObject);
+	btCollisionObject*	col1 = static_cast<btCollisionObject*>(m_box1.m_clientObject);
 
 #ifdef USE_HULL
 
@@ -264,29 +264,29 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 		{
 		
 			
-			PolyhedralConvexShape* polyhedron0 = static_cast<PolyhedralConvexShape*>(col0->m_collisionShape);
-			PolyhedralConvexShape* polyhedron1 = static_cast<PolyhedralConvexShape*>(col1->m_collisionShape);
+			btPolyhedralConvexShape* polyhedron0 = static_cast<btPolyhedralConvexShape*>(col0->m_collisionShape);
+			btPolyhedralConvexShape* polyhedron1 = static_cast<btPolyhedralConvexShape*>(col1->m_collisionShape);
 			if (polyhedron0->m_optionalHull && polyhedron1->m_optionalHull)
 			{
 				//printf("Hull-Hull");
 
 				//todo: cache this information, rather then initialize
-				Separation sep;
+				btSeparation sep;
 				sep.m_featureA = 0;
 				sep.m_featureB = 0;
 				sep.m_contact = -1;
 				sep.m_separator = 0;
 
-				//convert from SimdTransform to Transform
+				//convert from btTransform to Transform
 				
-				Transform trA = GetTransformFromSimdTransform(col0->m_worldTransform);
-				Transform trB = GetTransformFromSimdTransform(col1->m_worldTransform);
+				Transform trA = GetTransformFrombtTransform(col0->m_worldTransform);
+				Transform trB = GetTransformFrombtTransform(col1->m_worldTransform);
 
 				//either use persistent manifold or clear it every time
 				m_dispatcher->ClearManifold(m_manifoldPtr);
-				ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+				btManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
 
-				ManifoldResultCollector hullContactCollector(*resultOut);
+				btManifoldResultCollector hullContactCollector(*resultOut);
 				
 				Hull::ProcessHullHull(sep,*polyhedron0->m_optionalHull,*polyhedron1->m_optionalHull,
 					trA,trB,&hullContactCollector);
@@ -301,12 +301,12 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 #endif //USE_HULL
 
 	
-	ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+	btManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
 	
-	ConvexShape* min0 = static_cast<ConvexShape*>(col0->m_collisionShape);
-	ConvexShape* min1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+	btConvexShape* min0 = static_cast<btConvexShape*>(col0->m_collisionShape);
+	btConvexShape* min1 = static_cast<btConvexShape*>(col1->m_collisionShape);
 	
-	GjkPairDetector::ClosestPointInput input;
+	btGjkPairDetector::ClosestPointInput input;
 
 
 	//TODO: if (dispatchInfo.m_useContinuous)
@@ -328,7 +328,7 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 
 
 bool disableCcd = false;
-float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+float	btConvexConvexAlgorithm::CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
 	///Rather then checking ALL pairs, only calculate TOI when motion exceeds treshold
     
@@ -336,8 +336,8 @@ float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,Broad
 	///col0->m_worldTransform,
 	float resultFraction = 1.f;
 
-	CollisionObject* col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
-	CollisionObject* col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
+	btCollisionObject* col1 = static_cast<btCollisionObject*>(m_box1.m_clientObject);
+	btCollisionObject* col0 = static_cast<btCollisionObject*>(m_box0.m_clientObject);
 
 	float squareMot0 = (col0->m_interpolationWorldTransform.getOrigin() - col0->m_worldTransform.getOrigin()).length2();
     
@@ -366,14 +366,14 @@ float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,Broad
 		
 	/// Convex0 against sphere for Convex1
 	{
-		ConvexShape* convex0 = static_cast<ConvexShape*>(col0->m_collisionShape);
+		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->m_collisionShape);
 
-		SphereShape	sphere1(col1->m_ccdSweptShereRadius); //todo: allow non-zero sphere sizes, for better approximation
-		ConvexCast::CastResult result;
-		VoronoiSimplexSolver voronoiSimplex;
+		btSphereShape	sphere1(col1->m_ccdSweptShereRadius); //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
-		GjkConvexCast ccd1( convex0 ,&sphere1,&voronoiSimplex);
+		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))
@@ -399,14 +399,14 @@ float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,Broad
 
 	/// Sphere (for convex0) against Convex1
 	{
-		ConvexShape* convex1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->m_collisionShape);
 
-		SphereShape	sphere0(col0->m_ccdSweptShereRadius); //todo: allow non-zero sphere sizes, for better approximation
-		ConvexCast::CastResult result;
-		VoronoiSimplexSolver voronoiSimplex;
+		btSphereShape	sphere0(col0->m_ccdSweptShereRadius); //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
-		GjkConvexCast ccd1(&sphere0,convex1,&voronoiSimplex);
+		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))

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

@@ -23,21 +23,21 @@ subject to the following restrictions:
 #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
 #include "btCollisionCreateFunc.h"
 
-class ConvexPenetrationDepthSolver;
+class btConvexPenetrationDepthSolver;
 
 ///ConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations.
-class ConvexConvexAlgorithm : public CollisionAlgorithm
+class btConvexConvexAlgorithm : public btCollisionAlgorithm
 {
 	//ConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
-	VoronoiSimplexSolver	m_simplexSolver;
-	GjkPairDetector m_gjkPairDetector;
+	btVoronoiSimplexSolver	m_simplexSolver;
+	btGjkPairDetector m_gjkPairDetector;
 	bool	m_useEpa;
 public:
-	BroadphaseProxy	m_box0;
-	BroadphaseProxy	m_box1;
+	btBroadphaseProxy	m_box0;
+	btBroadphaseProxy	m_box1;
 
 	bool	m_ownManifold;
-	PersistentManifold*	m_manifoldPtr;
+	btPersistentManifold*	m_manifoldPtr;
 	bool			m_lowLevelOfDetail;
 
 	void	CheckPenetrationDepthSolver();
@@ -46,13 +46,13 @@ public:
 
 public:
 
-	ConvexConvexAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 
-	virtual ~ConvexConvexAlgorithm();
+	virtual ~btConvexConvexAlgorithm();
 
-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual float CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
 	void	SetLowLevelOfDetail(bool useLowLevel);
 
@@ -64,16 +64,16 @@ public:
 			m_gjkPairDetector.m_index1=index1;		
 	}
 
-	const PersistentManifold*	GetManifold()
+	const btPersistentManifold*	GetManifold()
 	{
 		return m_manifoldPtr;
 	}
 
-	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new ConvexConvexAlgorithm(0,ci,proxy0,proxy1);
+			return new btConvexConvexAlgorithm(0,ci,proxy0,proxy1);
 		}
 	};
 

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp

@@ -17,17 +17,17 @@ subject to the following restrictions:
 
 
 
-EmptyAlgorithm::EmptyAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
-	: CollisionAlgorithm(ci)
+btEmptyAlgorithm::btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+	: btCollisionAlgorithm(ci)
 {
 }
 
-void EmptyAlgorithm::ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+void btEmptyAlgorithm::ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
 
 }
 
-float EmptyAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+float btEmptyAlgorithm::CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
 	return 1.f;
 }

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h

@@ -21,23 +21,23 @@ subject to the following restrictions:
 #define ATTRIBUTE_ALIGNED(a)
 
 ///EmptyAlgorithm is a stub for unsupported collision pairs.
-///The dispatcher can dispatch a persistent EmptyAlgorithm to avoid a search every frame.
-class EmptyAlgorithm : public CollisionAlgorithm
+///The dispatcher can dispatch a persistent btEmptyAlgorithm to avoid a search every frame.
+class btEmptyAlgorithm : public btCollisionAlgorithm
 {
 
 public:
 	
-	EmptyAlgorithm(const CollisionAlgorithmConstructionInfo& ci);
+	btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
 
-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual float CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new EmptyAlgorithm(ci);
+			return new btEmptyAlgorithm(ci);
 		}
 	};
 

src/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -22,12 +22,12 @@ subject to the following restrictions:
 ///This is to allow MaterialCombiner/Custom Friction/Restitution values
 ContactAddedCallback		gContactAddedCallback=0;
 
-///User can override this material combiner by implementing gContactAddedCallback and setting body0->m_collisionFlags |= CollisionObject::customMaterialCallback;
-inline SimdScalar	calculateCombinedFriction(const CollisionObject* body0,const CollisionObject* body1)
+///User can override this material combiner by implementing gContactAddedCallback and setting body0->m_collisionFlags |= btCollisionObject::customMaterialCallback;
+inline btScalar	calculateCombinedFriction(const btCollisionObject* body0,const btCollisionObject* body1)
 {
-	SimdScalar friction = body0->getFriction() * body1->getFriction();
+	btScalar friction = body0->getFriction() * body1->getFriction();
 
-	const SimdScalar MAX_FRICTION  = 10.f;
+	const btScalar MAX_FRICTION  = 10.f;
 	if (friction < -MAX_FRICTION)
 		friction = -MAX_FRICTION;
 	if (friction > MAX_FRICTION)
@@ -36,14 +36,14 @@ inline SimdScalar	calculateCombinedFriction(const CollisionObject* body0,const C
 
 }
 
-inline SimdScalar	calculateCombinedRestitution(const CollisionObject* body0,const CollisionObject* body1)
+inline btScalar	calculateCombinedRestitution(const btCollisionObject* body0,const btCollisionObject* body1)
 {
 	return body0->getRestitution() * body1->getRestitution();
 }
 
 
 
-ManifoldResult::ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr)
+btManifoldResult::btManifoldResult(btCollisionObject* body0,btCollisionObject* body1,btPersistentManifold* manifoldPtr)
 		:m_manifoldPtr(manifoldPtr),
 		m_body0(body0),
 		m_body1(body1)
@@ -51,21 +51,21 @@ ManifoldResult::ManifoldResult(CollisionObject* body0,CollisionObject* body1,Per
 	}
 
 
-void ManifoldResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+void btManifoldResult::AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 {
 	if (depth > m_manifoldPtr->GetContactBreakingTreshold())
 		return;
 
 
-	SimdTransform transAInv = m_body0->m_cachedInvertedWorldTransform;
-	SimdTransform transBInv= m_body1->m_cachedInvertedWorldTransform;
+	btTransform transAInv = m_body0->m_cachedInvertedWorldTransform;
+	btTransform transBInv= m_body1->m_cachedInvertedWorldTransform;
 
 	//transAInv = m_body0->m_worldTransform.inverse();
 	//transBInv= m_body1->m_worldTransform.inverse();
-	SimdVector3 pointA = pointInWorld + normalOnBInWorld * depth;
-	SimdVector3 localA = transAInv(pointA );
-	SimdVector3 localB = transBInv(pointInWorld);
-	ManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
+	btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
+	btVector3 localA = transAInv(pointA );
+	btVector3 localB = transBInv(pointInWorld);
+	btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
 
 	
 
@@ -74,7 +74,7 @@ void ManifoldResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const S
 	{
 
 // This is not needed, just use the old info!
-//		const ManifoldPoint& oldPoint = m_manifoldPtr->GetContactPoint(insertIndex);
+//		const btManifoldPoint& oldPoint = m_manifoldPtr->GetContactPoint(insertIndex);
 //		newPt.CopyPersistentInformation(oldPoint);
 //		m_manifoldPtr->ReplaceContactPoint(newPt,insertIndex);
 
@@ -88,8 +88,8 @@ void ManifoldResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const S
 		//User can override friction and/or restitution
 		if (gContactAddedCallback &&
 			//and if either of the two bodies requires custom material
-			 ((m_body0->m_collisionFlags & CollisionObject::customMaterialCallback) ||
-			   (m_body1->m_collisionFlags & CollisionObject::customMaterialCallback)))
+			 ((m_body0->m_collisionFlags & btCollisionObject::customMaterialCallback) ||
+			   (m_body1->m_collisionFlags & btCollisionObject::customMaterialCallback)))
 		{
 			//experimental feature info, for per-triangle material etc.
 			(*gContactAddedCallback)(newPt,m_body0,m_partId0,m_index0,m_body1,m_partId1,m_index1);

src/BulletCollision/CollisionDispatch/btManifoldResult.h

@@ -18,30 +18,30 @@ subject to the following restrictions:
 #define MANIFOLD_RESULT_H
 
 #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
-struct CollisionObject;
-class PersistentManifold;
-class ManifoldPoint;
+struct btCollisionObject;
+class btPersistentManifold;
+class btManifoldPoint;
 
-typedef bool (*ContactAddedCallback)(ManifoldPoint& cp,	const CollisionObject* colObj0,int partId0,int index0,const CollisionObject* colObj1,int partId1,int index1);
+typedef bool (*ContactAddedCallback)(btManifoldPoint& cp,	const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1);
 extern ContactAddedCallback		gContactAddedCallback;
 
 
 
 ///ManifoldResult is a helper class to manage  contact results.
-class ManifoldResult : public DiscreteCollisionDetectorInterface::Result
+class btManifoldResult : public btDiscreteCollisionDetectorInterface::Result
 {
-	PersistentManifold* m_manifoldPtr;
-	CollisionObject* m_body0;
-	CollisionObject* m_body1;
+	btPersistentManifold* m_manifoldPtr;
+	btCollisionObject* m_body0;
+	btCollisionObject* m_body1;
 	int	m_partId0;
 	int m_partId1;
 	int m_index0;
 	int m_index1;
 public:
 
-	ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr);
+	btManifoldResult(btCollisionObject* body0,btCollisionObject* body1,btPersistentManifold* manifoldPtr);
 
-	virtual ~ManifoldResult() {};
+	virtual ~btManifoldResult() {};
 
 	virtual void SetShapeIdentifiers(int partId0,int index0,	int partId1,int index1)
 	{
@@ -51,7 +51,7 @@ public:
 			m_index1=index1;		
 	}
 
-	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth);
+	virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);
 
 
 

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -9,32 +9,32 @@
 #include <algorithm>
 
 
-SimulationIslandManager::SimulationIslandManager()
+btSimulationIslandManager::btSimulationIslandManager()
 {
 }
 
-SimulationIslandManager::~SimulationIslandManager()
+btSimulationIslandManager::~btSimulationIslandManager()
 {
 }
 
 
-void SimulationIslandManager::InitUnionFind(int n)
+void btSimulationIslandManager::InitUnionFind(int n)
 {
 		m_unionFind.reset(n);
 }
 		
 
-void SimulationIslandManager::FindUnions(Dispatcher* dispatcher)
+void btSimulationIslandManager::FindUnions(btDispatcher* dispatcher)
 {
 	
 	{
 		for (int i=0;i<dispatcher->GetNumManifolds();i++)
 		{
-			const PersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
+			const btPersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
 			//static objects (invmass 0.f) don't merge !
 
-			 const  CollisionObject* colObj0 = static_cast<const CollisionObject*>(manifold->GetBody0());
-			 const  CollisionObject* colObj1 = static_cast<const CollisionObject*>(manifold->GetBody1());
+			 const  btCollisionObject* colObj0 = static_cast<const btCollisionObject*>(manifold->GetBody0());
+			 const  btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->GetBody1());
 
 			if (((colObj0) && ((colObj0)->mergesSimulationIslands())) &&
 				((colObj1) && ((colObj1)->mergesSimulationIslands())))
@@ -43,29 +43,26 @@ void SimulationIslandManager::FindUnions(Dispatcher* dispatcher)
 				m_unionFind.unite((colObj0)->m_islandTag1,
 					(colObj1)->m_islandTag1);
 			}
-			
-			
 		}
 	}
-	
 }
 
 
-void	SimulationIslandManager::UpdateActivationState(CollisionWorld* colWorld,Dispatcher* dispatcher)
+void	btSimulationIslandManager::UpdateActivationState(btCollisionWorld* colWorld,btDispatcher* dispatcher)
 {
 	
 	InitUnionFind(colWorld->GetCollisionObjectArray().size());
 	
 	// put the index into m_controllers into m_tag	
 	{
-		std::vector<CollisionObject*>::iterator i;
+		std::vector<btCollisionObject*>::iterator i;
 		
 		int index = 0;
 		for (i=colWorld->GetCollisionObjectArray().begin();
 		!(i==colWorld->GetCollisionObjectArray().end()); i++)
 		{
 			
-			CollisionObject*	collisionObject= (*i);
+			btCollisionObject*	collisionObject= (*i);
 			collisionObject->m_islandTag1 = index;
 			collisionObject->m_hitFraction = 1.f;
 			index++;
@@ -83,19 +80,19 @@ void	SimulationIslandManager::UpdateActivationState(CollisionWorld* colWorld,Dis
 
 
 
-void	SimulationIslandManager::StoreIslandActivationState(CollisionWorld* colWorld)
+void	btSimulationIslandManager::StoreIslandActivationState(btCollisionWorld* colWorld)
 {
 	// put the islandId ('find' value) into m_tag	
 	{
 		
 		
-		std::vector<CollisionObject*>::iterator i;
+		std::vector<btCollisionObject*>::iterator i;
 		
 		int index = 0;
 		for (i=colWorld->GetCollisionObjectArray().begin();
 		!(i==colWorld->GetCollisionObjectArray().end()); i++)
 		{
-			CollisionObject* collisionObject= (*i);
+			btCollisionObject* collisionObject= (*i);
 			
 			if (collisionObject->mergesSimulationIslands())
 			{
@@ -109,17 +106,17 @@ void	SimulationIslandManager::StoreIslandActivationState(CollisionWorld* colWorl
 	}
 }
 
-inline	int	getIslandId(const PersistentManifold* lhs)
+inline	int	getIslandId(const btPersistentManifold* lhs)
 {
 	int islandId;
-	const CollisionObject* rcolObj0 = static_cast<const CollisionObject*>(lhs->GetBody0());
-	const CollisionObject* rcolObj1 = static_cast<const CollisionObject*>(lhs->GetBody1());
+	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;
 	return islandId;
 
 }
 
-bool PersistentManifoldSortPredicate(const PersistentManifold* lhs, const PersistentManifold* rhs)
+bool btPersistentManifoldSortPredicate(const btPersistentManifold* lhs, const btPersistentManifold* rhs)
 {
 	int rIslandId0,lIslandId0;
 	rIslandId0 = getIslandId(rhs);
@@ -131,7 +128,7 @@ bool PersistentManifoldSortPredicate(const PersistentManifold* lhs, const Persis
 //
 // todo: this is random access, it can be walked 'cache friendly'!
 //
-void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,CollisionObjectArray& collisionObjects, IslandCallback* callback)
+void btSimulationIslandManager::BuildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
 {
 	//we are going to sort the unionfind array, and store the element id in the size
 	//afterwards, we clean unionfind, to make sure no-one uses it anymore
@@ -158,7 +155,7 @@ void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,Coll
 		{
 			int i = GetUnionFind().getElement(idx).m_sz;
 
-			CollisionObject* colObj0 = collisionObjects[i];
+			btCollisionObject* colObj0 = collisionObjects[i];
 			if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 			{
 				printf("error in island management\n");
@@ -184,7 +181,7 @@ void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,Coll
 			for (idx=startIslandIndex;idx<endIslandIndex;idx++)
 			{
 				int i = GetUnionFind().getElement(idx).m_sz;
-				CollisionObject* colObj0 = collisionObjects[i];
+				btCollisionObject* colObj0 = collisionObjects[i];
 				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					printf("error in island management\n");
@@ -205,7 +202,7 @@ void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,Coll
 			{
 				int i = GetUnionFind().getElement(idx).m_sz;
 
-				CollisionObject* colObj0 = collisionObjects[i];
+				btCollisionObject* colObj0 = collisionObjects[i];
 				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					printf("error in island management\n");
@@ -224,17 +221,17 @@ void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,Coll
 		}
 	}
 
-	std::vector<PersistentManifold*>  islandmanifold;
+	std::vector<btPersistentManifold*>  islandmanifold;
 	int i;
 	int maxNumManifolds = dispatcher->GetNumManifolds();
 	islandmanifold.reserve(maxNumManifolds);
 
 	for (i=0;i<maxNumManifolds ;i++)
 	{
-		 PersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
+		 btPersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
 		 
-		 CollisionObject* colObj0 = static_cast<CollisionObject*>(manifold->GetBody0());
-		 CollisionObject* colObj1 = static_cast<CollisionObject*>(manifold->GetBody1());
+		 btCollisionObject* colObj0 = static_cast<btCollisionObject*>(manifold->GetBody0());
+		 btCollisionObject* colObj1 = static_cast<btCollisionObject*>(manifold->GetBody1());
 		
 		 //todo: check sleeping conditions!
 		 if (((colObj0) && colObj0->GetActivationState() != ISLAND_SLEEPING) ||
@@ -250,7 +247,7 @@ void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,Coll
 
 	// Sort manifolds, based on islands
 	// Sort the vector using predicate and std::sort
-	std::sort(islandmanifold.begin(), islandmanifold.end(), PersistentManifoldSortPredicate);
+	std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
 
 	//now process all active islands (sets of manifolds for now)
 

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

@@ -19,29 +19,29 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btUnionFind.h"
 #include "btCollisionCreateFunc.h"
 
-class CollisionWorld;
-class Dispatcher;
+class btCollisionWorld;
+class btDispatcher;
 
-///SimulationIslandManager creates and handles simulation islands, using UnionFind
-class SimulationIslandManager
+///SimulationIslandManager creates and handles simulation islands, using btUnionFind
+class btSimulationIslandManager
 {
-	UnionFind m_unionFind;
+	btUnionFind m_unionFind;
 
 public:
-	SimulationIslandManager();
-	virtual ~SimulationIslandManager();
+	btSimulationIslandManager();
+	virtual ~btSimulationIslandManager();
 
 
 	void InitUnionFind(int n);	
 	
 		
-	UnionFind& GetUnionFind() { return m_unionFind;}
+	btUnionFind& GetUnionFind() { return m_unionFind;}
 
-	virtual	void	UpdateActivationState(CollisionWorld* colWorld,Dispatcher* dispatcher);
-	virtual	void	StoreIslandActivationState(CollisionWorld* world);
+	virtual	void	UpdateActivationState(btCollisionWorld* colWorld,btDispatcher* dispatcher);
+	virtual	void	StoreIslandActivationState(btCollisionWorld* world);
 
 
-	void	FindUnions(Dispatcher* dispatcher);
+	void	FindUnions(btDispatcher* dispatcher);
 
 	
 
@@ -49,10 +49,10 @@ public:
 	{
 		virtual ~IslandCallback() {};
 
-		virtual	void	ProcessIsland(class PersistentManifold**	manifolds,int numManifolds) = 0;
+		virtual	void	ProcessIsland(class btPersistentManifold**	manifolds,int numManifolds) = 0;
 	};
 
-	void	BuildAndProcessIslands(Dispatcher* dispatcher,CollisionObjectArray& collisionObjects, IslandCallback* callback);
+	void	BuildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback);
 
 };
 

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -18,8 +18,8 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionShapes/btSphereShape.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
 
-SphereSphereCollisionAlgorithm::SphereSphereCollisionAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
-: CollisionAlgorithm(ci),
+btSphereSphereCollisionAlgorithm::btSphereSphereCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+: btCollisionAlgorithm(ci),
 m_ownManifold(false),
 m_manifoldPtr(mf)
 {
@@ -30,7 +30,7 @@ m_manifoldPtr(mf)
 	}
 }
 
-SphereSphereCollisionAlgorithm::~SphereSphereCollisionAlgorithm()
+btSphereSphereCollisionAlgorithm::~btSphereSphereCollisionAlgorithm()
 {
 	if (m_ownManifold)
 	{
@@ -39,42 +39,42 @@ SphereSphereCollisionAlgorithm::~SphereSphereCollisionAlgorithm()
 	}
 }
 
-void SphereSphereCollisionAlgorithm::ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+void btSphereSphereCollisionAlgorithm::ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
 	if (!m_manifoldPtr)
 		return;
 
-	CollisionObject*	col0 = static_cast<CollisionObject*>(proxy0->m_clientObject);
-	CollisionObject*	col1 = static_cast<CollisionObject*>(proxy1->m_clientObject);
-	SphereShape* sphere0 = (SphereShape*)col0->m_collisionShape;
-	SphereShape* sphere1 = (SphereShape*)col1->m_collisionShape;
+	btCollisionObject*	col0 = static_cast<btCollisionObject*>(proxy0->m_clientObject);
+	btCollisionObject*	col1 = static_cast<btCollisionObject*>(proxy1->m_clientObject);
+	btSphereShape* sphere0 = (btSphereShape*)col0->m_collisionShape;
+	btSphereShape* sphere1 = (btSphereShape*)col1->m_collisionShape;
 
-	SimdVector3 diff = col0->m_worldTransform.getOrigin()-  col1->m_worldTransform.getOrigin();
+	btVector3 diff = col0->m_worldTransform.getOrigin()-  col1->m_worldTransform.getOrigin();
 	float len = diff.length();
-	SimdScalar radius0 = sphere0->GetRadius();
-	SimdScalar radius1 = sphere1->GetRadius();
+	btScalar radius0 = sphere0->GetRadius();
+	btScalar radius1 = sphere1->GetRadius();
 
 	///iff distance positive, don't generate a new contact
 	if ( len > (radius0+radius1))
 		return;
 
 	///distance (negative means penetration)
-	SimdScalar dist = len - (radius0+radius1);
+	btScalar dist = len - (radius0+radius1);
 
-	SimdVector3 normalOnSurfaceB = diff / len;
+	btVector3 normalOnSurfaceB = diff / len;
 	///point on A (worldspace)
-	SimdVector3 pos0 = col0->m_worldTransform.getOrigin() - radius0 * normalOnSurfaceB;
+	btVector3 pos0 = col0->m_worldTransform.getOrigin() - radius0 * normalOnSurfaceB;
 	///point on B (worldspace)
-	SimdVector3 pos1 = col1->m_worldTransform.getOrigin() + radius1* normalOnSurfaceB;
+	btVector3 pos1 = col1->m_worldTransform.getOrigin() + radius1* normalOnSurfaceB;
 
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
-	ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+	btManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
 	resultOut->AddContactPoint(normalOnSurfaceB,pos1,dist);
 	m_dispatcher->ReleaseManifoldResult(resultOut);
 
 }
 
-float SphereSphereCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+float btSphereSphereCollisionAlgorithm::CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo)
 {
 	//not yet
 	return 1.f;

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

@@ -19,33 +19,33 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
-class PersistentManifold;
+class btPersistentManifold;
 
-/// SphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
+/// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
-/// Also provides the most basic sample for custom/user CollisionAlgorithm
-class SphereSphereCollisionAlgorithm : public CollisionAlgorithm
+/// Also provides the most basic sample for custom/user btCollisionAlgorithm
+class btSphereSphereCollisionAlgorithm : public btCollisionAlgorithm
 {
 	bool	m_ownManifold;
-	PersistentManifold*	m_manifoldPtr;
+	btPersistentManifold*	m_manifoldPtr;
 	
 public:
-	SphereSphereCollisionAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
-		: CollisionAlgorithm(ci) {}
+	btSphereSphereCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btCollisionAlgorithm(ci) {}
 
-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+	virtual float CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const btDispatcherInfo& dispatchInfo);
 
-	SphereSphereCollisionAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btSphereSphereCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 
-	virtual ~SphereSphereCollisionAlgorithm();
+	virtual ~btSphereSphereCollisionAlgorithm();
 
-	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
-		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 		{
-			return new SphereSphereCollisionAlgorithm(0,ci,proxy0,proxy1);
+			return new btSphereSphereCollisionAlgorithm(0,ci,proxy0,proxy1);
 		}
 	};
 

src/BulletCollision/CollisionDispatch/btUnionFind.cpp

@@ -19,28 +19,28 @@ subject to the following restrictions:
 
 
 
-UnionFind::~UnionFind()
+btUnionFind::~btUnionFind()
 {
 	Free();
 
 }
 
-UnionFind::UnionFind()
+btUnionFind::btUnionFind()
 { 
 
 }
 
-void	UnionFind::Allocate(int N)
+void	btUnionFind::Allocate(int N)
 {
 	m_elements.resize(N);
 }
-void	UnionFind::Free()
+void	btUnionFind::Free()
 {
 	m_elements.clear();
 }
 
 
-void	UnionFind::reset(int N)
+void	btUnionFind::reset(int N)
 {
 	Allocate(N);
 
@@ -50,15 +50,15 @@ void	UnionFind::reset(int N)
 	} 
 }
 
-bool UnionFindElementSortPredicate(const Element& lhs, const Element& rhs)
+bool btUnionFindElementSortPredicate(const btElement& lhs, const btElement& rhs)
 {
 	return lhs.m_id < rhs.m_id;
 }
 
 
-///this is a special operation, destroying the content of UnionFind.
+///this is a special operation, destroying the content of btUnionFind.
 ///it sorts the elements, based on island id, in order to make it easy to iterate over islands
-void	UnionFind::sortIslands()
+void	btUnionFind::sortIslands()
 {
 
 	//first store the original body index, and islandId
@@ -71,7 +71,7 @@ void	UnionFind::sortIslands()
 	}
 	
 	 // Sort the vector using predicate and std::sort
-	  std::sort(m_elements.begin(), m_elements.end(), UnionFindElementSortPredicate);
+	  std::sort(m_elements.begin(), m_elements.end(), btUnionFindElementSortPredicate);
 
 }
 

src/BulletCollision/CollisionDispatch/btUnionFind.h

@@ -17,7 +17,7 @@ subject to the following restrictions:
 #define UNION_FIND_H
 
 #include <vector>
-struct	Element
+struct	btElement
 {
 	int	m_id;
 	int	m_sz;
@@ -26,18 +26,18 @@ struct	Element
 ///UnionFind calculates connected subsets
 // Implements weighted Quick Union with path compression
 // optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable)
-class UnionFind
+class btUnionFind
   {
     private:
-		std::vector<Element>	m_elements;
+		std::vector<btElement>	m_elements;
 
     public:
 	  
-		UnionFind();
-		~UnionFind();
+		btUnionFind();
+		~btUnionFind();
 
 	
-		//this is a special operation, destroying the content of UnionFind.
+		//this is a special operation, destroying the content of btUnionFind.
 		//it sorts the elements, based on island id, in order to make it easy to iterate over islands
 		void	sortIslands();
 
@@ -52,11 +52,11 @@ class UnionFind
 		  return (x == m_elements[x].m_id);
 	  }
 
-	  Element&	getElement(int index)
+	  btElement&	getElement(int index)
 	  {
 		  return m_elements[index];
 	  }
-	  const Element& getElement(int index) const
+	  const btElement& getElement(int index) const
 	  {
 		  return m_elements[index];
 	  }