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

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

src/BulletCollision/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);

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)) &&

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...
 	}

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);
 	
 
 

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;

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 ;

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);

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;
 
 };
 

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;

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);

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);

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;

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;
 
 
 

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);

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;
 
 };
 

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);
 }

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);
 
 };
 

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++)
 	{

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
 	{

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);
 }

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;
 
 };
 

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);

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 
 	{

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);

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; }

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
 {
 
 }

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;
 
 
 };

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));
 
 }
 

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;

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;
 
 }

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();
 	}
 
 

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;
 }

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

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++)

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;
 		}

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;
 }

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";}
 
 };
 

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()
 {
 
 }

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;
 };
 
 

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;

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);
 	}

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();
 }

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;

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);
 		

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

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;