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.
2006-09-27 20:43:51 +00:00
parent d1e9a885f3
commit eb23bb5c0c
263 changed files with 7528 additions and 6714 deletions
--- a/src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
+++ b/src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
@@ -4,7 +4,7 @@


 //
-// AxisSweep3
+// btAxisSweep3
 //
 // Copyright (c) 2006 Simon Hobbs
 //
@@ -21,7 +21,7 @@

 #include <assert.h>

-BroadphaseProxy*	AxisSweep3::CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
+btBroadphaseProxy*	btAxisSweep3::CreateProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
 {
 		unsigned short handleId = AddHandle(min,max, userPtr,collisionFilterGroup,collisionFilterMask);
 		
@@ -30,13 +30,13 @@ BroadphaseProxy*	AxisSweep3::CreateProxy(  const SimdVector3& min,  const SimdVe
 		return handle;
 }

-void	AxisSweep3::DestroyProxy(BroadphaseProxy* proxy)
+void	btAxisSweep3::DestroyProxy(btBroadphaseProxy* proxy)
 {
 	Handle* handle = static_cast<Handle*>(proxy);
 	RemoveHandle(handle->m_handleId);
 }

-void	AxisSweep3::SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax)
+void	btAxisSweep3::SetAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax)
 {
 	Handle* handle = static_cast<Handle*>(proxy);
 	UpdateHandle(handle->m_handleId,aabbMin,aabbMax);
@@ -47,8 +47,8 @@ void	AxisSweep3::SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const



-AxisSweep3::AxisSweep3(const SimdPoint3& worldAabbMin,const SimdPoint3& worldAabbMax, int maxHandles)
-:OverlappingPairCache()
+btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles)
+:btOverlappingPairCache()
 {
 	//assert(bounds.HasVolume());

@@ -59,9 +59,9 @@ AxisSweep3::AxisSweep3(const SimdPoint3& worldAabbMin,const SimdPoint3& worldAab
 	m_worldAabbMin = worldAabbMin;
 	m_worldAabbMax = worldAabbMax;

-	SimdVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;
+	btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;

-	m_quantize = SimdVector3(65535.0f,65535.0f,65535.0f) / aabbSize;
+	m_quantize = btVector3(65535.0f,65535.0f,65535.0f) / aabbSize;

 	// allocate handles buffer and put all handles on free list
 	m_pHandles = new Handle[maxHandles];
@@ -99,7 +99,7 @@ AxisSweep3::AxisSweep3(const SimdPoint3& worldAabbMin,const SimdPoint3& worldAab
 	}
 }

-AxisSweep3::~AxisSweep3()
+btAxisSweep3::~btAxisSweep3()
 {
 	
 	for (int i = 2; i >= 0; i--)
@@ -107,15 +107,15 @@ AxisSweep3::~AxisSweep3()
 	delete[] m_pHandles;
 }

-void AxisSweep3::Quantize(unsigned short* out, const SimdPoint3& point, int isMax) const
+void btAxisSweep3::Quantize(unsigned short* out, const btPoint3& point, int isMax) const
 {
-	SimdPoint3 clampedPoint(point);
+	btPoint3 clampedPoint(point);
 	/*
 	if (isMax)
-		clampedPoint += SimdVector3(10,10,10);
+		clampedPoint += btVector3(10,10,10);
 	else
 	{
-		clampedPoint -= SimdVector3(10,10,10);
+		clampedPoint -= btVector3(10,10,10);
 	}
 	*/

@@ -123,7 +123,7 @@ void AxisSweep3::Quantize(unsigned short* out, const SimdPoint3& point, int isMa
 	clampedPoint.setMax(m_worldAabbMin);
 	clampedPoint.setMin(m_worldAabbMax);

-	SimdVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
+	btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
 	out[0] = (unsigned short)(((int)v.getX() & 0xfffc) | isMax);
 	out[1] = (unsigned short)(((int)v.getY() & 0xfffc) | isMax);
 	out[2] = (unsigned short)(((int)v.getZ() & 0xfffc) | isMax);
@@ -132,7 +132,7 @@ void AxisSweep3::Quantize(unsigned short* out, const SimdPoint3& point, int isMa



-unsigned short AxisSweep3::AllocHandle()
+unsigned short btAxisSweep3::AllocHandle()
 {
 	assert(m_firstFreeHandle);

@@ -143,7 +143,7 @@ unsigned short AxisSweep3::AllocHandle()
 	return handle;
 }

-void AxisSweep3::FreeHandle(unsigned short handle)
+void btAxisSweep3::FreeHandle(unsigned short handle)
 {
 	assert(handle > 0 && handle < m_maxHandles);

@@ -155,7 +155,7 @@ void AxisSweep3::FreeHandle(unsigned short handle)



-unsigned short AxisSweep3::AddHandle(const SimdPoint3& aabbMin,const SimdPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
+unsigned short btAxisSweep3::AddHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
 {
 	// quantize the bounds
 	unsigned short min[3], max[3];
@@ -208,7 +208,7 @@ unsigned short AxisSweep3::AddHandle(const SimdPoint3& aabbMin,const SimdPoint3&
 }


-void AxisSweep3::RemoveHandle(unsigned short handle)
+void btAxisSweep3::RemoveHandle(unsigned short handle)
 {
 	Handle* pHandle = GetHandle(handle);

@@ -256,7 +256,7 @@ void AxisSweep3::RemoveHandle(unsigned short handle)
 	
 }

-bool AxisSweep3::TestOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB)
+bool btAxisSweep3::TestOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB)
 {
 	//optimization 1: check the array index (memory address), instead of the m_pos

@@ -287,7 +287,7 @@ bool AxisSweep3::TestOverlap(int ignoreAxis,const Handle* pHandleA, const Handle
 	return true;
 }

-void AxisSweep3::UpdateHandle(unsigned short handle, const SimdPoint3& aabbMin,const SimdPoint3& aabbMax)
+void btAxisSweep3::UpdateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax)
 {
 //	assert(bounds.IsFinite());
 	//assert(bounds.HasVolume());
@@ -330,7 +330,7 @@ void AxisSweep3::UpdateHandle(unsigned short handle, const SimdPoint3& aabbMin,c
 }

 // sorting a min edge downwards can only ever *add* overlaps
-void AxisSweep3::SortMinDown(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::SortMinDown(int axis, unsigned short edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pPrev = pEdge - 1;
@@ -371,7 +371,7 @@ void AxisSweep3::SortMinDown(int axis, unsigned short edge, bool updateOverlaps)
 }

 // sorting a min edge upwards can only ever *remove* overlaps
-void AxisSweep3::SortMinUp(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::SortMinUp(int axis, unsigned short edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pNext = pEdge + 1;
@@ -388,7 +388,7 @@ void AxisSweep3::SortMinUp(int axis, unsigned short edge, bool updateOverlaps)
 			{
 				Handle* handle0 = GetHandle(pEdge->m_handle);
 				Handle* handle1 = GetHandle(pNext->m_handle);
-				BroadphasePair tmpPair(*handle0,*handle1);
+				btBroadphasePair tmpPair(*handle0,*handle1);
 				RemoveOverlappingPair(tmpPair);

 			}
@@ -413,7 +413,7 @@ void AxisSweep3::SortMinUp(int axis, unsigned short edge, bool updateOverlaps)
 }

 // sorting a max edge downwards can only ever *remove* overlaps
-void AxisSweep3::SortMaxDown(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::SortMaxDown(int axis, unsigned short edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pPrev = pEdge - 1;
@@ -430,7 +430,7 @@ void AxisSweep3::SortMaxDown(int axis, unsigned short edge, bool updateOverlaps)
 			{
 				Handle* handle0 = GetHandle(pEdge->m_handle);
 				Handle* handle1 = GetHandle(pPrev->m_handle);
-				BroadphasePair* pair = FindPair(handle0,handle1);
+				btBroadphasePair* pair = FindPair(handle0,handle1);
 				//assert(pair);

 				if (pair)
@@ -459,7 +459,7 @@ void AxisSweep3::SortMaxDown(int axis, unsigned short edge, bool updateOverlaps)
 }

 // sorting a max edge upwards can only ever *add* overlaps
-void AxisSweep3::SortMaxUp(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::SortMaxUp(int axis, unsigned short edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pNext = pEdge + 1;
--- a/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h
+++ b/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h
@@ -2,7 +2,7 @@
 //Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/

 //
-// AxisSweep3.h
+// btAxisSweep3.h
 //
 // Copyright (c) 2006 Simon Hobbs
 //
@@ -19,15 +19,15 @@
 #ifndef AXIS_SWEEP_3_H
 #define AXIS_SWEEP_3_H

-#include "LinearMath/SimdPoint3.h"
-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btPoint3.h"
+#include "LinearMath/btVector3.h"
 #include "btOverlappingPairCache.h"
 #include "btBroadphaseProxy.h"

-/// AxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
+/// btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
 /// It uses arrays rather then lists for storage of the 3 axis. Also it operates using integer coordinates instead of floats.
 /// The TestOverlap check is optimized to check the array index, rather then the actual AABB coordinates/pos
-class AxisSweep3 : public OverlappingPairCache
+class btAxisSweep3 : public btOverlappingPairCache
 {

 public:
@@ -43,7 +43,7 @@ public:
 	};

 public:
-	class Handle : public BroadphaseProxy
+	class Handle : public btBroadphaseProxy
 	{
 	public:
 		
@@ -52,7 +52,7 @@ public:
 		unsigned short m_handleId;
 		unsigned short m_pad;
 		
-		//void* m_pOwner; this is now in BroadphaseProxy.m_clientObject
+		//void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject
 	
 		inline void SetNextFree(unsigned short next) {m_minEdges[0] = next;}
 		inline unsigned short GetNextFree() const {return m_minEdges[0];}
@@ -60,10 +60,10 @@ public:

 	
 private:
-	SimdPoint3 m_worldAabbMin;						// overall system bounds
-	SimdPoint3 m_worldAabbMax;						// overall system bounds
+	btPoint3 m_worldAabbMin;						// overall system bounds
+	btPoint3 m_worldAabbMax;						// overall system bounds

-	SimdVector3 m_quantize;						// scaling factor for quantization
+	btVector3 m_quantize;						// scaling factor for quantization

 	int m_numHandles;						// number of active handles
 	int m_maxHandles;						// max number of handles
@@ -83,7 +83,7 @@ private:
 	//Overlap* AddOverlap(unsigned short handleA, unsigned short handleB);
 	//void RemoveOverlap(unsigned short handleA, unsigned short handleB);

-	void Quantize(unsigned short* out, const SimdPoint3& point, int isMax) const;
+	void Quantize(unsigned short* out, const btPoint3& point, int isMax) const;

 	void SortMinDown(int axis, unsigned short edge, bool updateOverlaps = true);
 	void SortMinUp(int axis, unsigned short edge, bool updateOverlaps = true);
@@ -91,24 +91,24 @@ private:
 	void SortMaxUp(int axis, unsigned short edge, bool updateOverlaps = true);

 public:
-	AxisSweep3(const SimdPoint3& worldAabbMin,const SimdPoint3& worldAabbMax, int maxHandles = 16384);
-	virtual	~AxisSweep3();
+	btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles = 16384);
+	virtual	~btAxisSweep3();

 	virtual void	RefreshOverlappingPairs()
 	{
 		//this is replace by sweep and prune
 	}
 	
-	unsigned short AddHandle(const SimdPoint3& aabbMin,const SimdPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask);
+	unsigned short AddHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask);
 	void RemoveHandle(unsigned short handle);
-	void UpdateHandle(unsigned short handle, const SimdPoint3& aabbMin,const SimdPoint3& aabbMax);
+	void UpdateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax);
 	inline Handle* GetHandle(unsigned short index) const {return m_pHandles + index;}


 	//Broadphase Interface
-	virtual BroadphaseProxy*	CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask);
-	virtual void	DestroyProxy(BroadphaseProxy* proxy);
-	virtual void	SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax);
+	virtual btBroadphaseProxy*	CreateProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask);
+	virtual void	DestroyProxy(btBroadphaseProxy* proxy);
+	virtual void	SetAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax);

 };

--- a/src/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
+++ b/src/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
@@ -18,21 +18,21 @@ subject to the following restrictions:



-struct DispatcherInfo;
-class Dispatcher;
-struct BroadphaseProxy;
-#include "LinearMath/SimdVector3.h"
+struct btDispatcherInfo;
+class btDispatcher;
+struct btBroadphaseProxy;
+#include "LinearMath/btVector3.h"

 ///BroadphaseInterface for aabb-overlapping object pairs
-class BroadphaseInterface
+class btBroadphaseInterface
 {
 public:
-	virtual ~BroadphaseInterface() {}
+	virtual ~btBroadphaseInterface() {}

-	virtual BroadphaseProxy*	CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask) =0;
-	virtual void	DestroyProxy(BroadphaseProxy* proxy)=0;
-	virtual void	SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax)=0;
-	virtual void	CleanProxyFromPairs(BroadphaseProxy* proxy)=0;
+	virtual btBroadphaseProxy*	CreateProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask) =0;
+	virtual void	DestroyProxy(btBroadphaseProxy* proxy)=0;
+	virtual void	SetAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax)=0;
+	virtual void	CleanProxyFromPairs(btBroadphaseProxy* proxy)=0;
 	

 };
--- a/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
+++ b/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
@@ -18,7 +18,7 @@ subject to the following restrictions:



-/// Dispatcher uses these types
+/// btDispatcher uses these types
 /// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave
 /// to facilitate type checking
 enum BroadphaseNativeTypes
@@ -56,18 +56,18 @@ CONCAVE_SHAPES_END_HERE,


 ///BroadphaseProxy
-struct BroadphaseProxy
+struct btBroadphaseProxy
 {
 	
-	//Usually the client CollisionObject or Rigidbody class
+	//Usually the client btCollisionObject or Rigidbody class
 	void*	m_clientObject;
 	short int m_collisionFilterGroup;
 	short int m_collisionFilterMask;

 	//used for memory pools
-	BroadphaseProxy() :m_clientObject(0){}
+	btBroadphaseProxy() :m_clientObject(0){}

-	BroadphaseProxy(void* userPtr,short int collisionFilterGroup, short int collisionFilterMask)
+	btBroadphaseProxy(void* userPtr,short int collisionFilterGroup, short int collisionFilterMask)
 		:m_clientObject(userPtr),
 		m_collisionFilterGroup(collisionFilterGroup),
 		m_collisionFilterMask(collisionFilterMask)
@@ -96,17 +96,17 @@ struct BroadphaseProxy
 	
 };

-class CollisionAlgorithm;
+class btCollisionAlgorithm;

-struct BroadphaseProxy;
+struct btBroadphaseProxy;

-//Increase SIMPLE_MAX_ALGORITHMS to allow multiple Dispatchers caching their own algorithms
+//Increase SIMPLE_MAX_ALGORITHMS to allow multiple btDispatchers caching their own algorithms
 #define SIMPLE_MAX_ALGORITHMS 1

 /// contains a pair of aabb-overlapping objects
-struct BroadphasePair
+struct btBroadphasePair
 {
-	BroadphasePair ()
+	btBroadphasePair ()
 		:
 	m_pProxy0(0),
 		m_pProxy1(0)
@@ -117,7 +117,7 @@ struct BroadphasePair
 		}
 	}

-	BroadphasePair(const BroadphasePair& other)
+	btBroadphasePair(const btBroadphasePair& other)
 		:		m_pProxy0(other.m_pProxy0),
 				m_pProxy1(other.m_pProxy1)
 	{
@@ -126,7 +126,7 @@ struct BroadphasePair
 			m_algorithms[i] = other.m_algorithms[i];
 		}
 	}
-	BroadphasePair(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+	btBroadphasePair(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
 	{

 		//keep them sorted, so the std::set operations work
@@ -148,15 +148,15 @@ struct BroadphasePair

 	}
 	
-	BroadphaseProxy* m_pProxy0;
-	BroadphaseProxy* m_pProxy1;
+	btBroadphaseProxy* m_pProxy0;
+	btBroadphaseProxy* m_pProxy1;
 	
-	mutable CollisionAlgorithm* m_algorithms[SIMPLE_MAX_ALGORITHMS];
+	mutable btCollisionAlgorithm* m_algorithms[SIMPLE_MAX_ALGORITHMS];
 };


 //comparison for set operation, see Solid DT_Encounter
-inline bool operator<(const BroadphasePair& a, const BroadphasePair& b) 
+inline bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
 { 
    return a.m_pProxy0 < b.m_pProxy0 || 
        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
--- a/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp
+++ b/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #include "btCollisionAlgorithm.h"
 #include "btDispatcher.h"

-CollisionAlgorithm::CollisionAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
+btCollisionAlgorithm::btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
 {
 	m_dispatcher = ci.m_dispatcher;
 }
--- a/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
+++ b/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
@@ -16,50 +16,50 @@ subject to the following restrictions:
 #ifndef COLLISION_ALGORITHM_H
 #define COLLISION_ALGORITHM_H

-struct BroadphaseProxy;
-class Dispatcher;
+struct btBroadphaseProxy;
+class btDispatcher;

-struct CollisionAlgorithmConstructionInfo
+struct btCollisionAlgorithmConstructionInfo
 {
-	CollisionAlgorithmConstructionInfo()
+	btCollisionAlgorithmConstructionInfo()
 		:m_dispatcher(0)
 	{
 	}
-	CollisionAlgorithmConstructionInfo(Dispatcher* dispatcher,int temp)
+	btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher,int temp)
 		:m_dispatcher(dispatcher)
 	{
 	}

-	Dispatcher*	m_dispatcher;
+	btDispatcher*	m_dispatcher;

 	int	GetDispatcherId();

 };


-///CollisionAlgorithm is an collision interface that is compatible with the Broadphase and Dispatcher.
+///CollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher.
 ///It is persistent over frames
-class CollisionAlgorithm
+class btCollisionAlgorithm
 {

 protected:

-	Dispatcher*	m_dispatcher;
+	btDispatcher*	m_dispatcher;

 protected:
 	int	GetDispatcherId();
 	
 public:

-	CollisionAlgorithm() {};
+	btCollisionAlgorithm() {};

-	CollisionAlgorithm(const CollisionAlgorithmConstructionInfo& ci);
+	btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);

-	virtual ~CollisionAlgorithm() {};
+	virtual ~btCollisionAlgorithm() {};

-	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const struct DispatcherInfo& dispatchInfo) = 0;
+	virtual void ProcessCollision (btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const struct btDispatcherInfo& dispatchInfo) = 0;

-	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const struct DispatcherInfo& dispatchInfo) = 0;
+	virtual float CalculateTimeOfImpact(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,const struct btDispatcherInfo& dispatchInfo) = 0;

 };

--- a/src/BulletCollision/BroadphaseCollision/btDispatcher.cpp
+++ b/src/BulletCollision/BroadphaseCollision/btDispatcher.cpp
@@ -15,7 +15,7 @@ subject to the following restrictions:

 #include "btDispatcher.h"

-Dispatcher::~Dispatcher()
+btDispatcher::~btDispatcher()
 {

 }
--- a/src/BulletCollision/BroadphaseCollision/btDispatcher.h
+++ b/src/BulletCollision/BroadphaseCollision/btDispatcher.h
@@ -16,29 +16,29 @@ subject to the following restrictions:
 #ifndef _DISPATCHER_H
 #define _DISPATCHER_H

-class CollisionAlgorithm;
-struct BroadphaseProxy;
-class RigidBody;
-struct	CollisionObject;
-class ManifoldResult;
-class OverlappingPairCache;
+class btCollisionAlgorithm;
+struct btBroadphaseProxy;
+class btRigidBody;
+struct	btCollisionObject;
+class btManifoldResult;
+class btOverlappingPairCache;

-enum CollisionDispatcherId
+enum btCollisionDispatcherId
 {
 	RIGIDBODY_DISPATCHER = 0,
 	USERCALLBACK_DISPATCHER
 };

-class PersistentManifold;
+class btPersistentManifold;

-struct DispatcherInfo
+struct btDispatcherInfo
 {
 	enum DispatchFunc
 	{
 		DISPATCH_DISCRETE = 1,
 		DISPATCH_CONTINUOUS
 	};
-	DispatcherInfo()
+	btDispatcherInfo()
 		:m_dispatchFunc(DISPATCH_DISCRETE),
 		m_timeOfImpact(1.f),
 		m_useContinuous(false),
@@ -52,46 +52,46 @@ struct DispatcherInfo
 	int		m_dispatchFunc;
 	float	m_timeOfImpact;
 	bool	m_useContinuous;
-	class IDebugDraw*	m_debugDraw;
+	class btIDebugDraw*	m_debugDraw;
 	bool	m_enableSatConvex;
 	
 };

-/// Dispatcher can be used in combination with broadphase to dispatch overlapping pairs.
+/// btDispatcher can be used in combination with broadphase to dispatch overlapping pairs.
 /// For example for pairwise collision detection or user callbacks (game logic).
-class Dispatcher
+class btDispatcher
 {


 public:
-	virtual ~Dispatcher() ;
+	virtual ~btDispatcher() ;

-	virtual CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) = 0;
+	virtual btCollisionAlgorithm* FindAlgorithm(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1) = 0;

 	//
 	// asume dispatchers to have unique id's in the range [0..max dispacher]
 	//
 	virtual int GetUniqueId() = 0;

-	virtual PersistentManifold*	GetNewManifold(void* body0,void* body1)=0;
+	virtual btPersistentManifold*	GetNewManifold(void* body0,void* body1)=0;

-	virtual void ReleaseManifold(PersistentManifold* manifold)=0;
+	virtual void ReleaseManifold(btPersistentManifold* manifold)=0;

-	virtual void ClearManifold(PersistentManifold* manifold)=0;
+	virtual void ClearManifold(btPersistentManifold* manifold)=0;

-	virtual bool	NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) = 0;
+	virtual bool	NeedsCollision(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1) = 0;

-	virtual bool	NeedsResponse(const CollisionObject& colObj0,const CollisionObject& colObj1)=0;
+	virtual bool	NeedsResponse(const btCollisionObject& colObj0,const btCollisionObject& colObj1)=0;

-	virtual	ManifoldResult* GetNewManifoldResult(CollisionObject* obj0,CollisionObject* obj1,PersistentManifold* manifold) =0;
+	virtual	btManifoldResult* GetNewManifoldResult(btCollisionObject* obj0,btCollisionObject* obj1,btPersistentManifold* manifold) =0;

-	virtual	void	ReleaseManifoldResult(ManifoldResult*)=0;
+	virtual	void	ReleaseManifoldResult(btManifoldResult*)=0;

-	virtual void	DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo)=0;
+	virtual void	DispatchAllCollisionPairs(btOverlappingPairCache* pairCache,btDispatcherInfo& dispatchInfo)=0;

 	virtual int GetNumManifolds() const = 0;

-	virtual PersistentManifold* GetManifoldByIndexInternal(int index) = 0;
+	virtual btPersistentManifold* GetManifoldByIndexInternal(int index) = 0;

 };

--- a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp
+++ b/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp
@@ -23,36 +23,36 @@ subject to the following restrictions:

 int	gOverlappingPairs = 0;

-OverlappingPairCache::OverlappingPairCache():
+btOverlappingPairCache::btOverlappingPairCache():
 m_blockedForChanges(false)
 //m_NumOverlapBroadphasePair(0)
 {
 }


-OverlappingPairCache::~OverlappingPairCache()
+btOverlappingPairCache::~btOverlappingPairCache()
 {
 	//todo/test: show we erase/delete data, or is it automatic
 }


-void	OverlappingPairCache::RemoveOverlappingPair(BroadphasePair& findPair)
+void	btOverlappingPairCache::RemoveOverlappingPair(btBroadphasePair& findPair)
 {
 	
-	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.find(findPair);
+	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.find(findPair);
 //	assert(it != m_overlappingPairSet.end());

 	if (it != m_overlappingPairSet.end())
 	{
 		gOverlappingPairs--;
-		BroadphasePair* pair = (BroadphasePair*)(&(*it));
+		btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
 		CleanOverlappingPair(*pair);	
 		m_overlappingPairSet.erase(it);
 	}
 }


-void	OverlappingPairCache::CleanOverlappingPair(BroadphasePair& pair)
+void	btOverlappingPairCache::CleanOverlappingPair(btBroadphasePair& pair)
 {
 	for (int dispatcherId=0;dispatcherId<SIMPLE_MAX_ALGORITHMS;dispatcherId++)
 	{
@@ -70,7 +70,7 @@ void	OverlappingPairCache::CleanOverlappingPair(BroadphasePair& pair)



-void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+void	btOverlappingPairCache::AddOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	//don't add overlap with own
 	assert(proxy0 != proxy1);
@@ -79,7 +79,7 @@ void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,Broadphase
 		return;


-	BroadphasePair pair(*proxy0,*proxy1);
+	btBroadphasePair pair(*proxy0,*proxy1);
 	
 	m_overlappingPairSet.insert(pair);
 	gOverlappingPairs++;
@@ -90,18 +90,18 @@ void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,Broadphase
 ///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed.
 ///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address)
 ///Also we can use a 2D bitmap, which can be useful for a future GPU implementation
- BroadphasePair*	OverlappingPairCache::FindPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+ btBroadphasePair*	btOverlappingPairCache::FindPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	if (!NeedsCollision(proxy0,proxy1))
 		return 0;

-	BroadphasePair tmpPair(*proxy0,*proxy1);
-	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.find(tmpPair);
+	btBroadphasePair tmpPair(*proxy0,*proxy1);
+	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.find(tmpPair);
 	if ((it == m_overlappingPairSet.end()))
 		return 0;

 	//assert(it != m_overlappingPairSet.end());
-	 BroadphasePair* pair = (BroadphasePair*)(&(*it));
+	 btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
 	return pair;
 }

@@ -109,21 +109,21 @@ void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,Broadphase



-void	OverlappingPairCache::CleanProxyFromPairs(BroadphaseProxy* proxy)
+void	btOverlappingPairCache::CleanProxyFromPairs(btBroadphaseProxy* proxy)
 {

-	class	CleanPairCallback : public OverlapCallback
+	class	CleanPairCallback : public btOverlapCallback
 	{
-		BroadphaseProxy* m_cleanProxy;
-		OverlappingPairCache*	m_pairCache;
+		btBroadphaseProxy* m_cleanProxy;
+		btOverlappingPairCache*	m_pairCache;

 	public:
-		CleanPairCallback(BroadphaseProxy* cleanProxy,OverlappingPairCache* pairCache)
+		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache)
 			:m_cleanProxy(cleanProxy),
 			m_pairCache(pairCache)
 		{
 		}
-		virtual	bool	ProcessOverlap(BroadphasePair& pair)
+		virtual	bool	ProcessOverlap(btBroadphasePair& pair)
 		{
 			if ((pair.m_pProxy0 == m_cleanProxy) ||
 				(pair.m_pProxy1 == m_cleanProxy))
@@ -143,19 +143,19 @@ void	OverlappingPairCache::CleanProxyFromPairs(BroadphaseProxy* proxy)



-void	OverlappingPairCache::RemoveOverlappingPairsContainingProxy(BroadphaseProxy* proxy)
+void	btOverlappingPairCache::RemoveOverlappingPairsContainingProxy(btBroadphaseProxy* proxy)
 {

-	class	RemovePairCallback : public OverlapCallback
+	class	RemovePairCallback : public btOverlapCallback
 	{
-		BroadphaseProxy* m_obsoleteProxy;
+		btBroadphaseProxy* m_obsoleteProxy;

 	public:
-		RemovePairCallback(BroadphaseProxy* obsoleteProxy)
+		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
 			:m_obsoleteProxy(obsoleteProxy)
 		{
 		}
-		virtual	bool	ProcessOverlap(BroadphasePair& pair)
+		virtual	bool	ProcessOverlap(btBroadphasePair& pair)
 		{
 			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
 				(pair.m_pProxy1 == m_obsoleteProxy));
@@ -171,18 +171,18 @@ void	OverlappingPairCache::RemoveOverlappingPairsContainingProxy(BroadphaseProxy



-void	OverlappingPairCache::ProcessAllOverlappingPairs(OverlapCallback* callback)
+void	btOverlappingPairCache::ProcessAllOverlappingPairs(btOverlapCallback* callback)
 {
-	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.begin();
+	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.begin();
 	for (; !(it==m_overlappingPairSet.end());)
 	{
 	
-		BroadphasePair* pair = (BroadphasePair*)(&(*it));
+		btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
 		if (callback->ProcessOverlap(*pair))
 		{
 			CleanOverlappingPair(*pair);

-			std::set<BroadphasePair>::iterator it2 = it;
+			std::set<btBroadphasePair>::iterator it2 = it;
 			//why does next line not compile under OS X??
 #ifdef MAC_OSX_FIXED_STL_SET
 			it2++;
--- a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
+++ b/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
@@ -20,51 +20,51 @@ subject to the following restrictions:

 #include "btBroadphaseInterface.h"
 #include "btBroadphaseProxy.h"
-#include "LinearMath/SimdPoint3.h"
+#include "LinearMath/btPoint3.h"
 #include <set>


-struct	OverlapCallback
+struct	btOverlapCallback
 {
-virtual ~OverlapCallback()
+virtual ~btOverlapCallback()
 {
 }
 	//return true for deletion of the pair
-	virtual bool	ProcessOverlap(BroadphasePair& pair) = 0;
+	virtual bool	ProcessOverlap(btBroadphasePair& pair) = 0;
 };

 ///OverlappingPairCache maintains the objects with overlapping AABB
-///Typically managed by the Broadphase, Axis3Sweep or SimpleBroadphase
-class	OverlappingPairCache : public BroadphaseInterface
+///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
+class	btOverlappingPairCache : public btBroadphaseInterface
 {
 	//avoid brute-force finding all the time
-	std::set<BroadphasePair>	m_overlappingPairSet;
+	std::set<btBroadphasePair>	m_overlappingPairSet;
 	
 	//during the dispatch, check that user doesn't destroy/create proxy
 	bool		m_blockedForChanges;
 	
 	public:
 		
-	OverlappingPairCache();	
-	virtual ~OverlappingPairCache();
+	btOverlappingPairCache();	
+	virtual ~btOverlappingPairCache();

-	void	ProcessAllOverlappingPairs(OverlapCallback*);
+	void	ProcessAllOverlappingPairs(btOverlapCallback*);

-	void	RemoveOverlappingPair(BroadphasePair& pair);
+	void	RemoveOverlappingPair(btBroadphasePair& pair);

-	void	CleanOverlappingPair(BroadphasePair& pair);
+	void	CleanOverlappingPair(btBroadphasePair& pair);
 	
-	void	AddOverlappingPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	void	AddOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);

-	BroadphasePair*	FindPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+	btBroadphasePair*	FindPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
 		
 	
-	void	CleanProxyFromPairs(BroadphaseProxy* proxy);
+	void	CleanProxyFromPairs(btBroadphaseProxy* proxy);

-	void	RemoveOverlappingPairsContainingProxy(BroadphaseProxy* proxy);
+	void	RemoveOverlappingPairsContainingProxy(btBroadphaseProxy* proxy);


-	inline bool NeedsCollision(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1) const
+	inline bool NeedsCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
 	{
 		bool collides = proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask;
 		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
--- a/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp
+++ b/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp
@@ -17,13 +17,13 @@ subject to the following restrictions:
 #include <BulletCollision/BroadphaseCollision/btDispatcher.h>
 #include <BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h>

-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdMatrix3x3.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
 #include <vector>


-void	SimpleBroadphase::validate()
+void	btSimpleBroadphase::validate()
 {
 	for (int i=0;i<m_numProxies;i++)
 	{
@@ -35,16 +35,16 @@ void	SimpleBroadphase::validate()
 	
 }

-SimpleBroadphase::SimpleBroadphase(int maxProxies)
-	:OverlappingPairCache(),
+btSimpleBroadphase::btSimpleBroadphase(int maxProxies)
+	:btOverlappingPairCache(),
 	m_firstFreeProxy(0),
 	m_numProxies(0),
 	m_maxProxies(maxProxies)
 {

-	m_proxies = new SimpleBroadphaseProxy[maxProxies];
+	m_proxies = new btSimpleBroadphaseProxy[maxProxies];
 	m_freeProxies = new int[maxProxies];
-	m_pProxies = new SimpleBroadphaseProxy*[maxProxies];
+	m_pProxies = new btSimpleBroadphaseProxy*[maxProxies];
 	

 	int i;
@@ -54,7 +54,7 @@ SimpleBroadphase::SimpleBroadphase(int maxProxies)
 	}
 }

-SimpleBroadphase::~SimpleBroadphase()
+btSimpleBroadphase::~btSimpleBroadphase()
 {
 	delete[] m_proxies;
 	delete []m_freeProxies;
@@ -70,7 +70,7 @@ SimpleBroadphase::~SimpleBroadphase()
 }


-BroadphaseProxy*	SimpleBroadphase::CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask)
+btBroadphaseProxy*	btSimpleBroadphase::CreateProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask)
 {
 	if (m_numProxies >= m_maxProxies)
 	{
@@ -80,10 +80,10 @@ BroadphaseProxy*	SimpleBroadphase::CreateProxy(  const SimdVector3& min,  const
 	assert(min[0]<= max[0] && min[1]<= max[1] && min[2]<= max[2]);

 	int freeIndex= m_freeProxies[m_firstFreeProxy];
-	SimpleBroadphaseProxy* proxy = new (&m_proxies[freeIndex])SimpleBroadphaseProxy(min,max,shapeType,userPtr,collisionFilterGroup,collisionFilterMask);
+	btSimpleBroadphaseProxy* proxy = new (&m_proxies[freeIndex])btSimpleBroadphaseProxy(min,max,shapeType,userPtr,collisionFilterGroup,collisionFilterMask);
 	m_firstFreeProxy++;

-	SimpleBroadphaseProxy* proxy1 = &m_proxies[0];
+	btSimpleBroadphaseProxy* proxy1 = &m_proxies[0];
 		
 	int index = proxy - proxy1;
 	assert(index == freeIndex);
@@ -95,10 +95,10 @@ BroadphaseProxy*	SimpleBroadphase::CreateProxy(  const SimdVector3& min,  const
 	return proxy;
 }

-class	RemovingOverlapCallback : public OverlapCallback
+class	RemovingOverlapCallback : public btOverlapCallback
 {
 protected:
-	virtual bool	ProcessOverlap(BroadphasePair& pair)
+	virtual bool	ProcessOverlap(btBroadphasePair& pair)
 	{
 		assert(0);
 	}
@@ -107,28 +107,28 @@ protected:
 class RemovePairContainingProxy
 {

-	BroadphaseProxy*	m_targetProxy;
+	btBroadphaseProxy*	m_targetProxy;
 	public:
 	virtual ~RemovePairContainingProxy()
 	{
 	}
 protected:
-	virtual bool ProcessOverlap(BroadphasePair& pair)
+	virtual bool ProcessOverlap(btBroadphasePair& pair)
 	{
-		SimpleBroadphaseProxy* proxy0 = static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy0);
-		SimpleBroadphaseProxy* proxy1 = static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy1);
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0);
+		btSimpleBroadphaseProxy* proxy1 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1);

 		return ((m_targetProxy == proxy0 || m_targetProxy == proxy1));
 	};
 };

-void	SimpleBroadphase::DestroyProxy(BroadphaseProxy* proxyOrg)
+void	btSimpleBroadphase::DestroyProxy(btBroadphaseProxy* proxyOrg)
 {
 		
 		int i;
 		
-		SimpleBroadphaseProxy* proxy0 = static_cast<SimpleBroadphaseProxy*>(proxyOrg);
-		SimpleBroadphaseProxy* proxy1 = &m_proxies[0];
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxyOrg);
+		btSimpleBroadphaseProxy* proxy1 = &m_proxies[0];
 	
 		int index = proxy0 - proxy1;
 		assert (index < m_maxProxies);
@@ -140,10 +140,10 @@ void	SimpleBroadphase::DestroyProxy(BroadphaseProxy* proxyOrg)
 		//then remove non-overlapping ones
 		/*for (i=0;i<GetNumOverlappingPairs();i++)
 		{
-			BroadphasePair& pair = GetOverlappingPair(i);
+			btBroadphasePair& pair = GetOverlappingPair(i);

-			SimpleBroadphaseProxy* proxy0 = GetSimpleProxyFromProxy(pair.m_pProxy0);
-			SimpleBroadphaseProxy* proxy1 = GetSimpleProxyFromProxy(pair.m_pProxy1);
+			btSimpleBroadphaseProxy* proxy0 = GetSimpleProxyFromProxy(pair.m_pProxy0);
+			btSimpleBroadphaseProxy* proxy1 = GetSimpleProxyFromProxy(pair.m_pProxy1);
 			if ((proxy0==proxyOrg) || (proxy1==proxyOrg))
 			{
 				RemoveOverlappingPair(pair);
@@ -167,9 +167,9 @@ void	SimpleBroadphase::DestroyProxy(BroadphaseProxy* proxyOrg)
 		
 }

-void	SimpleBroadphase::SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax)
+void	btSimpleBroadphase::SetAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax)
 {
-	SimpleBroadphaseProxy* sbp = GetSimpleProxyFromProxy(proxy);
+	btSimpleBroadphaseProxy* sbp = GetSimpleProxyFromProxy(proxy);
 	sbp->m_min = aabbMin;
 	sbp->m_max = aabbMax;
 }
@@ -182,7 +182,7 @@ void	SimpleBroadphase::SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin



-bool	SimpleBroadphase::AabbOverlap(SimpleBroadphaseProxy* proxy0,SimpleBroadphaseProxy* proxy1)
+bool	btSimpleBroadphase::AabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1)
 {
 	return proxy0->m_min[0] <= proxy1->m_max[0] && proxy1->m_min[0] <= proxy0->m_max[0] && 
 		   proxy0->m_min[1] <= proxy1->m_max[1] && proxy1->m_min[1] <= proxy0->m_max[1] &&
@@ -193,28 +193,28 @@ bool	SimpleBroadphase::AabbOverlap(SimpleBroadphaseProxy* proxy0,SimpleBroadphas


 //then remove non-overlapping ones
-class CheckOverlapCallback : public OverlapCallback
+class CheckOverlapCallback : public btOverlapCallback
 {
 public:
-	virtual bool ProcessOverlap(BroadphasePair& pair)
+	virtual bool ProcessOverlap(btBroadphasePair& pair)
 	{
-		return (!SimpleBroadphase::AabbOverlap(static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy0),static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy1)));
+		return (!btSimpleBroadphase::AabbOverlap(static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0),static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1)));
 	}
 };

-void	SimpleBroadphase::RefreshOverlappingPairs()
+void	btSimpleBroadphase::RefreshOverlappingPairs()
 {
 	//first check for new overlapping pairs
 	int i,j;

 	for (i=0;i<m_numProxies;i++)
 	{
-		BroadphaseProxy* proxy0 = m_pProxies[i];
+		btBroadphaseProxy* proxy0 = m_pProxies[i];
 		for (j=i+1;j<m_numProxies;j++)
 		{
-			BroadphaseProxy* proxy1 = m_pProxies[j];
-			SimpleBroadphaseProxy* p0 = GetSimpleProxyFromProxy(proxy0);
-			SimpleBroadphaseProxy* p1 = GetSimpleProxyFromProxy(proxy1);
+			btBroadphaseProxy* proxy1 = m_pProxies[j];
+			btSimpleBroadphaseProxy* p0 = GetSimpleProxyFromProxy(proxy0);
+			btSimpleBroadphaseProxy* p1 = GetSimpleProxyFromProxy(proxy1);

 			if (AabbOverlap(p0,p1))
 			{
--- a/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
+++ b/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
@@ -20,15 +20,15 @@ subject to the following restrictions:
 #include "btOverlappingPairCache.h"


-struct SimpleBroadphaseProxy : public BroadphaseProxy
+struct btSimpleBroadphaseProxy : public btBroadphaseProxy
 {
-	SimdVector3	m_min;
-	SimdVector3	m_max;
+	btVector3	m_min;
+	btVector3	m_max;
 	
-	SimpleBroadphaseProxy() {};
+	btSimpleBroadphaseProxy() {};

-	SimpleBroadphaseProxy(const SimdPoint3& minpt,const SimdPoint3& maxpt,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
-	:BroadphaseProxy(userPtr,collisionFilterGroup,collisionFilterMask),
+	btSimpleBroadphaseProxy(const btPoint3& minpt,const btPoint3& maxpt,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
+	:btBroadphaseProxy(userPtr,collisionFilterGroup,collisionFilterMask),
 	m_min(minpt),m_max(maxpt)		
 	{
 	}
@@ -37,14 +37,14 @@ struct SimpleBroadphaseProxy : public BroadphaseProxy
 };

 ///SimpleBroadphase is a brute force aabb culling broadphase based on O(n^2) aabb checks
-class SimpleBroadphase : public OverlappingPairCache
+class btSimpleBroadphase : public btOverlappingPairCache
 {

-	SimpleBroadphaseProxy*	m_proxies;
+	btSimpleBroadphaseProxy*	m_proxies;
 	int*				m_freeProxies;
 	int				m_firstFreeProxy;

-	SimpleBroadphaseProxy** m_pProxies;
+	btSimpleBroadphaseProxy** m_pProxies;
 	int				m_numProxies;

 	
@@ -52,9 +52,9 @@ class SimpleBroadphase : public OverlappingPairCache
 	int m_maxProxies;
 	
 	
-	inline SimpleBroadphaseProxy*	GetSimpleProxyFromProxy(BroadphaseProxy* proxy)
+	inline btSimpleBroadphaseProxy*	GetSimpleProxyFromProxy(btBroadphaseProxy* proxy)
 	{
-		SimpleBroadphaseProxy* proxy0 = static_cast<SimpleBroadphaseProxy*>(proxy);
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxy);
 		return proxy0;
 	}

@@ -66,18 +66,18 @@ protected:

 	virtual void	RefreshOverlappingPairs();
 public:
-	SimpleBroadphase(int maxProxies=16384);
-	virtual ~SimpleBroadphase();
+	btSimpleBroadphase(int maxProxies=16384);
+	virtual ~btSimpleBroadphase();


-		static bool	AabbOverlap(SimpleBroadphaseProxy* proxy0,SimpleBroadphaseProxy* proxy1);
+		static bool	AabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1);


-	virtual BroadphaseProxy*	CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask);
+	virtual btBroadphaseProxy*	CreateProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask);


-	virtual void	DestroyProxy(BroadphaseProxy* proxy);
-	virtual void	SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax);
+	virtual void	DestroyProxy(btBroadphaseProxy* proxy);
+	virtual void	SetAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax);
 		
 	
 	
--- a/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h
+++ b/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;
 	}
--- a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
+++ b/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;

--- a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h
+++ b/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);

 	

--- a/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
+++ b/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)));
 }
--- a/src/BulletCollision/CollisionDispatch/btCollisionObject.h
+++ b/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;
 	}
--- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
+++ b/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
--- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
+++ b/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();

--- a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
+++ b/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;
--- a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
+++ b/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);
 		}
 	};

--- a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
+++ b/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;
 		
--- a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
+++ b/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);
 		}
 	};

--- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp
+++ b/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))
--- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
+++ b/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);
 		}
 	};

--- a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp
+++ b/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;
 }
--- a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
+++ b/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);
 		}
 	};

--- a/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp
+++ b/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);
--- a/src/BulletCollision/CollisionDispatch/btManifoldResult.h
+++ b/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);



--- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
+++ b/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)

--- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
+++ b/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);

 };

--- a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp
+++ b/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;
--- a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
+++ b/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);
 		}
 	};

--- a/src/BulletCollision/CollisionDispatch/btUnionFind.cpp
+++ b/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);

 }

--- a/src/BulletCollision/CollisionDispatch/btUnionFind.h
+++ b/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];
 	  }
--- a/src/BulletCollision/CollisionShapes/btBoxShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btBoxShape.cpp
@@ -15,23 +15,23 @@ subject to the following restrictions:

 #include "btBoxShape.h"

-SimdVector3 BoxShape::GetHalfExtents() const
+btVector3 btBoxShape::GetHalfExtents() const
 {
 	return m_boxHalfExtents1 * m_localScaling;
 }
 //{ 


-void BoxShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btBoxShape::GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	SimdVector3 halfExtents = GetHalfExtents();
+	btVector3 halfExtents = GetHalfExtents();

-	SimdMatrix3x3 abs_b = t.getBasis().absolute();  
-	SimdPoint3 center = t.getOrigin();
-	SimdVector3 extent = SimdVector3(abs_b[0].dot(halfExtents),
+	btMatrix3x3 abs_b = t.getBasis().absolute();  
+	btPoint3 center = t.getOrigin();
+	btVector3 extent = btVector3(abs_b[0].dot(halfExtents),
 		   abs_b[1].dot(halfExtents),
 		  abs_b[2].dot(halfExtents));
-	extent += SimdVector3(GetMargin(),GetMargin(),GetMargin());
+	extent += btVector3(GetMargin(),GetMargin(),GetMargin());

 	aabbMin = center - extent;
 	aabbMax = center + extent;
@@ -40,14 +40,14 @@ void BoxShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3&
 }


-void	BoxShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btBoxShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//float margin = 0.f;
-	SimdVector3 halfExtents = GetHalfExtents();
+	btVector3 halfExtents = GetHalfExtents();

-	SimdScalar lx=2.f*(halfExtents.x());
-	SimdScalar ly=2.f*(halfExtents.y());
-	SimdScalar lz=2.f*(halfExtents.z());
+	btScalar lx=2.f*(halfExtents.x());
+	btScalar ly=2.f*(halfExtents.y());
+	btScalar lz=2.f*(halfExtents.z());

 	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
 	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
--- a/src/BulletCollision/CollisionShapes/btBoxShape.h
+++ b/src/BulletCollision/CollisionShapes/btBoxShape.h
@@ -19,82 +19,82 @@ subject to the following restrictions:
 #include "btPolyhedralConvexShape.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "LinearMath/SimdPoint3.h"
-#include "LinearMath/SimdMinMax.h"
+#include "LinearMath/btPoint3.h"
+#include "LinearMath/btSimdMinMax.h"

 ///BoxShape implements both a feature based (vertex/edge/plane) and implicit (getSupportingVertex) Box
-class BoxShape: public PolyhedralConvexShape
+class btBoxShape: public btPolyhedralConvexShape
 {

-	SimdVector3	m_boxHalfExtents1;
+	btVector3	m_boxHalfExtents1;


 public:

-	SimdVector3 GetHalfExtents() const;
+	btVector3 GetHalfExtents() const;
 	//{ return m_boxHalfExtents1 * m_localScaling;}
- 	//const SimdVector3& GetHalfExtents() const{ return m_boxHalfExtents1;}
+ 	//const btVector3& GetHalfExtents() const{ return m_boxHalfExtents1;}


 	
 	virtual int	GetShapeType() const { return BOX_SHAPE_PROXYTYPE;}

-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec) const
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec) const
 	{
 		
-		SimdVector3 halfExtents = GetHalfExtents();
+		btVector3 halfExtents = GetHalfExtents();
 		
-		SimdVector3 supVertex;
-		supVertex = SimdPoint3(vec.x() < SimdScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                     vec.y() < SimdScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                     vec.z() < SimdScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+		btVector3 supVertex;
+		supVertex = btPoint3(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
+                     vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
+                     vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
  
 		return supVertex;
 	}

-	virtual inline SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+	virtual inline btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 	{
-		SimdVector3 halfExtents = GetHalfExtents();
-		SimdVector3 margin(GetMargin(),GetMargin(),GetMargin());
+		btVector3 halfExtents = GetHalfExtents();
+		btVector3 margin(GetMargin(),GetMargin(),GetMargin());
 		halfExtents -= margin;

-		return SimdVector3(vec.x() < SimdScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                    vec.y() < SimdScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                    vec.z() < SimdScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+		return btVector3(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
 	}

-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 	{
-		SimdVector3 halfExtents = GetHalfExtents();
-		SimdVector3 margin(GetMargin(),GetMargin(),GetMargin());
+		btVector3 halfExtents = GetHalfExtents();
+		btVector3 margin(GetMargin(),GetMargin(),GetMargin());
 		halfExtents -= margin;


 		for (int i=0;i<numVectors;i++)
 		{
-			const SimdVector3& vec = vectors[i];
-			supportVerticesOut[i].setValue(vec.x() < SimdScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                    vec.y() < SimdScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                    vec.z() < SimdScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+			const btVector3& vec = vectors[i];
+			supportVerticesOut[i].setValue(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
 		}

 	}


-	BoxShape( const SimdVector3& boxHalfExtents) :  m_boxHalfExtents1(boxHalfExtents){};
+	btBoxShape( const btVector3& boxHalfExtents) :  m_boxHalfExtents1(boxHalfExtents){};
 	
-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;

 	

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const
 	{
 		//this plane might not be aligned...
-		SimdVector4 plane ;
+		btVector4 plane ;
 		GetPlaneEquation(plane,i);
-		planeNormal = SimdVector3(plane.getX(),plane.getY(),plane.getZ());
+		planeNormal = btVector3(plane.getX(),plane.getY(),plane.getZ());
 		planeSupport = LocalGetSupportingVertex(-planeNormal);
 	}

@@ -115,20 +115,20 @@ public:
 	}


-	virtual void GetVertex(int i,SimdVector3& vtx) const
+	virtual void GetVertex(int i,btVector3& vtx) const
 	{
-		SimdVector3 halfExtents = GetHalfExtents();
+		btVector3 halfExtents = GetHalfExtents();

-		vtx = SimdVector3(
+		vtx = btVector3(
 				halfExtents.x() * (1-(i&1)) - halfExtents.x() * (i&1),
 				halfExtents.y() * (1-((i&2)>>1)) - halfExtents.y() * ((i&2)>>1),
 				halfExtents.z() * (1-((i&4)>>2)) - halfExtents.z() * ((i&4)>>2));
 	}
 	

-	virtual void	GetPlaneEquation(SimdVector4& plane,int i) const
+	virtual void	GetPlaneEquation(btVector4& plane,int i) const
 	{
-		SimdVector3 halfExtents = GetHalfExtents();
+		btVector3 halfExtents = GetHalfExtents();

 		switch (i)
 		{
@@ -162,7 +162,7 @@ public:
 	}

 	
-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const
 	//virtual void GetEdge(int i,Edge& edge) const
 	{
 		int edgeVert0 = 0;
@@ -233,11 +233,11 @@ public:


 	
-	virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const
+	virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const
 	{
-		SimdVector3 halfExtents = GetHalfExtents();
+		btVector3 halfExtents = GetHalfExtents();

-		//SimdScalar minDist = 2*tolerance;
+		//btScalar minDist = 2*tolerance;
 		
 		bool result =	(pt.x() <= (halfExtents.x()+tolerance)) &&
 						(pt.x() >= (-halfExtents.x()-tolerance)) &&
--- a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
@@ -21,50 +21,50 @@ subject to the following restrictions:

 ///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
 ///Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
-BvhTriangleMeshShape::BvhTriangleMeshShape(StridingMeshInterface* meshInterface)
-:TriangleMeshShape(meshInterface)
+btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface)
+:btTriangleMeshShape(meshInterface)
 {
 	//construct bvh from meshInterface
 #ifndef DISABLE_BVH

-	m_bvh = new OptimizedBvh();
+	m_bvh = new btOptimizedBvh();
 	m_bvh->Build(meshInterface);

 #endif //DISABLE_BVH

 }

-BvhTriangleMeshShape::~BvhTriangleMeshShape()
+btBvhTriangleMeshShape::~btBvhTriangleMeshShape()
 {
 	delete m_bvh;
 }

 //perform bvh tree traversal and report overlapping triangles to 'callback'
-void	BvhTriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btBvhTriangleMeshShape::ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {

 #ifdef DISABLE_BVH
 	//brute force traverse all triangles
-	TriangleMeshShape::ProcessAllTriangles(callback,aabbMin,aabbMax);
+	btTriangleMeshShape::ProcessAllTriangles(callback,aabbMin,aabbMax);
 #else

 	//first get all the nodes

 	
-	struct	MyNodeOverlapCallback : public NodeOverlapCallback
+	struct	MyNodeOverlapCallback : public btNodeOverlapCallback
 	{
-		StridingMeshInterface*	m_meshInterface;
-		TriangleCallback*		m_callback;
-		SimdVector3				m_triangle[3];
+		btStridingMeshInterface*	m_meshInterface;
+		btTriangleCallback*		m_callback;
+		btVector3				m_triangle[3];


-		MyNodeOverlapCallback(TriangleCallback* callback,StridingMeshInterface* meshInterface)
+		MyNodeOverlapCallback(btTriangleCallback* callback,btStridingMeshInterface* meshInterface)
 			:m_meshInterface(meshInterface),
 			m_callback(callback)
 		{
 		}
 				
-		virtual void ProcessNode(const OptimizedBvhNode* node)
+		virtual void ProcessNode(const btOptimizedBvhNode* node)
 		{
 			const unsigned char *vertexbase;
 			int numverts;
@@ -89,7 +89,7 @@ void	BvhTriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const

 			int* gfxbase = (int*)(indexbase+node->m_triangleIndex*indexstride);
 			
-			const SimdVector3& meshScaling = m_meshInterface->getScaling();
+			const btVector3& meshScaling = m_meshInterface->getScaling();
 			for (int j=2;j>=0;j--)
 			{
 				
@@ -99,7 +99,7 @@ void	BvhTriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const
 #endif //DEBUG_TRIANGLE_MESH
 				float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);

-				m_triangle[j] = SimdVector3(
+				m_triangle[j] = btVector3(
 					graphicsbase[0]*meshScaling.getX(),
 					graphicsbase[1]*meshScaling.getY(),
 					graphicsbase[2]*meshScaling.getZ());
@@ -125,13 +125,13 @@ void	BvhTriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const
 }


-void	BvhTriangleMeshShape::setLocalScaling(const SimdVector3& scaling)
+void	btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 {
 	if ((getLocalScaling() -scaling).length2() > SIMD_EPSILON)
 	{
-		TriangleMeshShape::setLocalScaling(scaling);
+		btTriangleMeshShape::setLocalScaling(scaling);
 		delete m_bvh;
-		m_bvh = new OptimizedBvh();
+		m_bvh = new btOptimizedBvh();
 		m_bvh->Build(m_meshInterface);
 		//rebuild the bvh...
 	}
--- a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
+++ b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
@@ -21,16 +21,16 @@ subject to the following restrictions:

 ///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
 ///Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
-class BvhTriangleMeshShape : public TriangleMeshShape
+class btBvhTriangleMeshShape : public btTriangleMeshShape
 {

-	OptimizedBvh*	m_bvh;
+	btOptimizedBvh*	m_bvh;
 	
 	
 public:
-	BvhTriangleMeshShape(StridingMeshInterface* meshInterface);
+	btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface);

-	virtual ~BvhTriangleMeshShape();
+	virtual ~btBvhTriangleMeshShape();

 	
 	/*
@@ -42,14 +42,14 @@ public:



-	virtual void	ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	virtual void	ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;


 	//debugging
 	virtual char*	GetName()const {return "BVHTRIANGLEMESH";}


-	virtual void	setLocalScaling(const SimdVector3& scaling);
+	virtual void	setLocalScaling(const btVector3& scaling);
 	


--- a/src/BulletCollision/CollisionShapes/btCollisionShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btCollisionShape.cpp
@@ -15,11 +15,11 @@ subject to the following restrictions:

 #include "BulletCollision/CollisionShapes/btCollisionShape.h"

-void	CollisionShape::GetBoundingSphere(SimdVector3& center,SimdScalar& radius) const
+void	btCollisionShape::GetBoundingSphere(btVector3& center,btScalar& radius) const
 {
-	SimdTransform tr;
+	btTransform tr;
 	tr.setIdentity();
-	SimdVector3 aabbMin,aabbMax;
+	btVector3 aabbMin,aabbMax;

 	GetAabb(tr,aabbMin,aabbMax);

@@ -27,16 +27,16 @@ void	CollisionShape::GetBoundingSphere(SimdVector3& center,SimdScalar& radius) c
 	center = (aabbMin+aabbMax)*0.5f;
 }

-float	CollisionShape::GetAngularMotionDisc() const
+float	btCollisionShape::GetAngularMotionDisc() const
 {
-	SimdVector3	center;
+	btVector3	center;
 	float disc;
 	GetBoundingSphere(center,disc);
 	disc += (center).length();
 	return disc;
 }

-void CollisionShape::CalculateTemporalAabb(const SimdTransform& curTrans,const SimdVector3& linvel,const SimdVector3& angvel,SimdScalar timeStep, SimdVector3& temporalAabbMin,SimdVector3& temporalAabbMax)
+void btCollisionShape::CalculateTemporalAabb(const btTransform& curTrans,const btVector3& linvel,const btVector3& angvel,btScalar timeStep, btVector3& temporalAabbMin,btVector3& temporalAabbMax)
 {
 	//start with static aabb
 	GetAabb(curTrans,temporalAabbMin,temporalAabbMax);
@@ -49,7 +49,7 @@ void CollisionShape::CalculateTemporalAabb(const SimdTransform& curTrans,const S
 	float temporalAabbMinz = temporalAabbMin.getZ();

 	// add linear motion
-	SimdVector3 linMotion = linvel*timeStep;
+	btVector3 linMotion = linvel*timeStep;
 	//todo: simd would have a vector max/min operation, instead of per-element access
 	if (linMotion.x() > 0.f)
 		temporalAabbMaxx += linMotion.x(); 
@@ -65,10 +65,10 @@ void CollisionShape::CalculateTemporalAabb(const SimdTransform& curTrans,const S
 		temporalAabbMinz += linMotion.z();

 	//add conservative angular motion
-	SimdScalar angularMotion = angvel.length() * GetAngularMotionDisc() * timeStep;
-	SimdVector3 angularMotion3d(angularMotion,angularMotion,angularMotion);
-	temporalAabbMin = SimdVector3(temporalAabbMinx,temporalAabbMiny,temporalAabbMinz);
-	temporalAabbMax = SimdVector3(temporalAabbMaxx,temporalAabbMaxy,temporalAabbMaxz);
+	btScalar angularMotion = angvel.length() * GetAngularMotionDisc() * timeStep;
+	btVector3 angularMotion3d(angularMotion,angularMotion,angularMotion);
+	temporalAabbMin = btVector3(temporalAabbMinx,temporalAabbMiny,temporalAabbMinz);
+	temporalAabbMax = btVector3(temporalAabbMaxx,temporalAabbMaxy,temporalAabbMaxz);

 	temporalAabbMin -= angularMotion3d;
 	temporalAabbMax += angularMotion3d;
--- a/src/BulletCollision/CollisionShapes/btCollisionShape.h
+++ b/src/BulletCollision/CollisionShapes/btCollisionShape.h
@@ -16,27 +16,27 @@ subject to the following restrictions:
 #ifndef COLLISION_SHAPE_H
 #define COLLISION_SHAPE_H

-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdVector3.h"
-#include <LinearMath/SimdMatrix3x3.h>
-#include "LinearMath/SimdPoint3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include <LinearMath/btMatrix3x3.h>
+#include "LinearMath/btPoint3.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types

 ///CollisionShape provides generic interface for collidable objects
-class CollisionShape
+class btCollisionShape
 {
 public:

-	CollisionShape() :m_tempDebug(0)
+	btCollisionShape() :m_tempDebug(0)
 	{
 	}
-	virtual ~CollisionShape()
+	virtual ~btCollisionShape()
 	{
 	}

-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const =0;
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const =0;

-	virtual void	GetBoundingSphere(SimdVector3& center,SimdScalar& radius) const;
+	virtual void	GetBoundingSphere(btVector3& center,btScalar& radius) const;

 	virtual float	GetAngularMotionDisc() const;

@@ -44,30 +44,30 @@ public:

 	///CalculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep)
 	///result is conservative
-	void CalculateTemporalAabb(const SimdTransform& curTrans,const SimdVector3& linvel,const SimdVector3& angvel,SimdScalar timeStep, SimdVector3& temporalAabbMin,SimdVector3& temporalAabbMax);
+	void CalculateTemporalAabb(const btTransform& curTrans,const btVector3& linvel,const btVector3& angvel,btScalar timeStep, btVector3& temporalAabbMin,btVector3& temporalAabbMax);

 	inline bool	IsPolyhedral() const
 	{
-		return BroadphaseProxy::IsPolyhedral(GetShapeType());
+		return btBroadphaseProxy::IsPolyhedral(GetShapeType());
 	}

 	inline bool	IsConvex() const
 	{
-		return BroadphaseProxy::IsConvex(GetShapeType());
+		return btBroadphaseProxy::IsConvex(GetShapeType());
 	}
 	inline bool	IsConcave() const
 	{
-		return BroadphaseProxy::IsConcave(GetShapeType());
+		return btBroadphaseProxy::IsConcave(GetShapeType());
 	}
 	inline bool	IsCompound() const
 	{
-		return BroadphaseProxy::IsCompound(GetShapeType());
+		return btBroadphaseProxy::IsCompound(GetShapeType());
 	}

-	virtual void	setLocalScaling(const SimdVector3& scaling) =0;
-	virtual const SimdVector3& getLocalScaling() const =0;
+	virtual void	setLocalScaling(const btVector3& scaling) =0;
+	virtual const btVector3& getLocalScaling() const =0;

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia) = 0;
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia) = 0;

 //debugging support
 	virtual char*	GetName()const =0 ;
--- a/src/BulletCollision/CollisionShapes/btCompoundShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btCompoundShape.cpp
@@ -19,7 +19,7 @@ subject to the following restrictions:
 #include "btCollisionShape.h"


-CompoundShape::CompoundShape()
+btCompoundShape::btCompoundShape()
 :m_localAabbMin(1e30f,1e30f,1e30f),
 m_localAabbMax(-1e30f,-1e30f,-1e30f),
 m_aabbTree(0),
@@ -29,17 +29,17 @@ m_localScaling(1.f,1.f,1.f)
 }


-CompoundShape::~CompoundShape()
+btCompoundShape::~btCompoundShape()
 {
 }

-void	CompoundShape::AddChildShape(const SimdTransform& localTransform,CollisionShape* shape)
+void	btCompoundShape::AddChildShape(const btTransform& localTransform,btCollisionShape* shape)
 {
 	m_childTransforms.push_back(localTransform);
 	m_childShapes.push_back(shape);

 	//extend the local aabbMin/aabbMax
-	SimdVector3 localAabbMin,localAabbMax;
+	btVector3 localAabbMin,localAabbMax;
 	shape->GetAabb(localTransform,localAabbMin,localAabbMax);
 	for (int i=0;i<3;i++)
 	{
@@ -58,37 +58,37 @@ void	CompoundShape::AddChildShape(const SimdTransform& localTransform,CollisionS


 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-void CompoundShape::GetAabb(const SimdTransform& trans,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btCompoundShape::GetAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	SimdVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	SimdVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
 	
-	SimdMatrix3x3 abs_b = trans.getBasis().absolute();  
+	btMatrix3x3 abs_b = trans.getBasis().absolute();  

-	SimdPoint3 center = trans(localCenter);
+	btPoint3 center = trans(localCenter);

-	SimdVector3 extent = SimdVector3(abs_b[0].dot(localHalfExtents),
+	btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
 		   abs_b[1].dot(localHalfExtents),
 		  abs_b[2].dot(localHalfExtents));
-	extent += SimdVector3(GetMargin(),GetMargin(),GetMargin());
+	extent += btVector3(GetMargin(),GetMargin(),GetMargin());

 	aabbMin = center - extent;
 	aabbMax = center + extent;
 }

-void	CompoundShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btCompoundShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//approximation: take the inertia from the aabb for now
-	SimdTransform ident;
+	btTransform ident;
 	ident.setIdentity();
-	SimdVector3 aabbMin,aabbMax;
+	btVector3 aabbMin,aabbMax;
 	GetAabb(ident,aabbMin,aabbMax);
 	
-	SimdVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
 	
-	SimdScalar lx=2.f*(halfExtents.x());
-	SimdScalar ly=2.f*(halfExtents.y());
-	SimdScalar lz=2.f*(halfExtents.z());
+	btScalar lx=2.f*(halfExtents.x());
+	btScalar ly=2.f*(halfExtents.y());
+	btScalar lz=2.f*(halfExtents.z());

 	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
 	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
--- a/src/BulletCollision/CollisionShapes/btCompoundShape.h
+++ b/src/BulletCollision/CollisionShapes/btCompoundShape.h
@@ -18,69 +18,69 @@ subject to the following restrictions:

 #include "btCollisionShape.h"

-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdMatrix3x3.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
 #include <vector>
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

-class OptimizedBvh;
+class btOptimizedBvh;

-/// CompoundShape allows to store multiple other CollisionShapes
-/// This allows for concave collision objects. This is more general then the Static Concave TriangleMeshShape.
-class CompoundShape	: public CollisionShape
+/// btCompoundShape allows to store multiple other btCollisionShapes
+/// This allows for concave collision objects. This is more general then the Static Concave btTriangleMeshShape.
+class btCompoundShape	: public btCollisionShape
 {
-	std::vector<SimdTransform>		m_childTransforms;
-	std::vector<CollisionShape*>	m_childShapes;
-	SimdVector3						m_localAabbMin;
-	SimdVector3						m_localAabbMax;
+	std::vector<btTransform>		m_childTransforms;
+	std::vector<btCollisionShape*>	m_childShapes;
+	btVector3						m_localAabbMin;
+	btVector3						m_localAabbMax;

-	OptimizedBvh*					m_aabbTree;
+	btOptimizedBvh*					m_aabbTree;

 public:
-	CompoundShape();
+	btCompoundShape();

-	virtual ~CompoundShape();
+	virtual ~btCompoundShape();

-	void	AddChildShape(const SimdTransform& localTransform,CollisionShape* shape);
+	void	AddChildShape(const btTransform& localTransform,btCollisionShape* shape);

 	int		GetNumChildShapes() const
 	{
 		return m_childShapes.size();
 	}

-	CollisionShape* GetChildShape(int index)
+	btCollisionShape* GetChildShape(int index)
 	{
 		return m_childShapes[index];
 	}
-	const CollisionShape* GetChildShape(int index) const
+	const btCollisionShape* GetChildShape(int index) const
 	{
 		return m_childShapes[index];
 	}

-	SimdTransform	GetChildTransform(int index)
+	btTransform	GetChildTransform(int index)
 	{
 		return m_childTransforms[index];
 	}
-	const SimdTransform	GetChildTransform(int index) const
+	const btTransform	GetChildTransform(int index) const
 	{
 		return m_childTransforms[index];
 	}

 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-	void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;


-	virtual void	setLocalScaling(const SimdVector3& scaling)
+	virtual void	setLocalScaling(const btVector3& scaling)
 	{
 		m_localScaling = scaling;
 	}
-	virtual const SimdVector3& getLocalScaling() const 
+	virtual const btVector3& getLocalScaling() const 
 	{
 		return m_localScaling;
 	}

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);
 	
 	virtual int	GetShapeType() const { return COMPOUND_SHAPE_PROXYTYPE;}

@@ -100,15 +100,15 @@ public:
 	//this is optional, but should make collision queries faster, by culling non-overlapping nodes
 	void	CreateAabbTreeFromChildren();

-	const OptimizedBvh*					GetAabbTree() const
+	const btOptimizedBvh*					GetAabbTree() const
 	{
 		return m_aabbTree;
 	}

 private:
-	SimdScalar	m_collisionMargin;
+	btScalar	m_collisionMargin;
 protected:
-	SimdVector3	m_localScaling;
+	btVector3	m_localScaling;

 };

--- a/src/BulletCollision/CollisionShapes/btConcaveShape.h
+++ b/src/BulletCollision/CollisionShapes/btConcaveShape.h
@@ -24,7 +24,7 @@ subject to the following restrictions:

 ///Concave shape proves an interface concave shapes that can produce triangles that overlapping a given AABB.
 ///Static triangle mesh, infinite plane, height field/landscapes are example that implement this interface.
-class ConcaveShape : public CollisionShape
+class ConcaveShape : public btCollisionShape
 {
 protected:
 	float m_collisionMargin;
@@ -34,7 +34,7 @@ public:

 	virtual ~ConcaveShape();

-	virtual void	ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const = 0;
+	virtual void	ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const = 0;

 	virtual float GetMargin() const {
 		return m_collisionMargin;
--- a/src/BulletCollision/CollisionShapes/btConeShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btConeShape.cpp
@@ -14,7 +14,7 @@ subject to the following restrictions:
 */

 #include "btConeShape.h"
-#include "LinearMath/SimdPoint3.h"
+#include "LinearMath/btPoint3.h"

 #ifdef WIN32
 static int coneindices[3] = {1,2,0};
@@ -22,23 +22,23 @@ static int coneindices[3] = {1,2,0};
 static int coneindices[3] = {2,1,0};
 #endif

-ConeShape::ConeShape (SimdScalar radius,SimdScalar height):
+btConeShape::btConeShape (btScalar radius,btScalar height):
 m_radius (radius),
 m_height(height)
 {
-	SimdVector3 halfExtents;
+	btVector3 halfExtents;
 	m_sinAngle = (m_radius / sqrt(m_radius * m_radius + m_height * m_height));
 }


-SimdVector3 ConeShape::ConeLocalSupport(const SimdVector3& v) const
+btVector3 btConeShape::ConeLocalSupport(const btVector3& v) const
 {
 	
 	float halfHeight = m_height * 0.5f;

 if (v[coneindices[1]] > v.length() * m_sinAngle)
 {
-	SimdVector3 tmp;
+	btVector3 tmp;

 	tmp[coneindices[0]] = 0.f;
 	tmp[coneindices[1]] = halfHeight;
@@ -46,17 +46,17 @@ SimdVector3 ConeShape::ConeLocalSupport(const SimdVector3& v) const
 	return tmp;
 }
  else {
-    SimdScalar s = SimdSqrt(v[coneindices[0]] * v[coneindices[0]] + v[coneindices[2]] * v[coneindices[2]]);
+    btScalar s = btSqrt(v[coneindices[0]] * v[coneindices[0]] + v[coneindices[2]] * v[coneindices[2]]);
    if (s > SIMD_EPSILON) {
-      SimdScalar d = m_radius / s;
-	  SimdVector3 tmp;
+      btScalar d = m_radius / s;
+	  btVector3 tmp;
 	  tmp[coneindices[0]] = v[coneindices[0]] * d;
 	  tmp[coneindices[1]] = -halfHeight;
 	  tmp[coneindices[2]] = v[coneindices[2]] * d;
 	  return tmp;
    }
    else  {
-		SimdVector3 tmp;
+		btVector3 tmp;
 		tmp[coneindices[0]] = 0.f;
 		tmp[coneindices[1]] = -halfHeight;
 		tmp[coneindices[2]] = 0.f;
@@ -66,27 +66,27 @@ SimdVector3 ConeShape::ConeLocalSupport(const SimdVector3& v) const

 }

-SimdVector3	ConeShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec) const
+btVector3	btConeShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec) const
 {
 		return ConeLocalSupport(vec);
 }

-void	ConeShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btConeShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
-		const SimdVector3& vec = vectors[i];
+		const btVector3& vec = vectors[i];
 		supportVerticesOut[i] = ConeLocalSupport(vec);
 	}
 }


-SimdVector3	ConeShape::LocalGetSupportingVertex(const SimdVector3& vec)  const
+btVector3	btConeShape::LocalGetSupportingVertex(const btVector3& vec)  const
 {
-	SimdVector3 supVertex = ConeLocalSupport(vec);
+	btVector3 supVertex = ConeLocalSupport(vec);
 	if ( GetMargin()!=0.f )
 	{
-		SimdVector3 vecnorm = vec;
+		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
 			vecnorm.setValue(-1.f,-1.f,-1.f);
--- a/src/BulletCollision/CollisionShapes/btConeShape.h
+++ b/src/BulletCollision/CollisionShapes/btConeShape.h
@@ -20,7 +20,7 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types

 /// implements cone shape interface
-class ConeShape : public ConvexShape
+class btConeShape : public btConvexShape

 {

@@ -28,40 +28,40 @@ class ConeShape : public ConvexShape
 	float m_radius;
 	float m_height;
 	
-	SimdVector3 ConeLocalSupport(const SimdVector3& v) const;
+	btVector3 ConeLocalSupport(const btVector3& v) const;


 public:
-	ConeShape (SimdScalar radius,SimdScalar height);
+	btConeShape (btScalar radius,btScalar height);
 	
-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec) const;
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec) const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

 	float GetRadius() const { return m_radius;}
 	float GetHeight() const { return m_height;}


-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia)
 	{
-		SimdTransform identity;
+		btTransform identity;
 		identity.setIdentity();
-		SimdVector3 aabbMin,aabbMax;
+		btVector3 aabbMin,aabbMax;
 		GetAabb(identity,aabbMin,aabbMax);

-		SimdVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+		btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;

 		float margin = GetMargin();

-		SimdScalar lx=2.f*(halfExtents.x()+margin);
-		SimdScalar ly=2.f*(halfExtents.y()+margin);
-		SimdScalar lz=2.f*(halfExtents.z()+margin);
-		const SimdScalar x2 = lx*lx;
-		const SimdScalar y2 = ly*ly;
-		const SimdScalar z2 = lz*lz;
-		const SimdScalar scaledmass = mass * 0.08333333f;
+		btScalar lx=2.f*(halfExtents.x()+margin);
+		btScalar ly=2.f*(halfExtents.y()+margin);
+		btScalar lz=2.f*(halfExtents.z()+margin);
+		const btScalar x2 = lx*lx;
+		const btScalar y2 = ly*ly;
+		const btScalar z2 = lz*lz;
+		const btScalar scaledmass = mass * 0.08333333f;

-		inertia = scaledmass * (SimdVector3(y2+z2,x2+z2,x2+y2));
+		inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));

 //		inertia.x() = scaledmass * (y2+z2);
 //		inertia.y() = scaledmass * (x2+z2);
--- a/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
@@ -15,41 +15,41 @@ subject to the following restrictions:
 #include "btConvexHullShape.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

-#include "LinearMath/SimdQuaternion.h"
+#include "LinearMath/btQuaternion.h"


-ConvexHullShape ::ConvexHullShape (SimdPoint3* points,int numPoints,int stride)
+btConvexHullShape ::btConvexHullShape (btPoint3* points,int numPoints,int stride)
 {
 	m_points.resize(numPoints);
 	unsigned char* pointsBaseAddress = (unsigned char*)points;

 	for (int i=0;i<numPoints;i++)
 	{
-		SimdPoint3* point = (SimdPoint3*)(pointsBaseAddress + i*stride);
+		btPoint3* point = (btPoint3*)(pointsBaseAddress + i*stride);
 		m_points[i] = point[0];
 	}
 }

-SimdVector3	ConvexHullShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec0)const
+btVector3	btConvexHullShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	SimdVector3 supVec(0.f,0.f,0.f);
-	SimdScalar newDot,maxDot = -1e30f;
+	btVector3 supVec(0.f,0.f,0.f);
+	btScalar newDot,maxDot = -1e30f;

-	SimdVector3 vec = vec0;
-	SimdScalar lenSqr = vec.length2();
+	btVector3 vec = vec0;
+	btScalar lenSqr = vec.length2();
 	if (lenSqr < 0.0001f)
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / SimdSqrt(lenSqr );
+		float rlen = 1.f / btSqrt(lenSqr );
 		vec *= rlen;
 	}


 	for (size_t i=0;i<m_points.size();i++)
 	{
-		SimdPoint3 vtx = m_points[i] * m_localScaling;
+		btPoint3 vtx = m_points[i] * m_localScaling;

 		newDot = vec.dot(vtx);
 		if (newDot > maxDot)
@@ -61,9 +61,9 @@ SimdVector3	ConvexHullShape::LocalGetSupportingVertexWithoutMargin(const SimdVec
 	return supVec;
 }

-void	ConvexHullShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btConvexHullShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
-	SimdScalar newDot;
+	btScalar newDot;
 	//use 'w' component of supportVerticesOut?
 	{
 		for (int i=0;i<numVectors;i++)
@@ -73,11 +73,11 @@ void	ConvexHullShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const Si
 	}
 	for (size_t i=0;i<m_points.size();i++)
 	{
-		SimdPoint3 vtx = m_points[i] * m_localScaling;
+		btPoint3 vtx = m_points[i] * m_localScaling;

 		for (int j=0;j<numVectors;j++)
 		{
-			const SimdVector3& vec = vectors[j];
+			const btVector3& vec = vectors[j];
 			
 			newDot = vec.dot(vtx);
 			if (newDot > supportVerticesOut[j][3])
@@ -95,13 +95,13 @@ void	ConvexHullShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const Si
 	


-SimdVector3	ConvexHullShape::LocalGetSupportingVertex(const SimdVector3& vec)const
+btVector3	btConvexHullShape::LocalGetSupportingVertex(const btVector3& vec)const
 {
-	SimdVector3 supVertex = LocalGetSupportingVertexWithoutMargin(vec);
+	btVector3 supVertex = LocalGetSupportingVertexWithoutMargin(vec);

 	if ( GetMargin()!=0.f )
 	{
-		SimdVector3 vecnorm = vec;
+		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
 			vecnorm.setValue(-1.f,-1.f,-1.f);
@@ -121,18 +121,18 @@ SimdVector3	ConvexHullShape::LocalGetSupportingVertex(const SimdVector3& vec)con


 //currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection
-//Please note that you can debug-draw ConvexHullShape with the Raytracer Demo
-int	ConvexHullShape::GetNumVertices() const
+//Please note that you can debug-draw btConvexHullShape with the Raytracer Demo
+int	btConvexHullShape::GetNumVertices() const
 {
 	return m_points.size();
 }

-int ConvexHullShape::GetNumEdges() const
+int btConvexHullShape::GetNumEdges() const
 {
 	return m_points.size()*m_points.size();
 }

-void ConvexHullShape::GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
+void btConvexHullShape::GetEdge(int i,btPoint3& pa,btPoint3& pb) const
 {

 	int index0 = i%m_points.size();
@@ -141,23 +141,23 @@ void ConvexHullShape::GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
 	pb = m_points[index1]*m_localScaling;
 }

-void ConvexHullShape::GetVertex(int i,SimdPoint3& vtx) const
+void btConvexHullShape::GetVertex(int i,btPoint3& vtx) const
 {
 	vtx = m_points[i]*m_localScaling;
 }

-int	ConvexHullShape::GetNumPlanes() const
+int	btConvexHullShape::GetNumPlanes() const
 {
 	return 0;
 }

-void ConvexHullShape::GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const
+void btConvexHullShape::GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const
 {
 	assert(0);
 }

 //not yet
-bool ConvexHullShape::IsInside(const SimdPoint3& pt,SimdScalar tolerance) const
+bool btConvexHullShape::IsInside(const btPoint3& pt,btScalar tolerance) const
 {
 	assert(0);
 	return false;
--- a/src/BulletCollision/CollisionShapes/btConvexHullShape.h
+++ b/src/BulletCollision/CollisionShapes/btConvexHullShape.h
@@ -25,20 +25,20 @@ subject to the following restrictions:
 ///No connectivity is needed. LocalGetSupportingVertex iterates linearly though all vertices.
 ///on modern hardware, due to cache coherency this isn't that bad. Complex algorithms tend to trash the cash.
 ///(memory is much slower then the cpu)
-class ConvexHullShape : public PolyhedralConvexShape
+class btConvexHullShape : public btPolyhedralConvexShape
 {
-	std::vector<SimdPoint3>	m_points;
+	std::vector<btPoint3>	m_points;

 public:
-	ConvexHullShape(SimdPoint3* points,int numPoints, int stride=sizeof(SimdPoint3));
+	btConvexHullShape(btPoint3* points,int numPoints, int stride=sizeof(btPoint3));

-	void AddPoint(const SimdPoint3& point)
+	void AddPoint(const btPoint3& point)
 	{
 		m_points.push_back(point);
 	}
-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec)const;
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
 	

 	virtual int	GetShapeType()const { return CONVEX_HULL_SHAPE_PROXYTYPE; }
@@ -49,11 +49,11 @@ public:
 	
 	virtual int	GetNumVertices() const;
 	virtual int GetNumEdges() const;
-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const;
-	virtual void GetVertex(int i,SimdPoint3& vtx) const;
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const;
+	virtual void GetVertex(int i,btPoint3& vtx) const;
 	virtual int	GetNumPlanes() const;
-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const;
-	virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const;
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const;
+	virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const;



--- a/src/BulletCollision/CollisionShapes/btConvexShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btConvexShape.cpp
@@ -15,32 +15,32 @@ subject to the following restrictions:

 #include "btConvexShape.h"

-ConvexShape::ConvexShape()
+btConvexShape::btConvexShape()
 :m_collisionMargin(CONVEX_DISTANCE_MARGIN),
 m_localScaling(1.f,1.f,1.f)
 {
 }


-void	ConvexShape::setLocalScaling(const SimdVector3& scaling)
+void	btConvexShape::setLocalScaling(const btVector3& scaling)
 {
 	m_localScaling = scaling;
 }



-void	ConvexShape::GetAabbSlow(const SimdTransform& trans,SimdVector3&minAabb,SimdVector3&maxAabb) const
+void	btConvexShape::GetAabbSlow(const btTransform& trans,btVector3&minAabb,btVector3&maxAabb) const
 {

-	SimdScalar margin = GetMargin();
+	btScalar margin = GetMargin();
 	for (int i=0;i<3;i++)
 	{
-		SimdVector3 vec(0.f,0.f,0.f);
+		btVector3 vec(0.f,0.f,0.f);
 		vec[i] = 1.f;

-		SimdVector3 sv = LocalGetSupportingVertex(vec*trans.getBasis());
+		btVector3 sv = LocalGetSupportingVertex(vec*trans.getBasis());

-		SimdVector3 tmp = trans(sv);
+		btVector3 tmp = trans(sv);
 		maxAabb[i] = tmp[i]+margin;
 		vec[i] = -1.f;
 		tmp = trans(LocalGetSupportingVertex(vec*trans.getBasis()));
@@ -48,13 +48,13 @@ void	ConvexShape::GetAabbSlow(const SimdTransform& trans,SimdVector3&minAabb,Sim
 	}
 };

-SimdVector3	ConvexShape::LocalGetSupportingVertex(const SimdVector3& vec)const
+btVector3	btConvexShape::LocalGetSupportingVertex(const btVector3& vec)const
 {
-	 SimdVector3	supVertex = LocalGetSupportingVertexWithoutMargin(vec);
+	 btVector3	supVertex = LocalGetSupportingVertexWithoutMargin(vec);

 	if ( GetMargin()!=0.f )
 	{
-		SimdVector3 vecnorm = vec;
+		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
 			vecnorm.setValue(-1.f,-1.f,-1.f);
--- a/src/BulletCollision/CollisionShapes/btConvexShape.h
+++ b/src/BulletCollision/CollisionShapes/btConvexShape.h
@@ -18,45 +18,45 @@ subject to the following restrictions:

 #include "btCollisionShape.h"

-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdMatrix3x3.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
 #include <vector>
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

-//todo: get rid of this ConvexCastResult thing!
-struct ConvexCastResult;
+//todo: get rid of this btConvexCastResult thing!
+struct btConvexCastResult;


-/// ConvexShape is an abstract shape interface.
+/// btConvexShape is an abstract shape interface.
 /// The explicit part provides plane-equations, the implicit part provides GetClosestPoint interface.
-/// used in combination with GJK or ConvexCast
-class ConvexShape : public CollisionShape
+/// used in combination with GJK or btConvexCast
+class btConvexShape : public btCollisionShape
 {
 public:
-	ConvexShape();
+	btConvexShape();

-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec)const;
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec) const= 0;
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec) const= 0;
 	
 	//notice that the vectors should be unit length
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const= 0;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const= 0;

 	// testing for hullnode code

 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-	void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+	void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 	{
 		GetAabbSlow(t,aabbMin,aabbMax);
 	}


 	
-	virtual void GetAabbSlow(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	virtual void GetAabbSlow(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;


-	virtual void	setLocalScaling(const SimdVector3& scaling);
-	virtual const SimdVector3& getLocalScaling() const 
+	virtual void	setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const 
 	{
 		return m_localScaling;
 	}
@@ -71,10 +71,10 @@ public:
 		return m_collisionMargin;
 	}
 private:
-	SimdScalar	m_collisionMargin;
+	btScalar	m_collisionMargin;
 	//local scaling. collisionMargin is not scaled !
 protected:
-	SimdVector3	m_localScaling;
+	btVector3	m_localScaling;

 };

--- a/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
@@ -15,11 +15,11 @@ subject to the following restrictions:
 #include "btConvexTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

-#include "LinearMath/SimdQuaternion.h"
+#include "LinearMath/btQuaternion.h"
 #include "BulletCollision/CollisionShapes/btStridingMeshInterface.h"


-ConvexTriangleMeshShape ::ConvexTriangleMeshShape (StridingMeshInterface* meshInterface)
+btConvexTriangleMeshShape ::btConvexTriangleMeshShape (btStridingMeshInterface* meshInterface)
 :m_stridingMesh(meshInterface)
 {
 }
@@ -29,27 +29,27 @@ ConvexTriangleMeshShape ::ConvexTriangleMeshShape (StridingMeshInterface* meshIn

 ///It's not nice to have all this virtual function overhead, so perhaps we can also gather the points once
 ///but then we are duplicating
-class LocalSupportVertexCallback: public InternalTriangleIndexCallback
+class LocalSupportVertexCallback: public btInternalTriangleIndexCallback
 {

-	SimdVector3 m_supportVertexLocal;
+	btVector3 m_supportVertexLocal;
 public:

-	SimdScalar m_maxDot;
-	SimdVector3 m_supportVecLocal;
+	btScalar m_maxDot;
+	btVector3 m_supportVecLocal;

-	LocalSupportVertexCallback(const SimdVector3& supportVecLocal)
+	LocalSupportVertexCallback(const btVector3& supportVecLocal)
 		: m_supportVertexLocal(0.f,0.f,0.f),
 		m_maxDot(-1e30f),
                m_supportVecLocal(supportVecLocal)
 	{
 	}

-	virtual void InternalProcessTriangleIndex(SimdVector3* triangle,int partId,int  triangleIndex)
+	virtual void InternalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
 	{
 		for (int i=0;i<3;i++)
 		{
-			SimdScalar dot = m_supportVecLocal.dot(triangle[i]);
+			btScalar dot = m_supportVecLocal.dot(triangle[i]);
 			if (dot > m_maxDot)
 			{
 				m_maxDot = dot;
@@ -58,7 +58,7 @@ public:
 		}
 	}
 	
-	SimdVector3	GetSupportVertexLocal()
+	btVector3	GetSupportVertexLocal()
 	{
 		return m_supportVertexLocal;
 	}
@@ -69,30 +69,30 @@ public:



-SimdVector3	ConvexTriangleMeshShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec0)const
+btVector3	btConvexTriangleMeshShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	SimdVector3 supVec(0.f,0.f,0.f);
+	btVector3 supVec(0.f,0.f,0.f);

-	SimdVector3 vec = vec0;
-	SimdScalar lenSqr = vec.length2();
+	btVector3 vec = vec0;
+	btScalar lenSqr = vec.length2();
 	if (lenSqr < 0.0001f)
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / SimdSqrt(lenSqr );
+		float rlen = 1.f / btSqrt(lenSqr );
 		vec *= rlen;
 	}

 	LocalSupportVertexCallback	supportCallback(vec);
-	SimdVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(1e30f,1e30f,1e30f);
 	m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 	supVec = supportCallback.GetSupportVertexLocal();

 	return supVec;
 }

-void	ConvexTriangleMeshShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btConvexTriangleMeshShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	//use 'w' component of supportVerticesOut?
 	{
@@ -107,9 +107,9 @@ void	ConvexTriangleMeshShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(

 	for (int j=0;j<numVectors;j++)
 	{
-		const SimdVector3& vec = vectors[j];
+		const btVector3& vec = vectors[j];
 		LocalSupportVertexCallback	supportCallback(vec);
-		SimdVector3 aabbMax(1e30f,1e30f,1e30f);
+		btVector3 aabbMax(1e30f,1e30f,1e30f);
 		m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		supportVerticesOut[j] = supportCallback.GetSupportVertexLocal();
 	}
@@ -118,13 +118,13 @@ void	ConvexTriangleMeshShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(
 	


-SimdVector3	ConvexTriangleMeshShape::LocalGetSupportingVertex(const SimdVector3& vec)const
+btVector3	btConvexTriangleMeshShape::LocalGetSupportingVertex(const btVector3& vec)const
 {
-	SimdVector3 supVertex = LocalGetSupportingVertexWithoutMargin(vec);
+	btVector3 supVertex = LocalGetSupportingVertexWithoutMargin(vec);

 	if ( GetMargin()!=0.f )
 	{
-		SimdVector3 vecnorm = vec;
+		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
 			vecnorm.setValue(-1.f,-1.f,-1.f);
@@ -144,8 +144,8 @@ SimdVector3	ConvexTriangleMeshShape::LocalGetSupportingVertex(const SimdVector3&


 //currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection
-//Please note that you can debug-draw ConvexTriangleMeshShape with the Raytracer Demo
-int	ConvexTriangleMeshShape::GetNumVertices() const
+//Please note that you can debug-draw btConvexTriangleMeshShape with the Raytracer Demo
+int	btConvexTriangleMeshShape::GetNumVertices() const
 {
 	//cache this?
 	assert(0);
@@ -153,34 +153,34 @@ int	ConvexTriangleMeshShape::GetNumVertices() const
 	
 }

-int ConvexTriangleMeshShape::GetNumEdges() const
+int btConvexTriangleMeshShape::GetNumEdges() const
 {
 	assert(0);	
 	return 0;
 }

-void ConvexTriangleMeshShape::GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
+void btConvexTriangleMeshShape::GetEdge(int i,btPoint3& pa,btPoint3& pb) const
 {
 	assert(0);	
 }

-void ConvexTriangleMeshShape::GetVertex(int i,SimdPoint3& vtx) const
+void btConvexTriangleMeshShape::GetVertex(int i,btPoint3& vtx) const
 {
 	assert(0);
 }

-int	ConvexTriangleMeshShape::GetNumPlanes() const
+int	btConvexTriangleMeshShape::GetNumPlanes() const
 {
 	return 0;
 }

-void ConvexTriangleMeshShape::GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const
+void btConvexTriangleMeshShape::GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const
 {
 	assert(0);
 }

 //not yet
-bool ConvexTriangleMeshShape::IsInside(const SimdPoint3& pt,SimdScalar tolerance) const
+bool btConvexTriangleMeshShape::IsInside(const btPoint3& pt,btScalar tolerance) const
 {
 	assert(0);
 	return false;
@@ -188,7 +188,7 @@ bool ConvexTriangleMeshShape::IsInside(const SimdPoint3& pt,SimdScalar tolerance



-void	ConvexTriangleMeshShape::setLocalScaling(const SimdVector3& scaling)
+void	btConvexTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 {
 	m_stridingMesh->setScaling(scaling);
 }
--- a/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
+++ b/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
@@ -7,24 +7,24 @@

 #include <vector>

-/// ConvexTriangleMeshShape is a convex hull of a triangle mesh. If you just have a point cloud, you can use ConvexHullShape instead.
-/// It uses the StridingMeshInterface instead of a point cloud. This can avoid the duplication of the triangle mesh data.
-class ConvexTriangleMeshShape : public PolyhedralConvexShape
+/// btConvexTriangleMeshShape is a convex hull of a triangle mesh. If you just have a point cloud, you can use btConvexHullShape instead.
+/// It uses the btStridingMeshInterface instead of a point cloud. This can avoid the duplication of the triangle mesh data.
+class btConvexTriangleMeshShape : public btPolyhedralConvexShape
 {

-	class StridingMeshInterface*	m_stridingMesh;
+	class btStridingMeshInterface*	m_stridingMesh;

 public:
-	ConvexTriangleMeshShape(StridingMeshInterface* meshInterface);
+	btConvexTriangleMeshShape(btStridingMeshInterface* meshInterface);

-	class StridingMeshInterface*	GetStridingMesh()
+	class btStridingMeshInterface*	GetStridingMesh()
 	{
 		return m_stridingMesh;
 	}
 	
-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec)const;
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
 	
 	virtual int	GetShapeType()const { return CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE; }

@@ -33,14 +33,14 @@ public:
 	
 	virtual int	GetNumVertices() const;
 	virtual int GetNumEdges() const;
-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const;
-	virtual void GetVertex(int i,SimdPoint3& vtx) const;
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const;
+	virtual void GetVertex(int i,btPoint3& vtx) const;
 	virtual int	GetNumPlanes() const;
-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const;
-	virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const;
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const;
+	virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const;

 	
-	void	setLocalScaling(const SimdVector3& scaling);
+	void	setLocalScaling(const btVector3& scaling);

 };

--- a/src/BulletCollision/CollisionShapes/btCylinderShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btCylinderShape.cpp
@@ -13,29 +13,29 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 #include "btCylinderShape.h"
-#include "LinearMath/SimdPoint3.h"
+#include "LinearMath/btPoint3.h"

-CylinderShape::CylinderShape (const SimdVector3& halfExtents)
-:BoxShape(halfExtents)
+btCylinderShape::btCylinderShape (const btVector3& halfExtents)
+:btBoxShape(halfExtents)
 {

 }


-CylinderShapeX::CylinderShapeX (const SimdVector3& halfExtents)
-:CylinderShape(halfExtents)
+btCylinderShapeX::btCylinderShapeX (const btVector3& halfExtents)
+:btCylinderShape(halfExtents)
 {
 }


-CylinderShapeZ::CylinderShapeZ (const SimdVector3& halfExtents)
-:CylinderShape(halfExtents)
+btCylinderShapeZ::btCylinderShapeZ (const btVector3& halfExtents)
+:btCylinderShape(halfExtents)
 {
 }



-inline SimdVector3 CylinderLocalSupportX(const SimdVector3& halfExtents,const SimdVector3& v) 
+inline btVector3 CylinderLocalSupportX(const btVector3& halfExtents,const btVector3& v) 
 {
 const int cylinderUpAxis = 0;
 const int XX = 1;
@@ -50,11 +50,11 @@ const int ZZ = 2;
 	float halfHeight = halfExtents[cylinderUpAxis];


-    SimdVector3 tmp;
-	SimdScalar d ;
+    btVector3 tmp;
+	btScalar d ;

-    SimdScalar s = SimdSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
-    if (s != SimdScalar(0.0))
+    btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
+    if (s != btScalar(0.0))
 	{
        d = radius / s;  
 		tmp[XX] = v[XX] * d;
@@ -66,7 +66,7 @@ const int ZZ = 2;
 	{
 	    tmp[XX] = radius;
 		tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight;
-		tmp[ZZ] = SimdScalar(0.0);
+		tmp[ZZ] = btScalar(0.0);
 		return tmp;
    }

@@ -78,7 +78,7 @@ const int ZZ = 2;



-inline  SimdVector3 CylinderLocalSupportY(const SimdVector3& halfExtents,const SimdVector3& v) 
+inline  btVector3 CylinderLocalSupportY(const btVector3& halfExtents,const btVector3& v) 
 {

 const int cylinderUpAxis = 1;
@@ -91,11 +91,11 @@ const int ZZ = 2;
 	float halfHeight = halfExtents[cylinderUpAxis];


-    SimdVector3 tmp;
-	SimdScalar d ;
+    btVector3 tmp;
+	btScalar d ;

-    SimdScalar s = SimdSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
-    if (s != SimdScalar(0.0))
+    btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
+    if (s != btScalar(0.0))
 	{
        d = radius / s;  
 		tmp[XX] = v[XX] * d;
@@ -107,13 +107,13 @@ const int ZZ = 2;
 	{
 	    tmp[XX] = radius;
 		tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight;
-		tmp[ZZ] = SimdScalar(0.0);
+		tmp[ZZ] = btScalar(0.0);
 		return tmp;
    }

 }

-inline SimdVector3 CylinderLocalSupportZ(const SimdVector3& halfExtents,const SimdVector3& v) 
+inline btVector3 CylinderLocalSupportZ(const btVector3& halfExtents,const btVector3& v) 
 {
 const int cylinderUpAxis = 2;
 const int XX = 0;
@@ -128,11 +128,11 @@ const int ZZ = 1;
 	float halfHeight = halfExtents[cylinderUpAxis];


-    SimdVector3 tmp;
-	SimdScalar d ;
+    btVector3 tmp;
+	btScalar d ;

-    SimdScalar s = SimdSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
-    if (s != SimdScalar(0.0))
+    btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]);
+    if (s != btScalar(0.0))
 	{
        d = radius / s;  
 		tmp[XX] = v[XX] * d;
@@ -144,29 +144,29 @@ const int ZZ = 1;
 	{
 	    tmp[XX] = radius;
 		tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight;
-		tmp[ZZ] = SimdScalar(0.0);
+		tmp[ZZ] = btScalar(0.0);
 		return tmp;
    }


 }

-SimdVector3	CylinderShapeX::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+btVector3	btCylinderShapeX::LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
 	return CylinderLocalSupportX(GetHalfExtents(),vec);
 }


-SimdVector3	CylinderShapeZ::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+btVector3	btCylinderShapeZ::LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
 	return CylinderLocalSupportZ(GetHalfExtents(),vec);
 }
-SimdVector3	CylinderShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+btVector3	btCylinderShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
 	return CylinderLocalSupportY(GetHalfExtents(),vec);
 }

-void	CylinderShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btCylinderShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
@@ -174,7 +174,7 @@ void	CylinderShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const Simd
 	}
 }

-void	CylinderShapeZ::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btCylinderShapeZ::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
@@ -185,7 +185,7 @@ void	CylinderShapeZ::BatchedUnitVectorGetSupportingVertexWithoutMargin(const Sim



-void	CylinderShapeX::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btCylinderShapeX::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
--- a/src/BulletCollision/CollisionShapes/btCylinderShape.h
+++ b/src/BulletCollision/CollisionShapes/btCylinderShape.h
@@ -18,35 +18,35 @@ subject to the following restrictions:

 #include "btBoxShape.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btVector3.h"

 /// implements cylinder shape interface
-class CylinderShape : public BoxShape
+class btCylinderShape : public btBoxShape

 {

 public:
-	CylinderShape (const SimdVector3& halfExtents);
+	btCylinderShape (const btVector3& halfExtents);
 	
 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-	void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+	void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 	{
 		GetAabbSlow(t,aabbMin,aabbMax);
 	}

-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;

-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec) const
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec) const
 	{

-		SimdVector3 supVertex;
+		btVector3 supVertex;
 		supVertex = LocalGetSupportingVertexWithoutMargin(vec);
 		
 		if ( GetMargin()!=0.f )
 		{
-			SimdVector3 vecnorm = vec;
+			btVector3 vecnorm = vec;
 			if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 			{
 				vecnorm.setValue(-1.f,-1.f,-1.f);
@@ -59,7 +59,7 @@ public:


 	//use box inertia
-	//	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	//	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

 	virtual int	GetShapeType() const
 	{
@@ -86,13 +86,13 @@ public:

 };

-class CylinderShapeX : public CylinderShape
+class btCylinderShapeX : public btCylinderShape
 {
 public:
-	CylinderShapeX (const SimdVector3& halfExtents);
+	btCylinderShapeX (const btVector3& halfExtents);

-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
 	virtual int	GetUpAxis() const
 	{
 		return 0;
@@ -110,13 +110,13 @@ public:

 };

-class CylinderShapeZ : public CylinderShape
+class btCylinderShapeZ : public btCylinderShape
 {
 public:
-	CylinderShapeZ (const SimdVector3& halfExtents);
+	btCylinderShapeZ (const btVector3& halfExtents);

-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

 	virtual int	GetUpAxis() const
 	{
--- a/src/BulletCollision/CollisionShapes/btEmptyShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btEmptyShape.cpp
@@ -19,20 +19,20 @@ subject to the following restrictions:
 #include "btCollisionShape.h"


-EmptyShape::EmptyShape()
+btEmptyShape::btEmptyShape()
 {
 }


-EmptyShape::~EmptyShape()
+btEmptyShape::~btEmptyShape()
 {
 }


 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-void EmptyShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btEmptyShape::GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	SimdVector3 margin(GetMargin(),GetMargin(),GetMargin());
+	btVector3 margin(GetMargin(),GetMargin(),GetMargin());

 	aabbMin = t.getOrigin() - margin;

@@ -40,7 +40,7 @@ void EmptyShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3

 }

-void	EmptyShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btEmptyShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	assert(0);
 }
--- a/src/BulletCollision/CollisionShapes/btEmptyShape.h
+++ b/src/BulletCollision/CollisionShapes/btEmptyShape.h
@@ -18,39 +18,39 @@ subject to the following restrictions:

 #include "btConcaveShape.h"

-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdMatrix3x3.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
 #include <vector>
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"




-/// EmptyShape is a collision shape without actual collision detection. 
+/// btEmptyShape is a collision shape without actual collision detection. 
 ///It can be replaced by another shape during runtime
-class EmptyShape	: public ConcaveShape
+class btEmptyShape	: public ConcaveShape
 {
 public:
-	EmptyShape();
+	btEmptyShape();

-	virtual ~EmptyShape();
+	virtual ~btEmptyShape();


 	///GetAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-	void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;


-	virtual void	setLocalScaling(const SimdVector3& scaling)
+	virtual void	setLocalScaling(const btVector3& scaling)
 	{
 		m_localScaling = scaling;
 	}
-	virtual const SimdVector3& getLocalScaling() const 
+	virtual const btVector3& getLocalScaling() const 
 	{
 		return m_localScaling;
 	}

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);
 	
 	virtual int	GetShapeType() const { return EMPTY_SHAPE_PROXYTYPE;}

@@ -62,7 +62,7 @@ public:


 protected:
-	SimdVector3	m_localScaling;
+	btVector3	m_localScaling;

 };

--- a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #include "btMinkowskiSumShape.h"


-MinkowskiSumShape::MinkowskiSumShape(ConvexShape* shapeA,ConvexShape* shapeB)
+btMinkowskiSumShape::btMinkowskiSumShape(btConvexShape* shapeA,btConvexShape* shapeB)
 :m_shapeA(shapeA),
 m_shapeB(shapeB)
 {
@@ -24,14 +24,14 @@ m_shapeB(shapeB)
 	m_transB.setIdentity();
 }

-SimdVector3 MinkowskiSumShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+btVector3 btMinkowskiSumShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
-	SimdVector3 supVertexA = m_transA(m_shapeA->LocalGetSupportingVertexWithoutMargin(vec*m_transA.getBasis()));
-	SimdVector3 supVertexB = m_transB(m_shapeB->LocalGetSupportingVertexWithoutMargin(vec*m_transB.getBasis()));
+	btVector3 supVertexA = m_transA(m_shapeA->LocalGetSupportingVertexWithoutMargin(vec*m_transA.getBasis()));
+	btVector3 supVertexB = m_transB(m_shapeB->LocalGetSupportingVertexWithoutMargin(vec*m_transB.getBasis()));
 	return supVertexA + supVertexB;
 }

-void	MinkowskiSumShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btMinkowskiSumShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	//todo: could make recursive use of batching. probably this shape is not used frequently.
 	for (int i=0;i<numVectors;i++)
@@ -43,13 +43,13 @@ void	MinkowskiSumShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const



-float	MinkowskiSumShape::GetMargin() const
+float	btMinkowskiSumShape::GetMargin() const
 {
 	return m_shapeA->GetMargin() + m_shapeB->GetMargin();
 }


-void	MinkowskiSumShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btMinkowskiSumShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	assert(0);
 	inertia.setValue(0,0,0);
--- a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
+++ b/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
@@ -19,39 +19,39 @@ subject to the following restrictions:
 #include "btConvexShape.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types

-/// MinkowskiSumShape represents implicit (getSupportingVertex) based minkowski sum of two convex implicit shapes.
-class MinkowskiSumShape : public ConvexShape
+/// btMinkowskiSumShape represents implicit (getSupportingVertex) based minkowski sum of two convex implicit shapes.
+class btMinkowskiSumShape : public btConvexShape
 {

-	SimdTransform	m_transA;
-	SimdTransform	m_transB;
-	ConvexShape*	m_shapeA;
-	ConvexShape*	m_shapeB;
+	btTransform	m_transA;
+	btTransform	m_transB;
+	btConvexShape*	m_shapeA;
+	btConvexShape*	m_shapeB;

 public:

-	MinkowskiSumShape(ConvexShape* shapeA,ConvexShape* shapeB);
+	btMinkowskiSumShape(btConvexShape* shapeA,btConvexShape* shapeB);

-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;

-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;


-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	void	SetTransformA(const SimdTransform&	transA) { m_transA = transA;}
-	void	SetTransformB(const SimdTransform&	transB) { m_transB = transB;}
+	void	SetTransformA(const btTransform&	transA) { m_transA = transA;}
+	void	SetTransformB(const btTransform&	transB) { m_transB = transB;}

-	const SimdTransform& GetTransformA()const  { return m_transA;}
-	const SimdTransform& GetTransformB()const  { return m_transB;}
+	const btTransform& GetTransformA()const  { return m_transA;}
+	const btTransform& GetTransformB()const  { return m_transB;}


 	virtual int	GetShapeType() const { return MINKOWSKI_SUM_SHAPE_PROXYTYPE; }

 	virtual float	GetMargin() const;

-	const ConvexShape*	GetShapeA() const { return m_shapeA;}
-	const ConvexShape*	GetShapeB() const { return m_shapeB;}
+	const btConvexShape*	GetShapeA() const { return m_shapeA;}
+	const btConvexShape*	GetShapeB() const { return m_shapeB;}

 	virtual char*	GetName()const 
 	{
--- a/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
@@ -15,9 +15,9 @@ subject to the following restrictions:

 #include "btMultiSphereShape.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"
-#include "LinearMath/SimdQuaternion.h"
+#include "LinearMath/btQuaternion.h"

-MultiSphereShape::MultiSphereShape (const SimdVector3& inertiaHalfExtents,const SimdVector3* positions,const SimdScalar* radi,int numSpheres)
+btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,const btVector3* positions,const btScalar* radi,int numSpheres)
 :m_inertiaHalfExtents(inertiaHalfExtents)
 {
 	m_minRadius = 1e30f;
@@ -37,30 +37,30 @@ MultiSphereShape::MultiSphereShape (const SimdVector3& inertiaHalfExtents,const


 
- SimdVector3	MultiSphereShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec0)const
+ btVector3	btMultiSphereShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
 	int i;
-	SimdVector3 supVec(0,0,0);
+	btVector3 supVec(0,0,0);

-	SimdScalar maxDot(-1e30f);
+	btScalar maxDot(-1e30f);


-	SimdVector3 vec = vec0;
-	SimdScalar lenSqr = vec.length2();
+	btVector3 vec = vec0;
+	btScalar lenSqr = vec.length2();
 	if (lenSqr < 0.0001f)
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / SimdSqrt(lenSqr );
+		float rlen = 1.f / btSqrt(lenSqr );
 		vec *= rlen;
 	}

-	SimdVector3 vtx;
-	SimdScalar newDot;
+	btVector3 vtx;
+	btScalar newDot;

-	const SimdVector3* pos = &m_localPositions[0];
-	const SimdScalar* rad = &m_radi[0];
+	const btVector3* pos = &m_localPositions[0];
+	const btScalar* rad = &m_radi[0];

 	for (i=0;i<m_numSpheres;i++)
 	{
@@ -79,20 +79,20 @@ MultiSphereShape::MultiSphereShape (const SimdVector3& inertiaHalfExtents,const

 }

- void	MultiSphereShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+ void	btMultiSphereShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {

 	for (int j=0;j<numVectors;j++)
 	{
-		SimdScalar maxDot(-1e30f);
+		btScalar maxDot(-1e30f);

-		const SimdVector3& vec = vectors[j];
+		const btVector3& vec = vectors[j];

-		SimdVector3 vtx;
-		SimdScalar newDot;
+		btVector3 vtx;
+		btScalar newDot;

-		const SimdVector3* pos = &m_localPositions[0];
-		const SimdScalar* rad = &m_radi[0];
+		const btVector3* pos = &m_localPositions[0];
+		const btScalar* rad = &m_radi[0];

 		for (int i=0;i<m_numSpheres;i++)
 		{
@@ -116,27 +116,27 @@ MultiSphereShape::MultiSphereShape (const SimdVector3& inertiaHalfExtents,const



-void	MultiSphereShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btMultiSphereShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//as an approximation, take the inertia of the box that bounds the spheres

-	SimdTransform ident;
+	btTransform ident;
 	ident.setIdentity();
-//	SimdVector3 aabbMin,aabbMax;
+//	btVector3 aabbMin,aabbMax;

 //	GetAabb(ident,aabbMin,aabbMax);

-	SimdVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* 0.5f;
+	btVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* 0.5f;

 	float margin = CONVEX_DISTANCE_MARGIN;

-	SimdScalar lx=2.f*(halfExtents[0]+margin);
-	SimdScalar ly=2.f*(halfExtents[1]+margin);
-	SimdScalar lz=2.f*(halfExtents[2]+margin);
-	const SimdScalar x2 = lx*lx;
-	const SimdScalar y2 = ly*ly;
-	const SimdScalar z2 = lz*lz;
-	const SimdScalar scaledmass = mass * 0.08333333f;
+	btScalar lx=2.f*(halfExtents[0]+margin);
+	btScalar ly=2.f*(halfExtents[1]+margin);
+	btScalar lz=2.f*(halfExtents[2]+margin);
+	const btScalar x2 = lx*lx;
+	const btScalar y2 = ly*ly;
+	const btScalar z2 = lz*lz;
+	const btScalar scaledmass = mass * 0.08333333f;

 	inertia[0] = scaledmass * (y2+z2);
 	inertia[1] = scaledmass * (x2+z2);
--- a/src/BulletCollision/CollisionShapes/btMultiSphereShape.h
+++ b/src/BulletCollision/CollisionShapes/btMultiSphereShape.h
@@ -22,13 +22,13 @@ subject to the following restrictions:
 #define MAX_NUM_SPHERES 5

 ///MultiSphereShape represents implicit convex hull of a collection of spheres (using getSupportingVertex)
-class MultiSphereShape : public ConvexShape
+class btMultiSphereShape : public btConvexShape

 {
 	
-	SimdVector3 m_localPositions[MAX_NUM_SPHERES];
-	SimdScalar  m_radi[MAX_NUM_SPHERES];
-	SimdVector3	m_inertiaHalfExtents;
+	btVector3 m_localPositions[MAX_NUM_SPHERES];
+	btScalar  m_radi[MAX_NUM_SPHERES];
+	btVector3	m_inertiaHalfExtents;

 	int m_numSpheres;
 	float m_minRadius;
@@ -38,15 +38,15 @@ class MultiSphereShape : public ConvexShape


 public:
-	MultiSphereShape (const SimdVector3& inertiaHalfExtents,const SimdVector3* positions,const SimdScalar* radi,int numSpheres);
+	btMultiSphereShape (const btVector3& inertiaHalfExtents,const btVector3* positions,const btScalar* radi,int numSpheres);

 	///CollisionShape Interface
-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	/// ConvexShape Interface
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
+	/// btConvexShape Interface
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;

-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
 	

 	virtual int	GetShapeType() const { return MULTI_SPHERE_SHAPE_PROXYTYPE; }
--- a/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
+++ b/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
@@ -15,11 +15,11 @@ subject to the following restrictions:

 #include "btOptimizedBvh.h"
 #include "btStridingMeshInterface.h"
-#include "LinearMath/GenAabbUtil2.h"
+#include "LinearMath/btAabbUtil2.h"



-void OptimizedBvh::Build(StridingMeshInterface* triangles)
+void btOptimizedBvh::Build(btStridingMeshInterface* triangles)
 {
 	//int countTriangles = 0;

@@ -27,7 +27,7 @@ void OptimizedBvh::Build(StridingMeshInterface* triangles)

 	// NodeArray	triangleNodes;

-	struct	NodeTriangleCallback : public InternalTriangleIndexCallback
+	struct	NodeTriangleCallback : public btInternalTriangleIndexCallback
 	{
 		NodeArray&	m_triangleNodes;

@@ -37,12 +37,12 @@ void OptimizedBvh::Build(StridingMeshInterface* triangles)

 		}

-		virtual void InternalProcessTriangleIndex(SimdVector3* triangle,int partId,int  triangleIndex)
+		virtual void InternalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
 		{

-			OptimizedBvhNode node;
-			node.m_aabbMin = SimdVector3(1e30f,1e30f,1e30f); 
-			node.m_aabbMax = SimdVector3(-1e30f,-1e30f,-1e30f); 
+			btOptimizedBvhNode node;
+			node.m_aabbMin = btVector3(1e30f,1e30f,1e30f); 
+			node.m_aabbMax = btVector3(-1e30f,-1e30f,-1e30f); 
 			node.m_aabbMin.setMin(triangle[0]);
 			node.m_aabbMax.setMax(triangle[0]);
 			node.m_aabbMin.setMin(triangle[1]);
@@ -68,32 +68,32 @@ void OptimizedBvh::Build(StridingMeshInterface* triangles)

 	NodeTriangleCallback	callback(m_leafNodes);

-	SimdVector3 aabbMin(-1e30f,-1e30f,-1e30f);
-	SimdVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
+	btVector3 aabbMax(1e30f,1e30f,1e30f);

 	triangles->InternalProcessAllTriangles(&callback,aabbMin,aabbMax);

 	//now we have an array of leafnodes in m_leafNodes

-	m_contiguousNodes = new OptimizedBvhNode[2*m_leafNodes.size()];
+	m_contiguousNodes = new btOptimizedBvhNode[2*m_leafNodes.size()];
 	m_curNodeIndex = 0;

 	m_rootNode1 = BuildTree(m_leafNodes,0,m_leafNodes.size());


 	///create the leafnodes first
-//	OptimizedBvhNode* leafNodes = new OptimizedBvhNode;
+//	btOptimizedBvhNode* leafNodes = new btOptimizedBvhNode;
 }

-OptimizedBvh::~OptimizedBvh()
+btOptimizedBvh::~btOptimizedBvh()
 {
 	if (m_contiguousNodes)
 		delete m_contiguousNodes;
 }

-OptimizedBvhNode*	OptimizedBvh::BuildTree	(NodeArray&	leafNodes,int startIndex,int endIndex)
+btOptimizedBvhNode*	btOptimizedBvh::BuildTree	(NodeArray&	leafNodes,int startIndex,int endIndex)
 {
-	OptimizedBvhNode* internalNode;
+	btOptimizedBvhNode* internalNode;

 	int splitAxis, splitIndex, i;
 	int numIndices =endIndex-startIndex;
@@ -103,7 +103,7 @@ OptimizedBvhNode*	OptimizedBvh::BuildTree	(NodeArray&	leafNodes,int startIndex,i

 	if (numIndices==1)
 	{
-		return new (&m_contiguousNodes[m_curNodeIndex++]) OptimizedBvhNode(leafNodes[startIndex]);
+		return new (&m_contiguousNodes[m_curNodeIndex++]) btOptimizedBvhNode(leafNodes[startIndex]);
 	}
 	//calculate Best Splitting Axis and where to split it. Sort the incoming 'leafNodes' array within range 'startIndex/endIndex'.
 	
@@ -132,17 +132,17 @@ OptimizedBvhNode*	OptimizedBvh::BuildTree	(NodeArray&	leafNodes,int startIndex,i
 	return internalNode;
 }

-int	OptimizedBvh::SortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis)
+int	btOptimizedBvh::SortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis)
 {
 	int i;
 	int splitIndex =startIndex;
 	int numIndices = endIndex - startIndex;
 	float splitValue;

-	SimdVector3 means(0.f,0.f,0.f);
+	btVector3 means(0.f,0.f,0.f);
 	for (i=startIndex;i<endIndex;i++)
 	{
-		SimdVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		means+=center;
 	}
 	means *= (1.f/(float)numIndices);
@@ -152,11 +152,11 @@ int	OptimizedBvh::SortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,
 	//sort leafNodes so all values larger then splitValue comes first, and smaller values start from 'splitIndex'.
 	for (i=startIndex;i<endIndex;i++)
 	{
-		SimdVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		if (center[splitAxis] > splitValue)
 		{
 			//swap
-			OptimizedBvhNode tmp = leafNodes[i];
+			btOptimizedBvhNode tmp = leafNodes[i];
 			leafNodes[i] = leafNodes[splitIndex];
 			leafNodes[splitIndex] = tmp;
 			splitIndex++;
@@ -170,25 +170,25 @@ int	OptimizedBvh::SortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,
 }


-int	OptimizedBvh::CalcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex)
+int	btOptimizedBvh::CalcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex)
 {
 	int i;

-	SimdVector3 means(0.f,0.f,0.f);
-	SimdVector3 variance(0.f,0.f,0.f);
+	btVector3 means(0.f,0.f,0.f);
+	btVector3 variance(0.f,0.f,0.f);
 	int numIndices = endIndex-startIndex;

 	for (i=startIndex;i<endIndex;i++)
 	{
-		SimdVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		means+=center;
 	}
 	means *= (1.f/(float)numIndices);
 		
 	for (i=startIndex;i<endIndex;i++)
 	{
-		SimdVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
-		SimdVector3 diff2 = center-means;
+		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 diff2 = center-means;
 		diff2 = diff2 * diff2;
 		variance += diff2;
 	}
@@ -199,7 +199,7 @@ int	OptimizedBvh::CalcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endI



-void	OptimizedBvh::ReportAabbOverlappingNodex(NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btOptimizedBvh::ReportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 	//either choose recursive traversal (WalkTree) or stackless (WalkStacklessTree)

@@ -208,7 +208,7 @@ void	OptimizedBvh::ReportAabbOverlappingNodex(NodeOverlapCallback* nodeCallback,
 	WalkStacklessTree(m_rootNode1,nodeCallback,aabbMin,aabbMax);
 }

-void	OptimizedBvh::WalkTree(OptimizedBvhNode* rootNode,NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btOptimizedBvh::WalkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 	bool isLeafNode, aabbOverlap = TestAabbAgainstAabb2(aabbMin,aabbMax,rootNode->m_aabbMin,rootNode->m_aabbMax);
 	if (aabbOverlap)
@@ -228,7 +228,7 @@ void	OptimizedBvh::WalkTree(OptimizedBvhNode* rootNode,NodeOverlapCallback* node

 int maxIterations = 0;

-void	OptimizedBvh::WalkStacklessTree(OptimizedBvhNode* rootNode,NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btOptimizedBvh::WalkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 	int escapeIndex, curIndex = 0;
 	int walkIterations = 0;
@@ -267,7 +267,7 @@ void	OptimizedBvh::WalkStacklessTree(OptimizedBvhNode* rootNode,NodeOverlapCallb
 }


-void	OptimizedBvh::ReportSphereOverlappingNodex(NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btOptimizedBvh::ReportSphereOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {

 }
--- a/src/BulletCollision/CollisionShapes/btOptimizedBvh.h
+++ b/src/BulletCollision/CollisionShapes/btOptimizedBvh.h
@@ -15,26 +15,26 @@ subject to the following restrictions:

 #ifndef OPTIMIZED_BVH_H
 #define OPTIMIZED_BVH_H
-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btVector3.h"
 #include <vector>

-class StridingMeshInterface;
+class btStridingMeshInterface;

-/// OptimizedBvhNode contains both internal and leaf node information.
+/// btOptimizedBvhNode contains both internal and leaf node information.
 /// It hasn't been optimized yet for storage. Some obvious optimizations are:
 /// Removal of the pointers (can already be done, they are not used for traversal)
 /// and storing aabbmin/max as quantized integers.
 /// 'subpart' doesn't need an integer either. It allows to re-use graphics triangle
 /// meshes stored in a non-uniform way (like batches/subparts of triangle-fans
-struct OptimizedBvhNode
+struct btOptimizedBvhNode
 {

-	SimdVector3	m_aabbMin;
-	SimdVector3	m_aabbMax;
+	btVector3	m_aabbMin;
+	btVector3	m_aabbMax;

 //these 2 pointers are obsolete, the stackless traversal just uses the escape index
-	OptimizedBvhNode*	m_leftChild;
-	OptimizedBvhNode*	m_rightChild;
+	btOptimizedBvhNode*	m_leftChild;
+	btOptimizedBvhNode*	m_rightChild;

 	int	m_escapeIndex;

@@ -44,23 +44,23 @@ struct OptimizedBvhNode

 };

-class NodeOverlapCallback
+class btNodeOverlapCallback
 {
 public:
-	virtual ~NodeOverlapCallback() {};
+	virtual ~btNodeOverlapCallback() {};

-	virtual void ProcessNode(const OptimizedBvhNode* node) = 0;
+	virtual void ProcessNode(const btOptimizedBvhNode* node) = 0;
 };

-typedef std::vector<OptimizedBvhNode>	NodeArray;
+typedef std::vector<btOptimizedBvhNode>	NodeArray;


 ///OptimizedBvh store an AABB tree that can be quickly traversed on CPU (and SPU,GPU in future)
-class OptimizedBvh
+class btOptimizedBvh
 {
-	OptimizedBvhNode*	m_rootNode1;
+	btOptimizedBvhNode*	m_rootNode1;
 	
-	OptimizedBvhNode*	m_contiguousNodes;
+	btOptimizedBvhNode*	m_contiguousNodes;
 	int					m_curNodeIndex;

 	int					m_numNodes;
@@ -68,29 +68,29 @@ class OptimizedBvh
 	NodeArray			m_leafNodes;

 public:
-	OptimizedBvh() :m_rootNode1(0), m_numNodes(0) { }
-	virtual ~OptimizedBvh();
+	btOptimizedBvh() :m_rootNode1(0), m_numNodes(0) { }
+	virtual ~btOptimizedBvh();
 	
-	void	Build(StridingMeshInterface* triangles);
+	void	Build(btStridingMeshInterface* triangles);

-	OptimizedBvhNode*	BuildTree	(NodeArray&	leafNodes,int startIndex,int endIndex);
+	btOptimizedBvhNode*	BuildTree	(NodeArray&	leafNodes,int startIndex,int endIndex);

 	int	CalcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex);

 	int	SortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis);
 	
-	void	WalkTree(OptimizedBvhNode* rootNode,NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	void	WalkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
 	
-	void	WalkStacklessTree(OptimizedBvhNode* rootNode,NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	void	WalkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
 	

 	//OptimizedBvhNode*	GetRootNode() { return m_rootNode1;}

 	int					GetNumNodes() { return m_numNodes;}

-	void	ReportAabbOverlappingNodex(NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	void	ReportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;

-	void	ReportSphereOverlappingNodex(NodeOverlapCallback* nodeCallback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	void	ReportSphereOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;


 };
--- a/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
@@ -15,7 +15,7 @@ subject to the following restrictions:

 #include <BulletCollision/CollisionShapes/btPolyhedralConvexShape.h>

-PolyhedralConvexShape::PolyhedralConvexShape()
+btPolyhedralConvexShape::btPolyhedralConvexShape()
 :m_optionalHull(0)
 {

@@ -23,26 +23,26 @@ PolyhedralConvexShape::PolyhedralConvexShape()



-SimdVector3	PolyhedralConvexShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec0)const
+btVector3	btPolyhedralConvexShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
 	int i;
-	SimdVector3 supVec(0,0,0);
+	btVector3 supVec(0,0,0);

-	SimdScalar maxDot(-1e30f);
+	btScalar maxDot(-1e30f);

-	SimdVector3 vec = vec0;
-	SimdScalar lenSqr = vec.length2();
+	btVector3 vec = vec0;
+	btScalar lenSqr = vec.length2();
 	if (lenSqr < 0.0001f)
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / SimdSqrt(lenSqr );
+		float rlen = 1.f / btSqrt(lenSqr );
 		vec *= rlen;
 	}

-	SimdVector3 vtx;
-	SimdScalar newDot;
+	btVector3 vtx;
+	btScalar newDot;

 	for (i=0;i<GetNumVertices();i++)
 	{
@@ -59,12 +59,12 @@ SimdVector3	PolyhedralConvexShape::LocalGetSupportingVertexWithoutMargin(const S

 }

-void	PolyhedralConvexShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btPolyhedralConvexShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	int i;

-	SimdVector3 vtx;
-	SimdScalar newDot;
+	btVector3 vtx;
+	btScalar newDot;

 	for (int i=0;i<numVectors;i++)
 	{
@@ -74,7 +74,7 @@ void	PolyhedralConvexShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(co
 	for (int j=0;j<numVectors;j++)
 	{
 	
-		const SimdVector3& vec = vectors[j];
+		const btVector3& vec = vectors[j];

 		for (i=0;i<GetNumVertices();i++)
 		{
@@ -92,27 +92,27 @@ void	PolyhedralConvexShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(co



-void	PolyhedralConvexShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btPolyhedralConvexShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//not yet, return box inertia

 	float margin = GetMargin();

-	SimdTransform ident;
+	btTransform ident;
 	ident.setIdentity();
-	SimdVector3 aabbMin,aabbMax;
+	btVector3 aabbMin,aabbMax;
 	GetAabb(ident,aabbMin,aabbMax);
-	SimdVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;

-	SimdScalar lx=2.f*(halfExtents.x()+margin);
-	SimdScalar ly=2.f*(halfExtents.y()+margin);
-	SimdScalar lz=2.f*(halfExtents.z()+margin);
-	const SimdScalar x2 = lx*lx;
-	const SimdScalar y2 = ly*ly;
-	const SimdScalar z2 = lz*lz;
-	const SimdScalar scaledmass = mass * 0.08333333f;
+	btScalar lx=2.f*(halfExtents.x()+margin);
+	btScalar ly=2.f*(halfExtents.y()+margin);
+	btScalar lz=2.f*(halfExtents.z()+margin);
+	const btScalar x2 = lx*lx;
+	const btScalar y2 = ly*ly;
+	const btScalar z2 = lz*lz;
+	const btScalar scaledmass = mass * 0.08333333f;

-	inertia = scaledmass * (SimdVector3(y2+z2,x2+z2,x2+y2));
+	inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));

 }

--- a/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
+++ b/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
@@ -16,36 +16,36 @@ subject to the following restrictions:
 #ifndef BU_SHAPE
 #define BU_SHAPE

-#include <LinearMath/SimdPoint3.h>
-#include <LinearMath/SimdMatrix3x3.h>
+#include <LinearMath/btPoint3.h>
+#include <LinearMath/btMatrix3x3.h>
 #include <BulletCollision/CollisionShapes/btConvexShape.h>


 ///PolyhedralConvexShape is an interface class for feature based (vertex/edge/face) convex shapes.
-class PolyhedralConvexShape : public ConvexShape
+class btPolyhedralConvexShape : public btConvexShape
 {

 public:

-	PolyhedralConvexShape();
+	btPolyhedralConvexShape();

 	//brute force implementations
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
 	
-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);



 	virtual int	GetNumVertices() const = 0 ;
 	virtual int GetNumEdges() const = 0;
-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const = 0;
-	virtual void GetVertex(int i,SimdPoint3& vtx) const = 0;
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const = 0;
+	virtual void GetVertex(int i,btPoint3& vtx) const = 0;
 	virtual int	GetNumPlanes() const = 0;
-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i ) const = 0;
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const = 0;
 //	virtual int GetIndex(int i) const = 0 ; 

-	virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const = 0;
+	virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const = 0;
 	
 	/// optional Hull is for optional Separating Axis Test Hull collision detection, see Hull.cpp
 	class	Hull*	m_optionalHull;
--- a/src/BulletCollision/CollisionShapes/btSphereShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btSphereShape.cpp
@@ -16,20 +16,20 @@ subject to the following restrictions:
 #include "btSphereShape.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

-#include "LinearMath/SimdQuaternion.h"
+#include "LinearMath/btQuaternion.h"


-SphereShape ::SphereShape (SimdScalar radius)
+btSphereShape ::btSphereShape (btScalar radius)
 : m_radius(radius)
 {	
 }

-SimdVector3	SphereShape::LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+btVector3	btSphereShape::LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
-	return SimdVector3(0.f,0.f,0.f);
+	return btVector3(0.f,0.f,0.f);
 }

-void	SphereShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+void	btSphereShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
@@ -38,12 +38,12 @@ void	SphereShape::BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVe
 }


-SimdVector3	SphereShape::LocalGetSupportingVertex(const SimdVector3& vec)const
+btVector3	btSphereShape::LocalGetSupportingVertex(const btVector3& vec)const
 {
-	SimdVector3 supVertex;
+	btVector3 supVertex;
 	supVertex = LocalGetSupportingVertexWithoutMargin(vec);

-	SimdVector3 vecnorm = vec;
+	btVector3 vecnorm = vec;
 	if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 	{
 		vecnorm.setValue(-1.f,-1.f,-1.f);
@@ -55,19 +55,19 @@ SimdVector3	SphereShape::LocalGetSupportingVertex(const SimdVector3& vec)const


 //broken due to scaling
-void SphereShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btSphereShape::GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	const SimdVector3& center = t.getOrigin();
-	SimdVector3 extent(GetMargin(),GetMargin(),GetMargin());
+	const btVector3& center = t.getOrigin();
+	btVector3 extent(GetMargin(),GetMargin(),GetMargin());
 	aabbMin = center - extent;
 	aabbMax = center + extent;
 }



-void	SphereShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btSphereShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	SimdScalar elem = 0.4f * mass * GetMargin()*GetMargin();
+	btScalar elem = 0.4f * mass * GetMargin()*GetMargin();
 	inertia[0] = inertia[1] = inertia[2] = elem;

 }
--- a/src/BulletCollision/CollisionShapes/btSphereShape.h
+++ b/src/BulletCollision/CollisionShapes/btSphereShape.h
@@ -20,41 +20,41 @@ subject to the following restrictions:
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types

 ///SphereShape implements an implicit (getSupportingVertex) Sphere
-class SphereShape : public ConvexShape
+class btSphereShape : public btConvexShape

 {
-	SimdScalar m_radius;
+	btScalar m_radius;
 	
 public:
-	SphereShape (SimdScalar radius);
+	btSphereShape (btScalar radius);
 	
 	
-	virtual SimdVector3	LocalGetSupportingVertex(const SimdVector3& vec)const;
-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertex(const btVector3& vec)const;
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const;
 	//notice that the vectors should be unit length
-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const;
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;


-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;

 	virtual int	GetShapeType() const { return SPHERE_SHAPE_PROXYTYPE; }

-	SimdScalar	GetRadius() const { return m_radius;}
+	btScalar	GetRadius() const { return m_radius;}

 	//debugging
 	virtual char*	GetName()const {return "SPHERE";}

 	virtual void	SetMargin(float margin)
 	{
-		ConvexShape::SetMargin(margin);
+		btConvexShape::SetMargin(margin);
 	}
 	virtual float	GetMargin() const
 	{
 		//to improve gjk behaviour, use radius+margin as the full margin, so never get into the penetration case
 		//this means, non-uniform scaling is not supported anymore
-		return m_localScaling[0] * m_radius + ConvexShape::GetMargin();
+		return m_localScaling[0] * m_radius + btConvexShape::GetMargin();
 	}


--- a/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
@@ -15,10 +15,10 @@ subject to the following restrictions:

 #include "btStaticPlaneShape.h"

-#include "LinearMath/SimdTransformUtil.h"
+#include "LinearMath/btTransformUtil.h"


-StaticPlaneShape::StaticPlaneShape(const SimdVector3& planeNormal,SimdScalar planeConstant)
+btStaticPlaneShape::btStaticPlaneShape(const btVector3& planeNormal,btScalar planeConstant)
 :m_planeNormal(planeNormal),
 m_planeConstant(planeConstant),
 m_localScaling(0.f,0.f,0.f)
@@ -26,17 +26,17 @@ m_localScaling(0.f,0.f,0.f)
 }


-StaticPlaneShape::~StaticPlaneShape()
+btStaticPlaneShape::~btStaticPlaneShape()
 {
 }



-void StaticPlaneShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btStaticPlaneShape::GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	SimdVector3 infvec (1e30f,1e30f,1e30f);
+	btVector3 infvec (1e30f,1e30f,1e30f);

-	SimdVector3 center = m_planeNormal*m_planeConstant;
+	btVector3 center = m_planeNormal*m_planeConstant;
 	aabbMin = center + infvec*m_planeNormal;
 	aabbMax = aabbMin;
 	aabbMin.setMin(center - infvec*m_planeNormal);
@@ -50,25 +50,25 @@ void StaticPlaneShape::GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdV



-void	StaticPlaneShape::ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btStaticPlaneShape::ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {

-	SimdVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
-	SimdScalar radius = halfExtents.length();
-	SimdVector3 center = (aabbMax + aabbMin) * 0.5f;
+	btVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
+	btScalar radius = halfExtents.length();
+	btVector3 center = (aabbMax + aabbMin) * 0.5f;
 	
 	//this is where the triangles are generated, given AABB and plane equation (normal/constant)

-	SimdVector3 tangentDir0,tangentDir1;
+	btVector3 tangentDir0,tangentDir1;

 	//tangentDir0/tangentDir1 can be precalculated
-	SimdPlaneSpace1(m_planeNormal,tangentDir0,tangentDir1);
+	btPlaneSpace1(m_planeNormal,tangentDir0,tangentDir1);

-	SimdVector3 supVertex0,supVertex1;
+	btVector3 supVertex0,supVertex1;

-	SimdVector3 projectedCenter = center - (m_planeNormal.dot(center) - m_planeConstant)*m_planeNormal;
+	btVector3 projectedCenter = center - (m_planeNormal.dot(center) - m_planeConstant)*m_planeNormal;
 	
-	SimdVector3 triangle[3];
+	btVector3 triangle[3];
 	triangle[0] = projectedCenter + tangentDir0*radius + tangentDir1*radius;
 	triangle[1] = projectedCenter + tangentDir0*radius - tangentDir1*radius;
 	triangle[2] = projectedCenter - tangentDir0*radius - tangentDir1*radius;
@@ -83,18 +83,18 @@ void	StaticPlaneShape::ProcessAllTriangles(TriangleCallback* callback,const Simd

 }

-void	StaticPlaneShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btStaticPlaneShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//moving concave objects not supported
 	
 	inertia.setValue(0.f,0.f,0.f);
 }

-void	StaticPlaneShape::setLocalScaling(const SimdVector3& scaling)
+void	btStaticPlaneShape::setLocalScaling(const btVector3& scaling)
 {
 	m_localScaling = scaling;
 }
-const SimdVector3& StaticPlaneShape::getLocalScaling() const
+const btVector3& btStaticPlaneShape::getLocalScaling() const
 {
 	return m_localScaling;
 }
--- a/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h
+++ b/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h
@@ -21,20 +21,20 @@ subject to the following restrictions:

 ///StaticPlaneShape simulates an 'infinite' plane by dynamically reporting triangles approximated by intersection of the plane with the AABB.
 ///Assumed is that the other objects is not also infinite, so a reasonable sized AABB.
-class StaticPlaneShape : public ConcaveShape
+class btStaticPlaneShape : public ConcaveShape
 {
 protected:
-	SimdVector3	m_localAabbMin;
-	SimdVector3	m_localAabbMax;
+	btVector3	m_localAabbMin;
+	btVector3	m_localAabbMax;
 	
-	SimdVector3	m_planeNormal;
-	SimdScalar      m_planeConstant;
-	SimdVector3	m_localScaling;
+	btVector3	m_planeNormal;
+	btScalar      m_planeConstant;
+	btVector3	m_localScaling;

 public:
-	StaticPlaneShape(const SimdVector3& planeNormal,SimdScalar planeConstant);
+	btStaticPlaneShape(const btVector3& planeNormal,btScalar planeConstant);

-	virtual ~StaticPlaneShape();
+	virtual ~btStaticPlaneShape();


 	virtual int	GetShapeType() const
@@ -42,14 +42,14 @@ public:
 		return STATIC_PLANE_PROXYTYPE;
 	}

-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;

-	virtual void	ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	virtual void	ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	virtual void	setLocalScaling(const SimdVector3& scaling);
-	virtual const SimdVector3& getLocalScaling() const;
+	virtual void	setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
 	

 	//debugging
--- a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
+++ b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
@@ -15,13 +15,13 @@ subject to the following restrictions:

 #include "btStridingMeshInterface.h"

-StridingMeshInterface::~StridingMeshInterface()
+btStridingMeshInterface::~btStridingMeshInterface()
 {

 }


-void	StridingMeshInterface::InternalProcessAllTriangles(InternalTriangleIndexCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 	int numtotalphysicsverts = 0;
 	int part,graphicssubparts = getNumSubParts();
@@ -32,10 +32,10 @@ void	StridingMeshInterface::InternalProcessAllTriangles(InternalTriangleIndexCal
 	PHY_ScalarType gfxindextype;
 	int stride,numverts,numtriangles;
 	int gfxindex;
-	SimdVector3 triangle[3];
+	btVector3 triangle[3];
 	float* graphicsbase;

-	SimdVector3 meshScaling = getScaling();
+	btVector3 meshScaling = getScaling();

 	///if the number of parts is big, the performance might drop due to the innerloop switch on indextype
 	for (part=0;part<graphicssubparts ;part++)
--- a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
+++ b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
@@ -16,11 +16,11 @@ subject to the following restrictions:
 #ifndef STRIDING_MESHINTERFACE_H
 #define STRIDING_MESHINTERFACE_H

-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btVector3.h"
 #include "btTriangleCallback.h"

 /// PHY_ScalarType enumerates possible scalar types.
-/// See the StridingMeshInterface for its use
+/// See the btStridingMeshInterface for its use
 typedef enum PHY_ScalarType {
 	PHY_FLOAT,
 	PHY_DOUBLE,
@@ -29,25 +29,25 @@ typedef enum PHY_ScalarType {
 	PHY_FIXEDPOINT88
 } PHY_ScalarType;

-///	StridingMeshInterface is the interface class for high performance access to triangle meshes
+///	btStridingMeshInterface is the interface class for high performance access to triangle meshes
 /// It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory.
-class  StridingMeshInterface
+class  btStridingMeshInterface
 {
 	protected:
 	
-		SimdVector3 m_scaling;
+		btVector3 m_scaling;

 	public:
-		StridingMeshInterface() :m_scaling(1.f,1.f,1.f)
+		btStridingMeshInterface() :m_scaling(1.f,1.f,1.f)
 		{

 		}

-		virtual ~StridingMeshInterface();
+		virtual ~btStridingMeshInterface();



-		void	InternalProcessAllTriangles(InternalTriangleIndexCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+		void	InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;


 		/// get read and write access to a subpart of a triangle mesh
@@ -73,10 +73,10 @@ class  StridingMeshInterface
 		virtual void	preallocateVertices(int numverts)=0;
 		virtual void	preallocateIndices(int numindices)=0;

-		const SimdVector3&	getScaling() const {
+		const btVector3&	getScaling() const {
 			return m_scaling;
 		}
-		void	setScaling(const SimdVector3& scaling)
+		void	setScaling(const btVector3& scaling)
 		{
 			m_scaling = scaling;
 		}
--- a/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp
@@ -14,27 +14,27 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 #include "btTetrahedronShape.h"
-#include "LinearMath/SimdMatrix3x3.h"
+#include "LinearMath/btMatrix3x3.h"

-BU_Simplex1to4::BU_Simplex1to4()
+btBU_Simplex1to4::btBU_Simplex1to4()
 :m_numVertices(0)
 {
 }

-BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0)
+btBU_Simplex1to4::btBU_Simplex1to4(const btPoint3& pt0)
 :m_numVertices(0)
 {
 	AddVertex(pt0);
 }

-BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1)
+btBU_Simplex1to4::btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1)
 :m_numVertices(0)
 {
 	AddVertex(pt0);
 	AddVertex(pt1);
 }

-BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const SimdPoint3& pt2)
+btBU_Simplex1to4::btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1,const btPoint3& pt2)
 :m_numVertices(0)
 {
 	AddVertex(pt0);
@@ -42,7 +42,7 @@ BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const
 	AddVertex(pt2);
 }

-BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const SimdPoint3& pt2,const SimdPoint3& pt3)
+btBU_Simplex1to4::btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1,const btPoint3& pt2,const btPoint3& pt3)
 :m_numVertices(0)
 {
 	AddVertex(pt0);
@@ -55,18 +55,18 @@ BU_Simplex1to4::BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const



-void BU_Simplex1to4::AddVertex(const SimdPoint3& pt)
+void btBU_Simplex1to4::AddVertex(const btPoint3& pt)
 {
 	m_vertices[m_numVertices++] = pt;
 }


-int	BU_Simplex1to4::GetNumVertices() const
+int	btBU_Simplex1to4::GetNumVertices() const
 {
 	return m_numVertices;
 }

-int BU_Simplex1to4::GetNumEdges() const
+int btBU_Simplex1to4::GetNumEdges() const
 {
 	//euler formula, F-E+V = 2, so E = F+V-2

@@ -85,7 +85,7 @@ int BU_Simplex1to4::GetNumEdges() const
 	return 0;
 }

-void BU_Simplex1to4::GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
+void btBU_Simplex1to4::GetEdge(int i,btPoint3& pa,btPoint3& pb) const
 {
 	
    switch (m_numVertices)
@@ -149,12 +149,12 @@ void BU_Simplex1to4::GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const

 }

-void BU_Simplex1to4::GetVertex(int i,SimdPoint3& vtx) const
+void btBU_Simplex1to4::GetVertex(int i,btPoint3& vtx) const
 {
 	vtx = m_vertices[i];
 }

-int	BU_Simplex1to4::GetNumPlanes() const
+int	btBU_Simplex1to4::GetNumPlanes() const
 {
 	switch (m_numVertices)
 	{
@@ -176,17 +176,17 @@ int	BU_Simplex1to4::GetNumPlanes() const
 }


-void BU_Simplex1to4::GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i) const
+void btBU_Simplex1to4::GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i) const
 {
 	
 }

-int BU_Simplex1to4::GetIndex(int i) const
+int btBU_Simplex1to4::GetIndex(int i) const
 {
 	return 0;
 }

-bool BU_Simplex1to4::IsInside(const SimdPoint3& pt,SimdScalar tolerance) const
+bool btBU_Simplex1to4::IsInside(const btPoint3& pt,btScalar tolerance) const
 {
 	return false;
 }
--- a/src/BulletCollision/CollisionShapes/btTetrahedronShape.h
+++ b/src/BulletCollision/CollisionShapes/btTetrahedronShape.h
@@ -22,20 +22,20 @@ subject to the following restrictions:


 ///BU_Simplex1to4 implements feature based and implicit simplex of up to 4 vertices (tetrahedron, triangle, line, vertex).
-class BU_Simplex1to4 : public PolyhedralConvexShape
+class btBU_Simplex1to4 : public btPolyhedralConvexShape
 {
 protected:

 	int	m_numVertices;
-	SimdPoint3	m_vertices[4];
+	btPoint3	m_vertices[4];

 public:
-	BU_Simplex1to4();
+	btBU_Simplex1to4();

-	BU_Simplex1to4(const SimdPoint3& pt0);
-	BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1);
-	BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const SimdPoint3& pt2);
-	BU_Simplex1to4(const SimdPoint3& pt0,const SimdPoint3& pt1,const SimdPoint3& pt2,const SimdPoint3& pt3);
+	btBU_Simplex1to4(const btPoint3& pt0);
+	btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1);
+	btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1,const btPoint3& pt2);
+	btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1,const btPoint3& pt2,const btPoint3& pt3);

    
 	void	Reset()
@@ -46,7 +46,7 @@ public:

 	virtual int	GetShapeType() const{ return TETRAHEDRAL_SHAPE_PROXYTYPE; }

-	void AddVertex(const SimdPoint3& pt);
+	void AddVertex(const btPoint3& pt);

 	//PolyhedralConvexShape interface

@@ -54,21 +54,21 @@ public:

 	virtual int GetNumEdges() const;

-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const;
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const;
 	
-	virtual void GetVertex(int i,SimdPoint3& vtx) const;
+	virtual void GetVertex(int i,btPoint3& vtx) const;

 	virtual int	GetNumPlanes() const;

-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i) const;
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i) const;

 	virtual int GetIndex(int i) const;

-	virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const;
+	virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const;


 	///GetName is for debugging
-	virtual  char*	GetName()const { return "BU_Simplex1to4";}
+	virtual  char*	GetName()const { return "btBU_Simplex1to4";}

 };

--- a/src/BulletCollision/CollisionShapes/btTriangleCallback.cpp
+++ b/src/BulletCollision/CollisionShapes/btTriangleCallback.cpp
@@ -15,13 +15,13 @@ subject to the following restrictions:

 #include "btTriangleCallback.h"

-TriangleCallback::~TriangleCallback()
+btTriangleCallback::~btTriangleCallback()
 {

 }


-InternalTriangleIndexCallback::~InternalTriangleIndexCallback()
+btInternalTriangleIndexCallback::~btInternalTriangleIndexCallback()
 {

 }
--- a/src/BulletCollision/CollisionShapes/btTriangleCallback.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleCallback.h
@@ -16,23 +16,23 @@ subject to the following restrictions:
 #ifndef TRIANGLE_CALLBACK_H
 #define TRIANGLE_CALLBACK_H

-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btVector3.h"


-class TriangleCallback
+class btTriangleCallback
 {
 public:

-	virtual ~TriangleCallback();
-	virtual void ProcessTriangle(SimdVector3* triangle, int partId, int triangleIndex) = 0;
+	virtual ~btTriangleCallback();
+	virtual void ProcessTriangle(btVector3* triangle, int partId, int triangleIndex) = 0;
 };

-class InternalTriangleIndexCallback
+class btInternalTriangleIndexCallback
 {
 public:

-	virtual ~InternalTriangleIndexCallback();
-	virtual void InternalProcessTriangleIndex(SimdVector3* triangle,int partId,int  triangleIndex) = 0;
+	virtual ~btInternalTriangleIndexCallback();
+	virtual void InternalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex) = 0;
 };


--- a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
+++ b/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
@@ -15,9 +15,9 @@ subject to the following restrictions:

 #include "btTriangleIndexVertexArray.h"

-TriangleIndexVertexArray::TriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride)
+btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride)
 {
-	IndexedMesh mesh;
+	btIndexedMesh mesh;
 	
 	mesh.m_numTriangles = numTriangles;
 	mesh.m_triangleIndexBase = triangleIndexBase;
@@ -30,11 +30,11 @@ TriangleIndexVertexArray::TriangleIndexVertexArray(int numTriangles,int* triangl

 }

-void	TriangleIndexVertexArray::getLockedVertexIndexBase(unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& vertexStride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart)
+void	btTriangleIndexVertexArray::getLockedVertexIndexBase(unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& vertexStride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart)
 {
 	ASSERT(subpart< getNumSubParts() );
 	
-	IndexedMesh& mesh = m_indexedMeshes[subpart];
+	btIndexedMesh& mesh = m_indexedMeshes[subpart];

 	numverts = mesh.m_numVertices;
 	(*vertexbase) = (unsigned char *) mesh.m_vertexBase;
@@ -48,9 +48,9 @@ void	TriangleIndexVertexArray::getLockedVertexIndexBase(unsigned char **vertexba
 	indicestype = PHY_INTEGER;
 }

-void	TriangleIndexVertexArray::getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& vertexStride,const unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart) const
+void	btTriangleIndexVertexArray::getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& vertexStride,const unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart) const
 {
-	const IndexedMesh& mesh = m_indexedMeshes[subpart];
+	const btIndexedMesh& mesh = m_indexedMeshes[subpart];

 	numverts = mesh.m_numVertices;
 	(*vertexbase) = (const unsigned char *)mesh.m_vertexBase;
--- a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
@@ -19,7 +19,7 @@ subject to the following restrictions:
 ///IndexedMesh indexes into existing vertex and index arrays, in a similar way OpenGL glDrawElements
 ///instead of the number of indices, we pass the number of triangles
 ///todo: explain with pictures
-struct	IndexedMesh
+struct	btIndexedMesh
 	{
 		int			m_numTriangles;
 		int*		m_triangleIndexBase;
@@ -32,24 +32,24 @@ struct	IndexedMesh
 ///TriangleIndexVertexArray allows to use multiple meshes, by indexing into existing triangle/index arrays.
 ///Additional meshes can be added using AddIndexedMesh
 ///No duplcate is made of the vertex/index data, it only indexes into external vertex/index arrays.
-///So keep those arrays around during the lifetime of this TriangleIndexVertexArray.
-class TriangleIndexVertexArray : public StridingMeshInterface
+///So keep those arrays around during the lifetime of this btTriangleIndexVertexArray.
+class btTriangleIndexVertexArray : public btStridingMeshInterface
 {
-	std::vector<IndexedMesh>	m_indexedMeshes;
+	std::vector<btIndexedMesh>	m_indexedMeshes;

 		
 public:

 	

-	TriangleIndexVertexArray()
+	btTriangleIndexVertexArray()
 	{
 	}

 	//just to be backwards compatible
-	TriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride);
+	btTriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride);
 	
-	void	AddIndexedMesh(const IndexedMesh& mesh)
+	void	AddIndexedMesh(const btIndexedMesh& mesh)
 	{
 		m_indexedMeshes.push_back(mesh);
 	}
--- a/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp
+++ b/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp
@@ -18,17 +18,17 @@ subject to the following restrictions:

 static int	myindices[3] = {0,1,2};

-TriangleMesh::TriangleMesh ()
+btTriangleMesh::btTriangleMesh ()
 {

 }

-void	TriangleMesh::getLockedVertexIndexBase(unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart)
+void	btTriangleMesh::getLockedVertexIndexBase(unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart)
 {
 	numverts = 3;
 	*vertexbase = (unsigned char*)&m_triangles[subpart];
 	type = PHY_FLOAT;
-	stride = sizeof(SimdVector3);
+	stride = sizeof(btVector3);


 	numfaces = 1;
@@ -38,12 +38,12 @@ void	TriangleMesh::getLockedVertexIndexBase(unsigned char **vertexbase, int& num

 }

-void	TriangleMesh::getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,const unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart) const
+void	btTriangleMesh::getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,const unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart) const
 {
 	numverts = 3;
 	*vertexbase = (unsigned char*)&m_triangles[subpart];
 	type = PHY_FLOAT;
-	stride = sizeof(SimdVector3);
+	stride = sizeof(btVector3);


 	numfaces = 1;
@@ -55,7 +55,7 @@ void	TriangleMesh::getLockedReadOnlyVertexIndexBase(const unsigned char **vertex



-int		TriangleMesh::getNumSubParts() const
+int		btTriangleMesh::getNumSubParts() const
 {
 	return m_triangles.size();
 }
--- a/src/BulletCollision/CollisionShapes/btTriangleMesh.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleMesh.h
@@ -19,27 +19,27 @@ subject to the following restrictions:

 #include "BulletCollision/CollisionShapes/btStridingMeshInterface.h"
 #include <vector>
-#include <LinearMath/SimdVector3.h>
+#include <LinearMath/btVector3.h>

-struct MyTriangle
+struct btMyTriangle
 {
-	SimdVector3	m_vert0;
-	SimdVector3	m_vert1;
-	SimdVector3	m_vert2;
+	btVector3	m_vert0;
+	btVector3	m_vert1;
+	btVector3	m_vert2;
 };

-///TriangleMesh provides storage for a concave triangle mesh. It can be used as data for the TriangleMeshShape.
-class TriangleMesh : public StridingMeshInterface
+///TriangleMesh provides storage for a concave triangle mesh. It can be used as data for the btTriangleMeshShape.
+class btTriangleMesh : public btStridingMeshInterface
 {
-	std::vector<MyTriangle>	m_triangles;
+	std::vector<btMyTriangle>	m_triangles;
 	

 	public:
-		TriangleMesh ();
+		btTriangleMesh ();

-		void	AddTriangle(const SimdVector3& vertex0,const SimdVector3& vertex1,const SimdVector3& vertex2)
+		void	AddTriangle(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2)
 		{
-			MyTriangle tri;
+			btMyTriangle tri;
 			tri.m_vert0 = vertex0;
 			tri.m_vert1 = vertex1;
 			tri.m_vert2 = vertex2;
--- a/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
@@ -14,22 +14,22 @@ subject to the following restrictions:
 */

 #include "btTriangleMeshShape.h"
-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdQuaternion.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btQuaternion.h"
 #include "btStridingMeshInterface.h"
-#include "LinearMath/GenAabbUtil2.h"
+#include "LinearMath/btAabbUtil2.h"
 #include "BulletCollision/CollisionShapes/btCollisionMargin.h"

 #include "stdio.h"

-TriangleMeshShape::TriangleMeshShape(StridingMeshInterface* meshInterface)
+btTriangleMeshShape::btTriangleMeshShape(btStridingMeshInterface* meshInterface)
 : m_meshInterface(meshInterface)
 {
 	RecalcLocalAabb();
 }


-TriangleMeshShape::~TriangleMeshShape()
+btTriangleMeshShape::~btTriangleMeshShape()
 {
 		
 }
@@ -37,20 +37,20 @@ TriangleMeshShape::~TriangleMeshShape()



-void TriangleMeshShape::GetAabb(const SimdTransform& trans,SimdVector3& aabbMin,SimdVector3& aabbMax) const
+void btTriangleMeshShape::GetAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {

-	SimdVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	SimdVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
 	
-	SimdMatrix3x3 abs_b = trans.getBasis().absolute();  
+	btMatrix3x3 abs_b = trans.getBasis().absolute();  

-	SimdPoint3 center = trans(localCenter);
+	btPoint3 center = trans(localCenter);

-	SimdVector3 extent = SimdVector3(abs_b[0].dot(localHalfExtents),
+	btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
 		   abs_b[1].dot(localHalfExtents),
 		  abs_b[2].dot(localHalfExtents));
-	extent += SimdVector3(GetMargin(),GetMargin(),GetMargin());
+	extent += btVector3(GetMargin(),GetMargin(),GetMargin());

 	aabbMin = center - extent;
 	aabbMax = center + extent;
@@ -58,13 +58,13 @@ void TriangleMeshShape::GetAabb(const SimdTransform& trans,SimdVector3& aabbMin,
 	
 }

-void	TriangleMeshShape::RecalcLocalAabb()
+void	btTriangleMeshShape::RecalcLocalAabb()
 {
 	for (int i=0;i<3;i++)
 	{
-		SimdVector3 vec(0.f,0.f,0.f);
+		btVector3 vec(0.f,0.f,0.f);
 		vec[i] = 1.f;
-		SimdVector3 tmp = LocalGetSupportingVertex(vec);
+		btVector3 tmp = LocalGetSupportingVertex(vec);
 		m_localAabbMax[i] = tmp[i]+m_collisionMargin;
 		vec[i] = -1.f;
 		tmp = LocalGetSupportingVertex(vec);
@@ -74,28 +74,28 @@ void	TriangleMeshShape::RecalcLocalAabb()



-class SupportVertexCallback : public TriangleCallback
+class SupportVertexCallback : public btTriangleCallback
 {

-	SimdVector3 m_supportVertexLocal;
+	btVector3 m_supportVertexLocal;
 public:

-	SimdTransform	m_worldTrans;
-	SimdScalar m_maxDot;
-	SimdVector3 m_supportVecLocal;
+	btTransform	m_worldTrans;
+	btScalar m_maxDot;
+	btVector3 m_supportVecLocal;

-	SupportVertexCallback(const SimdVector3& supportVecWorld,const SimdTransform& trans)
+	SupportVertexCallback(const btVector3& supportVecWorld,const btTransform& trans)
 		: m_supportVertexLocal(0.f,0.f,0.f), m_worldTrans(trans) ,m_maxDot(-1e30f)
 		
 	{
 		m_supportVecLocal = supportVecWorld * m_worldTrans.getBasis();
 	}

-	virtual void ProcessTriangle( SimdVector3* triangle,int partId, int triangleIndex)
+	virtual void ProcessTriangle( btVector3* triangle,int partId, int triangleIndex)
 	{
 		for (int i=0;i<3;i++)
 		{
-			SimdScalar dot = m_supportVecLocal.dot(triangle[i]);
+			btScalar dot = m_supportVecLocal.dot(triangle[i]);
 			if (dot > m_maxDot)
 			{
 				m_maxDot = dot;
@@ -104,12 +104,12 @@ public:
 		}
 	}

-	SimdVector3 GetSupportVertexWorldSpace()
+	btVector3 GetSupportVertexWorldSpace()
 	{
 		return m_worldTrans(m_supportVertexLocal);
 	}

-	SimdVector3	GetSupportVertexLocal()
+	btVector3	GetSupportVertexLocal()
 	{
 		return m_supportVertexLocal;
 	}
@@ -117,13 +117,13 @@ public:
 };

 	
-void TriangleMeshShape::setLocalScaling(const SimdVector3& scaling)
+void btTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 {
 	m_meshInterface->setScaling(scaling);
 	RecalcLocalAabb();
 }

-const SimdVector3& TriangleMeshShape::getLocalScaling() const
+const btVector3& btTriangleMeshShape::getLocalScaling() const
 {
 	return m_meshInterface->getScaling();
 }
@@ -136,23 +136,23 @@ const SimdVector3& TriangleMeshShape::getLocalScaling() const
 //#define DEBUG_TRIANGLE_MESH


-void	TriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
+void	btTriangleMeshShape::ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {

-	struct FilteredCallback : public InternalTriangleIndexCallback
+	struct FilteredCallback : public btInternalTriangleIndexCallback
 	{
-		TriangleCallback* m_callback;
-		SimdVector3 m_aabbMin;
-		SimdVector3 m_aabbMax;
+		btTriangleCallback* m_callback;
+		btVector3 m_aabbMin;
+		btVector3 m_aabbMax;

-		FilteredCallback(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax)
+		FilteredCallback(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax)
 			:m_callback(callback),
 			m_aabbMin(aabbMin),
 			m_aabbMax(aabbMax)
 		{
 		}

-		virtual void InternalProcessTriangleIndex(SimdVector3* triangle,int partId,int triangleIndex)
+		virtual void InternalProcessTriangleIndex(btVector3* triangle,int partId,int triangleIndex)
 		{
 			if (TestTriangleAgainstAabb2(&triangle[0],m_aabbMin,m_aabbMax))
 			{
@@ -174,7 +174,7 @@ void	TriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const Sim



-void	TriangleMeshShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+void	btTriangleMeshShape::CalculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//moving concave objects not supported
 	assert(0);
@@ -182,16 +182,16 @@ void	TriangleMeshShape::CalculateLocalInertia(SimdScalar mass,SimdVector3& inert
 }


-SimdVector3 TriangleMeshShape::LocalGetSupportingVertex(const SimdVector3& vec) const
+btVector3 btTriangleMeshShape::LocalGetSupportingVertex(const btVector3& vec) const
 {
-	SimdVector3 supportVertex;
+	btVector3 supportVertex;

-	SimdTransform ident;
+	btTransform ident;
 	ident.setIdentity();

 	SupportVertexCallback supportCallback(vec,ident);

-	SimdVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(1e30f,1e30f,1e30f);
 	
 	ProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		
--- a/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h
@@ -21,22 +21,22 @@ subject to the following restrictions:


 ///Concave triangle mesh. Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
-class TriangleMeshShape : public ConcaveShape
+class btTriangleMeshShape : public ConcaveShape
 {
 protected:
-	StridingMeshInterface* m_meshInterface;
-	SimdVector3	m_localAabbMin;
-	SimdVector3	m_localAabbMax;
+	btStridingMeshInterface* m_meshInterface;
+	btVector3	m_localAabbMin;
+	btVector3	m_localAabbMax;
 	

 public:
-	TriangleMeshShape(StridingMeshInterface* meshInterface);
+	btTriangleMeshShape(btStridingMeshInterface* meshInterface);

-	virtual ~TriangleMeshShape();
+	virtual ~btTriangleMeshShape();

-	virtual SimdVector3 LocalGetSupportingVertex(const SimdVector3& vec) const;
+	virtual btVector3 LocalGetSupportingVertex(const btVector3& vec) const;

-	virtual SimdVector3	LocalGetSupportingVertexWithoutMargin(const SimdVector3& vec)const
+	virtual btVector3	LocalGetSupportingVertexWithoutMargin(const btVector3& vec)const
 	{
 		assert(0);
 		return LocalGetSupportingVertex(vec);
@@ -49,14 +49,14 @@ public:
 		return TRIANGLE_MESH_SHAPE_PROXYTYPE;
 	}

-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax) const;
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;

-	virtual void	ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const;
+	virtual void	ProcessAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia);
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia);

-	virtual void	setLocalScaling(const SimdVector3& scaling);
-	virtual const SimdVector3& getLocalScaling() const;
+	virtual void	setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
 	

 	//debugging
--- a/src/BulletCollision/CollisionShapes/btTriangleShape.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleShape.h
@@ -19,13 +19,13 @@ subject to the following restrictions:
 #include "btConvexShape.h"
 #include "BulletCollision/CollisionShapes/btBoxShape.h"

-class TriangleShape : public PolyhedralConvexShape
+class btTriangleShape : public btPolyhedralConvexShape
 {


 public:

-	SimdVector3	m_vertices1[3];
+	btVector3	m_vertices1[3];


 	virtual int GetNumVertices() const
@@ -33,11 +33,11 @@ public:
 		return 3;
 	}

-	const SimdVector3& GetVertexPtr(int index) const
+	const btVector3& GetVertexPtr(int index) const
 	{
 		return m_vertices1[index];
 	}
-	virtual void GetVertex(int index,SimdVector3& vert) const
+	virtual void GetVertex(int index,btVector3& vert) const
 	{
 		vert = m_vertices1[index];
 	}
@@ -51,31 +51,31 @@ public:
 		return 3;
 	}
 	
-	virtual void GetEdge(int i,SimdPoint3& pa,SimdPoint3& pb) const
+	virtual void GetEdge(int i,btPoint3& pa,btPoint3& pb) const
 	{
 		GetVertex(i,pa);
 		GetVertex((i+1)%3,pb);
 	}

-	virtual void GetAabb(const SimdTransform& t,SimdVector3& aabbMin,SimdVector3& aabbMax)const 
+	virtual void GetAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax)const 
 	{
 //		ASSERT(0);
 		GetAabbSlow(t,aabbMin,aabbMax);
 	}

-	SimdVector3 LocalGetSupportingVertexWithoutMargin(const SimdVector3& dir)const 
+	btVector3 LocalGetSupportingVertexWithoutMargin(const btVector3& dir)const 
 	{
-		SimdVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_vertices1[1]), dir.dot(m_vertices1[2]));
+		btVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_vertices1[1]), dir.dot(m_vertices1[2]));
 	  	return m_vertices1[dots.maxAxis()];

 	}

-	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const SimdVector3* vectors,SimdVector3* supportVerticesOut,int numVectors) const
+	virtual void	BatchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 	{
 		for (int i=0;i<numVectors;i++)
 		{
-			const SimdVector3& dir = vectors[i];
-			SimdVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_vertices1[1]), dir.dot(m_vertices1[2]));
+			const btVector3& dir = vectors[i];
+			btVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_vertices1[1]), dir.dot(m_vertices1[2]));
  			supportVerticesOut[i] = m_vertices1[dots.maxAxis()];
 		}

@@ -83,7 +83,7 @@ public:



-	TriangleShape(const SimdVector3& p0,const SimdVector3& p1,const SimdVector3& p2)
+	btTriangleShape(const btVector3& p0,const btVector3& p1,const btVector3& p2)
 	{
 		m_vertices1[0] = p0;
 		m_vertices1[1] = p1;
@@ -92,7 +92,7 @@ public:

 	

-	virtual void GetPlane(SimdVector3& planeNormal,SimdPoint3& planeSupport,int i) const
+	virtual void GetPlane(btVector3& planeNormal,btPoint3& planeSupport,int i) const
 	{
 		GetPlaneEquation(i,planeNormal,planeSupport);
 	}
@@ -102,31 +102,31 @@ public:
 		return 1;
 	}

-	void CalcNormal(SimdVector3& normal) const
+	void CalcNormal(btVector3& normal) const
 	{
 		normal = (m_vertices1[1]-m_vertices1[0]).cross(m_vertices1[2]-m_vertices1[0]);
 		normal.normalize();
 	}

-	virtual void GetPlaneEquation(int i, SimdVector3& planeNormal,SimdPoint3& planeSupport) const
+	virtual void GetPlaneEquation(int i, btVector3& planeNormal,btPoint3& planeSupport) const
 	{
 		CalcNormal(planeNormal);
 		planeSupport = m_vertices1[0];
 	}

-	virtual void	CalculateLocalInertia(SimdScalar mass,SimdVector3& inertia)
+	virtual void	CalculateLocalInertia(btScalar mass,btVector3& inertia)
 	{
 		ASSERT(0);
 		inertia.setValue(0.f,0.f,0.f);
 	}

-		virtual	bool IsInside(const SimdPoint3& pt,SimdScalar tolerance) const
+		virtual	bool IsInside(const btPoint3& pt,btScalar tolerance) const
 	{
-		SimdVector3 normal;
+		btVector3 normal;
 		CalcNormal(normal);
 		//distance to plane
-		SimdScalar dist = pt.dot(normal);
-		SimdScalar planeconst = m_vertices1[0].dot(normal);
+		btScalar dist = pt.dot(normal);
+		btScalar planeconst = m_vertices1[0].dot(normal);
 		dist -= planeconst;
 		if (dist >= -tolerance && dist <= tolerance)
 		{
@@ -134,13 +134,13 @@ public:
 			int i;
 			for (i=0;i<3;i++)
 			{
-				SimdPoint3 pa,pb;
+				btPoint3 pa,pb;
 				GetEdge(i,pa,pb);
-				SimdVector3 edge = pb-pa;
-				SimdVector3 edgeNormal = edge.cross(normal);
+				btVector3 edge = pb-pa;
+				btVector3 edgeNormal = edge.cross(normal);
 				edgeNormal.normalize();
-				SimdScalar dist = pt.dot( edgeNormal);
-				SimdScalar edgeConst = pa.dot(edgeNormal);
+				btScalar dist = pt.dot( edgeNormal);
+				btScalar edgeConst = pa.dot(edgeNormal);
 				dist -= edgeConst;
 				if (dist < -tolerance)
 					return false;
--- a/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp
@@ -18,7 +18,7 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionShapes/btConvexShape.h"
 #include "BulletCollision/CollisionShapes/btMinkowskiSumShape.h"
 #include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h"
-#include "LinearMath/SimdTransformUtil.h"
+#include "LinearMath/btTransformUtil.h"
 #include "BulletCollision/CollisionShapes/btSphereShape.h"

 #include "btGjkPairDetector.h"
@@ -26,7 +26,7 @@ subject to the following restrictions:



-ContinuousConvexCollision::ContinuousConvexCollision ( ConvexShape*	convexA,ConvexShape*	convexB,SimplexSolverInterface* simplexSolver, ConvexPenetrationDepthSolver* penetrationDepthSolver)
+btContinuousConvexCollision::btContinuousConvexCollision ( btConvexShape*	convexA,btConvexShape*	convexB,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver)
 :m_simplexSolver(simplexSolver),
 m_penetrationDepthSolver(penetrationDepthSolver),
 m_convexA(convexA),m_convexB(convexB)
@@ -37,37 +37,37 @@ m_convexA(convexA),m_convexB(convexB)
 /// You don't want your game ever to lock-up.
 #define MAX_ITERATIONS 1000

-bool	ContinuousConvexCollision::calcTimeOfImpact(
-				const SimdTransform& fromA,
-				const SimdTransform& toA,
-				const SimdTransform& fromB,
-				const SimdTransform& toB,
+bool	btContinuousConvexCollision::calcTimeOfImpact(
+				const btTransform& fromA,
+				const btTransform& toA,
+				const btTransform& fromB,
+				const btTransform& toB,
 				CastResult& result)
 {

 	m_simplexSolver->reset();

 	/// compute linear and angular velocity for this interval, to interpolate
-	SimdVector3 linVelA,angVelA,linVelB,angVelB;
-	SimdTransformUtil::CalculateVelocity(fromA,toA,1.f,linVelA,angVelA);
-	SimdTransformUtil::CalculateVelocity(fromB,toB,1.f,linVelB,angVelB);
+	btVector3 linVelA,angVelA,linVelB,angVelB;
+	btTransformUtil::CalculateVelocity(fromA,toA,1.f,linVelA,angVelA);
+	btTransformUtil::CalculateVelocity(fromB,toB,1.f,linVelB,angVelB);

-	SimdScalar boundingRadiusA = m_convexA->GetAngularMotionDisc();
-	SimdScalar boundingRadiusB = m_convexB->GetAngularMotionDisc();
+	btScalar boundingRadiusA = m_convexA->GetAngularMotionDisc();
+	btScalar boundingRadiusB = m_convexB->GetAngularMotionDisc();

-	SimdScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;
+	btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;

 	float radius = 0.001f;

-	SimdScalar lambda = 0.f;
-	SimdVector3 v(1,0,0);
+	btScalar lambda = 0.f;
+	btVector3 v(1,0,0);

 	int maxIter = MAX_ITERATIONS;

-	SimdVector3 n;
+	btVector3 n;
 	n.setValue(0.f,0.f,0.f);
 	bool hasResult = false;
-	SimdVector3 c;
+	btVector3 c;

 	float lastLambda = lambda;
 	//float epsilon = 0.001f;
@@ -76,21 +76,21 @@ bool	ContinuousConvexCollision::calcTimeOfImpact(
 	//first solution, using GJK


-	SimdTransform identityTrans;
+	btTransform identityTrans;
 	identityTrans.setIdentity();

-	SphereShape	raySphere(0.0f);
+	btSphereShape	raySphere(0.0f);
 	raySphere.SetMargin(0.f);


 //	result.DrawCoordSystem(sphereTr);

-	PointCollector	pointCollector1;
+	btPointCollector	pointCollector1;

 	{
 		
-		GjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,m_penetrationDepthSolver);		
-		GjkPairDetector::ClosestPointInput input;
+		btGjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,m_penetrationDepthSolver);		
+		btGjkPairDetector::ClosestPointInput input;
 	
 		//we don't use margins during CCD
 		gjk.SetIgnoreMargin(true);
@@ -105,7 +105,7 @@ bool	ContinuousConvexCollision::calcTimeOfImpact(

 	if (hasResult)
 	{
-		SimdScalar dist;
+		btScalar dist;
 		dist = pointCollector1.m_distance;
 		n = pointCollector1.m_normalOnBInWorld;
 		
@@ -143,17 +143,17 @@ bool	ContinuousConvexCollision::calcTimeOfImpact(
 			

 			//interpolate to next lambda
-			SimdTransform interpolatedTransA,interpolatedTransB,relativeTrans;
+			btTransform interpolatedTransA,interpolatedTransB,relativeTrans;

-			SimdTransformUtil::IntegrateTransform(fromA,linVelA,angVelA,lambda,interpolatedTransA);
-			SimdTransformUtil::IntegrateTransform(fromB,linVelB,angVelB,lambda,interpolatedTransB);
+			btTransformUtil::IntegrateTransform(fromA,linVelA,angVelA,lambda,interpolatedTransA);
+			btTransformUtil::IntegrateTransform(fromB,linVelB,angVelB,lambda,interpolatedTransB);
 			relativeTrans = interpolatedTransB.inverseTimes(interpolatedTransA);

 			result.DebugDraw( lambda );

-			PointCollector	pointCollector;
-			GjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,m_penetrationDepthSolver);
-			GjkPairDetector::ClosestPointInput input;
+			btPointCollector	pointCollector;
+			btGjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,m_penetrationDepthSolver);
+			btGjkPairDetector::ClosestPointInput input;
 			input.m_transformA = interpolatedTransA;
 			input.m_transformB = interpolatedTransB;
 			gjk.GetClosestPoints(input,pointCollector,0);
@@ -187,7 +187,7 @@ bool	ContinuousConvexCollision::calcTimeOfImpact(
 /*
 //todo:
 	//if movement away from normal, discard result
-	SimdVector3 move = transBLocalTo.getOrigin() - transBLocalFrom.getOrigin();
+	btVector3 move = transBLocalTo.getOrigin() - transBLocalFrom.getOrigin();
 	if (result.m_fraction < 1.f)
 	{
 		if (move.dot(result.m_normal) <= 0.f)
--- a/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h
@@ -19,30 +19,30 @@ subject to the following restrictions:

 #include "btConvexCast.h"
 #include "btSimplexSolverInterface.h"
-class ConvexPenetrationDepthSolver;
-class ConvexShape;
+class btConvexPenetrationDepthSolver;
+class btConvexShape;

-/// ContinuousConvexCollision implements angular and linear time of impact for convex objects.
+/// btContinuousConvexCollision implements angular and linear time of impact for convex objects.
 /// Based on Brian Mirtich's Conservative Advancement idea (PhD thesis).
 /// Algorithm operates in worldspace, in order to keep inbetween motion globally consistent.
 /// It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops
-class ContinuousConvexCollision : public ConvexCast
+class btContinuousConvexCollision : public btConvexCast
 {
-	SimplexSolverInterface* m_simplexSolver;
-	ConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
-	ConvexShape*	m_convexA;
-	ConvexShape*	m_convexB;
+	btSimplexSolverInterface* m_simplexSolver;
+	btConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
+	btConvexShape*	m_convexA;
+	btConvexShape*	m_convexB;


 public:

-	ContinuousConvexCollision (ConvexShape*	shapeA,ConvexShape*	shapeB ,SimplexSolverInterface* simplexSolver,ConvexPenetrationDepthSolver* penetrationDepthSolver);
+	btContinuousConvexCollision (btConvexShape*	shapeA,btConvexShape*	shapeB ,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver* penetrationDepthSolver);

 	virtual bool	calcTimeOfImpact(
-				const SimdTransform& fromA,
-				const SimdTransform& toA,
-				const SimdTransform& fromB,
-				const SimdTransform& toB,
+				const btTransform& fromA,
+				const btTransform& toA,
+				const btTransform& fromB,
+				const btTransform& toB,
 				CastResult& result);


--- a/src/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp
@@ -15,6 +15,6 @@ subject to the following restrictions:

 #include "btConvexCast.h"

-ConvexCast::~ConvexCast()
+btConvexCast::~btConvexCast()
 {
 }
--- a/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h
@@ -17,28 +17,28 @@ subject to the following restrictions:
 #ifndef CONVEX_CAST_H
 #define CONVEX_CAST_H

-#include <LinearMath/SimdTransform.h>
-#include <LinearMath/SimdVector3.h>
-#include <LinearMath/SimdScalar.h>
-class MinkowskiSumShape;
-#include "LinearMath/GenIDebugDraw.h"
+#include <LinearMath/btTransform.h>
+#include <LinearMath/btVector3.h>
+#include <LinearMath/btScalar.h>
+class btMinkowskiSumShape;
+#include "LinearMath/btIDebugDraw.h"

-/// ConvexCast is an interface for Casting
-class ConvexCast
+/// btConvexCast is an interface for Casting
+class btConvexCast
 {
 public:


-	virtual ~ConvexCast();
+	virtual ~btConvexCast();

 	///RayResult stores the closest result
 	/// alternatively, add a callback method to decide about closest/all results
 	struct	CastResult
 	{
-		//virtual bool	addRayResult(const SimdVector3& normal,SimdScalar	fraction) = 0;
+		//virtual bool	addRayResult(const btVector3& normal,btScalar	fraction) = 0;
 				
-		virtual void	DebugDraw(SimdScalar	fraction) {}
-		virtual void	DrawCoordSystem(const SimdTransform& trans) {}
+		virtual void	DebugDraw(btScalar	fraction) {}
+		virtual void	DrawCoordSystem(const btTransform& trans) {}

 		CastResult()
 			:m_fraction(1e30f),
@@ -49,22 +49,22 @@ public:

 		virtual ~CastResult() {};

-		SimdVector3	m_normal;
-		SimdScalar	m_fraction;
-		SimdTransform	m_hitTransformA;
-		SimdTransform	m_hitTransformB;
+		btVector3	m_normal;
+		btScalar	m_fraction;
+		btTransform	m_hitTransformA;
+		btTransform	m_hitTransformB;

-		IDebugDraw* m_debugDrawer;
+		btIDebugDraw* m_debugDrawer;

 	};


 	/// cast a convex against another convex object
 	virtual bool	calcTimeOfImpact(
-					const SimdTransform& fromA,
-					const SimdTransform& toA,
-					const SimdTransform& fromB,
-					const SimdTransform& toB,
+					const btTransform& fromA,
+					const btTransform& toA,
+					const btTransform& fromB,
+					const btTransform& toB,
 					CastResult& result) = 0;
 };

--- a/src/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
@@ -17,23 +17,23 @@ subject to the following restrictions:
 #ifndef CONVEX_PENETRATION_DEPTH_H
 #define CONVEX_PENETRATION_DEPTH_H

-class SimdVector3;
+class btVector3;
 #include "btSimplexSolverInterface.h"
-class ConvexShape;
-#include "LinearMath/SimdPoint3.h"
-class SimdTransform;
+class btConvexShape;
+#include "LinearMath/btPoint3.h"
+class btTransform;

 ///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.
-class ConvexPenetrationDepthSolver
+class btConvexPenetrationDepthSolver
 {
 public:	
 	
-	virtual ~ConvexPenetrationDepthSolver() {};
-	virtual bool CalcPenDepth( SimplexSolverInterface& simplexSolver,
-		ConvexShape* convexA,ConvexShape* convexB,
-					const SimdTransform& transA,const SimdTransform& transB,
-				SimdVector3& v, SimdPoint3& pa, SimdPoint3& pb,
-				class IDebugDraw* debugDraw
+	virtual ~btConvexPenetrationDepthSolver() {};
+	virtual bool CalcPenDepth( btSimplexSolverInterface& simplexSolver,
+		btConvexShape* convexA,btConvexShape* convexB,
+					const btTransform& transA,const btTransform& transB,
+				btVector3& v, btPoint3& pa, btPoint3& pb,
+				class btIDebugDraw* debugDraw
 				) = 0;


--- a/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
@@ -16,8 +16,8 @@ subject to the following restrictions:

 #ifndef DISCRETE_COLLISION_DETECTOR_INTERFACE_H
 #define DISCRETE_COLLISION_DETECTOR_INTERFACE_H
-#include "LinearMath/SimdTransform.h"
-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"


 /// This interface is made to be used by an iterative approach to do TimeOfImpact calculations
@@ -25,7 +25,7 @@ subject to the following restrictions:
 /// the closest point is on the second object (B), and the normal points from the surface on B towards A.
 /// distance is between closest points on B and closest point on A. So you can calculate closest point on A
 /// by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB
-struct DiscreteCollisionDetectorInterface
+struct btDiscreteCollisionDetectorInterface
 {
 	void operator delete(void* ptr) {};

@@ -37,7 +37,7 @@ struct DiscreteCollisionDetectorInterface

 		///SetShapeIdentifiers provides experimental support for per-triangle material / custom material combiner
 		virtual void SetShapeIdentifiers(int partId0,int index0,	int partId1,int index1)=0;
-		virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)=0;
+		virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)=0;
 	};

 	struct ClosestPointInput
@@ -47,35 +47,35 @@ struct DiscreteCollisionDetectorInterface
 		{
 		}

-		SimdTransform m_transformA;
-		SimdTransform m_transformB;
-		SimdScalar	m_maximumDistanceSquared;
+		btTransform m_transformA;
+		btTransform m_transformB;
+		btScalar	m_maximumDistanceSquared;
 	};

-	virtual ~DiscreteCollisionDetectorInterface() {};
+	virtual ~btDiscreteCollisionDetectorInterface() {};

 	//
 	// give either closest points (distance > 0) or penetration (distance)
 	// the normal always points from B towards A
 	//
-	virtual void	GetClosestPoints(const ClosestPointInput& input,Result& output,class IDebugDraw* debugDraw) = 0;
+	virtual void	GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw) = 0;

-	SimdScalar	getCollisionMargin() { return 0.2f;}
+	btScalar	getCollisionMargin() { return 0.2f;}
 };

-struct StorageResult : public DiscreteCollisionDetectorInterface::Result
+struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
 {
-		SimdVector3	m_normalOnSurfaceB;
-		SimdVector3	m_closestPointInB;
-		SimdScalar	m_distance; //negative means penetration !
+		btVector3	m_normalOnSurfaceB;
+		btVector3	m_closestPointInB;
+		btScalar	m_distance; //negative means penetration !

-		StorageResult() : m_distance(1e30f)
+		btStorageResult() : m_distance(1e30f)
 		{

 		}
-		virtual ~StorageResult() {};
+		virtual ~btStorageResult() {};

-		virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+		virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 		{
 			if (depth < m_distance)
 			{
--- a/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp
@@ -22,37 +22,37 @@ subject to the following restrictions:
 #include "btPointCollector.h"


-GjkConvexCast::GjkConvexCast(ConvexShape* convexA,ConvexShape* convexB,SimplexSolverInterface* simplexSolver)
+btGjkConvexCast::btGjkConvexCast(btConvexShape* convexA,btConvexShape* convexB,btSimplexSolverInterface* simplexSolver)
 :m_simplexSolver(simplexSolver),
 m_convexA(convexA),
 m_convexB(convexB)
 {
 }

-bool	GjkConvexCast::calcTimeOfImpact(
-					const SimdTransform& fromA,
-					const SimdTransform& toA,
-					const SimdTransform& fromB,
-					const SimdTransform& toB,
+bool	btGjkConvexCast::calcTimeOfImpact(
+					const btTransform& fromA,
+					const btTransform& toA,
+					const btTransform& fromB,
+					const btTransform& toB,
 					CastResult& result)
 {


-	MinkowskiSumShape combi(m_convexA,m_convexB);
-	MinkowskiSumShape* convex = &combi;
+	btMinkowskiSumShape combi(m_convexA,m_convexB);
+	btMinkowskiSumShape* convex = &combi;

-	SimdTransform	rayFromLocalA;
-	SimdTransform	rayToLocalA;
+	btTransform	rayFromLocalA;
+	btTransform	rayToLocalA;

 	rayFromLocalA = fromA.inverse()* fromB;
 	rayToLocalA = toA.inverse()* toB;


-	SimdTransform trA,trB;
-	trA = SimdTransform(fromA);
-	trB = SimdTransform(fromB);
-	trA.setOrigin(SimdPoint3(0,0,0));
-	trB.setOrigin(SimdPoint3(0,0,0));
+	btTransform trA,trB;
+	trA = btTransform(fromA);
+	trB = btTransform(fromB);
+	trA.setOrigin(btPoint3(0,0,0));
+	trB.setOrigin(btPoint3(0,0,0));

 	convex->SetTransformA(trA);
 	convex->SetTransformB(trB);
@@ -62,38 +62,38 @@ bool	GjkConvexCast::calcTimeOfImpact(

 	float radius = 0.01f;

-	SimdScalar lambda = 0.f;
-	SimdVector3 s = rayFromLocalA.getOrigin();
-	SimdVector3 r = rayToLocalA.getOrigin()-rayFromLocalA.getOrigin();
-	SimdVector3 x = s;
-	SimdVector3 n;
+	btScalar lambda = 0.f;
+	btVector3 s = rayFromLocalA.getOrigin();
+	btVector3 r = rayToLocalA.getOrigin()-rayFromLocalA.getOrigin();
+	btVector3 x = s;
+	btVector3 n;
 	n.setValue(0,0,0);
 	bool hasResult = false;
-	SimdVector3 c;
+	btVector3 c;

 	float lastLambda = lambda;

 	//first solution, using GJK

 	//no penetration support for now, perhaps pass a pointer when we really want it
-	ConvexPenetrationDepthSolver* penSolverPtr = 0;
+	btConvexPenetrationDepthSolver* penSolverPtr = 0;

-	SimdTransform identityTrans;
+	btTransform identityTrans;
 	identityTrans.setIdentity();

-	SphereShape	raySphere(0.0f);
+	btSphereShape	raySphere(0.0f);
 	raySphere.SetMargin(0.f);

-	SimdTransform sphereTr;
+	btTransform sphereTr;
 	sphereTr.setIdentity();
 	sphereTr.setOrigin( rayFromLocalA.getOrigin());

 	result.DrawCoordSystem(sphereTr);
 	{
-		PointCollector	pointCollector1;
-		GjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);		
+		btPointCollector	pointCollector1;
+		btGjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);		

-		GjkPairDetector::ClosestPointInput input;
+		btGjkPairDetector::ClosestPointInput input;
 		input.m_transformA = sphereTr;
 		input.m_transformB = identityTrans;
 		gjk.GetClosestPoints(input,pointCollector1,0);
@@ -107,7 +107,7 @@ bool	GjkConvexCast::calcTimeOfImpact(

 	if (hasResult)
 	{
-		SimdScalar dist;
+		btScalar dist;
 		dist = (c-x).length();
 		if (dist < radius)
 		{
@@ -120,7 +120,7 @@ bool	GjkConvexCast::calcTimeOfImpact(
 		{
 			
 			n = x - c;
-			SimdScalar nDotr = n.dot(r);
+			btScalar nDotr = n.dot(r);

 			if (nDotr >= -(SIMD_EPSILON*SIMD_EPSILON))
 				return false;
@@ -135,9 +135,9 @@ bool	GjkConvexCast::calcTimeOfImpact(

 			sphereTr.setOrigin( x );
 			result.DrawCoordSystem(sphereTr);
-			PointCollector	pointCollector;
-			GjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);
-			GjkPairDetector::ClosestPointInput input;
+			btPointCollector	pointCollector;
+			btGjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);
+			btGjkPairDetector::ClosestPointInput input;
 			input.m_transformA = sphereTr;
 			input.m_transformB = identityTrans;
 			gjk.GetClosestPoints(input,pointCollector,0);
--- a/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
@@ -20,29 +20,29 @@ subject to the following restrictions:

 #include <BulletCollision/CollisionShapes/btCollisionMargin.h>

-#include "LinearMath/SimdVector3.h"
+#include "LinearMath/btVector3.h"
 #include "btConvexCast.h"
-class ConvexShape;
-class MinkowskiSumShape;
+class btConvexShape;
+class btMinkowskiSumShape;
 #include "btSimplexSolverInterface.h"

 ///GjkConvexCast performs a raycast on a convex object using support mapping.
-class GjkConvexCast : public ConvexCast
+class btGjkConvexCast : public btConvexCast
 {
-	SimplexSolverInterface*	m_simplexSolver;
-	ConvexShape*	m_convexA;
-	ConvexShape*	m_convexB;
+	btSimplexSolverInterface*	m_simplexSolver;
+	btConvexShape*	m_convexA;
+	btConvexShape*	m_convexB;

 public:

-	GjkConvexCast(ConvexShape*	convexA,ConvexShape* convexB,SimplexSolverInterface* simplexSolver);
+	btGjkConvexCast(btConvexShape*	convexA,btConvexShape* convexB,btSimplexSolverInterface* simplexSolver);

 	/// cast a convex against another convex object
 	virtual bool	calcTimeOfImpact(
-					const SimdTransform& fromA,
-					const SimdTransform& toA,
-					const SimdTransform& fromB,
-					const SimdTransform& toB,
+					const btTransform& fromA,
+					const btTransform& toA,
+					const btTransform& fromB,
+					const btTransform& toB,
 					CastResult& result);

 };
--- a/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp
@@ -22,14 +22,14 @@ subject to the following restrictions:
 #include <stdio.h> //for debug printf
 #endif

-static const SimdScalar rel_error = SimdScalar(1.0e-5);
-SimdScalar rel_error2 = rel_error * rel_error;
+static const btScalar rel_error = btScalar(1.0e-5);
+btScalar rel_error2 = rel_error * rel_error;
 float maxdist2 = 1.e30f;


 int gGjkMaxIter=1000;

-GjkPairDetector::GjkPairDetector(ConvexShape* objectA,ConvexShape* objectB,SimplexSolverInterface* simplexSolver,ConvexPenetrationDepthSolver*	penetrationDepthSolver)
+btGjkPairDetector::btGjkPairDetector(btConvexShape* objectA,btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver*	penetrationDepthSolver)
 :m_cachedSeparatingAxis(0.f,0.f,1.f),
 m_penetrationDepthSolver(penetrationDepthSolver),
 m_simplexSolver(simplexSolver),
@@ -43,11 +43,11 @@ m_index1(-1)
 {
 }

-void GjkPairDetector::GetClosestPoints(const ClosestPointInput& input,Result& output,class IDebugDraw* debugDraw)
+void btGjkPairDetector::GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
 {
-	SimdScalar distance=0.f;
-	SimdVector3	normalInB(0.f,0.f,0.f);
-	SimdVector3 pointOnA,pointOnB;
+	btScalar distance=0.f;
+	btVector3	normalInB(0.f,0.f,0.f);
+	btVector3 pointOnA,pointOnB;

 	float marginA = m_minkowskiA->GetMargin();
 	float marginB = m_minkowskiB->GetMargin();
@@ -66,10 +66,10 @@ int curIter = 0;
 	bool checkPenetration = true;

 	{
-		SimdScalar squaredDistance = SIMD_INFINITY;
-		SimdScalar delta = 0.f;
+		btScalar squaredDistance = SIMD_INFINITY;
+		btScalar delta = 0.f;
 		
-		SimdScalar margin = marginA + marginB;
+		btScalar margin = marginA + marginB;
 		
 		

@@ -77,11 +77,11 @@ int curIter = 0;
 		
 		while (true)
 		{
-			//degeneracy, this is typically due to invalid/uninitialized worldtransforms for a CollisionObject
+			//degeneracy, this is typically due to invalid/uninitialized worldtransforms for a btCollisionObject
 			if (curIter++ > gGjkMaxIter)
 			{
 				#if defined(DEBUG) || defined (_DEBUG)
-					printf("GjkPairDetector maxIter exceeded:%i\n",curIter);
+					printf("btGjkPairDetector maxIter exceeded:%i\n",curIter);
 					printf("sepAxis=(%f,%f,%f), squaredDistance = %f, shapeTypeA=%i,shapeTypeB=%i\n",
 					m_cachedSeparatingAxis.getX(),
 					m_cachedSeparatingAxis.getY(),
@@ -94,19 +94,19 @@ int curIter = 0;

 			}

-			SimdVector3 seperatingAxisInA = (-m_cachedSeparatingAxis)* input.m_transformA.getBasis();
-			SimdVector3 seperatingAxisInB = m_cachedSeparatingAxis* input.m_transformB.getBasis();
+			btVector3 seperatingAxisInA = (-m_cachedSeparatingAxis)* input.m_transformA.getBasis();
+			btVector3 seperatingAxisInB = m_cachedSeparatingAxis* input.m_transformB.getBasis();

-			SimdVector3 pInA = m_minkowskiA->LocalGetSupportingVertexWithoutMargin(seperatingAxisInA);
-			SimdVector3 qInB = m_minkowskiB->LocalGetSupportingVertexWithoutMargin(seperatingAxisInB);
-			SimdPoint3  pWorld = input.m_transformA(pInA);	
-			SimdPoint3  qWorld = input.m_transformB(qInB);
+			btVector3 pInA = m_minkowskiA->LocalGetSupportingVertexWithoutMargin(seperatingAxisInA);
+			btVector3 qInB = m_minkowskiB->LocalGetSupportingVertexWithoutMargin(seperatingAxisInB);
+			btPoint3  pWorld = input.m_transformA(pInA);	
+			btPoint3  qWorld = input.m_transformB(qInB);
 			
-			SimdVector3 w	= pWorld - qWorld;
+			btVector3 w	= pWorld - qWorld;
 			delta = m_cachedSeparatingAxis.dot(w);

 			// potential exit, they don't overlap
-			if ((delta > SimdScalar(0.0)) && (delta * delta > squaredDistance * input.m_maximumDistanceSquared)) 
+			if ((delta > btScalar(0.0)) && (delta * delta > squaredDistance * input.m_maximumDistanceSquared)) 
 			{
 				checkPenetration = false;
 				break;
@@ -134,7 +134,7 @@ int curIter = 0;
 				break;
 			}

-			SimdScalar previousSquaredDistance = squaredDistance;
+			btScalar previousSquaredDistance = squaredDistance;
 			squaredDistance = m_cachedSeparatingAxis.length2();
 			
 			//redundant m_simplexSolver->compute_points(pointOnA, pointOnB);
@@ -165,10 +165,10 @@ int curIter = 0;
 			//valid normal
 			if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
 			{
-				float rlen = 1.f / SimdSqrt(lenSqr );
+				float rlen = 1.f / btSqrt(lenSqr );
 				normalInB *= rlen; //normalize
-				SimdScalar s = SimdSqrt(squaredDistance);
-				ASSERT(s > SimdScalar(0.0));
+				btScalar s = btSqrt(squaredDistance);
+				ASSERT(s > btScalar(0.0));
 				pointOnA -= m_cachedSeparatingAxis * (marginA / s);
 				pointOnB += m_cachedSeparatingAxis * (marginB / s);
 				distance = ((1.f/rlen) - margin);
@@ -198,7 +198,7 @@ int curIter = 0;
 					float lenSqr = normalInB.length2();
 					if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
 					{
-						normalInB /= SimdSqrt(lenSqr);
+						normalInB /= btSqrt(lenSqr);
 						distance = -(pointOnA-pointOnB).length();
 					} else
 					{
--- a/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h
@@ -20,24 +20,24 @@ subject to the following restrictions:
 #define GJK_PAIR_DETECTOR_H

 #include "btDiscreteCollisionDetectorInterface.h"
-#include "LinearMath/SimdPoint3.h"
+#include "LinearMath/btPoint3.h"

 #include <BulletCollision/CollisionShapes/btCollisionMargin.h>

-class ConvexShape;
+class btConvexShape;
 #include "btSimplexSolverInterface.h"
-class ConvexPenetrationDepthSolver;
+class btConvexPenetrationDepthSolver;

-/// GjkPairDetector uses GJK to implement the DiscreteCollisionDetectorInterface
-class GjkPairDetector : public DiscreteCollisionDetectorInterface
+/// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
+class btGjkPairDetector : public btDiscreteCollisionDetectorInterface
 {
 	

-	SimdVector3	m_cachedSeparatingAxis;
-	ConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
-	SimplexSolverInterface* m_simplexSolver;
-	ConvexShape* m_minkowskiA;
-	ConvexShape* m_minkowskiB;
+	btVector3	m_cachedSeparatingAxis;
+	btConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
+	btSimplexSolverInterface* m_simplexSolver;
+	btConvexShape* m_minkowskiA;
+	btConvexShape* m_minkowskiB;
 	bool		m_ignoreMargin;
 	

@@ -50,26 +50,26 @@ public:
 	int	m_partId1;
 	int	m_index1;

-	GjkPairDetector(ConvexShape* objectA,ConvexShape* objectB,SimplexSolverInterface* simplexSolver,ConvexPenetrationDepthSolver*	penetrationDepthSolver);
-	virtual ~GjkPairDetector() {};
+	btGjkPairDetector(btConvexShape* objectA,btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver*	penetrationDepthSolver);
+	virtual ~btGjkPairDetector() {};

-	virtual void	GetClosestPoints(const ClosestPointInput& input,Result& output,class IDebugDraw* debugDraw);
+	virtual void	GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw);

-	void SetMinkowskiA(ConvexShape* minkA)
+	void SetMinkowskiA(btConvexShape* minkA)
 	{
 		m_minkowskiA = minkA;
 	}

-	void SetMinkowskiB(ConvexShape* minkB)
+	void SetMinkowskiB(btConvexShape* minkB)
 	{
 		m_minkowskiB = minkB;
 	}
-	void SetCachedSeperatingAxis(const SimdVector3& seperatingAxis)
+	void SetCachedSeperatingAxis(const btVector3& seperatingAxis)
 	{
 		m_cachedSeparatingAxis = seperatingAxis;
 	}

-	void	SetPenetrationDepthSolver(ConvexPenetrationDepthSolver*	penetrationDepthSolver)
+	void	SetPenetrationDepthSolver(btConvexPenetrationDepthSolver*	penetrationDepthSolver)
 	{
 		m_penetrationDepthSolver = penetrationDepthSolver;
 	}
--- a/src/BulletCollision/NarrowPhaseCollision/btManifoldContactAddResult.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btManifoldContactAddResult.cpp
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #include "btManifoldContactAddResult.h"
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"

-ManifoldContactAddResult::ManifoldContactAddResult(SimdTransform transA,SimdTransform transB,PersistentManifold* manifoldPtr)
+btManifoldContactAddResult::btManifoldContactAddResult(btTransform transA,btTransform transB,btPersistentManifold* manifoldPtr)
 		:m_manifoldPtr(manifoldPtr)
 {
 	m_transAInv = transA.inverse();
@@ -25,16 +25,16 @@ ManifoldContactAddResult::ManifoldContactAddResult(SimdTransform transA,SimdTran
 }


-void ManifoldContactAddResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+void btManifoldContactAddResult::AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 {
 	if (depth > m_manifoldPtr->GetContactBreakingTreshold())
 		return;


-	SimdVector3 pointA = pointInWorld + normalOnBInWorld * depth;
-	SimdVector3 localA = m_transAInv(pointA );
-	SimdVector3 localB = m_transBInv(pointInWorld);
-	ManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
+	btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
+	btVector3 localA = m_transAInv(pointA );
+	btVector3 localB = m_transBInv(pointInWorld);
+	btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);

 	int insertIndex = m_manifoldPtr->GetCacheEntry(newPt);
 	if (insertIndex >= 0)
--- a/src/BulletCollision/NarrowPhaseCollision/btManifoldContactAddResult.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btManifoldContactAddResult.h
@@ -18,19 +18,19 @@ subject to the following restrictions:
 #define MANIFOLD_CONTACT_ADD_RESULT_H

 #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
-class PersistentManifold;
+class btPersistentManifold;

-class ManifoldContactAddResult : public DiscreteCollisionDetectorInterface::Result
+class btManifoldContactAddResult : public btDiscreteCollisionDetectorInterface::Result
 {
-	PersistentManifold* m_manifoldPtr;
-	SimdTransform	m_transAInv;
-	SimdTransform	m_transBInv;
+	btPersistentManifold* m_manifoldPtr;
+	btTransform	m_transAInv;
+	btTransform	m_transBInv;

 public:

-	ManifoldContactAddResult(SimdTransform transA,SimdTransform transB,PersistentManifold* manifoldPtr);
+	btManifoldContactAddResult(btTransform transA,btTransform transB,btPersistentManifold* manifoldPtr);

-	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth);
+	virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);

 };

--- a/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h
@@ -16,8 +16,8 @@ subject to the following restrictions:
 #ifndef MANIFOLD_CONTACT_POINT_H
 #define MANIFOLD_CONTACT_POINT_H

-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransformUtil.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransformUtil.h"



@@ -25,17 +25,17 @@ subject to the following restrictions:

 /// ManifoldContactPoint collects and maintains persistent contactpoints.
 /// used to improve stability and performance of rigidbody dynamics response.
-class ManifoldPoint
+class btManifoldPoint
 	{
 		public:
-			ManifoldPoint()
+			btManifoldPoint()
 				:m_userPersistentData(0)
 			{
 			}

-			ManifoldPoint( const SimdVector3 &pointA, const SimdVector3 &pointB, 
-					const SimdVector3 &normal, 
-					SimdScalar distance ) :
+			btManifoldPoint( const btVector3 &pointA, const btVector3 &pointB, 
+					const btVector3 &normal, 
+					btScalar distance ) :
 					m_localPointA( pointA ), 
 					m_localPointB( pointB ), 
 					m_normalWorldOnB( normal ), 
@@ -51,12 +51,12 @@ class ManifoldPoint

 			

-			SimdVector3 m_localPointA;			
-			SimdVector3 m_localPointB;			
-			SimdVector3	m_positionWorldOnB;
+			btVector3 m_localPointA;			
+			btVector3 m_localPointB;			
+			btVector3	m_positionWorldOnB;
 			///m_positionWorldOnA is redundant information, see GetPositionWorldOnA(), but for clarity
-			SimdVector3	m_positionWorldOnA;
-			SimdVector3 m_normalWorldOnB;
+			btVector3	m_positionWorldOnA;
+			btVector3 m_normalWorldOnB;
 		
 			float	m_distance1;
 			float	m_combinedFriction;
@@ -76,12 +76,12 @@ class ManifoldPoint
 				return m_lifeTime;
 			}

-			SimdVector3 GetPositionWorldOnA() {
+			btVector3 GetPositionWorldOnA() {
 				return m_positionWorldOnA;
 //				return m_positionWorldOnB + m_normalWorldOnB * m_distance1;
 			}

-			const SimdVector3& GetPositionWorldOnB()
+			const btVector3& GetPositionWorldOnB()
 			{
 				return m_positionWorldOnB;
 			}
--- a/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp
@@ -20,22 +20,22 @@ subject to the following restrictions:
 #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"


-struct MyResult : public DiscreteCollisionDetectorInterface::Result
+struct MyResult : public btDiscreteCollisionDetectorInterface::Result
 {

 	MyResult():m_hasResult(false)
 	{
 	}
 	
-	SimdVector3 m_normalOnBInWorld;
-	SimdVector3 m_pointInWorld;
+	btVector3 m_normalOnBInWorld;
+	btVector3 m_pointInWorld;
 	float m_depth;
 	bool	m_hasResult;

 	virtual void SetShapeIdentifiers(int partId0,int index0,	int partId1,int index1)
 	{
 	}
-	void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+	void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 	{
 		m_normalOnBInWorld = normalOnBInWorld;
 		m_pointInWorld = pointInWorld;
@@ -45,80 +45,80 @@ struct MyResult : public DiscreteCollisionDetectorInterface::Result
 };

 #define NUM_UNITSPHERE_POINTS 42
-static SimdVector3	sPenetrationDirections[NUM_UNITSPHERE_POINTS] = 
+static btVector3	sPenetrationDirections[NUM_UNITSPHERE_POINTS] = 
 {
-SimdVector3(0.000000f , -0.000000f,-1.000000f),
-SimdVector3(0.723608f , -0.525725f,-0.447219f),
-SimdVector3(-0.276388f , -0.850649f,-0.447219f),
-SimdVector3(-0.894426f , -0.000000f,-0.447216f),
-SimdVector3(-0.276388f , 0.850649f,-0.447220f),
-SimdVector3(0.723608f , 0.525725f,-0.447219f),
-SimdVector3(0.276388f , -0.850649f,0.447220f),
-SimdVector3(-0.723608f , -0.525725f,0.447219f),
-SimdVector3(-0.723608f , 0.525725f,0.447219f),
-SimdVector3(0.276388f , 0.850649f,0.447219f),
-SimdVector3(0.894426f , 0.000000f,0.447216f),
-SimdVector3(-0.000000f , 0.000000f,1.000000f),
-SimdVector3(0.425323f , -0.309011f,-0.850654f),
-SimdVector3(-0.162456f , -0.499995f,-0.850654f),
-SimdVector3(0.262869f , -0.809012f,-0.525738f),
-SimdVector3(0.425323f , 0.309011f,-0.850654f),
-SimdVector3(0.850648f , -0.000000f,-0.525736f),
-SimdVector3(-0.525730f , -0.000000f,-0.850652f),
-SimdVector3(-0.688190f , -0.499997f,-0.525736f),
-SimdVector3(-0.162456f , 0.499995f,-0.850654f),
-SimdVector3(-0.688190f , 0.499997f,-0.525736f),
-SimdVector3(0.262869f , 0.809012f,-0.525738f),
-SimdVector3(0.951058f , 0.309013f,0.000000f),
-SimdVector3(0.951058f , -0.309013f,0.000000f),
-SimdVector3(0.587786f , -0.809017f,0.000000f),
-SimdVector3(0.000000f , -1.000000f,0.000000f),
-SimdVector3(-0.587786f , -0.809017f,0.000000f),
-SimdVector3(-0.951058f , -0.309013f,-0.000000f),
-SimdVector3(-0.951058f , 0.309013f,-0.000000f),
-SimdVector3(-0.587786f , 0.809017f,-0.000000f),
-SimdVector3(-0.000000f , 1.000000f,-0.000000f),
-SimdVector3(0.587786f , 0.809017f,-0.000000f),
-SimdVector3(0.688190f , -0.499997f,0.525736f),
-SimdVector3(-0.262869f , -0.809012f,0.525738f),
-SimdVector3(-0.850648f , 0.000000f,0.525736f),
-SimdVector3(-0.262869f , 0.809012f,0.525738f),
-SimdVector3(0.688190f , 0.499997f,0.525736f),
-SimdVector3(0.525730f , 0.000000f,0.850652f),
-SimdVector3(0.162456f , -0.499995f,0.850654f),
-SimdVector3(-0.425323f , -0.309011f,0.850654f),
-SimdVector3(-0.425323f , 0.309011f,0.850654f),
-SimdVector3(0.162456f , 0.499995f,0.850654f)
+btVector3(0.000000f , -0.000000f,-1.000000f),
+btVector3(0.723608f , -0.525725f,-0.447219f),
+btVector3(-0.276388f , -0.850649f,-0.447219f),
+btVector3(-0.894426f , -0.000000f,-0.447216f),
+btVector3(-0.276388f , 0.850649f,-0.447220f),
+btVector3(0.723608f , 0.525725f,-0.447219f),
+btVector3(0.276388f , -0.850649f,0.447220f),
+btVector3(-0.723608f , -0.525725f,0.447219f),
+btVector3(-0.723608f , 0.525725f,0.447219f),
+btVector3(0.276388f , 0.850649f,0.447219f),
+btVector3(0.894426f , 0.000000f,0.447216f),
+btVector3(-0.000000f , 0.000000f,1.000000f),
+btVector3(0.425323f , -0.309011f,-0.850654f),
+btVector3(-0.162456f , -0.499995f,-0.850654f),
+btVector3(0.262869f , -0.809012f,-0.525738f),
+btVector3(0.425323f , 0.309011f,-0.850654f),
+btVector3(0.850648f , -0.000000f,-0.525736f),
+btVector3(-0.525730f , -0.000000f,-0.850652f),
+btVector3(-0.688190f , -0.499997f,-0.525736f),
+btVector3(-0.162456f , 0.499995f,-0.850654f),
+btVector3(-0.688190f , 0.499997f,-0.525736f),
+btVector3(0.262869f , 0.809012f,-0.525738f),
+btVector3(0.951058f , 0.309013f,0.000000f),
+btVector3(0.951058f , -0.309013f,0.000000f),
+btVector3(0.587786f , -0.809017f,0.000000f),
+btVector3(0.000000f , -1.000000f,0.000000f),
+btVector3(-0.587786f , -0.809017f,0.000000f),
+btVector3(-0.951058f , -0.309013f,-0.000000f),
+btVector3(-0.951058f , 0.309013f,-0.000000f),
+btVector3(-0.587786f , 0.809017f,-0.000000f),
+btVector3(-0.000000f , 1.000000f,-0.000000f),
+btVector3(0.587786f , 0.809017f,-0.000000f),
+btVector3(0.688190f , -0.499997f,0.525736f),
+btVector3(-0.262869f , -0.809012f,0.525738f),
+btVector3(-0.850648f , 0.000000f,0.525736f),
+btVector3(-0.262869f , 0.809012f,0.525738f),
+btVector3(0.688190f , 0.499997f,0.525736f),
+btVector3(0.525730f , 0.000000f,0.850652f),
+btVector3(0.162456f , -0.499995f,0.850654f),
+btVector3(-0.425323f , -0.309011f,0.850654f),
+btVector3(-0.425323f , 0.309011f,0.850654f),
+btVector3(0.162456f , 0.499995f,0.850654f)
 };


-bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simplexSolver,
-												   ConvexShape* convexA,ConvexShape* convexB,
-												   const SimdTransform& transA,const SimdTransform& transB,
-												   SimdVector3& v, SimdPoint3& pa, SimdPoint3& pb,
-												   class IDebugDraw* debugDraw
+bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& simplexSolver,
+												   btConvexShape* convexA,btConvexShape* convexB,
+												   const btTransform& transA,const btTransform& transB,
+												   btVector3& v, btPoint3& pa, btPoint3& pb,
+												   class btIDebugDraw* debugDraw
 												   )
 {

 	//just take fixed number of orientation, and sample the penetration depth in that direction
 	float minProj = 1e30f;
-	SimdVector3 minNorm;
-	SimdVector3 minVertex;
-	SimdVector3 minA,minB;
-	SimdVector3 seperatingAxisInA,seperatingAxisInB;
-	SimdVector3 pInA,qInB,pWorld,qWorld,w;
+	btVector3 minNorm;
+	btVector3 minVertex;
+	btVector3 minA,minB;
+	btVector3 seperatingAxisInA,seperatingAxisInB;
+	btVector3 pInA,qInB,pWorld,qWorld,w;

 #define USE_BATCHED_SUPPORT 1
 #ifdef USE_BATCHED_SUPPORT
-	SimdVector3	supportVerticesABatch[NUM_UNITSPHERE_POINTS];
-	SimdVector3	supportVerticesBBatch[NUM_UNITSPHERE_POINTS];
-	SimdVector3	seperatingAxisInABatch[NUM_UNITSPHERE_POINTS];
-	SimdVector3	seperatingAxisInBBatch[NUM_UNITSPHERE_POINTS];
+	btVector3	supportVerticesABatch[NUM_UNITSPHERE_POINTS];
+	btVector3	supportVerticesBBatch[NUM_UNITSPHERE_POINTS];
+	btVector3	seperatingAxisInABatch[NUM_UNITSPHERE_POINTS];
+	btVector3	seperatingAxisInBBatch[NUM_UNITSPHERE_POINTS];
 	int i;

 	for (i=0;i<NUM_UNITSPHERE_POINTS;i++)
 	{
-		const SimdVector3& norm = sPenetrationDirections[i];
+		const btVector3& norm = sPenetrationDirections[i];
 		seperatingAxisInABatch[i] = (-norm)* transA.getBasis();
 		seperatingAxisInBBatch[i] = norm * transB.getBasis();
 	}
@@ -127,7 +127,7 @@ bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simpl
 	convexB->BatchedUnitVectorGetSupportingVertexWithoutMargin(seperatingAxisInBBatch,supportVerticesBBatch,NUM_UNITSPHERE_POINTS);
 	for (i=0;i<NUM_UNITSPHERE_POINTS;i++)
 	{
-		const SimdVector3& norm = sPenetrationDirections[i];
+		const btVector3& norm = sPenetrationDirections[i];
 		seperatingAxisInA = seperatingAxisInABatch[i];
 		seperatingAxisInB = seperatingAxisInBBatch[i];

@@ -150,7 +150,7 @@ bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simpl
 #else
 	for (int i=0;i<NUM_UNITSPHERE_POINTS;i++)
 	{
-		const SimdVector3& norm = sPenetrationDirections[i];
+		const btVector3& norm = sPenetrationDirections[i];
 		seperatingAxisInA = (-norm)* transA.getBasis();
 		seperatingAxisInB = norm* transB.getBasis();
 		pInA = convexA->LocalGetSupportingVertexWithoutMargin(seperatingAxisInA);
@@ -183,10 +183,10 @@ bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simpl
 #ifdef DEBUG_DRAW
 	if (debugDraw)
 	{
-		SimdVector3 color(0,1,0);
+		btVector3 color(0,1,0);
 		debugDraw->DrawLine(minA,minB,color);
-		color = SimdVector3 (1,1,1);
-		SimdVector3 vec = minB-minA;
+		color = btVector3 (1,1,1);
+		btVector3 vec = minB-minA;
 		float prj2 = minNorm.dot(vec);
 		debugDraw->DrawLine(minA,minA+(minNorm*minProj),color);

@@ -195,18 +195,18 @@ bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simpl

 	

-	GjkPairDetector gjkdet(convexA,convexB,&simplexSolver,0);
+	btGjkPairDetector gjkdet(convexA,convexB,&simplexSolver,0);

-	SimdScalar offsetDist = minProj;
-	SimdVector3 offset = minNorm * offsetDist;
+	btScalar offsetDist = minProj;
+	btVector3 offset = minNorm * offsetDist;
 	


-	GjkPairDetector::ClosestPointInput input;
+	btGjkPairDetector::ClosestPointInput input;
 		
-	SimdVector3 newOrg = transA.getOrigin() + offset;
+	btVector3 newOrg = transA.getOrigin() + offset;

-	SimdTransform displacedTrans = transA;
+	btTransform displacedTrans = transA;
 	displacedTrans.setOrigin(newOrg);

 	input.m_transformA = displacedTrans;
@@ -232,7 +232,7 @@ bool MinkowskiPenetrationDepthSolver::CalcPenDepth(SimplexSolverInterface& simpl
 #ifdef DEBUG_DRAW
 		if (debugDraw)
 		{
-			SimdVector3 color(1,0,0);
+			btVector3 color(1,0,0);
 			debugDraw->DrawLine(pa,pb,color);
 		}
 #endif//DEBUG_DRAW
--- a/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h
@@ -20,15 +20,15 @@ subject to the following restrictions:

 ///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
 ///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.
-class MinkowskiPenetrationDepthSolver : public ConvexPenetrationDepthSolver
+class btMinkowskiPenetrationDepthSolver : public btConvexPenetrationDepthSolver
 {
 public:

-	virtual bool CalcPenDepth( SimplexSolverInterface& simplexSolver,
-	ConvexShape* convexA,ConvexShape* convexB,
-				const SimdTransform& transA,const SimdTransform& transB,
-			SimdVector3& v, SimdPoint3& pa, SimdPoint3& pb,
-			class IDebugDraw* debugDraw
+	virtual bool CalcPenDepth( btSimplexSolverInterface& simplexSolver,
+	btConvexShape* convexA,btConvexShape* convexB,
+				const btTransform& transA,const btTransform& transB,
+			btVector3& v, btPoint3& pa, btPoint3& pb,
+			class btIDebugDraw* debugDraw
 			);

 };
--- a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp
@@ -15,7 +15,7 @@ subject to the following restrictions:


 #include "btPersistentManifold.h"
-#include "LinearMath/SimdTransform.h"
+#include "LinearMath/btTransform.h"
 #include <assert.h>

 float						gContactBreakingTreshold = 0.02f;
@@ -23,7 +23,7 @@ ContactDestroyedCallback	gContactDestroyedCallback = 0;



-PersistentManifold::PersistentManifold()
+btPersistentManifold::btPersistentManifold()
 :m_body0(0),
 m_body1(0),
 m_cachedPoints (0),
@@ -32,7 +32,7 @@ m_index1(0)
 }


-void	PersistentManifold::ClearManifold()
+void	btPersistentManifold::ClearManifold()
 {
 	int i;
 	for (i=0;i<m_cachedPoints;i++)
@@ -44,7 +44,7 @@ void	PersistentManifold::ClearManifold()

 #ifdef DEBUG_PERSISTENCY
 #include <stdio.h>
-void	PersistentManifold::DebugPersistency()
+void	btPersistentManifold::DebugPersistency()
 {
 	int i;
 	printf("DebugPersistency : numPoints %d\n",m_cachedPoints);
@@ -55,7 +55,7 @@ void	PersistentManifold::DebugPersistency()
 }
 #endif //DEBUG_PERSISTENCY

-void PersistentManifold::ClearUserCache(ManifoldPoint& pt)
+void btPersistentManifold::ClearUserCache(btManifoldPoint& pt)
 {

 	void* oldPtr = pt.m_userPersistentData;
@@ -91,7 +91,7 @@ void PersistentManifold::ClearUserCache(ManifoldPoint& pt)
 }


-int PersistentManifold::SortCachedPoints(const ManifoldPoint& pt) 
+int btPersistentManifold::SortCachedPoints(const btManifoldPoint& pt) 
 {

 		//calculate 4 possible cases areas, and take biggest area
@@ -111,55 +111,55 @@ int PersistentManifold::SortCachedPoints(const ManifoldPoint& pt)
 		}
 #endif //KEEP_DEEPEST_POINT
 		
-		SimdScalar res0(0.f),res1(0.f),res2(0.f),res3(0.f);
+		btScalar res0(0.f),res1(0.f),res2(0.f),res3(0.f);
 		if (maxPenetrationIndex != 0)
 		{
-			SimdVector3 a0 = pt.m_localPointA-m_pointCache[1].m_localPointA;
-			SimdVector3 b0 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
-			SimdVector3 cross = a0.cross(b0);
+			btVector3 a0 = pt.m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 b0 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
+			btVector3 cross = a0.cross(b0);
 			res0 = cross.length2();
 		}
 		if (maxPenetrationIndex != 1)
 		{
-			SimdVector3 a1 = pt.m_localPointA-m_pointCache[0].m_localPointA;
-			SimdVector3 b1 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
-			SimdVector3 cross = a1.cross(b1);
+			btVector3 a1 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b1 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
+			btVector3 cross = a1.cross(b1);
 			res1 = cross.length2();
 		}

 		if (maxPenetrationIndex != 2)
 		{
-			SimdVector3 a2 = pt.m_localPointA-m_pointCache[0].m_localPointA;
-			SimdVector3 b2 = m_pointCache[3].m_localPointA-m_pointCache[1].m_localPointA;
-			SimdVector3 cross = a2.cross(b2);
+			btVector3 a2 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b2 = m_pointCache[3].m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 cross = a2.cross(b2);
 			res2 = cross.length2();
 		}

 		if (maxPenetrationIndex != 3)
 		{
-			SimdVector3 a3 = pt.m_localPointA-m_pointCache[0].m_localPointA;
-			SimdVector3 b3 = m_pointCache[2].m_localPointA-m_pointCache[1].m_localPointA;
-			SimdVector3 cross = a3.cross(b3);
+			btVector3 a3 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b3 = m_pointCache[2].m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 cross = a3.cross(b3);
 			res3 = cross.length2();
 		}

-		SimdVector4 maxvec(res0,res1,res2,res3);
+		btVector4 maxvec(res0,res1,res2,res3);
 		int biggestarea = maxvec.closestAxis4();
 		return biggestarea;
 }


-int PersistentManifold::GetCacheEntry(const ManifoldPoint& newPoint) const
+int btPersistentManifold::GetCacheEntry(const btManifoldPoint& newPoint) const
 {
-	SimdScalar shortestDist =  GetContactBreakingTreshold() * GetContactBreakingTreshold();
+	btScalar shortestDist =  GetContactBreakingTreshold() * GetContactBreakingTreshold();
 	int size = GetNumContacts();
 	int nearestPoint = -1;
 	for( int i = 0; i < size; i++ )
 	{
-		const ManifoldPoint &mp = m_pointCache[i];
+		const btManifoldPoint &mp = m_pointCache[i];

-		SimdVector3 diffA =  mp.m_localPointA- newPoint.m_localPointA;
-		const SimdScalar distToManiPoint = diffA.dot(diffA);
+		btVector3 diffA =  mp.m_localPointA- newPoint.m_localPointA;
+		const btScalar distToManiPoint = diffA.dot(diffA);
 		if( distToManiPoint < shortestDist )
 		{
 			shortestDist = distToManiPoint;
@@ -169,7 +169,7 @@ int PersistentManifold::GetCacheEntry(const ManifoldPoint& newPoint) const
 	return nearestPoint;
 }

-void PersistentManifold::AddManifoldPoint(const ManifoldPoint& newPoint)
+void btPersistentManifold::AddManifoldPoint(const btManifoldPoint& newPoint)
 {
 	assert(ValidContactDistance(newPoint));

@@ -193,19 +193,19 @@ void PersistentManifold::AddManifoldPoint(const ManifoldPoint& newPoint)
 	ReplaceContactPoint(newPoint,insertIndex);
 }

-float	PersistentManifold::GetContactBreakingTreshold() const
+float	btPersistentManifold::GetContactBreakingTreshold() const
 {
 	return gContactBreakingTreshold;
 }

-void PersistentManifold::RefreshContactPoints(const SimdTransform& trA,const SimdTransform& trB)
+void btPersistentManifold::RefreshContactPoints(const btTransform& trA,const btTransform& trB)
 {
 	int i;

 	/// first refresh worldspace positions and distance
 	for (i=GetNumContacts()-1;i>=0;i--)
 	{
-		ManifoldPoint &manifoldPoint = m_pointCache[i];
+		btManifoldPoint &manifoldPoint = m_pointCache[i];
 		manifoldPoint.m_positionWorldOnA = trA( manifoldPoint.m_localPointA );
 		manifoldPoint.m_positionWorldOnB = trB( manifoldPoint.m_localPointB );
 		manifoldPoint.m_distance1 = (manifoldPoint.m_positionWorldOnA -  manifoldPoint.m_positionWorldOnB).dot(manifoldPoint.m_normalWorldOnB);
@@ -213,12 +213,12 @@ void PersistentManifold::RefreshContactPoints(const SimdTransform& trA,const Sim
 	}

 	/// then 
-	SimdScalar distance2d;
-	SimdVector3 projectedDifference,projectedPoint;
+	btScalar distance2d;
+	btVector3 projectedDifference,projectedPoint;
 	for (i=GetNumContacts()-1;i>=0;i--)
 	{
 		
-		ManifoldPoint &manifoldPoint = m_pointCache[i];
+		btManifoldPoint &manifoldPoint = m_pointCache[i];
 		//contact becomes invalid when signed distance exceeds margin (projected on contactnormal direction)
 		if (!ValidContactDistance(manifoldPoint))
 		{
--- a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h
@@ -17,11 +17,11 @@ subject to the following restrictions:
 #define PERSISTENT_MANIFOLD_H


-#include "LinearMath/SimdVector3.h"
-#include "LinearMath/SimdTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
 #include "btManifoldPoint.h"

-struct CollisionResult;
+struct btCollisionResult;

 ///contact breaking and merging treshold
 extern float gContactBreakingTreshold;
@@ -36,10 +36,10 @@ extern ContactDestroyedCallback	gContactDestroyedCallback;

 ///PersistentManifold maintains contact points, and reduces them to 4.
 ///It does contact filtering/contact reduction.
-class PersistentManifold 
+class btPersistentManifold 
 {

-	ManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];
+	btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];

 	/// this two body pointers can point to the physics rigidbody class.
 	/// void* will allow any rigidbody class
@@ -49,17 +49,17 @@ class PersistentManifold

 	
 	/// sort cached points so most isolated points come first
-	int	SortCachedPoints(const ManifoldPoint& pt);
+	int	SortCachedPoints(const btManifoldPoint& pt);

-	int		FindContactPoint(const ManifoldPoint* unUsed, int numUnused,const ManifoldPoint& pt);
+	int		FindContactPoint(const btManifoldPoint* unUsed, int numUnused,const btManifoldPoint& pt);

 public:

 	int m_index1;

-	PersistentManifold();
+	btPersistentManifold();

-	PersistentManifold(void* body0,void* body1)
+	btPersistentManifold(void* body0,void* body1)
 		: m_body0(body0),m_body1(body1),m_cachedPoints(0)
 	{
 	}
@@ -76,7 +76,7 @@ public:
 		m_body1 = body1;
 	}

-	void ClearUserCache(ManifoldPoint& pt);
+	void ClearUserCache(btManifoldPoint& pt);

 #ifdef DEBUG_PERSISTENCY
 	void	DebugPersistency();
@@ -84,13 +84,13 @@ public:
 	
 	inline int	GetNumContacts() const { return m_cachedPoints;}

-	inline const ManifoldPoint& GetContactPoint(int index) const
+	inline const btManifoldPoint& GetContactPoint(int index) const
 	{
 		ASSERT(index < m_cachedPoints);
 		return m_pointCache[index];
 	}

-	inline ManifoldPoint& GetContactPoint(int index)
+	inline btManifoldPoint& GetContactPoint(int index)
 	{
 		ASSERT(index < m_cachedPoints);
 		return m_pointCache[index];
@@ -99,9 +99,9 @@ public:
 	/// todo: get this margin from the current physics / collision environment
 	float	GetContactBreakingTreshold() const;
 	
-	int GetCacheEntry(const ManifoldPoint& newPoint) const;
+	int GetCacheEntry(const btManifoldPoint& newPoint) const;

-	void AddManifoldPoint( const ManifoldPoint& newPoint);
+	void AddManifoldPoint( const btManifoldPoint& newPoint);

 	void RemoveContactPoint (int index)
 	{
@@ -113,7 +113,7 @@ public:
 		m_pointCache[lastUsedIndex].m_userPersistentData = 0;
 		m_cachedPoints--;
 	}
-	void ReplaceContactPoint(const ManifoldPoint& newPoint,int insertIndex)
+	void ReplaceContactPoint(const btManifoldPoint& newPoint,int insertIndex)
 	{
 		assert(ValidContactDistance(newPoint));

@@ -122,12 +122,12 @@ public:
 		m_pointCache[insertIndex] = newPoint;
 	}

-	bool ValidContactDistance(const ManifoldPoint& pt) const
+	bool ValidContactDistance(const btManifoldPoint& pt) const
 	{
 		return pt.m_distance1 <= GetContactBreakingTreshold();
 	}
 	/// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
-	void	RefreshContactPoints(  const SimdTransform& trA,const SimdTransform& trB);
+	void	RefreshContactPoints(  const btTransform& trA,const btTransform& trB);

 	void	ClearManifold();

--- a/src/BulletCollision/NarrowPhaseCollision/btPointCollector.h
+++ b/src/BulletCollision/NarrowPhaseCollision/btPointCollector.h
@@ -20,17 +20,17 @@ subject to the following restrictions:



-struct PointCollector : public DiscreteCollisionDetectorInterface::Result
+struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result
 {
 	
 	
-	SimdVector3 m_normalOnBInWorld;
-	SimdVector3 m_pointInWorld;
-	SimdScalar	m_distance;//negative means penetration
+	btVector3 m_normalOnBInWorld;
+	btVector3 m_pointInWorld;
+	btScalar	m_distance;//negative means penetration

 	bool	m_hasResult;

-	PointCollector () 
+	btPointCollector () 
 		: m_distance(1e30f),m_hasResult(false)
 	{
 	}
@@ -40,7 +40,7 @@ struct PointCollector : public DiscreteCollisionDetectorInterface::Result
 		//??
 	}

-	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+	virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
 	{
 		if (depth< m_distance)
 		{
--- a/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp
@@ -16,7 +16,7 @@ subject to the following restrictions:

 #include "btRaycastCallback.h"

-TriangleRaycastCallback::TriangleRaycastCallback(const SimdVector3& from,const SimdVector3& to)
+btTriangleRaycastCallback::btTriangleRaycastCallback(const btVector3& from,const btVector3& to)
 	:
 	m_from(from),
 	m_to(to),
@@ -27,18 +27,18 @@ TriangleRaycastCallback::TriangleRaycastCallback(const SimdVector3& from,const S



-void TriangleRaycastCallback::ProcessTriangle(SimdVector3* triangle,int partId, int triangleIndex)
+void btTriangleRaycastCallback::ProcessTriangle(btVector3* triangle,int partId, int triangleIndex)
 {
 	

-	const SimdVector3 &vert0=triangle[0];
-	const SimdVector3 &vert1=triangle[1];
-	const SimdVector3 &vert2=triangle[2];
+	const btVector3 &vert0=triangle[0];
+	const btVector3 &vert1=triangle[1];
+	const btVector3 &vert2=triangle[2];

-	SimdVector3 v10; v10 = vert1 - vert0 ;
-	SimdVector3 v20; v20 = vert2 - vert0 ;
+	btVector3 v10; v10 = vert1 - vert0 ;
+	btVector3 v20; v20 = vert2 - vert0 ;

-	SimdVector3 triangleNormal; triangleNormal = v10.cross( v20 );
+	btVector3 triangleNormal; triangleNormal = v10.cross( v20 );
 	
 	const float dist = vert0.dot(triangleNormal);
 	float dist_a = triangleNormal.dot(m_from) ;
@@ -64,22 +64,22 @@ void TriangleRaycastCallback::ProcessTriangle(SimdVector3* triangle,int partId,

 		float edge_tolerance =triangleNormal.length2();		
 		edge_tolerance *= -0.0001f;
-		SimdVector3 point; point.setInterpolate3( m_from, m_to, distance);
+		btVector3 point; point.setInterpolate3( m_from, m_to, distance);
 		{
-			SimdVector3 v0p; v0p = vert0 - point;
-			SimdVector3 v1p; v1p = vert1 - point;
-			SimdVector3 cp0; cp0 = v0p.cross( v1p );
+			btVector3 v0p; v0p = vert0 - point;
+			btVector3 v1p; v1p = vert1 - point;
+			btVector3 cp0; cp0 = v0p.cross( v1p );

 			if ( (float)(cp0.dot(triangleNormal)) >=edge_tolerance) 
 			{
 						

-				SimdVector3 v2p; v2p = vert2 -  point;
-				SimdVector3 cp1;
+				btVector3 v2p; v2p = vert2 -  point;
+				btVector3 cp1;
 				cp1 = v1p.cross( v2p);
 				if ( (float)(cp1.dot(triangleNormal)) >=edge_tolerance) 
 				{
-					SimdVector3 cp2;
+					btVector3 cp2;
 					cp2 = v2p.cross(v0p);
 					
 					if ( (float)(cp2.dot(triangleNormal)) >=edge_tolerance) 
--- a/Show More
+++ b/Show More