Contribution to add optional double precision floating point support. Define BT_USE_DOUBLE_PRECISION for all involved libraries/apps.

src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp

@@ -61,7 +61,7 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab
 
 	btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;
 
-	m_quantize = btVector3(65535.0f,65535.0f,65535.0f) / aabbSize;
+	m_quantize = btVector3(btScalar(65535.0),btScalar(65535.0),btScalar(65535.0)) / aabbSize;
 
 	// allocate handles buffer and put all handles on free list
 	m_pHandles = new Handle[maxHandles];

src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h

@@ -16,6 +16,8 @@ subject to the following restrictions:
 #ifndef COLLISION_ALGORITHM_H
 #define COLLISION_ALGORITHM_H
 
+#include "LinearMath/btScalar.h"
+
 struct btBroadphaseProxy;
 class btDispatcher;
 class btManifoldResult;
@@ -66,7 +68,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
 
 };
 

src/BulletCollision/BroadphaseCollision/btDispatcher.h

@@ -16,6 +16,8 @@ subject to the following restrictions:
 #ifndef _DISPATCHER_H
 #define _DISPATCHER_H
 
+#include "LinearMath/btScalar.h"
+
 class btCollisionAlgorithm;
 struct btBroadphaseProxy;
 class btRigidBody;
@@ -34,10 +36,10 @@ struct btDispatcherInfo
 		DISPATCH_CONTINUOUS
 	};
 	btDispatcherInfo()
-		:m_timeStep(0.f),
+		:m_timeStep(btScalar(0.)),
 		m_stepCount(0),
 		m_dispatchFunc(DISPATCH_DISCRETE),
-		m_timeOfImpact(1.f),
+		m_timeOfImpact(btScalar(1.)),
 		m_useContinuous(false),
 		m_debugDraw(0),
 		m_enableSatConvex(false),
@@ -46,10 +48,10 @@ struct btDispatcherInfo
 	{
 
 	}
-	float	m_timeStep;
+	btScalar	m_timeStep;
 	int		m_stepCount;
 	int		m_dispatchFunc;
-	float	m_timeOfImpact;
+	btScalar	m_timeOfImpact;
 	bool	m_useContinuous;
 	class btIDebugDraw*	m_debugDraw;
 	bool	m_enableSatConvex;

src/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp

@@ -13,6 +13,7 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
+#include "LinearMath/btScalar.h"
 #include "SphereTriangleDetector.h"
 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
 #include "BulletCollision/CollisionShapes/btSphereShape.h"
@@ -32,9 +33,9 @@ void	SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input,Res
 	const btTransform& transformB = input.m_transformB;
 
 	btVector3 point,normal;
-	btScalar timeOfImpact = 1.f;
-	btScalar depth = 0.f;
-//	output.m_distance = 1e30f;
+	btScalar timeOfImpact = btScalar(1.);
+	btScalar depth = btScalar(0.);
+//	output.m_distance = btScalar(1e30);
 	//move sphere into triangle space
 	btTransform	sphereInTr = transformB.inverseTimes(transformA);
 
@@ -45,19 +46,19 @@ void	SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input,Res
 
 }
 
-#define MAX_OVERLAP 0.f
+#define MAX_OVERLAP btScalar(0.)
 
 
 
 // See also geometrictools.com
 // Basic idea: D = |p - (lo + t0*lv)| where t0 = lv . (p - lo) / lv . lv
-float SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest) {
+btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest) {
 	btVector3 diff = p - from;
 	btVector3 v = to - from;
-	float t = v.dot(diff);
+	btScalar t = v.dot(diff);
 	
 	if (t > 0) {
-		float dotVV = v.dot(v);
+		btScalar dotVV = v.dot(v);
 		if (t < dotVV) {
 			t /= dotVV;
 			diff -= t*v;
@@ -80,7 +81,7 @@ bool SphereTriangleDetector::facecontains(const btVector3 &p,const btVector3* ve
 }
 
 ///combined discrete/continuous sphere-triangle
-bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, float &timeOfImpact)
+bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact)
 {
 
 	const btVector3* vertices = &m_triangle->getVertexPtr(0);
@@ -92,25 +93,25 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 	btVector3 normal = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[0]);
 	normal.normalize();
 	btVector3 p1ToCentre = c - vertices[0];
-	float distanceFromPlane = p1ToCentre.dot(normal);
+	btScalar distanceFromPlane = p1ToCentre.dot(normal);
 
-	if (distanceFromPlane < 0.f)
+	if (distanceFromPlane < btScalar(0.))
 	{
 		//triangle facing the other way
 	
-		distanceFromPlane *= -1.f;
-		normal *= -1.f;
+		distanceFromPlane *= btScalar(-1.);
+		normal *= btScalar(-1.);
 	}
 
 	///todo: move this gContactBreakingThreshold into a proper structure
-	extern float gContactBreakingThreshold;
+	extern btScalar gContactBreakingThreshold;
 
-	float contactMargin = gContactBreakingThreshold;
+	btScalar contactMargin = gContactBreakingThreshold;
 	bool isInsideContactPlane = distanceFromPlane < r + contactMargin;
 	bool isInsideShellPlane = distanceFromPlane < r;
 	
-	float deltaDotNormal = delta.dot(normal);
-	if (!isInsideShellPlane && deltaDotNormal >= 0.0f)
+	btScalar deltaDotNormal = delta.dot(normal);
+	if (!isInsideShellPlane && deltaDotNormal >= btScalar(0.0))
 		return false;
 
 	// Check for contact / intersection
@@ -123,7 +124,7 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 			contactPoint = c - normal*distanceFromPlane;
 		} else {
 			// Could be inside one of the contact capsules
-			float contactCapsuleRadiusSqr = (r + contactMargin) * (r + contactMargin);
+			btScalar contactCapsuleRadiusSqr = (r + contactMargin) * (r + contactMargin);
 			btVector3 nearestOnEdge;
 			for (int i = 0; i < m_triangle->getNumEdges(); i++) {
 				
@@ -132,7 +133,7 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 				
 				m_triangle->getEdge(i,pa,pb);
 
-				float distanceSqr = SegmentSqrDistance(pa,pb,c, nearestOnEdge);
+				btScalar distanceSqr = SegmentSqrDistance(pa,pb,c, nearestOnEdge);
 				if (distanceSqr < contactCapsuleRadiusSqr) {
 					// Yep, we're inside a capsule
 					hasContact = true;
@@ -145,9 +146,9 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 
 	if (hasContact) {
 		btVector3 contactToCentre = c - contactPoint;
-		float distanceSqr = contactToCentre.length2();
+		btScalar distanceSqr = contactToCentre.length2();
 		if (distanceSqr < (r - MAX_OVERLAP)*(r - MAX_OVERLAP)) {
-			float distance = sqrtf(distanceSqr);
+			btScalar distance = btSqrt(distanceSqr);
 			if (1)
 			{
 				resultNormal = contactToCentre;
@@ -158,12 +159,12 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 			return true;
 		}
 
-		if (delta.dot(contactToCentre) >= 0.0f) 
+		if (delta.dot(contactToCentre) >= btScalar(0.0)) 
 			return false;
 		
 		// Moving towards the contact point -> collision
 		point = contactPoint;
-		timeOfImpact = 0.0f;
+		timeOfImpact = btScalar(0.0);
 		return true;
 	}
 	
@@ -189,7 +190,7 @@ bool SphereTriangleDetector::pointInTriangle(const btVector3 vertices[], const b
 	btVector3 edge2_normal( edge2.cross(normal));
 	btVector3 edge3_normal( edge3.cross(normal));
 	
-	float r1, r2, r3;
+	btScalar r1, r2, r3;
 	r1 = edge1_normal.dot( p1_to_p );
 	r2 = edge2_normal.dot( p2_to_p );
 	r3 = edge3_normal.dot( p3_to_p );

src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h

@@ -36,7 +36,7 @@ struct SphereTriangleDetector : public btDiscreteCollisionDetectorInterface
 
 private:
 
-	bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, float &timeOfImpact);
+	bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact);
 	bool pointInTriangle(const btVector3 vertices[], const btVector3 &normal, btVector3 *p );
 	bool facecontains(const btVector3 &p,const btVector3* vertices,btVector3& normal);
 

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -347,7 +347,7 @@ void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair,
 				} else
 				{
 					//continuous collision detection query, time of impact (toi)
-					float toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
+					btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
 					if (dispatchInfo.m_timeOfImpact > toi)
 						dispatchInfo.m_timeOfImpact = toi;
 
@@ -355,4 +355,4 @@ void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair,
 			}
 		}
 
-}
+}

src/BulletCollision/CollisionDispatch/btCollisionObject.cpp

@@ -20,11 +20,11 @@ btCollisionObject::btCollisionObject()
 		m_collisionShape(0),
 		m_collisionFlags(0),
 		m_activationState1(1),
-		m_deactivationTime(0.f),
+		m_deactivationTime(btScalar(0.)),
 		m_userObjectPointer(0),
-		m_hitFraction(1.f),
-		m_ccdSweptSphereRadius(0.f),
-		m_ccdSquareMotionThreshold(0.f)
+		m_hitFraction(btScalar(1.)),
+		m_ccdSweptSphereRadius(btScalar(0.)),
+		m_ccdSquareMotionThreshold(btScalar(0.))
 {
 	
 }
@@ -46,7 +46,7 @@ void btCollisionObject::activate(bool forceActivation)
 	if (forceActivation || !(m_collisionFlags & (CF_STATIC_OBJECT|CF_KINEMATIC_OBJECT)))
 	{
 		setActivationState(ACTIVE_TAG);
-		m_deactivationTime = 0.f;
+		m_deactivationTime = btScalar(0.);
 	}
 }
 

src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -55,7 +55,7 @@ protected:
 
 	int				m_islandTag1;
 	int				m_activationState1;
-	float			m_deactivationTime;
+	btScalar			m_deactivationTime;
 
 	btScalar		m_friction;
 	btScalar		m_restitution;
@@ -67,13 +67,13 @@ protected:
 	void*			m_internalOwner;
 
 	///time of impact calculation
-	float			m_hitFraction; 
+	btScalar			m_hitFraction; 
 	
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	float			m_ccdSweptSphereRadius;
+	btScalar			m_ccdSweptSphereRadius;
 
 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
-	float			m_ccdSquareMotionThreshold;
+	btScalar			m_ccdSquareMotionThreshold;
 
 public:
 
@@ -137,11 +137,11 @@ public:
 	
 	void setActivationState(int newState);
 
-	void	setDeactivationTime(float time)
+	void	setDeactivationTime(btScalar time)
 	{
 		m_deactivationTime = time;
 	}
-	float	getDeactivationTime() const
+	btScalar	getDeactivationTime() const
 	{
 		return m_deactivationTime;
 	}
@@ -155,19 +155,19 @@ public:
 		return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
 	}
 
-		void	setRestitution(float rest)
+		void	setRestitution(btScalar rest)
 	{
 		m_restitution = rest;
 	}
-	float	getRestitution() const
+	btScalar	getRestitution() const
 	{
 		return m_restitution;
 	}
-	void	setFriction(float frict)
+	void	setFriction(btScalar frict)
 	{
 		m_friction = frict;
 	}
-	float	getFriction() const
+	btScalar	getFriction() const
 	{
 		return m_friction;
 	}
@@ -251,12 +251,12 @@ public:
 		m_islandTag1 = tag;
 	}
 
-	const float			getHitFraction() const
+	const btScalar			getHitFraction() const
 	{
 		return m_hitFraction; 
 	}
 
-	void	setHitFraction(float hitFraction)
+	void	setHitFraction(btScalar hitFraction)
 	{
 		m_hitFraction = hitFraction;
 	}
@@ -273,25 +273,25 @@ public:
 	}
 	
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	float			getCcdSweptSphereRadius() const
+	btScalar			getCcdSweptSphereRadius() const
 	{
 		return m_ccdSweptSphereRadius;
 	}
 
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	void	setCcdSweptSphereRadius(float radius)
+	void	setCcdSweptSphereRadius(btScalar radius)
 	{
 		m_ccdSweptSphereRadius = radius;
 	}
 
-	float 	getCcdSquareMotionThreshold() const
+	btScalar 	getCcdSquareMotionThreshold() const
 	{
 		return m_ccdSquareMotionThreshold;
 	}
 
 
 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
-	void	setCcdSquareMotionThreshold(float ccdSquareMotionThreshold)
+	void	setCcdSquareMotionThreshold(btScalar ccdSquareMotionThreshold)
 	{
 		m_ccdSquareMotionThreshold = ccdSquareMotionThreshold;
 	}

src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -185,12 +185,12 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 					  RayResultCallback& resultCallback)
 {
 	
-	btSphereShape pointShape(0.0f);
+	btSphereShape pointShape(btScalar(0.0));
 
 	if (collisionShape->isConvex())
 			{
 				btConvexCast::CastResult castResult;
-				castResult.m_fraction = 1.f;//??
+				castResult.m_fraction = btScalar(1.);//??
 
 				btConvexShape* convexShape = (btConvexShape*) collisionShape;
 				btVoronoiSimplexSolver	simplexSolver;
@@ -201,7 +201,7 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
 				{
 					//add hit
-					if (castResult.m_normal.length2() > 0.0001f)
+					if (castResult.m_normal.length2() > btScalar(0.0001))
 					{
 						castResult.m_normal.normalize();
 						if (castResult.m_fraction < resultCallback.m_closestHitFraction)
@@ -252,7 +252,7 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 								}
 
 
-							virtual float reportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex )
+							virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
 							{
 								btCollisionWorld::LocalShapeInfo	shapeInfo;
 								shapeInfo.m_shapePart = partId;
@@ -333,7 +333,7 @@ void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
 		btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 		collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
 
-		float hitLambda = 1.f; //could use resultCallback.m_closestHitFraction, but needs testing
+		btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
 		btVector3 hitNormal;
 		if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
 		{

src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -137,7 +137,7 @@ public:
 		LocalRayResult(btCollisionObject*	collisionObject, 
 			LocalShapeInfo*	localShapeInfo,
 			const btVector3&		hitNormalLocal,
-			float hitFraction)
+			btScalar hitFraction)
 		:m_collisionObject(collisionObject),
 		m_localShapeInfo(m_localShapeInfo),
 		m_hitNormalLocal(hitNormalLocal),
@@ -148,7 +148,7 @@ public:
 		btCollisionObject*	m_collisionObject;
 		LocalShapeInfo*			m_localShapeInfo;
 		const btVector3&		m_hitNormalLocal;
-		float					m_hitFraction;
+		btScalar					m_hitFraction;
 
 	};
 
@@ -158,17 +158,17 @@ public:
 		virtual ~RayResultCallback()
 		{
 		}
-		float	m_closestHitFraction;
+		btScalar	m_closestHitFraction;
 		bool	HasHit()
 		{
-			return (m_closestHitFraction < 1.f);
+			return (m_closestHitFraction < btScalar(1.));
 		}
 
 		RayResultCallback()
-			:m_closestHitFraction(1.f)
+			:m_closestHitFraction(btScalar(1.))
 		{
 		}
-		virtual	float	AddSingleResult(LocalRayResult& rayResult) = 0;
+		virtual	btScalar	AddSingleResult(LocalRayResult& rayResult) = 0;
 	};
 
 	struct	ClosestRayResultCallback : public RayResultCallback
@@ -187,7 +187,7 @@ public:
 		btVector3	m_hitPointWorld;
 		btCollisionObject*	m_collisionObject;
 		
-		virtual	float	AddSingleResult(LocalRayResult& rayResult)
+		virtual	btScalar	AddSingleResult(LocalRayResult& rayResult)
 		{
 
 //caller already does the filter on the m_closestHitFraction

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -89,7 +89,7 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 	}
 }
 
-float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 
 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
@@ -106,7 +106,7 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 	//then use each overlapping node AABB against Tree0
 	//and vise versa.
 
-	float hitFraction = 1.f;
+	btScalar hitFraction = btScalar(1.);
 
 	int numChildren = m_childCollisionAlgorithms.size();
 	int i;
@@ -124,7 +124,7 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 		colObj->setWorldTransform( newChildWorldTrans );
 
 		colObj->setCollisionShape( childShape );
-		float frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);
+		btScalar frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);
 		if (frac<hitFraction)
 		{
 			hitFraction = frac;

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -41,7 +41,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	float	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	btScalar	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -95,7 +95,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);
 
 		//btVector3 center = triangle[0] + triangle[1]+triangle[2];
-		//center *= 0.333333f;
+		//center *= btScalar(0.333333);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(center),color);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(center),color);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(center),color);
@@ -134,7 +134,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 
 
 
-void	btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+void	btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	m_dispatchInfoPtr = &dispatchInfo;
 	m_collisionMarginTriangle = collisionMarginTriangle;
@@ -146,7 +146,7 @@ void	btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTrian
 	btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->getCollisionShape());
 	//CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
 	convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
-	float extraMargin = collisionMarginTriangle;
+	btScalar extraMargin = collisionMarginTriangle;
 	btVector3 extra(extraMargin,extraMargin,extraMargin);
 
 	m_aabbMax += extra;
@@ -176,7 +176,7 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod
 		
 		if (convexBody->getCollisionShape()->isConvex())
 		{
-			float collisionMarginTriangle = concaveShape->getMargin();
+			btScalar collisionMarginTriangle = concaveShape->getMargin();
 					
 			resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr);
 			m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle,dispatchInfo,resultOut);
@@ -196,7 +196,7 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod
 }
 
 
-float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 
 	btCollisionObject* convexbody = m_isSwapped ? body1 : body0;
@@ -207,10 +207,10 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 
 	//only perform CCD above a certain threshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
-	float squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
 	if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
 	{
-		return 1.f;
+		return btScalar(1.);
 	}
 
 	//const btVector3& from = convexbody->m_worldTransform.getOrigin();
@@ -227,11 +227,11 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		btTransform m_ccdSphereToTrans;
 		btTransform	m_meshTransform;
 
-		float	m_ccdSphereRadius;
-		float	m_hitFraction;
+		btScalar	m_ccdSphereRadius;
+		btScalar	m_hitFraction;
 	
 
-		LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,float ccdSphereRadius,float hitFraction)
+		LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,btScalar ccdSphereRadius,btScalar hitFraction)
 			:m_ccdSphereFromTrans(from),
 			m_ccdSphereToTrans(to),
 			m_ccdSphereRadius(ccdSphereRadius),
@@ -276,11 +276,11 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		rayAabbMin.setMin(convexToLocal.getOrigin());
 		btVector3 rayAabbMax = convexFromLocal.getOrigin();
 		rayAabbMax.setMax(convexToLocal.getOrigin());
-		float ccdRadius0 = convexbody->getCcdSweptSphereRadius();
+		btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
 		rayAabbMin -= btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
 		rayAabbMax += btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
 
-		float curHitFraction = 1.f; //is this available?
+		btScalar curHitFraction = btScalar(1.); //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
 			convexbody->getCcdSweptSphereRadius(),curHitFraction);
 
@@ -304,6 +304,6 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		}
 	}
 
-	return 1.f;
+	return btScalar(1.);
 
 }

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

@@ -38,7 +38,7 @@ class btConvexTriangleCallback : public btTriangleCallback
 
 	btDispatcher*	m_dispatcher;
 	const btDispatcherInfo* m_dispatchInfoPtr;
-	float m_collisionMarginTriangle;
+	btScalar m_collisionMarginTriangle;
 	
 public:
 int	m_triangleCount;
@@ -47,7 +47,7 @@ int	m_triangleCount;
 
 	btConvexTriangleCallback(btDispatcher* dispatcher,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped);
 
-	void	setTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	void	setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	virtual ~btConvexTriangleCallback();
 
@@ -86,7 +86,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	float	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	btScalar	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	void	clearCache();
 

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -133,7 +133,7 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
 	input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
 	input.m_stackAlloc = dispatchInfo.m_stackAllocator;
 
-//	input.m_maximumDistanceSquared = 1e30f;
+//	input.m_maximumDistanceSquared = btScalar(1e30);
 	
 	input.m_transformA = body0->getWorldTransform();
 	input.m_transformB = body1->getWorldTransform();
@@ -146,24 +146,24 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
 
 
 bool disableCcd = false;
-float	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	///Rather then checking ALL pairs, only calculate TOI when motion exceeds threshold
     
 	///Linear motion for one of objects needs to exceed m_ccdSquareMotionThreshold
 	///col0->m_worldTransform,
-	float resultFraction = 1.f;
+	btScalar resultFraction = btScalar(1.);
 
 
-	float squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2();
-	float squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2();
     
 	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
 		squareMot1 < col1->getCcdSquareMotionThreshold())
 		return resultFraction;
 
 	if (disableCcd)
-		return 1.f;
+		return btScalar(1.);
 
 
 	//An adhoc way of testing the Continuous Collision Detection algorithms

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

@@ -44,7 +44,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	void	setLowLevelOfDetail(bool useLowLevel);
 

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp

@@ -27,9 +27,9 @@ void btEmptyAlgorithm::processCollision (btCollisionObject* body0,btCollisionObj
 
 }
 
-float btEmptyAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btEmptyAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
-	return 1.f;
+	return btScalar(1.);
 }
 
 

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h

@@ -31,7 +31,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{

src/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -27,7 +27,7 @@ inline btScalar	calculateCombinedFriction(const btCollisionObject* body0,const b
 {
 	btScalar friction = body0->getFriction() * body1->getFriction();
 
-	const btScalar MAX_FRICTION  = 10.f;
+	const btScalar MAX_FRICTION  = btScalar(10.);
 	if (friction < -MAX_FRICTION)
 		friction = -MAX_FRICTION;
 	if (friction > MAX_FRICTION)
@@ -53,7 +53,7 @@ btManifoldResult::btManifoldResult(btCollisionObject* body0,btCollisionObject* b
 }
 
 
-void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 {
 	assert(m_manifoldPtr);
 	//order in manifold needs to match

src/BulletCollision/CollisionDispatch/btManifoldResult.h

@@ -68,7 +68,7 @@ public:
 			m_index1=index1;		
 	}
 
-	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);
+	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);
 
 
 

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -33,7 +33,7 @@ void btSimulationIslandManager::findUnions(btDispatcher* dispatcher)
 		for (int i=0;i<dispatcher->getNumManifolds();i++)
 		{
 			const btPersistentManifold* manifold = dispatcher->getManifoldByIndexInternal(i);
-			//static objects (invmass 0.f) don't merge !
+			//static objects (invmass btScalar(0.)) don't merge !
 
 			 const  btCollisionObject* colObj0 = static_cast<const btCollisionObject*>(manifold->getBody0());
 			 const  btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->getBody1());
@@ -66,7 +66,7 @@ void	btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 			
 			btCollisionObject*	collisionObject= (*i);
 			collisionObject->setIslandTag(index);
-			collisionObject->setHitFraction(1.f);
+			collisionObject->setHitFraction(btScalar(1.));
 			index++;
 			
 		}
@@ -268,7 +268,7 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 	int startManifoldIndex = 0;
 	int endManifoldIndex = 1;
 
-	int islandId;
+	//int islandId;
 
 
 		//update the sleeping state for bodies, if all are sleeping

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -64,7 +64,7 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b
 	btVector3 sphereCenter = sphereObj->getWorldTransform().getOrigin();
 	btScalar radius = sphere0->getRadius();
 	
-	float dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);
+	btScalar dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);
 
 	if (dist < SIMD_EPSILON)
 	{
@@ -81,10 +81,10 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b
 
 }
 
-float btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }
 
 
@@ -117,14 +117,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	/////////////////////////////////////////////////
 
 	btVector3	tmp, prel, n[6], normal, v3P;
-	btScalar   fSep = 10000000.0f, fSepThis;
+	btScalar   fSep = btScalar(10000000.0), fSepThis;
 
-	n[0].setValue( -1.0f,  0.0f,  0.0f );
-	n[1].setValue(  0.0f, -1.0f,  0.0f );
-	n[2].setValue(  0.0f,  0.0f, -1.0f );
-	n[3].setValue(  1.0f,  0.0f,  0.0f );
-	n[4].setValue(  0.0f,  1.0f,  0.0f );
-	n[5].setValue(  0.0f,  0.0f,  1.0f );
+	n[0].setValue( btScalar(-1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[1].setValue(  btScalar(0.0), btScalar(-1.0),  btScalar(0.0) );
+	n[2].setValue(  btScalar(0.0),  btScalar(0.0), btScalar(-1.0) );
+	n[3].setValue(  btScalar(1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[4].setValue(  btScalar(0.0),  btScalar(1.0),  btScalar(0.0) );
+	n[5].setValue(  btScalar(0.0),  btScalar(0.0),  btScalar(1.0) );
 
 	// convert  point in local space
 	prel = m44T.invXform( sphereCenter);
@@ -136,7 +136,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	for (int i=0;i<6;i++)
 	{
 		int j = i<3? 0:1;
-		if ( (fSepThis = ((v3P-bounds[j]) .dot(n[i]))) > 0.0f )
+		if ( (fSepThis = ((v3P-bounds[j]) .dot(n[i]))) > btScalar(0.0) )
 		{
 			v3P = v3P - n[i]*fSepThis;		
 			bFound = true;
@@ -154,9 +154,9 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 		pointOnBox = v3P + normal*margins;
 		v3PointOnSphere = prel - normal*fRadius;
 
-		if ( ((v3PointOnSphere - pointOnBox) .dot (normal)) > 0.0f )
+		if ( ((v3PointOnSphere - pointOnBox) .dot (normal)) > btScalar(0.0) )
 		{
-			return 1.0f;
+			return btScalar(1.0);
 		}
 
 		// transform back in world space
@@ -171,7 +171,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 		{
 			fSep = - btSqrt(fSeps2);
 			normal = (pointOnBox-v3PointOnSphere);
-			normal *= 1.f/fSep;
+			normal *= btScalar(1.)/fSep;
 		}
 
 		return fSep;
@@ -185,10 +185,10 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	bounds[0] = boundsVec[0];
 	bounds[1] = boundsVec[1];
 
-	if ( fPenetration <= 0.0f )
+	if ( fPenetration <= btScalar(0.0) )
 		return (fPenetration-margins);
 	else
-		return 1.0f;
+		return btScalar(1.0);
 }
 
 btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject* boxObj,btVector3& pointOnBox, btVector3& v3PointOnSphere, const btVector3& sphereCenter, btScalar fRadius, const btVector3& aabbMin, const btVector3& aabbMax) 
@@ -200,14 +200,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject*
 	bounds[1] = aabbMax;
 
 	btVector3	p0, tmp, prel, n[6], normal;
-	btScalar   fSep = -10000000.0f, fSepThis;
+	btScalar   fSep = btScalar(-10000000.0), fSepThis;
 
-	n[0].setValue( -1.0f,  0.0f,  0.0f );
-	n[1].setValue(  0.0f, -1.0f,  0.0f );
-	n[2].setValue(  0.0f,  0.0f, -1.0f );
-	n[3].setValue(  1.0f,  0.0f,  0.0f );
-	n[4].setValue(  0.0f,  1.0f,  0.0f );
-	n[5].setValue(  0.0f,  0.0f,  1.0f );
+	n[0].setValue( btScalar(-1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[1].setValue(  btScalar(0.0), btScalar(-1.0),  btScalar(0.0) );
+	n[2].setValue(  btScalar(0.0),  btScalar(0.0), btScalar(-1.0) );
+	n[3].setValue(  btScalar(1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[4].setValue(  btScalar(0.0),  btScalar(1.0),  btScalar(0.0) );
+	n[5].setValue(  btScalar(0.0),  btScalar(0.0),  btScalar(1.0) );
 
 	const btTransform&	m44T = boxObj->getWorldTransform();
 
@@ -219,7 +219,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject*
 	for (int i=0;i<6;i++)
 	{
 		int j = i<3 ? 0:1;
-		if ( (fSepThis = ((prel-bounds[j]) .dot( n[i]))-fRadius) > 0.0f )	return 1.0f;
+		if ( (fSepThis = ((prel-bounds[j]) .dot( n[i]))-fRadius) > btScalar(0.0) )	return btScalar(1.0);
 		if ( fSepThis > fSep )
 		{
 			p0 = bounds[j];	normal = (btVector3&)n[i];

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h

@@ -38,7 +38,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	btScalar getSphereDistance( btCollisionObject* boxObj,btVector3& v3PointOnBox, btVector3& v3PointOnSphere, const btVector3& v3SphereCenter, btScalar fRadius );
 

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -48,7 +48,7 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0
 	btSphereShape* sphere1 = (btSphereShape*)col1->getCollisionShape();
 
 	btVector3 diff = col0->getWorldTransform().getOrigin()-  col1->getWorldTransform().getOrigin();
-	float len = diff.length();
+	btScalar len = diff.length();
 	btScalar radius0 = sphere0->getRadius();
 	btScalar radius1 = sphere1->getRadius();
 
@@ -71,8 +71,8 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0
 
 }
 
-float btSphereSphereCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereSphereCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

@@ -37,7 +37,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	
 	virtual ~btSphereSphereCollisionAlgorithm();

src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp

@@ -56,7 +56,7 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co
 	SphereTriangleDetector detector(sphere,triangle);
 	
 	btDiscreteCollisionDetectorInterface::ClosestPointInput input;
-	input.m_maximumDistanceSquared = 1e30f;//todo: tighter bounds
+	input.m_maximumDistanceSquared = btScalar(1e30);//todo: tighter bounds
 	input.m_transformA = col0->getWorldTransform();
 	input.m_transformB = col1->getWorldTransform();
 
@@ -64,8 +64,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co
 
 }
 
-float btSphereTriangleCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereTriangleCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }

src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h

@@ -38,7 +38,7 @@ public:
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 
 	
 	virtual ~btSphereTriangleCollisionAlgorithm();

src/BulletCollision/CollisionShapes/btBoxShape.cpp

@@ -42,16 +42,16 @@ void btBoxShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabb
 
 void	btBoxShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	//float margin = 0.f;
+	//btScalar margin = btScalar(0.);
 	btVector3 halfExtents = getHalfExtents();
 
-	btScalar lx=2.f*(halfExtents.x());
-	btScalar ly=2.f*(halfExtents.y());
-	btScalar lz=2.f*(halfExtents.z());
+	btScalar lx=btScalar(2.)*(halfExtents.x());
+	btScalar ly=btScalar(2.)*(halfExtents.y());
+	btScalar lz=btScalar(2.)*(halfExtents.z());
 
-	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
-	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
-	inertia[2] = mass/(12.0f) * (lx*lx + ly*ly);
+	inertia[0] = mass/(btScalar(12.0)) * (ly*ly + lz*lz);
+	inertia[1] = mass/(btScalar(12.0)) * (lx*lx + lz*lz);
+	inertia[2] = mass/(btScalar(12.0)) * (lx*lx + ly*ly);
 
 
 }

src/BulletCollision/CollisionShapes/btBoxShape.h

@@ -41,9 +41,9 @@ public:
 		btVector3 halfExtents = getHalfExtents();
 		
 		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()); 
+		supVertex = btPoint3(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                     vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                     vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
   
 		return supVertex;
 	}
@@ -54,9 +54,9 @@ public:
 		btVector3 margin(getMargin(),getMargin(),getMargin());
 		halfExtents -= margin;
 
-		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()); 
+		return btVector3(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
 	}
 
 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
@@ -69,9 +69,9 @@ public:
 		for (int i=0;i<numVectors;i++)
 		{
 			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()); 
+			supportVerticesOut[i].setValue(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
 		}
 
 	}
@@ -132,27 +132,27 @@ public:
 		switch (i)
 		{
 		case 0:
-			plane.setValue(1.f,0.f,0.f);
+			plane.setValue(btScalar(1.),btScalar(0.),btScalar(0.));
 			plane[3] = -halfExtents.x();
 			break;
 		case 1:
-			plane.setValue(-1.f,0.f,0.f);
+			plane.setValue(btScalar(-1.),btScalar(0.),btScalar(0.));
 			plane[3] = -halfExtents.x();
 			break;
 		case 2:
-			plane.setValue(0.f,1.f,0.f);
+			plane.setValue(btScalar(0.),btScalar(1.),btScalar(0.));
 			plane[3] = -halfExtents.y();
 			break;
 		case 3:
-			plane.setValue(0.f,-1.f,0.f);
+			plane.setValue(btScalar(0.),btScalar(-1.),btScalar(0.));
 			plane[3] = -halfExtents.y();
 			break;
 		case 4:
-			plane.setValue(0.f,0.f,1.f);
+			plane.setValue(btScalar(0.),btScalar(0.),btScalar(1.));
 			plane[3] = -halfExtents.z();
 			break;
 		case 5:
-			plane.setValue(0.f,0.f,-1.f);
+			plane.setValue(btScalar(0.),btScalar(0.),btScalar(-1.));
 			plane[3] = -halfExtents.z();
 			break;
 		default:
@@ -265,22 +265,22 @@ public:
 		switch (index)
 		{
 		case 0:
-			penetrationVector.setValue(1.f,0.f,0.f);
+			penetrationVector.setValue(btScalar(1.),btScalar(0.),btScalar(0.));
 			break;
 		case 1:
-			penetrationVector.setValue(-1.f,0.f,0.f);
+			penetrationVector.setValue(btScalar(-1.),btScalar(0.),btScalar(0.));
 			break;
 		case 2:
-			penetrationVector.setValue(0.f,1.f,0.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(1.),btScalar(0.));
 			break;
 		case 3:
-			penetrationVector.setValue(0.f,-1.f,0.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(-1.),btScalar(0.));
 			break;
 		case 4:
-			penetrationVector.setValue(0.f,0.f,1.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(0.),btScalar(1.));
 			break;
 		case 5:
-			penetrationVector.setValue(0.f,0.f,-1.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(0.),btScalar(-1.));
 			break;
 		default:
 			assert(0);

src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp

@@ -96,7 +96,7 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 #ifdef DEBUG_TRIANGLE_MESH
 				printf("%d ,",graphicsindex);
 #endif //DEBUG_TRIANGLE_MESH
-				float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);
+				btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);
 
 				m_triangle[j] = btVector3(
 					graphicsbase[0]*meshScaling.getX(),

src/BulletCollision/CollisionShapes/btCollisionMargin.h

@@ -18,7 +18,7 @@ subject to the following restrictions:
 
 //used by Gjk and some other algorithms
 
-#define CONVEX_DISTANCE_MARGIN 0.04f// 0.1f//;//0.01f
+#define CONVEX_DISTANCE_MARGIN btScalar(0.04)// btScalar(0.1)//;//btScalar(0.01)
 
 
 

src/BulletCollision/CollisionShapes/btCollisionShape.cpp

@@ -23,14 +23,14 @@ void	btCollisionShape::getBoundingSphere(btVector3& center,btScalar& radius) con
 
 	getAabb(tr,aabbMin,aabbMax);
 
-	radius = (aabbMax-aabbMin).length()*0.5f;
-	center = (aabbMin+aabbMax)*0.5f;
+	radius = (aabbMax-aabbMin).length()*btScalar(0.5);
+	center = (aabbMin+aabbMax)*btScalar(0.5);
 }
 
-float	btCollisionShape::getAngularMotionDisc() const
+btScalar	btCollisionShape::getAngularMotionDisc() const
 {
 	btVector3	center;
-	float disc;
+	btScalar disc;
 	getBoundingSphere(center,disc);
 	disc += (center).length();
 	return disc;
@@ -41,25 +41,25 @@ void btCollisionShape::calculateTemporalAabb(const btTransform& curTrans,const b
 	//start with static aabb
 	getAabb(curTrans,temporalAabbMin,temporalAabbMax);
 
-	float temporalAabbMaxx = temporalAabbMax.getX();
-	float temporalAabbMaxy = temporalAabbMax.getY();
-	float temporalAabbMaxz = temporalAabbMax.getZ();
-	float temporalAabbMinx = temporalAabbMin.getX();
-	float temporalAabbMiny = temporalAabbMin.getY();
-	float temporalAabbMinz = temporalAabbMin.getZ();
+	btScalar temporalAabbMaxx = temporalAabbMax.getX();
+	btScalar temporalAabbMaxy = temporalAabbMax.getY();
+	btScalar temporalAabbMaxz = temporalAabbMax.getZ();
+	btScalar temporalAabbMinx = temporalAabbMin.getX();
+	btScalar temporalAabbMiny = temporalAabbMin.getY();
+	btScalar temporalAabbMinz = temporalAabbMin.getZ();
 
 	// add linear motion
 	btVector3 linMotion = linvel*timeStep;
 	//todo: simd would have a vector max/min operation, instead of per-element access
-	if (linMotion.x() > 0.f)
+	if (linMotion.x() > btScalar(0.))
 		temporalAabbMaxx += linMotion.x(); 
 	else
 		temporalAabbMinx += linMotion.x();
-	if (linMotion.y() > 0.f)
+	if (linMotion.y() > btScalar(0.))
 		temporalAabbMaxy += linMotion.y(); 
 	else
 		temporalAabbMiny += linMotion.y();
-	if (linMotion.z() > 0.f)
+	if (linMotion.z() > btScalar(0.))
 		temporalAabbMaxz += linMotion.z(); 
 	else
 		temporalAabbMinz += linMotion.z();

src/BulletCollision/CollisionShapes/btCollisionShape.h

@@ -40,7 +40,7 @@ public:
 	virtual void	getBoundingSphere(btVector3& center,btScalar& radius) const;
 
 	///getAngularMotionDisc returns the maximus radius needed for Conservative Advancement to handle time-of-impact with rotations.
-	virtual float	getAngularMotionDisc() const;
+	virtual btScalar	getAngularMotionDisc() const;
 
 	virtual int		getShapeType() const=0;
 
@@ -84,8 +84,8 @@ public:
 	const char * m_tempDebug;
 //endif debugging support
 
-	virtual void	setMargin(float margin) = 0;
-	virtual float	getMargin() const = 0;
+	virtual void	setMargin(btScalar margin) = 0;
+	virtual btScalar	getMargin() const = 0;
 
 };	
 

src/BulletCollision/CollisionShapes/btCompoundShape.cpp

@@ -20,11 +20,11 @@ subject to the following restrictions:
 
 
 btCompoundShape::btCompoundShape()
-:m_localAabbMin(1e30f,1e30f,1e30f),
-m_localAabbMax(-1e30f,-1e30f,-1e30f),
+:m_localAabbMin(btScalar(1e30),btScalar(1e30),btScalar(1e30)),
+m_localAabbMax(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)),
 m_aabbTree(0),
-m_collisionMargin(0.f),
-m_localScaling(1.f,1.f,1.f)
+m_collisionMargin(btScalar(0.)),
+m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.))
 {
 }
 
@@ -60,8 +60,8 @@ void	btCompoundShape::addChildShape(const btTransform& localTransform,btCollisio
 	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
 void btCompoundShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
 	
 	btMatrix3x3 abs_b = trans.getBasis().absolute();  
 
@@ -84,15 +84,15 @@ void	btCompoundShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 	btVector3 aabbMin,aabbMax;
 	getAabb(ident,aabbMin,aabbMax);
 	
-	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);
 	
-	btScalar lx=2.f*(halfExtents.x());
-	btScalar ly=2.f*(halfExtents.y());
-	btScalar lz=2.f*(halfExtents.z());
+	btScalar lx=btScalar(2.)*(halfExtents.x());
+	btScalar ly=btScalar(2.)*(halfExtents.y());
+	btScalar lz=btScalar(2.)*(halfExtents.z());
 
-	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
-	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
-	inertia[2] = mass/(12.0f) * (lx*lx + ly*ly);
+	inertia[0] = mass/(btScalar(12.0)) * (ly*ly + lz*lz);
+	inertia[1] = mass/(btScalar(12.0)) * (lx*lx + lz*lz);
+	inertia[2] = mass/(btScalar(12.0)) * (lx*lx + ly*ly);
 
 }
 

src/BulletCollision/CollisionShapes/btCompoundShape.h

@@ -85,11 +85,11 @@ public:
 	
 	virtual int	getShapeType() const { return COMPOUND_SHAPE_PROXYTYPE;}
 
-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		m_collisionMargin = margin;
 	}
-	virtual float	getMargin() const
+	virtual btScalar	getMargin() const
 	{
 		return m_collisionMargin;
 	}

src/BulletCollision/CollisionShapes/btConcaveShape.cpp

@@ -17,7 +17,7 @@ subject to the following restrictions:
 
 #include "btConcaveShape.h"
 
-btConcaveShape::btConcaveShape() : m_collisionMargin(0.f)
+btConcaveShape::btConcaveShape() : m_collisionMargin(btScalar(0.))
 {
 
 }

src/BulletCollision/CollisionShapes/btConcaveShape.h

@@ -27,7 +27,7 @@ subject to the following restrictions:
 class btConcaveShape : public btCollisionShape
 {
 protected:
-	float m_collisionMargin;
+	btScalar m_collisionMargin;
 
 public:
 	btConcaveShape();
@@ -36,10 +36,10 @@ public:
 
 	virtual void	processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const = 0;
 
-	virtual float getMargin() const {
+	virtual btScalar getMargin() const {
 		return m_collisionMargin;
 	}
-	virtual void setMargin(float collisionMargin)
+	virtual void setMargin(btScalar collisionMargin)
 	{
 		m_collisionMargin = collisionMargin;
 	}

src/BulletCollision/CollisionShapes/btConeShape.cpp

@@ -24,7 +24,7 @@ m_height(height)
 {
 	setConeUpIndex(1);
 	btVector3 halfExtents;
-	m_sinAngle = (m_radius / sqrt(m_radius * m_radius + m_height * m_height));
+	m_sinAngle = (m_radius / btSqrt(m_radius * m_radius + m_height * m_height));
 }
 
 btConeShapeZ::btConeShapeZ (btScalar radius,btScalar height):
@@ -67,15 +67,15 @@ void	btConeShape::setConeUpIndex(int upIndex)
 btVector3 btConeShape::coneLocalSupport(const btVector3& v) const
 {
 	
-	float halfHeight = m_height * 0.5f;
+	btScalar halfHeight = m_height * btScalar(0.5);
 
  if (v[m_coneIndices[1]] > v.length() * m_sinAngle)
  {
 	btVector3 tmp;
 
-	tmp[m_coneIndices[0]] = 0.f;
+	tmp[m_coneIndices[0]] = btScalar(0.);
 	tmp[m_coneIndices[1]] = halfHeight;
-	tmp[m_coneIndices[2]] = 0.f;
+	tmp[m_coneIndices[2]] = btScalar(0.);
 	return tmp;
  }
   else {
@@ -90,9 +90,9 @@ btVector3 btConeShape::coneLocalSupport(const btVector3& v) const
     }
     else  {
 		btVector3 tmp;
-		tmp[m_coneIndices[0]] = 0.f;
+		tmp[m_coneIndices[0]] = btScalar(0.);
 		tmp[m_coneIndices[1]] = -halfHeight;
-		tmp[m_coneIndices[2]] = 0.f;
+		tmp[m_coneIndices[2]] = btScalar(0.);
 		return tmp;
 	}
   }
@@ -117,12 +117,12 @@ void	btConeShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVect
 btVector3	btConeShape::localGetSupportingVertex(const btVector3& vec)  const
 {
 	btVector3 supVertex = coneLocalSupport(vec);
-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;

src/BulletCollision/CollisionShapes/btConeShape.h

@@ -24,9 +24,9 @@ class btConeShape : public btConvexShape
 
 {
 
-	float m_sinAngle;
-	float m_radius;
-	float m_height;
+	btScalar m_sinAngle;
+	btScalar m_radius;
+	btScalar m_height;
 	int		m_coneIndices[3];
 	btVector3 coneLocalSupport(const btVector3& v) const;
 
@@ -38,8 +38,8 @@ public:
 	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;}
+	btScalar getRadius() const { return m_radius;}
+	btScalar getHeight() const { return m_height;}
 
 
 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia)
@@ -49,17 +49,17 @@ public:
 		btVector3 aabbMin,aabbMax;
 		getAabb(identity,aabbMin,aabbMax);
 
-		btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+		btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);
 
-		float margin = getMargin();
+		btScalar margin = getMargin();
 
-		btScalar lx=2.f*(halfExtents.x()+margin);
-		btScalar ly=2.f*(halfExtents.y()+margin);
-		btScalar lz=2.f*(halfExtents.z()+margin);
+		btScalar lx=btScalar(2.)*(halfExtents.x()+margin);
+		btScalar ly=btScalar(2.)*(halfExtents.y()+margin);
+		btScalar lz=btScalar(2.)*(halfExtents.z()+margin);
 		const btScalar x2 = lx*lx;
 		const btScalar y2 = ly*ly;
 		const btScalar z2 = lz*lz;
-		const btScalar scaledmass = mass * 0.08333333f;
+		const btScalar scaledmass = mass * btScalar(0.08333333);
 
 		inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));
 

src/BulletCollision/CollisionShapes/btConvexHullShape.cpp

@@ -19,7 +19,7 @@ subject to the following restrictions:
 
 
 
-btConvexHullShape ::btConvexHullShape (const float* points,int numPoints,int stride)
+btConvexHullShape ::btConvexHullShape (const btScalar* points,int numPoints,int stride)
 {
 	m_points.resize(numPoints);
 
@@ -34,17 +34,17 @@ btConvexHullShape ::btConvexHullShape (const float* points,int numPoints,int str
 
 btVector3	btConvexHullShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	btVector3 supVec(0.f,0.f,0.f);
-	btScalar newDot,maxDot = -1e30f;
+	btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));
+	btScalar newDot,maxDot = btScalar(-1e30);
 
 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}
 
@@ -70,7 +70,7 @@ void	btConvexHullShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const
 	{
 		for (int i=0;i<numVectors;i++)
 		{
-			supportVerticesOut[i][3] = -1e30f;
+			supportVerticesOut[i][3] = btScalar(-1e30);
 		}
 	}
 	for (size_t i=0;i<m_points.size();i++)
@@ -101,12 +101,12 @@ btVector3	btConvexHullShape::localGetSupportingVertex(const btVector3& vec)const
 {
 	btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec);
 
-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;

src/BulletCollision/CollisionShapes/btConvexHullShape.h

@@ -31,10 +31,10 @@ class btConvexHullShape : public btPolyhedralConvexShape
 	btAlignedObjectArray<btPoint3>	m_points;
 
 public:
-	///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive float (x,y,z), the striding defines the number of bytes between each point, in memory.
+	///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory.
 	///It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint.
 	///btConvexHullShape make an internal copy of the points.
-	btConvexHullShape(const float* points=0,int numPoints=0, int stride=sizeof(btPoint3));
+	btConvexHullShape(const btScalar* points=0,int numPoints=0, int stride=sizeof(btPoint3));
 
 	void addPoint(const btPoint3& point)
 	{

src/BulletCollision/CollisionShapes/btConvexShape.cpp

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #include "btConvexShape.h"
 
 btConvexShape::btConvexShape()
-: m_localScaling(1.f,1.f,1.f),
+: m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.)),
 m_collisionMargin(CONVEX_DISTANCE_MARGIN)
 {
 }
@@ -35,14 +35,14 @@ void	btConvexShape::getAabbSlow(const btTransform& trans,btVector3&minAabb,btVec
 	btScalar margin = getMargin();
 	for (int i=0;i<3;i++)
 	{
-		btVector3 vec(0.f,0.f,0.f);
-		vec[i] = 1.f;
+		btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
+		vec[i] = btScalar(1.);
 
 		btVector3 sv = localGetSupportingVertex(vec*trans.getBasis());
 
 		btVector3 tmp = trans(sv);
 		maxAabb[i] = tmp[i]+margin;
-		vec[i] = -1.f;
+		vec[i] = btScalar(-1.);
 		tmp = trans(localGetSupportingVertex(vec*trans.getBasis()));
 		minAabb[i] = tmp[i]-margin;
 	}
@@ -52,12 +52,12 @@ btVector3	btConvexShape::localGetSupportingVertex(const btVector3& vec)const
  {
 	 btVector3	supVertex = localGetSupportingVertexWithoutMargin(vec);
 
-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;

src/BulletCollision/CollisionShapes/btConvexShape.h

@@ -75,11 +75,11 @@ public:
 	}
 
 
-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		m_collisionMargin = margin;
 	}
-	virtual float	getMargin() const
+	virtual btScalar	getMargin() const
 	{
 		return m_collisionMargin;
 	}

src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp

@@ -39,8 +39,8 @@ public:
 	btVector3 m_supportVecLocal;
 
 	LocalSupportVertexCallback(const btVector3& supportVecLocal)
-		: m_supportVertexLocal(0.f,0.f,0.f),
-		m_maxDot(-1e30f),
+		: m_supportVertexLocal(btScalar(0.),btScalar(0.),btScalar(0.)),
+		m_maxDot(btScalar(-1e30)),
                 m_supportVecLocal(supportVecLocal)
 	{
 	}
@@ -71,21 +71,21 @@ public:
 
 btVector3	btConvexTriangleMeshShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	btVector3 supVec(0.f,0.f,0.f);
+	btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));
 
 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}
 
 	LocalSupportVertexCallback	supportCallback(vec);
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 	supVec = supportCallback.GetSupportVertexLocal();
 
@@ -98,7 +98,7 @@ void	btConvexTriangleMeshShape::batchedUnitVectorGetSupportingVertexWithoutMargi
 	{
 		for (int i=0;i<numVectors;i++)
 		{
-			supportVerticesOut[i][3] = -1e30f;
+			supportVerticesOut[i][3] = btScalar(-1e30);
 		}
 	}
 	
@@ -109,7 +109,7 @@ void	btConvexTriangleMeshShape::batchedUnitVectorGetSupportingVertexWithoutMargi
 	{
 		const btVector3& vec = vectors[j];
 		LocalSupportVertexCallback	supportCallback(vec);
-		btVector3 aabbMax(1e30f,1e30f,1e30f);
+		btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 		m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		supportVerticesOut[j] = supportCallback.GetSupportVertexLocal();
 	}
@@ -122,12 +122,12 @@ btVector3	btConvexTriangleMeshShape::localGetSupportingVertex(const btVector3& v
 {
 	btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec);
 
-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;

src/BulletCollision/CollisionShapes/btCylinderShape.cpp

@@ -46,8 +46,8 @@ const int ZZ = 2;
 	// extents of the cylinder is: X,Y is for radius, and Z for height
 
 
-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];
 
 
     btVector3 tmp;
@@ -87,8 +87,8 @@ const int YY = 1;
 const int ZZ = 2;
 
 
-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];
 
 
     btVector3 tmp;
@@ -124,8 +124,8 @@ const int ZZ = 1;
 	// extents of the cylinder is: X,Y is for radius, and Z for height
 
 
-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];
 
 
     btVector3 tmp;

src/BulletCollision/CollisionShapes/btCylinderShape.h

@@ -44,12 +44,12 @@ public:
 		btVector3 supVertex;
 		supVertex = localGetSupportingVertexWithoutMargin(vec);
 		
-		if ( getMargin()!=0.f )
+		if ( getMargin()!=btScalar(0.) )
 		{
 			btVector3 vecnorm = vec;
 			if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 			{
-				vecnorm.setValue(-1.f,-1.f,-1.f);
+				vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 			} 
 			vecnorm.normalize();
 			supVertex+= getMargin() * vecnorm;
@@ -71,7 +71,7 @@ public:
 		return 1;
 	}
 
-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getX();
 	}
@@ -103,7 +103,7 @@ public:
 		return "CylinderX";
 	}
 
-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getY();
 	}
@@ -128,7 +128,7 @@ public:
 		return "CylinderZ";
 	}
 
-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getX();
 	}

src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp

@@ -19,7 +19,7 @@ subject to the following restrictions:
 
 
 btHeightfieldTerrainShape::btHeightfieldTerrainShape()
-:m_localScaling(0.f,0.f,0.f)
+:m_localScaling(btScalar(0.),btScalar(0.),btScalar(0.))
 {
 }
 
@@ -32,8 +32,8 @@ btHeightfieldTerrainShape::~btHeightfieldTerrainShape()
 
 void btHeightfieldTerrainShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	aabbMin.setValue(-1e30f,-1e30f,-1e30f);
-	aabbMax.setValue(1e30f,1e30f,1e30f);
+	aabbMin.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	aabbMax.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
 }
 
@@ -43,9 +43,9 @@ void btHeightfieldTerrainShape::getAabb(const btTransform& t,btVector3& aabbMin,
 void	btHeightfieldTerrainShape::processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 
-	btVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
+	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
 	btScalar radius = halfExtents.length();
-	btVector3 center = (aabbMax + aabbMin) * 0.5f;
+	btVector3 center = (aabbMax + aabbMin) * btScalar(0.5);
 	
 	//TODO
 	//this is where the triangles are generated, given AABB and plane equation (normal/constant)
@@ -79,7 +79,7 @@ void	btHeightfieldTerrainShape::calculateLocalInertia(btScalar mass,btVector3& i
 {
 	//moving concave objects not supported
 	
-	inertia.setValue(0.f,0.f,0.f);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }
 
 void	btHeightfieldTerrainShape::setLocalScaling(const btVector3& scaling)

src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp

@@ -43,7 +43,7 @@ void	btMinkowskiSumShape::batchedUnitVectorGetSupportingVertexWithoutMargin(cons
 
 
 
-float	btMinkowskiSumShape::getMargin() const
+btScalar	btMinkowskiSumShape::getMargin() const
 {
 	return m_shapeA->getMargin() + m_shapeB->getMargin();
 }

src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h

@@ -48,7 +48,7 @@ public:
 
 	virtual int	getShapeType() const { return MINKOWSKI_SUM_SHAPE_PROXYTYPE; }
 
-	virtual float	getMargin() const;
+	virtual btScalar	getMargin() const;
 
 	const btConvexShape*	getShapeA() const { return m_shapeA;}
 	const btConvexShape*	getShapeB() const { return m_shapeB;}

src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp

@@ -20,7 +20,7 @@ subject to the following restrictions:
 btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,const btVector3* positions,const btScalar* radi,int numSpheres)
 :m_inertiaHalfExtents(inertiaHalfExtents)
 {
-	float startMargin = 1e30f;
+	btScalar startMargin = btScalar(1e30);
 
 	m_numSpheres = numSpheres;
 	for (int i=0;i<m_numSpheres;i++)
@@ -42,17 +42,17 @@ btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,cons
 	int i;
 	btVector3 supVec(0,0,0);
 
-	btScalar maxDot(-1e30f);
+	btScalar maxDot(btScalar(-1e30));
 
 
 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}
 
@@ -84,7 +84,7 @@ btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,cons
 
 	for (int j=0;j<numVectors;j++)
 	{
-		btScalar maxDot(-1e30f);
+		btScalar maxDot(btScalar(-1e30));
 
 		const btVector3& vec = vectors[j];
 
@@ -126,17 +126,17 @@ void	btMultiSphereShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 
 //	getAabb(ident,aabbMin,aabbMax);
 
-	btVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* 0.5f;
+	btVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* btScalar(0.5);
 
-	float margin = CONVEX_DISTANCE_MARGIN;
+	btScalar margin = CONVEX_DISTANCE_MARGIN;
 
-	btScalar lx=2.f*(halfExtents[0]+margin);
-	btScalar ly=2.f*(halfExtents[1]+margin);
-	btScalar lz=2.f*(halfExtents[2]+margin);
+	btScalar lx=btScalar(2.)*(halfExtents[0]+margin);
+	btScalar ly=btScalar(2.)*(halfExtents[1]+margin);
+	btScalar lz=btScalar(2.)*(halfExtents[2]+margin);
 	const btScalar x2 = lx*lx;
 	const btScalar y2 = ly*ly;
 	const btScalar z2 = lz*lz;
-	const btScalar scaledmass = mass * 0.08333333f;
+	const btScalar scaledmass = mass * btScalar(.08333333);
 
 	inertia[0] = scaledmass * (y2+z2);
 	inertia[1] = scaledmass * (x2+z2);

src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp

@@ -46,8 +46,8 @@ void btOptimizedBvh::build(btStridingMeshInterface* triangles)
 		{
 
 			btOptimizedBvhNode node;
-			node.m_aabbMin = btVector3(1e30f,1e30f,1e30f); 
-			node.m_aabbMax = btVector3(-1e30f,-1e30f,-1e30f); 
+			node.m_aabbMin = btVector3(btScalar(1e30),btScalar(1e30),btScalar(1e30)); 
+			node.m_aabbMax = btVector3(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)); 
 			node.m_aabbMin.setMin(triangle[0]);
 			node.m_aabbMax.setMax(triangle[0]);
 			node.m_aabbMin.setMin(triangle[1]);
@@ -73,8 +73,8 @@ void btOptimizedBvh::build(btStridingMeshInterface* triangles)
 
 	NodeTriangleCallback	callback(m_leafNodes);
 
-	btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMin(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
 	triangles->InternalProcessAllTriangles(&callback,aabbMin,aabbMax);
 
@@ -118,8 +118,8 @@ btOptimizedBvhNode*	btOptimizedBvh::buildTree	(NodeArray&	leafNodes,int startInd
 
 	internalNode = &m_contiguousNodes[m_curNodeIndex++];
 	
-	internalNode->m_aabbMax.setValue(-1e30f,-1e30f,-1e30f);
-	internalNode->m_aabbMin.setValue(1e30f,1e30f,1e30f);
+	internalNode->m_aabbMax.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	internalNode->m_aabbMin.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	
 	for (i=startIndex;i<endIndex;i++)
 	{
@@ -142,22 +142,22 @@ int	btOptimizedBvh::sortAndCalcSplittingIndex(NodeArray&	leafNodes,int startInde
 	int i;
 	int splitIndex =startIndex;
 	int numIndices = endIndex - startIndex;
-	float splitValue;
+	btScalar splitValue;
 
-	btVector3 means(0.f,0.f,0.f);
+	btVector3 means(btScalar(0.),btScalar(0.),btScalar(0.));
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		means+=center;
 	}
-	means *= (1.f/(float)numIndices);
+	means *= (btScalar(1.)/(btScalar)numIndices);
 	
 	splitValue = means[splitAxis];
 	
 	//sort leafNodes so all values larger then splitValue comes first, and smaller values start from 'splitIndex'.
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		if (center[splitAxis] > splitValue)
 		{
 			//swap
@@ -179,25 +179,25 @@ int	btOptimizedBvh::calcSplittingAxis(NodeArray&	leafNodes,int startIndex,int en
 {
 	int i;
 
-	btVector3 means(0.f,0.f,0.f);
-	btVector3 variance(0.f,0.f,0.f);
+	btVector3 means(btScalar(0.),btScalar(0.),btScalar(0.));
+	btVector3 variance(btScalar(0.),btScalar(0.),btScalar(0.));
 	int numIndices = endIndex-startIndex;
 
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		means+=center;
 	}
-	means *= (1.f/(float)numIndices);
+	means *= (btScalar(1.)/(btScalar)numIndices);
 		
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
 		btVector3 diff2 = center-means;
 		diff2 = diff2 * diff2;
 		variance += diff2;
 	}
-	variance *= (1.f/	((float)numIndices-1)	);
+	variance *= (btScalar(1.)/	((btScalar)numIndices-1)	);
 	
 	return variance.maxAxis();
 }

src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp

@@ -28,16 +28,16 @@ btVector3	btPolyhedralConvexShape::localGetSupportingVertexWithoutMargin(const b
 	int i;
 	btVector3 supVec(0,0,0);
 
-	btScalar maxDot(-1e30f);
+	btScalar maxDot(btScalar(-1e30));
 
 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}
 
@@ -68,7 +68,7 @@ void	btPolyhedralConvexShape::batchedUnitVectorGetSupportingVertexWithoutMargin(
 
 	for (i=0;i<numVectors;i++)
 	{
-		supportVerticesOut[i][3] = -1e30f;
+		supportVerticesOut[i][3] = btScalar(-1e30);
 	}
 
 	for (int j=0;j<numVectors;j++)
@@ -96,21 +96,21 @@ void	btPolyhedralConvexShape::calculateLocalInertia(btScalar mass,btVector3& ine
 {
 	//not yet, return box inertia
 
-	float margin = getMargin();
+	btScalar margin = getMargin();
 
 	btTransform ident;
 	ident.setIdentity();
 	btVector3 aabbMin,aabbMax;
 	getAabb(ident,aabbMin,aabbMax);
-	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);
 
-	btScalar lx=2.f*(halfExtents.x()+margin);
-	btScalar ly=2.f*(halfExtents.y()+margin);
-	btScalar lz=2.f*(halfExtents.z()+margin);
+	btScalar lx=btScalar(2.)*(halfExtents.x()+margin);
+	btScalar ly=btScalar(2.)*(halfExtents.y()+margin);
+	btScalar lz=btScalar(2.)*(halfExtents.z()+margin);
 	const btScalar x2 = lx*lx;
 	const btScalar y2 = ly*ly;
 	const btScalar z2 = lz*lz;
-	const btScalar scaledmass = mass * 0.08333333f;
+	const btScalar scaledmass = mass * btScalar(0.08333333);
 
 	inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));
 

src/BulletCollision/CollisionShapes/btSphereShape.cpp

@@ -26,14 +26,14 @@ btSphereShape ::btSphereShape (btScalar radius)
 
 btVector3	btSphereShape::localGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
-	return btVector3(0.f,0.f,0.f);
+	return btVector3(btScalar(0.),btScalar(0.),btScalar(0.));
 }
 
 void	btSphereShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
 	for (int i=0;i<numVectors;i++)
 	{
-		supportVerticesOut[i].setValue(0.f,0.f,0.f);
+		supportVerticesOut[i].setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	}
 }
 
@@ -46,7 +46,7 @@ btVector3	btSphereShape::localGetSupportingVertex(const btVector3& vec)const
 	btVector3 vecnorm = vec;
 	if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 	{
-		vecnorm.setValue(-1.f,-1.f,-1.f);
+		vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 	} 
 	vecnorm.normalize();
 	supVertex+= getMargin() * vecnorm;
@@ -67,7 +67,7 @@ void btSphereShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& a
 
 void	btSphereShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	btScalar elem = 0.4f * mass * getMargin()*getMargin();
+	btScalar elem = btScalar(0.4) * mass * getMargin()*getMargin();
 	inertia[0] = inertia[1] = inertia[2] = elem;
 
 }

src/BulletCollision/CollisionShapes/btSphereShape.h

@@ -45,11 +45,11 @@ public:
 	//debugging
 	virtual char*	getName()const {return "SPHERE";}
 
-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		btConvexShape::setMargin(margin);
 	}
-	virtual float	getMargin() const
+	virtual btScalar	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

src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp

@@ -21,7 +21,7 @@ subject to the following restrictions:
 btStaticPlaneShape::btStaticPlaneShape(const btVector3& planeNormal,btScalar planeConstant)
 :m_planeNormal(planeNormal),
 m_planeConstant(planeConstant),
-m_localScaling(0.f,0.f,0.f)
+m_localScaling(btScalar(0.),btScalar(0.),btScalar(0.))
 {
 }
 
@@ -34,7 +34,7 @@ btStaticPlaneShape::~btStaticPlaneShape()
 
 void btStaticPlaneShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	btVector3 infvec (1e30f,1e30f,1e30f);
+	btVector3 infvec (btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
 	btVector3 center = m_planeNormal*m_planeConstant;
 	aabbMin = center + infvec*m_planeNormal;
@@ -42,8 +42,8 @@ void btStaticPlaneShape::getAabb(const btTransform& t,btVector3& aabbMin,btVecto
 	aabbMin.setMin(center - infvec*m_planeNormal);
 	aabbMax.setMax(center - infvec*m_planeNormal); 
 
-	aabbMin.setValue(-1e30f,-1e30f,-1e30f);
-	aabbMax.setValue(1e30f,1e30f,1e30f);
+	aabbMin.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	aabbMax.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
 }
 
@@ -53,9 +53,9 @@ void btStaticPlaneShape::getAabb(const btTransform& t,btVector3& aabbMin,btVecto
 void	btStaticPlaneShape::processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 
-	btVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
+	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
 	btScalar radius = halfExtents.length();
-	btVector3 center = (aabbMax + aabbMin) * 0.5f;
+	btVector3 center = (aabbMax + aabbMin) * btScalar(0.5);
 	
 	//this is where the triangles are generated, given AABB and plane equation (normal/constant)
 
@@ -87,7 +87,7 @@ void	btStaticPlaneShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
 	//moving concave objects not supported
 	
-	inertia.setValue(0.f,0.f,0.f);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }
 
 void	btStaticPlaneShape::setLocalScaling(const btVector3& scaling)

src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp

@@ -33,7 +33,7 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 	int stride,numverts,numtriangles;
 	int gfxindex;
 	btVector3 triangle[3];
-	float* graphicsbase;
+	btScalar* graphicsbase;
 
 	btVector3 meshScaling = getScaling();
 
@@ -50,11 +50,11 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
 					int* tri_indices= (int*)(indexbase+gfxindex*indexstride);
-					graphicsbase = (float*)(vertexbase+tri_indices[0]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[1]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
 					triangle[1].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[2]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[2]*stride);
 					triangle[2].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
 					callback->internalProcessTriangleIndex(triangle,part,gfxindex);
 				}
@@ -65,11 +65,11 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
 					short int* tri_indices= (short int*)(indexbase+gfxindex*indexstride);
-					graphicsbase = (float*)(vertexbase+tri_indices[0]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[1]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
 					triangle[1].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[2]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[2]*stride);
 					triangle[2].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
 					callback->internalProcessTriangleIndex(triangle,part,gfxindex);
 				}

src/BulletCollision/CollisionShapes/btStridingMeshInterface.h

@@ -38,7 +38,7 @@ class  btStridingMeshInterface
 		btVector3 m_scaling;
 
 	public:
-		btStridingMeshInterface() :m_scaling(1.f,1.f,1.f)
+		btStridingMeshInterface() :m_scaling(btScalar(1.),btScalar(1.),btScalar(1.))
 		{
 
 		}

src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp

@@ -15,7 +15,7 @@ subject to the following restrictions:
 
 #include "btTriangleIndexVertexArray.h"
 
-btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride)
+btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,btScalar* vertexBase,int vertexStride)
 {
 	btIndexedMesh mesh;
 	

src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h

@@ -28,7 +28,7 @@ struct	btIndexedMesh
 		int*		m_triangleIndexBase;
 		int			m_triangleIndexStride;
 		int			m_numVertices;
-		float*		m_vertexBase;
+		btScalar*		m_vertexBase;
 		int			m_vertexStride;
 	};
 
@@ -50,7 +50,7 @@ public:
 	}
 
 	//just to be backwards compatible
-	btTriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride);
+	btTriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,btScalar* vertexBase,int vertexStride);
 	
 	void	addIndexedMesh(const btIndexedMesh& mesh)
 	{

src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp

@@ -40,8 +40,8 @@ btTriangleMeshShape::~btTriangleMeshShape()
 void btTriangleMeshShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {
 
-	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
 	
 	btMatrix3x3 abs_b = trans.getBasis().absolute();  
 
@@ -62,11 +62,11 @@ void	btTriangleMeshShape::recalcLocalAabb()
 {
 	for (int i=0;i<3;i++)
 	{
-		btVector3 vec(0.f,0.f,0.f);
-		vec[i] = 1.f;
+		btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
+		vec[i] = btScalar(1.);
 		btVector3 tmp = localGetSupportingVertex(vec);
 		m_localAabbMax[i] = tmp[i]+m_collisionMargin;
-		vec[i] = -1.f;
+		vec[i] = btScalar(-1.);
 		tmp = localGetSupportingVertex(vec);
 		m_localAabbMin[i] = tmp[i]-m_collisionMargin;
 	}
@@ -85,7 +85,7 @@ public:
 	btVector3 m_supportVecLocal;
 
 	SupportVertexCallback(const btVector3& supportVecWorld,const btTransform& trans)
-		: m_supportVertexLocal(0.f,0.f,0.f), m_worldTrans(trans) ,m_maxDot(-1e30f)
+		: m_supportVertexLocal(btScalar(0.),btScalar(0.),btScalar(0.)), m_worldTrans(trans) ,m_maxDot(btScalar(-1e30))
 		
 	{
 		m_supportVecLocal = supportVecWorld * m_worldTrans.getBasis();
@@ -178,7 +178,7 @@ void	btTriangleMeshShape::calculateLocalInertia(btScalar mass,btVector3& inertia
 {
 	//moving concave objects not supported
 	assert(0);
-	inertia.setValue(0.f,0.f,0.f);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }
 
 
@@ -191,7 +191,7 @@ btVector3 btTriangleMeshShape::localGetSupportingVertex(const btVector3& vec) co
 
 	SupportVertexCallback supportCallback(vec,ident);
 
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	
 	processAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		

src/BulletCollision/CollisionShapes/btTriangleShape.h

@@ -117,7 +117,7 @@ public:
 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia)
 	{
 		btAssert(0);
-		inertia.setValue(0.f,0.f,0.f);
+		inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	}
 
 		virtual	bool isInside(const btPoint3& pt,btScalar tolerance) const
@@ -166,7 +166,7 @@ public:
 		{
 			calcNormal(penetrationVector);
 			if (index)
-				penetrationVector *= -1.f;
+				penetrationVector *= btScalar(-1.);
 		}
 
 

src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp

@@ -49,28 +49,28 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 
 	/// compute linear and angular velocity for this interval, to interpolate
 	btVector3 linVelA,angVelA,linVelB,angVelB;
-	btTransformUtil::calculateVelocity(fromA,toA,1.f,linVelA,angVelA);
-	btTransformUtil::calculateVelocity(fromB,toB,1.f,linVelB,angVelB);
+	btTransformUtil::calculateVelocity(fromA,toA,btScalar(1.),linVelA,angVelA);
+	btTransformUtil::calculateVelocity(fromB,toB,btScalar(1.),linVelB,angVelB);
 
 	btScalar boundingRadiusA = m_convexA->getAngularMotionDisc();
 	btScalar boundingRadiusB = m_convexB->getAngularMotionDisc();
 
 	btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;
 
-	float radius = 0.001f;
+	btScalar radius = btScalar(0.001);
 
-	btScalar lambda = 0.f;
+	btScalar lambda = btScalar(0.);
 	btVector3 v(1,0,0);
 
 	int maxIter = MAX_ITERATIONS;
 
 	btVector3 n;
-	n.setValue(0.f,0.f,0.f);
+	n.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	bool hasResult = false;
 	btVector3 c;
 
-	float lastLambda = lambda;
-	//float epsilon = 0.001f;
+	btScalar lastLambda = lambda;
+	//btScalar epsilon = btScalar(0.001);
 
 	int numIter = 0;
 	//first solution, using GJK
@@ -79,8 +79,8 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 	btTransform identityTrans;
 	identityTrans.setIdentity();
 
-	btSphereShape	raySphere(0.0f);
-	raySphere.setMargin(0.f);
+	btSphereShape	raySphere(btScalar(0.0));
+	raySphere.setMargin(btScalar(0.));
 
 
 //	result.drawCoordSystem(sphereTr);
@@ -116,23 +116,23 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 			if (numIter > maxIter)
 				return false; //todo: report a failure
 
-			float dLambda = 0.f;
+			btScalar dLambda = btScalar(0.);
 
 			//calculate safe moving fraction from distance / (linear+rotational velocity)
 			
-			//float clippedDist  = GEN_min(angularConservativeRadius,dist);
-			//float clippedDist  = dist;
+			//btScalar clippedDist  = GEN_min(angularConservativeRadius,dist);
+			//btScalar clippedDist  = dist;
 			
-			float projectedLinearVelocity = (linVelB-linVelA).dot(n);
+			btScalar projectedLinearVelocity = (linVelB-linVelA).dot(n);
 			
 			dLambda = dist / (projectedLinearVelocity+ maxAngularProjectedVelocity);
 
 			lambda = lambda + dLambda;
 
-			if (lambda > 1.f)
+			if (lambda > btScalar(1.))
 				return false;
 
-			if (lambda < 0.f)
+			if (lambda < btScalar(0.))
 				return false;
 
 			//todo: next check with relative epsilon
@@ -159,7 +159,7 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 			gjk.getClosestPoints(input,pointCollector,0);
 			if (pointCollector.m_hasResult)
 			{
-				if (pointCollector.m_distance < 0.f)
+				if (pointCollector.m_distance < btScalar(0.))
 				{
 					//degenerate ?!
 					result.m_fraction = lastLambda;
@@ -188,9 +188,9 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 //todo:
 	//if movement away from normal, discard result
 	btVector3 move = transBLocalTo.getOrigin() - transBLocalFrom.getOrigin();
-	if (result.m_fraction < 1.f)
+	if (result.m_fraction < btScalar(1.))
 	{
-		if (move.dot(result.m_normal) <= 0.f)
+		if (move.dot(result.m_normal) <= btScalar(0.))
 		{
 		}
 	}

src/BulletCollision/NarrowPhaseCollision/btConvexCast.h

@@ -41,7 +41,7 @@ public:
 		virtual void	drawCoordSystem(const btTransform& trans) {}
 
 		CastResult()
-			:m_fraction(1e30f),
+			:m_fraction(btScalar(1e30)),
 			m_debugDrawer(0)
 		{
 		}

src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h

@@ -36,13 +36,13 @@ struct btDiscreteCollisionDetectorInterface
 
 		///setShapeIdentifiers provides experimental support for per-triangle material / custom material combiner
 		virtual void setShapeIdentifiers(int partId0,int index0,	int partId1,int index1)=0;
-		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)=0;
+		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)=0;
 	};
 
 	struct ClosestPointInput
 	{
 		ClosestPointInput()
-			:m_maximumDistanceSquared(1e30f),
+			:m_maximumDistanceSquared(btScalar(1e30)),
 			m_stackAlloc(0)
 		{
 		}
@@ -69,13 +69,13 @@ struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
 		btVector3	m_closestPointInB;
 		btScalar	m_distance; //negative means penetration !
 
-		btStorageResult() : m_distance(1e30f)
+		btStorageResult() : m_distance(btScalar(1e30))
 		{
 
 		}
 		virtual ~btStorageResult() {};
 
-		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 		{
 			if (depth < m_distance)
 			{

src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp

@@ -60,9 +60,9 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 
 
 
-	float radius = 0.01f;
+	btScalar radius = btScalar(0.01);
 
-	btScalar lambda = 0.f;
+	btScalar lambda = btScalar(0.);
 	btVector3 s = rayFromLocalA.getOrigin();
 	btVector3 r = rayToLocalA.getOrigin()-rayFromLocalA.getOrigin();
 	btVector3 x = s;
@@ -71,7 +71,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 	bool hasResult = false;
 	btVector3 c;
 
-	float lastLambda = lambda;
+	btScalar lastLambda = lambda;
 
 	//first solution, using GJK
 
@@ -81,8 +81,8 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 	btTransform identityTrans;
 	identityTrans.setIdentity();
 
-	btSphereShape	raySphere(0.0f);
-	raySphere.setMargin(0.f);
+	btSphereShape	raySphere(btScalar(0.0));
+	raySphere.setMargin(btScalar(0.));
 
 	btTransform sphereTr;
 	sphereTr.setIdentity();
@@ -112,7 +112,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 		if (dist < radius)
 		{
 			//penetration
-			lastLambda = 1.f;
+			lastLambda = btScalar(1.);
 		}
 
 		//not close enough
@@ -143,7 +143,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 			gjk.getClosestPoints(input,pointCollector,0);
 			if (pointCollector.m_hasResult)
 			{
-				if (pointCollector.m_distance < 0.f)
+				if (pointCollector.m_distance < btScalar(0.))
 				{
 					//degeneracy, report a hit
 					result.m_fraction = lastLambda;
@@ -160,7 +160,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 
 		}
 
-		if (lastLambda < 1.f)
+		if (lastLambda < btScalar(1.))
 		{
 		
 			result.m_fraction = lastLambda;

src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp

@@ -27,7 +27,7 @@ bool btGjkEpaPenetrationDepthSolver::calcPenDepth( btSimplexSolverInterface& sim
 {
 
 
-	const btScalar				radialmargin(0.f);
+	const btScalar				radialmargin(btScalar(0.));
 	
 	btGjkEpaSolver::sResults	results;
 	if(btGjkEpaSolver::Collide(	pConvexA,transformA,

src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp

@@ -27,7 +27,7 @@ subject to the following restrictions:
 #endif
 
 //must be above the machine epsilon
-#define REL_ERROR2 1.0e-6f
+#define REL_ERROR2 btScalar(1.0e-6)
 
 //temp globals, to improve GJK/EPA/penetration calculations
 int gNumDeepPenetrationChecks = 0;
@@ -36,7 +36,7 @@ int gNumGjkChecks = 0;
 
 
 btGjkPairDetector::btGjkPairDetector(btConvexShape* objectA,btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver*	penetrationDepthSolver)
-:m_cachedSeparatingAxis(0.f,0.f,1.f),
+:m_cachedSeparatingAxis(btScalar(0.),btScalar(0.),btScalar(1.)),
 m_penetrationDepthSolver(penetrationDepthSolver),
 m_simplexSolver(simplexSolver),
 m_minkowskiA(objectA),
@@ -49,25 +49,25 @@ m_catchDegeneracies(1)
 
 void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
 {
-	btScalar distance=0.f;
-	btVector3	normalInB(0.f,0.f,0.f);
+	btScalar distance=btScalar(0.);
+	btVector3	normalInB(btScalar(0.),btScalar(0.),btScalar(0.));
 	btVector3 pointOnA,pointOnB;
 	btTransform	localTransA = input.m_transformA;
 	btTransform localTransB = input.m_transformB;
-	btVector3 positionOffset = (localTransA.getOrigin() + localTransB.getOrigin()) * 0.5f;
+	btVector3 positionOffset = (localTransA.getOrigin() + localTransB.getOrigin()) * btScalar(0.5);
 	localTransA.getOrigin() -= positionOffset;
 	localTransB.getOrigin() -= positionOffset;
 
-	float marginA = m_minkowskiA->getMargin();
-	float marginB = m_minkowskiB->getMargin();
+	btScalar marginA = m_minkowskiA->getMargin();
+	btScalar marginB = m_minkowskiB->getMargin();
 
 	gNumGjkChecks++;
 
 	//for CCD we don't use margins
 	if (m_ignoreMargin)
 	{
-		marginA = 0.f;
-		marginB = 0.f;
+		marginA = btScalar(0.);
+		marginB = btScalar(0.);
 	}
 
 	m_curIter = 0;
@@ -83,7 +83,7 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 
 	{
 		btScalar squaredDistance = SIMD_INFINITY;
-		btScalar delta = 0.f;
+		btScalar delta = btScalar(0.);
 		
 		btScalar margin = marginA + marginB;
 		
@@ -120,12 +120,12 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 				break;
 			}
 			// are we getting any closer ?
-			float f0 = squaredDistance - delta;
-			float f1 = squaredDistance * REL_ERROR2;
+			btScalar f0 = squaredDistance - delta;
+			btScalar f1 = squaredDistance * REL_ERROR2;
 
 			if (f0 <= f1)
 			{
-				if (f0 <= 0.f)
+				if (f0 <= btScalar(0.))
 				{
 					m_degenerateSimplex = 2;
 				}
@@ -191,7 +191,7 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 		{
 			m_simplexSolver->compute_points(pointOnA, pointOnB);
 			normalInB = pointOnA-pointOnB;
-			float lenSqr = m_cachedSeparatingAxis.length2();
+			btScalar lenSqr = m_cachedSeparatingAxis.length2();
 			//valid normal
 			if (lenSqr < 0.0001)
 			{
@@ -199,14 +199,14 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 			} 
 			if (lenSqr > SIMD_EPSILON*SIMD_EPSILON)
 			{
-				float rlen = 1.f / btSqrt(lenSqr );
+				btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 				normalInB *= rlen; //normalize
 				btScalar s = btSqrt(squaredDistance);
 			
 				btAssert(s > btScalar(0.0));
 				pointOnA -= m_cachedSeparatingAxis * (marginA / s);
 				pointOnB += m_cachedSeparatingAxis * (marginB / s);
-				distance = ((1.f/rlen) - margin);
+				distance = ((btScalar(1.)/rlen) - margin);
 				isValid = true;
 				
 				m_lastUsedMethod = 1;
@@ -243,11 +243,11 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 				if (isValid2)
 				{
 					btVector3 tmpNormalInB = tmpPointOnB-tmpPointOnA;
-					float lenSqr = tmpNormalInB.length2();
+					btScalar lenSqr = tmpNormalInB.length2();
 					if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
 					{
 						tmpNormalInB /= btSqrt(lenSqr);
-						float distance2 = -(tmpPointOnA-tmpPointOnB).length();
+						btScalar distance2 = -(tmpPointOnA-tmpPointOnB).length();
 						//only replace valid penetrations when the result is deeper (check)
 						if (!isValid || (distance2 < distance))
 						{

src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h

@@ -40,8 +40,8 @@ class btManifoldPoint
 					m_localPointB( pointB ), 
 					m_normalWorldOnB( normal ), 
 					m_distance1( distance ),
-					m_combinedFriction(0.f),
-					m_combinedRestitution(0.f),
+					m_combinedFriction(btScalar(0.)),
+					m_combinedRestitution(btScalar(0.)),
 					m_userPersistentData(0),					
 					m_lifeTime(0)
 			{
@@ -58,16 +58,16 @@ class btManifoldPoint
 			btVector3	m_positionWorldOnA;
 			btVector3 m_normalWorldOnB;
 		
-			float	m_distance1;
-			float	m_combinedFriction;
-			float	m_combinedRestitution;
+			btScalar	m_distance1;
+			btScalar	m_combinedFriction;
+			btScalar	m_combinedRestitution;
 
 				
 			mutable void*	m_userPersistentData;
 
 			int		m_lifeTime;//lifetime of the contactpoint in frames
 			
-			float getDistance() const
+			btScalar getDistance() const
 			{
 				return m_distance1;
 			}
@@ -86,7 +86,7 @@ class btManifoldPoint
 				return m_positionWorldOnB;
 			}
 
-			void	setDistance(float dist)
+			void	setDistance(btScalar dist)
 			{
 				m_distance1 = dist;
 			}

src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp

@@ -25,48 +25,48 @@ subject to the following restrictions:
 #define NUM_UNITSPHERE_POINTS 42
 static btVector3	sPenetrationDirections[NUM_UNITSPHERE_POINTS+MAX_PREFERRED_PENETRATION_DIRECTIONS*2] = 
 {
-btVector3(0.000000f , -0.000000f,-1.000000f),
-btVector3(0.723608f , -0.525725f,-0.447219f),
-btVector3(-0.276388f , -0.850649f,-0.447219f),
-btVector3(-0.894426f , -0.000000f,-0.447216f),
-btVector3(-0.276388f , 0.850649f,-0.447220f),
-btVector3(0.723608f , 0.525725f,-0.447219f),
-btVector3(0.276388f , -0.850649f,0.447220f),
-btVector3(-0.723608f , -0.525725f,0.447219f),
-btVector3(-0.723608f , 0.525725f,0.447219f),
-btVector3(0.276388f , 0.850649f,0.447219f),
-btVector3(0.894426f , 0.000000f,0.447216f),
-btVector3(-0.000000f , 0.000000f,1.000000f),
-btVector3(0.425323f , -0.309011f,-0.850654f),
-btVector3(-0.162456f , -0.499995f,-0.850654f),
-btVector3(0.262869f , -0.809012f,-0.525738f),
-btVector3(0.425323f , 0.309011f,-0.850654f),
-btVector3(0.850648f , -0.000000f,-0.525736f),
-btVector3(-0.525730f , -0.000000f,-0.850652f),
-btVector3(-0.688190f , -0.499997f,-0.525736f),
-btVector3(-0.162456f , 0.499995f,-0.850654f),
-btVector3(-0.688190f , 0.499997f,-0.525736f),
-btVector3(0.262869f , 0.809012f,-0.525738f),
-btVector3(0.951058f , 0.309013f,0.000000f),
-btVector3(0.951058f , -0.309013f,0.000000f),
-btVector3(0.587786f , -0.809017f,0.000000f),
-btVector3(0.000000f , -1.000000f,0.000000f),
-btVector3(-0.587786f , -0.809017f,0.000000f),
-btVector3(-0.951058f , -0.309013f,-0.000000f),
-btVector3(-0.951058f , 0.309013f,-0.000000f),
-btVector3(-0.587786f , 0.809017f,-0.000000f),
-btVector3(-0.000000f , 1.000000f,-0.000000f),
-btVector3(0.587786f , 0.809017f,-0.000000f),
-btVector3(0.688190f , -0.499997f,0.525736f),
-btVector3(-0.262869f , -0.809012f,0.525738f),
-btVector3(-0.850648f , 0.000000f,0.525736f),
-btVector3(-0.262869f , 0.809012f,0.525738f),
-btVector3(0.688190f , 0.499997f,0.525736f),
-btVector3(0.525730f , 0.000000f,0.850652f),
-btVector3(0.162456f , -0.499995f,0.850654f),
-btVector3(-0.425323f , -0.309011f,0.850654f),
-btVector3(-0.425323f , 0.309011f,0.850654f),
-btVector3(0.162456f , 0.499995f,0.850654f)
+btVector3(btScalar(0.000000) , btScalar(-0.000000),btScalar(-1.000000)),
+btVector3(btScalar(0.723608) , btScalar(-0.525725),btScalar(-0.447219)),
+btVector3(btScalar(-0.276388) , btScalar(-0.850649),btScalar(-0.447219)),
+btVector3(btScalar(-0.894426) , btScalar(-0.000000),btScalar(-0.447216)),
+btVector3(btScalar(-0.276388) , btScalar(0.850649),btScalar(-0.447220)),
+btVector3(btScalar(0.723608) , btScalar(0.525725),btScalar(-0.447219)),
+btVector3(btScalar(0.276388) , btScalar(-0.850649),btScalar(0.447220)),
+btVector3(btScalar(-0.723608) , btScalar(-0.525725),btScalar(0.447219)),
+btVector3(btScalar(-0.723608) , btScalar(0.525725),btScalar(0.447219)),
+btVector3(btScalar(0.276388) , btScalar(0.850649),btScalar(0.447219)),
+btVector3(btScalar(0.894426) , btScalar(0.000000),btScalar(0.447216)),
+btVector3(btScalar(-0.000000) , btScalar(0.000000),btScalar(1.000000)),
+btVector3(btScalar(0.425323) , btScalar(-0.309011),btScalar(-0.850654)),
+btVector3(btScalar(-0.162456) , btScalar(-0.499995),btScalar(-0.850654)),
+btVector3(btScalar(0.262869) , btScalar(-0.809012),btScalar(-0.525738)),
+btVector3(btScalar(0.425323) , btScalar(0.309011),btScalar(-0.850654)),
+btVector3(btScalar(0.850648) , btScalar(-0.000000),btScalar(-0.525736)),
+btVector3(btScalar(-0.525730) , btScalar(-0.000000),btScalar(-0.850652)),
+btVector3(btScalar(-0.688190) , btScalar(-0.499997),btScalar(-0.525736)),
+btVector3(btScalar(-0.162456) , btScalar(0.499995),btScalar(-0.850654)),
+btVector3(btScalar(-0.688190) , btScalar(0.499997),btScalar(-0.525736)),
+btVector3(btScalar(0.262869) , btScalar(0.809012),btScalar(-0.525738)),
+btVector3(btScalar(0.951058) , btScalar(0.309013),btScalar(0.000000)),
+btVector3(btScalar(0.951058) , btScalar(-0.309013),btScalar(0.000000)),
+btVector3(btScalar(0.587786) , btScalar(-0.809017),btScalar(0.000000)),
+btVector3(btScalar(0.000000) , btScalar(-1.000000),btScalar(0.000000)),
+btVector3(btScalar(-0.587786) , btScalar(-0.809017),btScalar(0.000000)),
+btVector3(btScalar(-0.951058) , btScalar(-0.309013),btScalar(-0.000000)),
+btVector3(btScalar(-0.951058) , btScalar(0.309013),btScalar(-0.000000)),
+btVector3(btScalar(-0.587786) , btScalar(0.809017),btScalar(-0.000000)),
+btVector3(btScalar(-0.000000) , btScalar(1.000000),btScalar(-0.000000)),
+btVector3(btScalar(0.587786) , btScalar(0.809017),btScalar(-0.000000)),
+btVector3(btScalar(0.688190) , btScalar(-0.499997),btScalar(0.525736)),
+btVector3(btScalar(-0.262869) , btScalar(-0.809012),btScalar(0.525738)),
+btVector3(btScalar(-0.850648) , btScalar(0.000000),btScalar(0.525736)),
+btVector3(btScalar(-0.262869) , btScalar(0.809012),btScalar(0.525738)),
+btVector3(btScalar(0.688190) , btScalar(0.499997),btScalar(0.525736)),
+btVector3(btScalar(0.525730) , btScalar(0.000000),btScalar(0.850652)),
+btVector3(btScalar(0.162456) , btScalar(-0.499995),btScalar(0.850654)),
+btVector3(btScalar(-0.425323) , btScalar(-0.309011),btScalar(0.850654)),
+btVector3(btScalar(-0.425323) , btScalar(0.309011),btScalar(0.850654)),
+btVector3(btScalar(0.162456) , btScalar(0.499995),btScalar(0.850654))
 };
 
 
@@ -88,13 +88,13 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 		
 		btVector3 m_normalOnBInWorld;
 		btVector3 m_pointInWorld;
-		float m_depth;
+		btScalar m_depth;
 		bool	m_hasResult;
 
 		virtual void setShapeIdentifiers(int partId0,int index0,	int partId1,int index1)
 		{
 		}
-		void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+		void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 		{
 			m_normalOnBInWorld = normalOnBInWorld;
 			m_pointInWorld = pointInWorld;
@@ -104,7 +104,7 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 	};
 
 	//just take fixed number of orientation, and sample the penetration depth in that direction
-	float minProj = 1e30f;
+	btScalar minProj = btScalar(1e30);
 	btVector3 minNorm;
 	btVector3 minVertex;
 	btVector3 minA,minB;
@@ -180,7 +180,7 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 		pWorld = transA(pInA);	
 		qWorld = transB(qInB);
 		w	= qWorld - pWorld;
-		float delta = norm.dot(w);
+		btScalar delta = norm.dot(w);
 		//find smallest delta
 		if (delta < minProj)
 		{
@@ -234,7 +234,7 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 		pWorld = transA(pInA);	
 		qWorld = transB(qInB);
 		w	= qWorld - pWorld;
-		float delta = norm.dot(w);
+		btScalar delta = norm.dot(w);
 		//find smallest delta
 		if (delta < minProj)
 		{
@@ -251,7 +251,7 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 	minA += minNorm*convexA->getMargin();
 	minB -= minNorm*convexB->getMargin();
 	//no penetration
-	if (minProj < 0.f)
+	if (minProj < btScalar(0.))
 		return false;
 
 	minProj += (convexA->getMargin() + convexB->getMargin());
@@ -268,7 +268,7 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 		debugDraw->drawLine(minA,minB,color);
 		color = btVector3 (1,1,1);
 		btVector3 vec = minB-minA;
-		float prj2 = minNorm.dot(vec);
+		btScalar prj2 = minNorm.dot(vec);
 		debugDraw->drawLine(minA,minA+(minNorm*minProj),color);
 
 	}
@@ -292,16 +292,16 @@ bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& s
 
 	input.m_transformA = displacedTrans;
 	input.m_transformB = transB;
-	input.m_maximumDistanceSquared = 1e30f;//minProj;
+	input.m_maximumDistanceSquared = btScalar(1e30);//minProj;
 	
 	btIntermediateResult res;
 	gjkdet.getClosestPoints(input,res,debugDraw);
 
-	float correctedMinNorm = minProj - res.m_depth;
+	btScalar correctedMinNorm = minProj - res.m_depth;
 
 
 	//the penetration depth is over-estimated, relax it
-	float penetration_relaxation= 1.f;
+	btScalar penetration_relaxation= btScalar(1.);
 	minNorm*=penetration_relaxation;
 
 	if (res.m_hasResult)

src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp

@@ -18,7 +18,7 @@ subject to the following restrictions:
 #include "LinearMath/btTransform.h"
 #include <assert.h>
 
-float						gContactBreakingThreshold = 0.02f;
+btScalar					gContactBreakingThreshold = btScalar(0.02);
 ContactDestroyedCallback	gContactDestroyedCallback = 0;
 
 
@@ -100,7 +100,7 @@ int btPersistentManifold::sortCachedPoints(const btManifoldPoint& pt)
 		int maxPenetrationIndex = -1;
 #define KEEP_DEEPEST_POINT 1
 #ifdef KEEP_DEEPEST_POINT
-		float maxPenetration = pt.getDistance();
+		btScalar maxPenetration = pt.getDistance();
 		for (int i=0;i<4;i++)
 		{
 			if (m_pointCache[i].getDistance() < maxPenetration)
@@ -111,7 +111,7 @@ int btPersistentManifold::sortCachedPoints(const btManifoldPoint& pt)
 		}
 #endif //KEEP_DEEPEST_POINT
 		
-		btScalar res0(0.f),res1(0.f),res2(0.f),res3(0.f);
+		btScalar res0(btScalar(0.)),res1(btScalar(0.)),res2(btScalar(0.)),res3(btScalar(0.));
 		if (maxPenetrationIndex != 0)
 		{
 			btVector3 a0 = pt.m_localPointA-m_pointCache[1].m_localPointA;
@@ -193,7 +193,7 @@ void btPersistentManifold::AddManifoldPoint(const btManifoldPoint& newPoint)
 	replaceContactPoint(newPoint,insertIndex);
 }
 
-float	btPersistentManifold::getContactBreakingThreshold() const
+btScalar	btPersistentManifold::getContactBreakingThreshold() const
 {
 	return gContactBreakingThreshold;
 }

src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h

@@ -24,7 +24,7 @@ subject to the following restrictions:
 struct btCollisionResult;
 
 ///contact breaking and merging threshold
-extern float gContactBreakingThreshold;
+extern btScalar gContactBreakingThreshold;
 
 typedef bool (*ContactDestroyedCallback)(void* userPersistentData);
 extern ContactDestroyedCallback	gContactDestroyedCallback;
@@ -97,7 +97,7 @@ public:
 	}
 
 	/// todo: get this margin from the current physics / collision environment
-	float	getContactBreakingThreshold() const;
+	btScalar	getContactBreakingThreshold() const;
 	
 	int getCacheEntry(const btManifoldPoint& newPoint) const;
 

src/BulletCollision/NarrowPhaseCollision/btPointCollector.h

@@ -31,7 +31,7 @@ struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result
 	bool	m_hasResult;
 
 	btPointCollector () 
-		: m_distance(1e30f),m_hasResult(false)
+		: m_distance(btScalar(1e30)),m_hasResult(false)
 	{
 	}
 
@@ -40,7 +40,7 @@ struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result
 		//??
 	}
 
-	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 	{
 		if (depth< m_distance)
 		{

src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp

@@ -20,7 +20,7 @@ btTriangleRaycastCallback::btTriangleRaycastCallback(const btVector3& from,const
 	:
 	m_from(from),
 	m_to(to),
-	m_hitFraction(1.f)
+	m_hitFraction(btScalar(1.))
 {
 
 }
@@ -40,19 +40,19 @@ void btTriangleRaycastCallback::processTriangle(btVector3* triangle,int partId,
 
 	btVector3 triangleNormal; triangleNormal = v10.cross( v20 );
 	
-	const float dist = vert0.dot(triangleNormal);
-	float dist_a = triangleNormal.dot(m_from) ;
+	const btScalar dist = vert0.dot(triangleNormal);
+	btScalar dist_a = triangleNormal.dot(m_from) ;
 	dist_a-= dist;
-	float dist_b = triangleNormal.dot(m_to);
+	btScalar dist_b = triangleNormal.dot(m_to);
 	dist_b -= dist;
 
-	if ( dist_a * dist_b >= 0.0f)
+	if ( dist_a * dist_b >= btScalar(0.0) )
 	{
 		return ; // same sign
 	}
 	
-	const float proj_length=dist_a-dist_b;
-	const float distance = (dist_a)/(proj_length);
+	const btScalar proj_length=dist_a-dist_b;
+	const btScalar distance = (dist_a)/(proj_length);
 	// Now we have the intersection point on the plane, we'll see if it's inside the triangle
 	// Add an epsilon as a tolerance for the raycast,
 	// in case the ray hits exacly on the edge of the triangle.
@@ -62,27 +62,27 @@ void btTriangleRaycastCallback::processTriangle(btVector3* triangle,int partId,
 	{
 		
 
-		float edge_tolerance =triangleNormal.length2();		
-		edge_tolerance *= -0.0001f;
+		btScalar edge_tolerance =triangleNormal.length2();		
+		edge_tolerance *= btScalar(-0.0001);
 		btVector3 point; point.setInterpolate3( m_from, m_to, distance);
 		{
 			btVector3 v0p; v0p = vert0 - point;
 			btVector3 v1p; v1p = vert1 - point;
 			btVector3 cp0; cp0 = v0p.cross( v1p );
 
-			if ( (float)(cp0.dot(triangleNormal)) >=edge_tolerance) 
+			if ( (btScalar)(cp0.dot(triangleNormal)) >=edge_tolerance) 
 			{
 						
 
 				btVector3 v2p; v2p = vert2 -  point;
 				btVector3 cp1;
 				cp1 = v1p.cross( v2p);
-				if ( (float)(cp1.dot(triangleNormal)) >=edge_tolerance) 
+				if ( (btScalar)(cp1.dot(triangleNormal)) >=edge_tolerance) 
 				{
 					btVector3 cp2;
 					cp2 = v2p.cross(v0p);
 					
-					if ( (float)(cp2.dot(triangleNormal)) >=edge_tolerance) 
+					if ( (btScalar)(cp2.dot(triangleNormal)) >=edge_tolerance) 
 					{
 
 						if ( dist_a > 0 )

src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h

@@ -28,13 +28,13 @@ public:
 	btVector3 m_from;
 	btVector3 m_to;
 
-	float	m_hitFraction;
+	btScalar	m_hitFraction;
 
 	btTriangleRaycastCallback(const btVector3& from,const btVector3& to);
 	
 	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
 
-	virtual float reportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex ) = 0;
+	virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex ) = 0;
 	
 };
 

src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp

@@ -52,9 +52,9 @@ bool	btSubsimplexConvexCast::calcTimeOfImpact(
 
 	convex->setTransformB(btTransform(rayFromLocalA.getBasis()));
 
-	//float radius = 0.01f;
+	//btScalar radius = btScalar(0.01);
 
-	btScalar lambda = 0.f;
+	btScalar lambda = btScalar(0.);
 	//todo: need to verify this:
 	//because of minkowski difference, we need the inverse direction
 	
@@ -69,27 +69,27 @@ bool	btSubsimplexConvexCast::calcTimeOfImpact(
 	int maxIter = MAX_ITERATIONS;
 
 	btVector3 n;
-	n.setValue(0.f,0.f,0.f);
+	n.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	bool hasResult = false;
 	btVector3 c;
 
-	float lastLambda = lambda;
+	btScalar lastLambda = lambda;
 
 
-	float dist2 = v.length2();
-	float epsilon = 0.0001f;
+	btScalar dist2 = v.length2();
+	btScalar epsilon = btScalar(0.0001);
 
 	btVector3	w,p;
-	float VdotR;
+	btScalar VdotR;
 	
 	while ( (dist2 > epsilon) && maxIter--)
 	{
 		p = convex->localGetSupportingVertex( v);
 		 w = x - p;
 
-		float VdotW = v.dot(w);
+		btScalar VdotW = v.dot(w);
 
-		if ( VdotW > 0.f)
+		if ( VdotW > btScalar(0.))
 		{
 			VdotR = v.dot(r);
 
@@ -117,7 +117,7 @@ bool	btSubsimplexConvexCast::calcTimeOfImpact(
 			//printf("numverts = %i\n",m_simplexSolver->numVertices());
 		} else
 		{
-			dist2 = 0.f;
+			dist2 = btScalar(0.);
 		} 
 	}
 

src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp

@@ -70,7 +70,7 @@ void btVoronoiSimplexSolver::reset()
 	m_cachedValidClosest = false;
 	m_numVertices = 0;
 	m_needsUpdate = true;
-	m_lastW = btVector3(1e30f,1e30f,1e30f);
+	m_lastW = btVector3(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	m_cachedBC.reset();
 }
 
@@ -109,7 +109,7 @@ bool	btVoronoiSimplexSolver::updateClosestVectorAndPoints()
 				m_cachedP2 = m_simplexPointsQ[0];
 				m_cachedV = m_cachedP1-m_cachedP2; //== m_simplexVectorW[0]
 				m_cachedBC.reset();
-				m_cachedBC.setBarycentricCoordinates(1.f,0.f,0.f,0.f);
+				m_cachedBC.setBarycentricCoordinates(btScalar(1.),btScalar(0.),btScalar(0.),btScalar(0.));
 				m_cachedValidClosest = m_cachedBC.isValid();
 				break;
 			};
@@ -120,13 +120,13 @@ bool	btVoronoiSimplexSolver::updateClosestVectorAndPoints()
 					const btVector3& to = m_simplexVectorW[1];
 					btVector3 nearest;
 
-					btVector3 p (0.f,0.f,0.f);
+					btVector3 p (btScalar(0.),btScalar(0.),btScalar(0.));
 					btVector3 diff = p - from;
 					btVector3 v = to - from;
-					float t = v.dot(diff);
+					btScalar t = v.dot(diff);
 					
 					if (t > 0) {
-						float dotVV = v.dot(v);
+						btScalar dotVV = v.dot(v);
 						if (t < dotVV) {
 							t /= dotVV;
 							diff -= t*v;
@@ -159,7 +159,7 @@ bool	btVoronoiSimplexSolver::updateClosestVectorAndPoints()
 		case 3:
 			{
 				//closest point origin from triangle
-				btVector3 p (0.f,0.f,0.f);
+				btVector3 p (btScalar(0.),btScalar(0.),btScalar(0.));
 				
 				const btVector3& a = m_simplexVectorW[0];
 				const btVector3& b = m_simplexVectorW[1];
@@ -187,7 +187,7 @@ bool	btVoronoiSimplexSolver::updateClosestVectorAndPoints()
 			{
 
 				
-				btVector3 p (0.f,0.f,0.f);
+				btVector3 p (btScalar(0.),btScalar(0.),btScalar(0.));
 				
 				const btVector3& a = m_simplexVectorW[0];
 				const btVector3& b = m_simplexVectorW[1];
@@ -222,7 +222,7 @@ bool	btVoronoiSimplexSolver::updateClosestVectorAndPoints()
 					{
 						m_cachedValidClosest = true;
 						//degenerate case == false, penetration = true + zero
-						m_cachedV.setValue(0.f,0.f,0.f);
+						m_cachedV.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 					}
 					break;
 				}
@@ -256,7 +256,7 @@ bool btVoronoiSimplexSolver::closest(btVector3& v)
 btScalar btVoronoiSimplexSolver::maxVertex()
 {
 	int i, numverts = numVertices();
-	btScalar maxV = 0.f;
+	btScalar maxV = btScalar(0.);
 	for (i=0;i<numverts;i++)
 	{
 		btScalar curLen2 = m_simplexVectorW[i].length2();
@@ -288,7 +288,7 @@ bool btVoronoiSimplexSolver::inSimplex(const btVector3& w)
 {
 	bool found = false;
 	int i, numverts = numVertices();
-	//btScalar maxV = 0.f;
+	//btScalar maxV = btScalar(0.);
 	
 	//w is in the current (reduced) simplex
 	for (i=0;i<numverts;i++)
@@ -335,9 +335,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
     btVector3 ab = b - a;
     btVector3 ac = c - a;
     btVector3 ap = p - a;
-    float d1 = ab.dot(ap);
-    float d2 = ac.dot(ap);
-    if (d1 <= 0.0f && d2 <= 0.0f) 
+    btScalar d1 = ab.dot(ap);
+    btScalar d2 = ac.dot(ap);
+    if (d1 <= btScalar(0.0) && d2 <= btScalar(0.0)) 
 	{
 		result.m_closestPointOnSimplex = a;
 		result.m_usedVertices.usedVertexA = true;
@@ -347,9 +347,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
 
     // Check if P in vertex region outside B
     btVector3 bp = p - b;
-    float d3 = ab.dot(bp);
-    float d4 = ac.dot(bp);
-    if (d3 >= 0.0f && d4 <= d3) 
+    btScalar d3 = ab.dot(bp);
+    btScalar d4 = ac.dot(bp);
+    if (d3 >= btScalar(0.0) && d4 <= d3) 
 	{
 		result.m_closestPointOnSimplex = b;
 		result.m_usedVertices.usedVertexB = true;
@@ -358,9 +358,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
 		return true; // b; // barycentric coordinates (0,1,0)
 	}
     // Check if P in edge region of AB, if so return projection of P onto AB
-    float vc = d1*d4 - d3*d2;
-    if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f) {
-        float v = d1 / (d1 - d3);
+    btScalar vc = d1*d4 - d3*d2;
+    if (vc <= btScalar(0.0) && d1 >= btScalar(0.0) && d3 <= btScalar(0.0)) {
+        btScalar v = d1 / (d1 - d3);
 		result.m_closestPointOnSimplex = a + v * ab;
 		result.m_usedVertices.usedVertexA = true;
 		result.m_usedVertices.usedVertexB = true;
@@ -371,9 +371,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
 
     // Check if P in vertex region outside C
     btVector3 cp = p - c;
-    float d5 = ab.dot(cp);
-    float d6 = ac.dot(cp);
-    if (d6 >= 0.0f && d5 <= d6) 
+    btScalar d5 = ab.dot(cp);
+    btScalar d6 = ac.dot(cp);
+    if (d6 >= btScalar(0.0) && d5 <= d6) 
 	{
 		result.m_closestPointOnSimplex = c;
 		result.m_usedVertices.usedVertexC = true;
@@ -382,9 +382,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
 	}
 
     // Check if P in edge region of AC, if so return projection of P onto AC
-    float vb = d5*d2 - d1*d6;
-    if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f) {
-        float w = d2 / (d2 - d6);
+    btScalar vb = d5*d2 - d1*d6;
+    if (vb <= btScalar(0.0) && d2 >= btScalar(0.0) && d6 <= btScalar(0.0)) {
+        btScalar w = d2 / (d2 - d6);
 		result.m_closestPointOnSimplex = a + w * ac;
 		result.m_usedVertices.usedVertexA = true;
 		result.m_usedVertices.usedVertexC = true;
@@ -394,9 +394,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
     }
 
     // Check if P in edge region of BC, if so return projection of P onto BC
-    float va = d3*d6 - d5*d4;
-    if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f) {
-        float w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+    btScalar va = d3*d6 - d5*d4;
+    if (va <= btScalar(0.0) && (d4 - d3) >= btScalar(0.0) && (d5 - d6) >= btScalar(0.0)) {
+        btScalar w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
 		
 		result.m_closestPointOnSimplex = b + w * (c - b);
 		result.m_usedVertices.usedVertexB = true;
@@ -407,9 +407,9 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
     }
 
     // P inside face region. Compute Q through its barycentric coordinates (u,v,w)
-    float denom = 1.0f / (va + vb + vc);
-    float v = vb * denom;
-    float w = vc * denom;
+    btScalar denom = btScalar(1.0) / (va + vb + vc);
+    btScalar v = vb * denom;
+    btScalar w = vc * denom;
     
 	result.m_closestPointOnSimplex = a + ab * v + ac * w;
 	result.m_usedVertices.usedVertexA = true;
@@ -418,7 +418,7 @@ bool	btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btP
 	result.setBarycentricCoordinates(1-v-w,v,w);
 	
 	return true;
-//	return a + ab * v + ac * w; // = u*a + v*b + w*c, u = va * denom = 1.0f - v - w
+//	return a + ab * v + ac * w; // = u*a + v*b + w*c, u = va * denom = btScalar(1.0) - v - w
 
 }
 
@@ -431,18 +431,18 @@ int btVoronoiSimplexSolver::pointOutsideOfPlane(const btPoint3& p, const btPoint
 {
 	btVector3 normal = (b-a).cross(c-a);
 
-    float signp = (p - a).dot(normal); // [AP AB AC]
-    float signd = (d - a).dot( normal); // [AD AB AC]
+    btScalar signp = (p - a).dot(normal); // [AP AB AC]
+    btScalar signd = (d - a).dot( normal); // [AD AB AC]
 
 #ifdef CATCH_DEGENERATE_TETRAHEDRON
-	if (signd * signd < (1e-4f * 1e-4f))
+	if (signd * signd < (btScalar(1e-4) * btScalar(1e-4)))
 	{
 //		printf("affine dependent/degenerate\n");//
 		return -1;
 	}
 #endif
 	// Points on opposite sides if expression signs are opposite
-    return signp * signd < 0.f;
+    return signp * signd < btScalar(0.);
 }
 
 
@@ -475,14 +475,14 @@ bool	btVoronoiSimplexSolver::closestPtPointTetrahedron(const btPoint3& p, const
 	 }
 
 
-    float bestSqDist = FLT_MAX;
+    btScalar bestSqDist = FLT_MAX;
     // If point outside face abc then compute closest point on abc
 	if (pointOutsideABC) 
 	{
         closestPtPointTriangle(p, a, b, c,tempResult);
 		btPoint3 q = tempResult.m_closestPointOnSimplex;
 		
-        float sqDist = (q - p).dot( q - p);
+        btScalar sqDist = (q - p).dot( q - p);
         // Update best closest point if (squared) distance is less than current best
         if (sqDist < bestSqDist) {
 			bestSqDist = sqDist;
@@ -510,7 +510,7 @@ bool	btVoronoiSimplexSolver::closestPtPointTetrahedron(const btPoint3& p, const
 		btPoint3 q = tempResult.m_closestPointOnSimplex;
 		//convert result bitmask!
 
-        float sqDist = (q - p).dot( q - p);
+        btScalar sqDist = (q - p).dot( q - p);
         if (sqDist < bestSqDist) 
 		{
 			bestSqDist = sqDist;
@@ -537,7 +537,7 @@ bool	btVoronoiSimplexSolver::closestPtPointTetrahedron(const btPoint3& p, const
 		btPoint3 q = tempResult.m_closestPointOnSimplex;
 		//convert result bitmask!
 
-        float sqDist = (q - p).dot( q - p);
+        btScalar sqDist = (q - p).dot( q - p);
         if (sqDist < bestSqDist) 
 		{
 			bestSqDist = sqDist;
@@ -563,7 +563,7 @@ bool	btVoronoiSimplexSolver::closestPtPointTetrahedron(const btPoint3& p, const
         closestPtPointTriangle(p, b, d, c,tempResult);
 		btPoint3 q = tempResult.m_closestPointOnSimplex;
 		//convert result bitmask!
-        float sqDist = (q - p).dot( q - p);
+        btScalar sqDist = (q - p).dot( q - p);
         if (sqDist < bestSqDist) 
 		{
 			bestSqDist = sqDist;

src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h

@@ -55,7 +55,7 @@ struct	btSubSimplexClosestResult
 	//stores the simplex vertex-usage, using the MASK, 
 	// if m_usedVertices & MASK then the related vertex is used
 	btUsageBitfield	m_usedVertices;
-	float	m_barycentricCoords[4];
+	btScalar	m_barycentricCoords[4];
 	bool m_degenerate;
 
 	void	reset()
@@ -66,15 +66,15 @@ struct	btSubSimplexClosestResult
 	}
 	bool	isValid()
 	{
-		bool valid = (m_barycentricCoords[0] >= 0.f) &&
-			(m_barycentricCoords[1] >= 0.f) &&
-			(m_barycentricCoords[2] >= 0.f) &&
-			(m_barycentricCoords[3] >= 0.f);
+		bool valid = (m_barycentricCoords[0] >= btScalar(0.)) &&
+			(m_barycentricCoords[1] >= btScalar(0.)) &&
+			(m_barycentricCoords[2] >= btScalar(0.)) &&
+			(m_barycentricCoords[3] >= btScalar(0.));
 
 
 		return valid;
 	}
-	void	setBarycentricCoordinates(float a=0.f,float b=0.f,float c=0.f,float d=0.f)
+	void	setBarycentricCoordinates(btScalar a=btScalar(0.),btScalar b=btScalar(0.),btScalar c=btScalar(0.),btScalar d=btScalar(0.))
 	{
 		m_barycentricCoords[0] = a;
 		m_barycentricCoords[1] = b;

src/BulletDynamics/ConstraintSolver/btConstraintSolver.h

@@ -16,6 +16,8 @@ subject to the following restrictions:
 #ifndef CONSTRAINT_SOLVER_H
 #define CONSTRAINT_SOLVER_H
 
+#include "LinearMath/btScalar.h"
+
 class btPersistentManifold;
 class btRigidBody;
 class btTypedConstraint;
@@ -31,7 +33,7 @@ public:
 
 	virtual ~btConstraintSolver() {}
 	
-	virtual float solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints, const btContactSolverInfo& info,class btIDebugDraw* debugDrawer = 0) = 0;
+	virtual btScalar solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints, const btContactSolverInfo& info,class btIDebugDraw* debugDrawer = 0) = 0;
 
 };
 

src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp

@@ -30,13 +30,13 @@ subject to the following restrictions:
 //bilateral constraint between two dynamic objects
 void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
                       btRigidBody& body2, const btVector3& pos2,
-                      btScalar distance, const btVector3& normal,btScalar& impulse ,float timeStep)
+                      btScalar distance, const btVector3& normal,btScalar& impulse ,btScalar timeStep)
 {
-	float normalLenSqr = normal.length2();
-	ASSERT2(fabs(normalLenSqr) < 1.1f);
-	if (normalLenSqr > 1.1f)
+	btScalar normalLenSqr = normal.length2();
+	ASSERT2(btFabs(normalLenSqr) < btScalar(1.1));
+	if (normalLenSqr > btScalar(1.1))
 	{
-		impulse = 0.f;
+		impulse = btScalar(0.);
 		return;
 	}
 	btVector3 rel_pos1 = pos1 - body1.getCenterOfMassPosition(); 
@@ -54,24 +54,24 @@ void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
 		body2.getInvInertiaDiagLocal(),body2.getInvMass());
 
 	btScalar jacDiagAB = jac.getDiagonal();
-	btScalar jacDiagABInv = 1.f / jacDiagAB;
+	btScalar jacDiagABInv = btScalar(1.) / jacDiagAB;
 	
 	  btScalar rel_vel = jac.getRelativeVelocity(
 		body1.getLinearVelocity(),
 		body1.getCenterOfMassTransform().getBasis().transpose() * body1.getAngularVelocity(),
 		body2.getLinearVelocity(),
 		body2.getCenterOfMassTransform().getBasis().transpose() * body2.getAngularVelocity()); 
-	float a;
+	btScalar a;
 	a=jacDiagABInv;
 
 
 	rel_vel = normal.dot(vel);
 	
 	//todo: move this into proper structure
-	btScalar contactDamping = 0.2f;
+	btScalar contactDamping = btScalar(0.2);
 
 #ifdef ONLY_USE_LINEAR_MASS
-	btScalar massTerm = 1.f / (body1.getInvMass() + body2.getInvMass());
+	btScalar massTerm = btScalar(1.) / (body1.getInvMass() + body2.getInvMass());
 	impulse = - contactDamping * rel_vel * massTerm;
 #else	
 	btScalar velocityImpulse = -contactDamping * rel_vel * jacDiagABInv;
@@ -82,7 +82,7 @@ void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
 
 
 //response  between two dynamic objects with friction
-float resolveSingleCollision(
+btScalar resolveSingleCollision(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,
@@ -102,11 +102,11 @@ float resolveSingleCollision(
 	btScalar rel_vel;
 	rel_vel = normal.dot(vel);
 	
-	btScalar Kfps = 1.f / solverInfo.m_timeStep ;
+	btScalar Kfps = btScalar(1.) / solverInfo.m_timeStep ;
 
-	// float damping = solverInfo.m_damping ;
-	float Kerp = solverInfo.m_erp;
-	float Kcor = Kerp *Kfps;
+	// btScalar damping = solverInfo.m_damping ;
+	btScalar Kerp = solverInfo.m_erp;
+	btScalar Kcor = Kerp *Kfps;
 
 	btConstraintPersistentData* cpd = (btConstraintPersistentData*) contactPoint.m_userPersistentData;
 	assert(cpd);
@@ -121,9 +121,9 @@ float resolveSingleCollision(
 	btScalar normalImpulse = penetrationImpulse+velocityImpulse;
 	
 	// See Erin Catto's GDC 2006 paper: Clamp the accumulated impulse
-	float oldNormalImpulse = cpd->m_appliedImpulse;
-	float sum = oldNormalImpulse + normalImpulse;
-	cpd->m_appliedImpulse = 0.f > sum ? 0.f: sum;
+	btScalar oldNormalImpulse = cpd->m_appliedImpulse;
+	btScalar sum = oldNormalImpulse + normalImpulse;
+	cpd->m_appliedImpulse = btScalar(0.) > sum ? btScalar(0.): sum;
 
 	normalImpulse = cpd->m_appliedImpulse - oldNormalImpulse;
 
@@ -145,7 +145,7 @@ float resolveSingleCollision(
 }
 
 
-float resolveSingleFriction(
+btScalar resolveSingleFriction(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,
@@ -161,11 +161,11 @@ float resolveSingleFriction(
 	btConstraintPersistentData* cpd = (btConstraintPersistentData*) contactPoint.m_userPersistentData;
 	assert(cpd);
 
-	float combinedFriction = cpd->m_friction;
+	btScalar combinedFriction = cpd->m_friction;
 	
 	btScalar limit = cpd->m_appliedImpulse * combinedFriction;
 	
-	if (cpd->m_appliedImpulse>0.f)
+	if (cpd->m_appliedImpulse>btScalar(0.))
 	//friction
 	{
 		//apply friction in the 2 tangential directions
@@ -183,7 +183,7 @@ float resolveSingleFriction(
 
 			// calculate j that moves us to zero relative velocity
 			j1 = -vrel * cpd->m_jacDiagABInvTangent0;
-			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse0;
+			btScalar oldTangentImpulse = cpd->m_accumulatedTangentImpulse0;
 			cpd->m_accumulatedTangentImpulse0 = oldTangentImpulse + j1;
 			GEN_set_min(cpd->m_accumulatedTangentImpulse0, limit);
 			GEN_set_max(cpd->m_accumulatedTangentImpulse0, -limit);
@@ -197,7 +197,7 @@ float resolveSingleFriction(
 			
 			// calculate j that moves us to zero relative velocity
 			j2 = -vrel * cpd->m_jacDiagABInvTangent1;
-			float oldTangentImpulse = cpd->m_accumulatedTangentImpulse1;
+			btScalar oldTangentImpulse = cpd->m_accumulatedTangentImpulse1;
 			cpd->m_accumulatedTangentImpulse1 = oldTangentImpulse + j2;
 			GEN_set_min(cpd->m_accumulatedTangentImpulse1, limit);
 			GEN_set_max(cpd->m_accumulatedTangentImpulse1, -limit);
@@ -226,7 +226,7 @@ float resolveSingleFriction(
 }
 
 
-float resolveSingleFrictionOriginal(
+btScalar resolveSingleFrictionOriginal(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,
@@ -242,10 +242,10 @@ float resolveSingleFrictionOriginal(
 	btConstraintPersistentData* cpd = (btConstraintPersistentData*) contactPoint.m_userPersistentData;
 	assert(cpd);
 
-	float combinedFriction = cpd->m_friction;
+	btScalar combinedFriction = cpd->m_friction;
 	
 	btScalar limit = cpd->m_appliedImpulse * combinedFriction;
-	//if (contactPoint.m_appliedImpulse>0.f)
+	//if (contactPoint.m_appliedImpulse>btScalar(0.))
 	//friction
 	{
 		//apply friction in the 2 tangential directions
@@ -260,7 +260,7 @@ float resolveSingleFrictionOriginal(
 
 			// calculate j that moves us to zero relative velocity
 			btScalar j = -vrel * cpd->m_jacDiagABInvTangent0;
-			float total = cpd->m_accumulatedTangentImpulse0 + j;
+			btScalar total = cpd->m_accumulatedTangentImpulse0 + j;
 			GEN_set_min(total, limit);
 			GEN_set_max(total, -limit);
 			j = total - cpd->m_accumulatedTangentImpulse0;
@@ -280,7 +280,7 @@ float resolveSingleFrictionOriginal(
 			
 			// calculate j that moves us to zero relative velocity
 			btScalar j = -vrel * cpd->m_jacDiagABInvTangent1;
-			float total = cpd->m_accumulatedTangentImpulse1 + j;
+			btScalar total = cpd->m_accumulatedTangentImpulse1 + j;
 			GEN_set_min(total, limit);
 			GEN_set_max(total, -limit);
 			j = total - cpd->m_accumulatedTangentImpulse1;
@@ -295,7 +295,7 @@ float resolveSingleFrictionOriginal(
 
 //velocity + friction
 //response  between two dynamic objects with friction
-float resolveSingleCollisionCombined(
+btScalar resolveSingleCollisionCombined(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,
@@ -315,11 +315,11 @@ float resolveSingleCollisionCombined(
 	btScalar rel_vel;
 	rel_vel = normal.dot(vel);
 	
-	btScalar Kfps = 1.f / solverInfo.m_timeStep ;
+	btScalar Kfps = btScalar(1.) / solverInfo.m_timeStep ;
 
-	//float damping = solverInfo.m_damping ;
-	float Kerp = solverInfo.m_erp;
-	float Kcor = Kerp *Kfps;
+	//btScalar damping = solverInfo.m_damping ;
+	btScalar Kerp = solverInfo.m_erp;
+	btScalar Kcor = Kerp *Kfps;
 
 	btConstraintPersistentData* cpd = (btConstraintPersistentData*) contactPoint.m_userPersistentData;
 	assert(cpd);
@@ -334,9 +334,9 @@ float resolveSingleCollisionCombined(
 	btScalar normalImpulse = penetrationImpulse+velocityImpulse;
 	
 	// See Erin Catto's GDC 2006 paper: Clamp the accumulated impulse
-	float oldNormalImpulse = cpd->m_appliedImpulse;
-	float sum = oldNormalImpulse + normalImpulse;
-	cpd->m_appliedImpulse = 0.f > sum ? 0.f: sum;
+	btScalar oldNormalImpulse = cpd->m_appliedImpulse;
+	btScalar sum = oldNormalImpulse + normalImpulse;
+	cpd->m_appliedImpulse = btScalar(0.) > sum ? btScalar(0.): sum;
 
 	normalImpulse = cpd->m_appliedImpulse - oldNormalImpulse;
 
@@ -367,7 +367,7 @@ float resolveSingleCollisionCombined(
 		btVector3 lat_vel = vel - normal * rel_vel;
 		btScalar lat_rel_vel = lat_vel.length();
 
-		float combinedFriction = cpd->m_friction;
+		btScalar combinedFriction = cpd->m_friction;
 
 		if (cpd->m_appliedImpulse > 0)
 		if (lat_rel_vel > SIMD_EPSILON)
@@ -390,12 +390,12 @@ float resolveSingleCollisionCombined(
 
 	return normalImpulse;
 }
-float resolveSingleFrictionEmpty(
+btScalar resolveSingleFrictionEmpty(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,
 	const btContactSolverInfo& solverInfo)
 {
-	return 0.f;
+	return btScalar(0.);
 };
 

src/BulletDynamics/ConstraintSolver/btContactConstraint.h

@@ -33,7 +33,7 @@ enum {
 };
 
 
-typedef float (*ContactSolverFunc)(btRigidBody& body1,
+typedef btScalar (*ContactSolverFunc)(btRigidBody& body1,
 									 btRigidBody& body2,
 									 class btManifoldPoint& contactPoint,
 									 const btContactSolverInfo& info);
@@ -42,15 +42,15 @@ typedef float (*ContactSolverFunc)(btRigidBody& body1,
 struct btConstraintPersistentData
 {
 	inline btConstraintPersistentData()
-	:m_appliedImpulse(0.f),
-	m_prevAppliedImpulse(0.f),
-	m_accumulatedTangentImpulse0(0.f),
-	m_accumulatedTangentImpulse1(0.f),
-	m_jacDiagABInv(0.f),
+	:m_appliedImpulse(btScalar(0.)),
+	m_prevAppliedImpulse(btScalar(0.)),
+	m_accumulatedTangentImpulse0(btScalar(0.)),
+	m_accumulatedTangentImpulse1(btScalar(0.)),
+	m_jacDiagABInv(btScalar(0.)),
 	m_persistentLifeTime(0),
-	m_restitution(0.f),
-	m_friction(0.f),
-	m_penetration(0.f),
+	m_restitution(btScalar(0.)),
+	m_friction(btScalar(0.)),
+	m_penetration(btScalar(0.)),
 	m_contactSolverFunc(0),
 	m_frictionSolverFunc(0)
 	{
@@ -58,18 +58,18 @@ struct btConstraintPersistentData
 	
 					
 				/// total applied impulse during most recent frame
-			float	m_appliedImpulse;
-			float	m_prevAppliedImpulse;
-			float	m_accumulatedTangentImpulse0;
-			float	m_accumulatedTangentImpulse1;
+			btScalar	m_appliedImpulse;
+			btScalar	m_prevAppliedImpulse;
+			btScalar	m_accumulatedTangentImpulse0;
+			btScalar	m_accumulatedTangentImpulse1;
 			
-			float	m_jacDiagABInv;
-			float	m_jacDiagABInvTangent0;
-			float	m_jacDiagABInvTangent1;
+			btScalar	m_jacDiagABInv;
+			btScalar	m_jacDiagABInvTangent0;
+			btScalar	m_jacDiagABInvTangent1;
 			int		m_persistentLifeTime;
-			float	m_restitution;
-			float	m_friction;
-			float	m_penetration;
+			btScalar	m_restitution;
+			btScalar	m_friction;
+			btScalar	m_penetration;
 			btVector3	m_frictionWorldTangential0;
 			btVector3	m_frictionWorldTangential1;
 
@@ -91,19 +91,19 @@ struct btConstraintPersistentData
 ///positive distance = separation, negative distance = penetration
 void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
                       btRigidBody& body2, const btVector3& pos2,
-                      btScalar distance, const btVector3& normal,btScalar& impulse ,float timeStep);
+                      btScalar distance, const btVector3& normal,btScalar& impulse ,btScalar timeStep);
 
 
 ///contact constraint resolution:
 ///calculate and apply impulse to satisfy non-penetration and non-negative relative velocity constraint
 ///positive distance = separation, negative distance = penetration
-float resolveSingleCollision(
+btScalar resolveSingleCollision(
 	btRigidBody& body1,
 	btRigidBody& body2,
 		btManifoldPoint& contactPoint,
 		 const btContactSolverInfo& info);
 
-float resolveSingleFriction(
+btScalar resolveSingleFriction(
 	btRigidBody& body1,
 	btRigidBody& body2,
 	btManifoldPoint& contactPoint,

src/BulletDynamics/ConstraintSolver/btContactSolverInfo.h

@@ -22,25 +22,25 @@ struct btContactSolverInfo
 
 	inline btContactSolverInfo()
 	{
-		m_tau = 0.6f;
-		m_damping = 1.0f;
-		m_friction = 0.3f;
-		m_restitution = 0.f;
-		m_maxErrorReduction = 20.f;
+		m_tau = btScalar(0.6);
+		m_damping = btScalar(1.0);
+		m_friction = btScalar(0.3);
+		m_restitution = btScalar(0.);
+		m_maxErrorReduction = btScalar(20.);
 		m_numIterations = 10;
-		m_erp = 0.4f;
-		m_sor = 1.3f;
+		m_erp = btScalar(0.4);
+		m_sor = btScalar(1.3);
 	}
 
-	float	m_tau;
-	float	m_damping;
-	float	m_friction;
-	float	m_timeStep;
-	float	m_restitution;
+	btScalar	m_tau;
+	btScalar	m_damping;
+	btScalar	m_friction;
+	btScalar	m_timeStep;
+	btScalar	m_restitution;
 	int		m_numIterations;
-	float	m_maxErrorReduction;
-	float	m_sor;
-	float	m_erp;
+	btScalar	m_maxErrorReduction;
+	btScalar	m_sor;
+	btScalar	m_erp;
 
 };
 

src/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp

@@ -18,7 +18,7 @@ subject to the following restrictions:
 #include "BulletDynamics/Dynamics/btRigidBody.h"
 #include "LinearMath/btTransformUtil.h"
 
-static const btScalar kSign[] = { 1.0f, -1.0f, 1.0f };
+static const btScalar kSign[] = { btScalar(1.0), btScalar(-1.0), btScalar(1.0) };
 static const int kAxisA[] = { 1, 0, 0 };
 static const int kAxisB[] = { 2, 2, 1 };
 #define GENERIC_D6_DISABLE_WARMSTARTING 1
@@ -38,9 +38,9 @@ btGeneric6DofConstraint::btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody&
 	//so start all locked
 	for (int i=0; i<6;++i)
 	{
-		m_lowerLimit[i] = 0.0f;
-		m_upperLimit[i] = 0.0f;
-		m_accumulatedImpulse[i] = 0.0f;
+		m_lowerLimit[i] = btScalar(0.0);
+		m_upperLimit[i] = btScalar(0.0);
+		m_accumulatedImpulse[i] = btScalar(0.0);
 	}
 
 }
@@ -83,7 +83,7 @@ void btGeneric6DofConstraint::buildJacobian()
 
 			//optionally disable warmstarting
 #ifdef GENERIC_D6_DISABLE_WARMSTARTING
-			m_accumulatedImpulse[i] = 0.f;
+			m_accumulatedImpulse[i] = btScalar(0.);
 #endif //GENERIC_D6_DISABLE_WARMSTARTING
 
 			// Apply accumulated impulse
@@ -115,7 +115,7 @@ void btGeneric6DofConstraint::buildJacobian()
 				m_rbB.getInvInertiaDiagLocal());
 
 #ifdef GENERIC_D6_DISABLE_WARMSTARTING
-			m_accumulatedImpulse[i + 3] = 0.f;
+			m_accumulatedImpulse[i + 3] = btScalar(0.);
 #endif //GENERIC_D6_DISABLE_WARMSTARTING
 
 			// Apply accumulated impulse
@@ -127,7 +127,7 @@ void btGeneric6DofConstraint::buildJacobian()
 	}
 }
 
-float getMatrixElem(const btMatrix3x3& mat,int index)
+btScalar getMatrixElem(const btMatrix3x3& mat,int index)
 {
 	int row = index%3;
 	int col = index / 3;
@@ -143,9 +143,9 @@ bool	MatrixToEulerXYZ(const btMatrix3x3& mat,btVector3& xyz)
 
 ///	0..8
 
-	 if (getMatrixElem(mat,2) < 1.0f)
+	 if (getMatrixElem(mat,2) < btScalar(1.0))
     {
-        if (getMatrixElem(mat,2) > -1.0f)
+        if (getMatrixElem(mat,2) > btScalar(-1.0))
         {
             xyz[0] = btAtan2(-getMatrixElem(mat,5),getMatrixElem(mat,8));
             xyz[1] = btAsin(getMatrixElem(mat,2));
@@ -157,7 +157,7 @@ bool	MatrixToEulerXYZ(const btMatrix3x3& mat,btVector3& xyz)
             // WARNING.  Not unique.  XA - ZA = -atan2(r10,r11)
             xyz[0] = -btAtan2(getMatrixElem(mat,3),getMatrixElem(mat,4));
             xyz[1] = -SIMD_HALF_PI;
-            xyz[2] = 0.0f;
+            xyz[2] = btScalar(0.0);
             return false;
         }
     }
@@ -175,8 +175,8 @@ bool	MatrixToEulerXYZ(const btMatrix3x3& mat,btVector3& xyz)
 
 void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 {
-	btScalar tau = 0.1f;
-	btScalar damping = 1.0f;
+	btScalar tau = btScalar(0.1);
+	btScalar damping = btScalar(1.0);
 
 	btVector3 pivotAInW = m_rbA.getCenterOfMassTransform() * m_frameInA.getOrigin();
 	btVector3 pivotBInW = m_rbB.getCenterOfMassTransform() * m_frameInB.getOrigin();
@@ -199,7 +199,7 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 			localNormalInA[i] = 1;
 			btVector3 normalWorld = m_rbA.getCenterOfMassTransform().getBasis() * localNormalInA;
 
-			btScalar jacDiagABInv = 1.f / m_jacLinear[i].getDiagonal();
+			btScalar jacDiagABInv = btScalar(1.) / m_jacLinear[i].getDiagonal();
 
 			//velocity error (first order error)
 			btScalar rel_vel = m_jacLinear[i].getRelativeVelocity(m_rbA.getLinearVelocity(),angvelA, 
@@ -207,8 +207,8 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 		
 			//positional error (zeroth order error)
 			btScalar depth = -(pivotAInW - pivotBInW).dot(normalWorld); 
-			btScalar	lo = -1e30f;
-			btScalar	hi = 1e30f;
+			btScalar	lo = btScalar(-1e30);
+			btScalar	hi = btScalar(1e30);
 		
 			//handle the limits
 			if (m_lowerLimit[i] < m_upperLimit[i])
@@ -217,14 +217,14 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 					if (depth > m_upperLimit[i])
 					{
 						depth -= m_upperLimit[i];
-						lo = 0.f;
+						lo = btScalar(0.);
 					
 					} else
 					{
 						if (depth < m_lowerLimit[i])
 						{
 							depth -= m_lowerLimit[i];
-							hi = 0.f;
+							hi = btScalar(0.);
 						} else
 						{
 							continue;
@@ -234,9 +234,9 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 			}
 
 			btScalar normalImpulse= (tau*depth/timeStep - damping*rel_vel) * jacDiagABInv;
-			float oldNormalImpulse = m_accumulatedImpulse[i];
-			float sum = oldNormalImpulse + normalImpulse;
-			m_accumulatedImpulse[i] = sum > hi ? 0.f : sum < lo ? 0.f : sum;
+			btScalar oldNormalImpulse = m_accumulatedImpulse[i];
+			btScalar sum = oldNormalImpulse + normalImpulse;
+			m_accumulatedImpulse[i] = sum > hi ? btScalar(0.) : sum < lo ? btScalar(0.) : sum;
 			normalImpulse = m_accumulatedImpulse[i] - oldNormalImpulse;
 
 			btVector3 impulse_vector = normalWorld * normalImpulse;
@@ -267,7 +267,7 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 			btVector3 angvelA = m_rbA.getCenterOfMassTransform().getBasis().transpose() * m_rbA.getAngularVelocity();
 			btVector3 angvelB = m_rbB.getCenterOfMassTransform().getBasis().transpose() * m_rbB.getAngularVelocity();
 		
-			btScalar jacDiagABInv = 1.f / m_jacAng[i].getDiagonal();
+			btScalar jacDiagABInv = btScalar(1.) / m_jacAng[i].getDiagonal();
 			
 			//velocity error (first order error)
 			btScalar rel_vel = m_jacAng[i].getRelativeVelocity(m_rbA.getLinearVelocity(),angvelA, 
@@ -279,27 +279,27 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 
 			btScalar rel_pos = kSign[i] * axisA.dot(axisB);
 
-			btScalar	lo = -1e30f;
-			btScalar	hi = 1e30f;
+			btScalar	lo = btScalar(-1e30);
+			btScalar	hi = btScalar(1e30);
 		
 			//handle the twist limit
 			if (m_lowerLimit[i+3] < m_upperLimit[i+3])
 			{
 				//clamp the values
-				btScalar loLimit =  m_upperLimit[i+3] > -3.1415 ? m_lowerLimit[i+3] : -1e30f;
-				btScalar hiLimit = m_upperLimit[i+3] < 3.1415 ? m_upperLimit[i+3] : 1e30f;
+				btScalar loLimit =  m_upperLimit[i+3] > -3.1415 ? m_lowerLimit[i+3] : btScalar(-1e30);
+				btScalar hiLimit = m_upperLimit[i+3] < 3.1415 ? m_upperLimit[i+3] : btScalar(1e30);
 
-				float projAngle  = -2.f*xyz[i];
+				btScalar projAngle  = btScalar(-2.)*xyz[i];
 				
 				if (projAngle < loLimit)
 				{
-					hi = 0.f;
+					hi = btScalar(0.);
 					rel_pos = (loLimit - projAngle);
 				} else
 				{
 					if (projAngle > hiLimit)
 					{
-						lo = 0.f;
+						lo = btScalar(0.);
 						rel_pos = (hiLimit - projAngle);
 					} else
 					{
@@ -311,9 +311,9 @@ void	btGeneric6DofConstraint::solveConstraint(btScalar	timeStep)
 			//impulse
 			
 			btScalar normalImpulse= -(tau*rel_pos/timeStep + damping*rel_vel) * jacDiagABInv;
-			float oldNormalImpulse = m_accumulatedImpulse[i+3];
-			float sum = oldNormalImpulse + normalImpulse;
-			m_accumulatedImpulse[i+3] = sum > hi ? 0.f : sum < lo ? 0.f : sum;
+			btScalar oldNormalImpulse = m_accumulatedImpulse[i+3];
+			btScalar sum = oldNormalImpulse + normalImpulse;
+			m_accumulatedImpulse[i+3] = sum > hi ? btScalar(0.) : sum < lo ? btScalar(0.) : sum;
 			normalImpulse = m_accumulatedImpulse[i+3] - oldNormalImpulse;
 			
 			// Dirk: Not needed - we could actually project onto Jacobian entry here (same as above)

src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp

@@ -49,7 +49,7 @@ m_enableAngularMotor(false)
 
 void	btHingeConstraint::buildJacobian()
 {
-	m_appliedImpulse = 0.f;
+	m_appliedImpulse = btScalar(0.);
 
 	btVector3	normal(0,0,0);
 
@@ -115,8 +115,8 @@ void	btHingeConstraint::solveConstraint(btScalar	timeStep)
 	btVector3 pivotBInW = m_rbB.getCenterOfMassTransform()*m_pivotInB;
 
 	btVector3 normal(0,0,0);
-	btScalar tau = 0.3f;
-	btScalar damping = 1.f;
+	btScalar tau = btScalar(0.3);
+	btScalar damping = btScalar(1.);
 
 //linear part
 	if (!m_angularOnly)
@@ -124,7 +124,7 @@ void	btHingeConstraint::solveConstraint(btScalar	timeStep)
 		for (int i=0;i<3;i++)
 		{		
 			normal[i] = 1;
-			btScalar jacDiagABInv = 1.f / m_jac[i].getDiagonal();
+			btScalar jacDiagABInv = btScalar(1.) / m_jac[i].getDiagonal();
 
 			btVector3 rel_pos1 = pivotAInW - m_rbA.getCenterOfMassPosition(); 
 			btVector3 rel_pos2 = pivotBInW - m_rbB.getCenterOfMassPosition();
@@ -165,27 +165,27 @@ void	btHingeConstraint::solveConstraint(btScalar	timeStep)
 		btVector3 velrelOrthog = angAorthog-angBorthog;
 		{
 			//solve orthogonal angular velocity correction
-			float relaxation = 1.f;
-			float len = velrelOrthog.length();
-			if (len > 0.00001f)
+			btScalar relaxation = btScalar(1.);
+			btScalar len = velrelOrthog.length();
+			if (len > btScalar(0.00001))
 			{
 				btVector3 normal = velrelOrthog.normalized();
-				float denom = getRigidBodyA().computeAngularImpulseDenominator(normal) +
+				btScalar denom = getRigidBodyA().computeAngularImpulseDenominator(normal) +
 					getRigidBodyB().computeAngularImpulseDenominator(normal);
 				// scale for mass and relaxation
 				//todo:  expose this 0.9 factor to developer
-				velrelOrthog *= (1.f/denom) * 0.9f;
+				velrelOrthog *= (btScalar(1.)/denom) * btScalar(0.9);
 			}
 
 			//solve angular positional correction
-			btVector3 angularError = -axisA.cross(axisB) *(1.f/timeStep);
-			float len2 = angularError.length();
-			if (len2>0.00001f)
+			btVector3 angularError = -axisA.cross(axisB) *(btScalar(1.)/timeStep);
+			btScalar len2 = angularError.length();
+			if (len2>btScalar(0.00001))
 			{
 				btVector3 normal2 = angularError.normalized();
-				float denom2 = getRigidBodyA().computeAngularImpulseDenominator(normal2) +
+				btScalar denom2 = getRigidBodyA().computeAngularImpulseDenominator(normal2) +
 						getRigidBodyB().computeAngularImpulseDenominator(normal2);
-				angularError *= (1.f/denom2) * relaxation;
+				angularError *= (btScalar(1.)/denom2) * relaxation;
 			}
 
 			m_rbA.applyTorqueImpulse(-velrelOrthog+angularError);
@@ -204,10 +204,10 @@ void	btHingeConstraint::solveConstraint(btScalar	timeStep)
 			btScalar desiredMotorVel = m_motorTargetVelocity;
 			btScalar motor_relvel = desiredMotorVel - projRelVel;
 
-			float denom3 = getRigidBodyA().computeAngularImpulseDenominator(axisA) +
+			btScalar denom3 = getRigidBodyA().computeAngularImpulseDenominator(axisA) +
 					getRigidBodyB().computeAngularImpulseDenominator(axisA);
 
-			btScalar unclippedMotorImpulse = (1.f/denom3) * motor_relvel;;
+			btScalar unclippedMotorImpulse = (btScalar(1.)/denom3) * motor_relvel;;
 			//todo: should clip against accumulated impulse
 			btScalar clippedMotorImpulse = unclippedMotorImpulse > m_maxMotorImpulse ? m_maxMotorImpulse : unclippedMotorImpulse;
 			clippedMotorImpulse = clippedMotorImpulse < -m_maxMotorImpulse ? -m_maxMotorImpulse : clippedMotorImpulse;

src/BulletDynamics/ConstraintSolver/btJacobianEntry.h

@@ -50,7 +50,7 @@ public:
 		m_1MinvJt = inertiaInvB * m_bJ;
 		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ) + massInvB + m_1MinvJt.dot(m_bJ);
 
-		btAssert(m_Adiag > 0.0f);
+		btAssert(m_Adiag > btScalar(0.0));
 	}
 
 	//angular constraint between two different rigidbodies
@@ -59,7 +59,7 @@ public:
 		const btMatrix3x3& world2B,
 		const btVector3& inertiaInvA,
 		const btVector3& inertiaInvB)
-		:m_linearJointAxis(btVector3(0.f,0.f,0.f))
+		:m_linearJointAxis(btVector3(btScalar(0.),btScalar(0.),btScalar(0.)))
 	{
 		m_aJ= world2A*jointAxis;
 		m_bJ = world2B*-jointAxis;
@@ -67,7 +67,7 @@ public:
 		m_1MinvJt = inertiaInvB * m_bJ;
 		m_Adiag =  m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
 
-		btAssert(m_Adiag > 0.0f);
+		btAssert(m_Adiag > btScalar(0.0));
 	}
 
 	//angular constraint between two different rigidbodies
@@ -75,7 +75,7 @@ public:
 		const btVector3& axisInB,
 		const btVector3& inertiaInvA,
 		const btVector3& inertiaInvB)
-		: m_linearJointAxis(btVector3(0.f,0.f,0.f))
+		: m_linearJointAxis(btVector3(btScalar(0.),btScalar(0.),btScalar(0.)))
 		, m_aJ(axisInA)
 		, m_bJ(-axisInB)
 	{
@@ -83,7 +83,7 @@ public:
 		m_1MinvJt = inertiaInvB * m_bJ;
 		m_Adiag =  m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
 
-		btAssert(m_Adiag > 0.0f);
+		btAssert(m_Adiag > btScalar(0.0));
 	}
 
 	//constraint on one rigidbody
@@ -98,10 +98,10 @@ public:
 		m_aJ= world2A*(rel_pos1.cross(jointAxis));
 		m_bJ = world2A*(rel_pos2.cross(-jointAxis));
 		m_0MinvJt	= inertiaInvA * m_aJ;
-		m_1MinvJt = btVector3(0.f,0.f,0.f);
+		m_1MinvJt = btVector3(btScalar(0.),btScalar(0.),btScalar(0.));
 		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ);
 
-		btAssert(m_Adiag > 0.0f);
+		btAssert(m_Adiag > btScalar(0.0));
 	}
 
 	btScalar	getDiagonal() const { return m_Adiag; }

src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp

@@ -39,7 +39,7 @@ btPoint2PointConstraint::btPoint2PointConstraint(btRigidBody& rbA,const btVector
 
 void	btPoint2PointConstraint::buildJacobian()
 {
-	m_appliedImpulse = 0.f;
+	m_appliedImpulse = btScalar(0.);
 
 	btVector3	normal(0,0,0);
 
@@ -76,7 +76,7 @@ void	btPoint2PointConstraint::solveConstraint(btScalar	timeStep)
 	for (int i=0;i<3;i++)
 	{		
 		normal[i] = 1;
-		btScalar jacDiagABInv = 1.f / m_jac[i].getDiagonal();
+		btScalar jacDiagABInv = btScalar(1.) / m_jac[i].getDiagonal();
 
 		btVector3 rel_pos1 = pivotAInW - m_rbA.getCenterOfMassPosition(); 
 		btVector3 rel_pos2 = pivotBInW - m_rbB.getCenterOfMassPosition();

src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h

@@ -26,12 +26,12 @@ class btRigidBody;
 struct	btConstraintSetting
 {
 	btConstraintSetting()	:
-		m_tau(0.3f),
-		m_damping(1.f)
+		m_tau(btScalar(0.3)),
+		m_damping(btScalar(1.))
 	{
 	}
-	float		m_tau;
-	float		m_damping;
+	btScalar		m_tau;
+	btScalar		m_damping;
 };
 
 /// point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space

src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp

@@ -84,10 +84,10 @@ int btRandInt2 (int n)
 
 int btRandIntWrong (int n)
 {
-  float a = float(n) / 4294967296.0f;
+  btScalar a = btScalar(n) / btScalar(4294967296.0);
 //  printf("n = %d\n",n);
 //  printf("a = %f\n",a);
-  int res = (int) (float(btRand2()) * a);
+  int res = (int) (btScalar(btRand2()) * a);
 //	printf("res=%d\n",res);
   return res;
 }
@@ -125,7 +125,7 @@ btSequentialImpulseConstraintSolver::btSequentialImpulseConstraintSolver()
 }
 
 /// btSequentialImpulseConstraintSolver Sequentially applies impulses
-float btSequentialImpulseConstraintSolver3::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
+btScalar btSequentialImpulseConstraintSolver3::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
 {
 	
 	btContactSolverInfo info = infoGlobal;
@@ -209,12 +209,12 @@ float btSequentialImpulseConstraintSolver3::solveGroup(btPersistentManifold** ma
 	btProfiler::endBlock("solve");
 #endif //USE_PROFILE
 
-	return 0.f;
+	return btScalar(0.);
 }
 
 
 /// btSequentialImpulseConstraintSolver Sequentially applies impulses
-float btSequentialImpulseConstraintSolver::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
+btScalar btSequentialImpulseConstraintSolver::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
 {
 	
 	btContactSolverInfo info = infoGlobal;
@@ -293,11 +293,11 @@ float btSequentialImpulseConstraintSolver::solveGroup(btPersistentManifold** man
 	btProfiler::endBlock("solve");
 #endif //USE_PROFILE
 
-	return 0.f;
+	return btScalar(0.);
 }
 
 
-float penetrationResolveFactor = 0.9f;
+btScalar penetrationResolveFactor = btScalar(0.9);
 btScalar restitutionCurve(btScalar rel_vel, btScalar restitution)
 {
 	btScalar rest = restitution * -rel_vel;
@@ -324,7 +324,7 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 		for (int i=0;i<numpoints ;i++)
 		{
 			btManifoldPoint& cp = manifoldPtr->getContactPoint(i);
-			if (cp.getDistance() <= 0.f)
+			if (cp.getDistance() <= btScalar(0.))
 			{
 				const btVector3& pos1 = cp.getPositionWorldOnA();
 				const btVector3& pos2 = cp.getPositionWorldOnB();
@@ -373,7 +373,7 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 				}
 				assert(cpd);
 
-				cpd->m_jacDiagABInv = 1.f / jacDiagAB;
+				cpd->m_jacDiagABInv = btScalar(1.) / jacDiagAB;
 
 				//Dependent on Rigidbody A and B types, fetch the contact/friction response func
 				//perhaps do a similar thing for friction/restutution combiner funcs...
@@ -387,14 +387,14 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 				btScalar rel_vel;
 				rel_vel = cp.m_normalWorldOnB.dot(vel);
 				
-				float combinedRestitution = cp.m_combinedRestitution;
+				btScalar combinedRestitution = cp.m_combinedRestitution;
 				
 				cpd->m_penetration = cp.getDistance();
 				cpd->m_friction = cp.m_combinedFriction;
 				cpd->m_restitution = restitutionCurve(rel_vel, combinedRestitution);
-				if (cpd->m_restitution <= 0.) //0.f)
+				if (cpd->m_restitution <= 0.) //btScalar(0.))
 				{
-					cpd->m_restitution = 0.0f;
+					cpd->m_restitution = btScalar(0.0);
 
 				};
 				
@@ -405,18 +405,18 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 
 				if (cpd->m_restitution > penVel)
 				{
-					cpd->m_penetration = 0.f;
+					cpd->m_penetration = btScalar(0.);
 				} 				
 				
 				
 
-				float relaxation = info.m_damping;
+				btScalar relaxation = info.m_damping;
 				if (m_solverMode & SOLVER_USE_WARMSTARTING)
 				{
 					cpd->m_appliedImpulse *= relaxation;
 				} else
 				{
-					cpd->m_appliedImpulse =0.f;
+					cpd->m_appliedImpulse =btScalar(0.);
 				}
 	
 				//for friction
@@ -429,12 +429,12 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 #define NO_FRICTION_WARMSTART 1
 
 	#ifdef NO_FRICTION_WARMSTART
-				cpd->m_accumulatedTangentImpulse0 = 0.f;
-				cpd->m_accumulatedTangentImpulse1 = 0.f;
+				cpd->m_accumulatedTangentImpulse0 = btScalar(0.);
+				cpd->m_accumulatedTangentImpulse1 = btScalar(0.);
 	#endif //NO_FRICTION_WARMSTART
-				float denom0 = body0->computeImpulseDenominator(pos1,cpd->m_frictionWorldTangential0);
-				float denom1 = body1->computeImpulseDenominator(pos2,cpd->m_frictionWorldTangential0);
-				float denom = relaxation/(denom0+denom1);
+				btScalar denom0 = body0->computeImpulseDenominator(pos1,cpd->m_frictionWorldTangential0);
+				btScalar denom1 = body1->computeImpulseDenominator(pos2,cpd->m_frictionWorldTangential0);
+				btScalar denom = relaxation/(denom0+denom1);
 				cpd->m_jacDiagABInvTangent0 = denom;
 
 
@@ -489,16 +489,16 @@ void	btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol
 	}
 }
 
-float btSequentialImpulseConstraintSolver::solve(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer)
+btScalar btSequentialImpulseConstraintSolver::solve(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer)
 {
 
-	float maxImpulse = 0.f;
+	btScalar maxImpulse = btScalar(0.);
 
 	{
 
 		btVector3 color(0,1,0);
 		{
-			if (cp.getDistance() <= 0.f)
+			if (cp.getDistance() <= btScalar(0.))
 			{
 
 				if (iter == 0)
@@ -510,7 +510,7 @@ float btSequentialImpulseConstraintSolver::solve(btRigidBody* body0,btRigidBody*
 				{
 
 					btConstraintPersistentData* cpd = (btConstraintPersistentData*) cp.m_userPersistentData;
-					float impulse = cpd->m_contactSolverFunc(
+					btScalar impulse = cpd->m_contactSolverFunc(
 						*body0,*body1,
 						cp,
 						info);
@@ -525,7 +525,7 @@ float btSequentialImpulseConstraintSolver::solve(btRigidBody* body0,btRigidBody*
 	return maxImpulse;
 }
 
-float btSequentialImpulseConstraintSolver::solveFriction(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer)
+btScalar btSequentialImpulseConstraintSolver::solveFriction(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer)
 {
 
 
@@ -534,7 +534,7 @@ float btSequentialImpulseConstraintSolver::solveFriction(btRigidBody* body0,btRi
 		btVector3 color(0,1,0);
 		{
 			
-			if (cp.getDistance() <= 0.f)
+			if (cp.getDistance() <= btScalar(0.))
 			{
 
 				btConstraintPersistentData* cpd = (btConstraintPersistentData*) cp.m_userPersistentData;
@@ -549,5 +549,5 @@ float btSequentialImpulseConstraintSolver::solveFriction(btRigidBody* body0,btRi
 
 	
 	}
-	return 0.f;
+	return btScalar(0.);
 }

src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h

@@ -31,8 +31,8 @@ class btSequentialImpulseConstraintSolver : public btConstraintSolver
 {
 
 protected:
-	float solve(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer);
-	float solveFriction(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer);
+	btScalar solve(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer);
+	btScalar solveFriction(btRigidBody* body0,btRigidBody* body1, btManifoldPoint& cp, const btContactSolverInfo& info,int iter,btIDebugDraw* debugDrawer);
 	void  prepareConstraints(btPersistentManifold* manifoldPtr, const btContactSolverInfo& info,btIDebugDraw* debugDrawer);
 
 	ContactSolverFunc m_contactDispatch[MAX_CONTACT_SOLVER_TYPES][MAX_CONTACT_SOLVER_TYPES];
@@ -68,7 +68,7 @@ public:
 
 	virtual ~btSequentialImpulseConstraintSolver() {}
 	
-	virtual float solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& info, btIDebugDraw* debugDrawer=0);
+	virtual btScalar solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& info, btIDebugDraw* debugDrawer=0);
 
 	void	setSolverMode(int mode)
 	{
@@ -88,7 +88,7 @@ public:
 
 	btSequentialImpulseConstraintSolver3();
 
-	virtual float solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& info, btIDebugDraw* debugDrawer=0);
+	virtual btScalar solveGroup(btPersistentManifold** manifold,int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& info, btIDebugDraw* debugDrawer=0);
 
 
 };

src/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp

@@ -44,11 +44,11 @@ void btSolve2LinearConstraint::resolveUnilateralPairConstraint(
 					  btScalar& imp0,btScalar& imp1)
 {
 
-	imp0 = 0.f;
-	imp1 = 0.f;
+	imp0 = btScalar(0.);
+	imp1 = btScalar(0.);
 
-	btScalar len = fabs(normalA.length())-1.f;
-	if (fabs(len) >= SIMD_EPSILON)
+	btScalar len = btFabs(normalA.length()) - btScalar(1.);
+	if (btFabs(len) >= SIMD_EPSILON)
 		return;
 
 	btAssert(len < SIMD_EPSILON);
@@ -67,7 +67,7 @@ void btSolve2LinearConstraint::resolveUnilateralPairConstraint(
 	const btScalar vel1 = normalB.dot(body1->getVelocityInLocalPoint(rel_posB1)-body2->getVelocityInLocalPoint(rel_posB1));
 
 //	btScalar penetrationImpulse = (depth*contactTau*timeCorrection)  * massTerm;//jacDiagABInv
-	btScalar massTerm = 1.f / (invMassA + invMassB);
+	btScalar massTerm = btScalar(1.) / (invMassA + invMassB);
 
 
 	// calculate rhs (or error) terms
@@ -87,7 +87,7 @@ void btSolve2LinearConstraint::resolveUnilateralPairConstraint(
 
 
 	btScalar nonDiag = jacA.getNonDiagonal(jacB,invMassA,invMassB);
-	btScalar	invDet = 1.0f / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag );
+	btScalar	invDet = btScalar(1.0) / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag );
 	
 	//imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet;
 	//imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * - nonDiag * invDet;
@@ -126,11 +126,11 @@ void btSolve2LinearConstraint::resolveBilateralPairConstraint(
 					  btScalar& imp0,btScalar& imp1)
 {
 
-	imp0 = 0.f;
-	imp1 = 0.f;
+	imp0 = btScalar(0.);
+	imp1 = btScalar(0.);
 
-	btScalar len = fabs(normalA.length())-1.f;
-	if (fabs(len) >= SIMD_EPSILON)
+	btScalar len = btFabs(normalA.length()) - btScalar(1.);
+	if (btFabs(len) >= SIMD_EPSILON)
 		return;
 
 	btAssert(len < SIMD_EPSILON);
@@ -164,7 +164,7 @@ void btSolve2LinearConstraint::resolveBilateralPairConstraint(
 
 
 	btScalar nonDiag = jacA.getNonDiagonal(jacB,invMassA,invMassB);
-	btScalar	invDet = 1.0f / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag );
+	btScalar	invDet = btScalar(1.0) / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag );
 	
 	//imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet;
 	//imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * - nonDiag * invDet;
@@ -178,41 +178,41 @@ void btSolve2LinearConstraint::resolveBilateralPairConstraint(
 	//[jA nD] * [imp0] = [dv0]
 	//[nD jB]   [imp1]   [dv1]
 
-	if ( imp0 > 0.0f)
+	if ( imp0 > btScalar(0.0))
 	{
-		if ( imp1 > 0.0f )
+		if ( imp1 > btScalar(0.0) )
 		{
 			//both positive
 		}
 		else
 		{
-			imp1 = 0.f;
+			imp1 = btScalar(0.);
 
 			// now imp0>0 imp1<0
 			imp0 = dv0 / jacA.getDiagonal();
-			if ( imp0 > 0.0f )
+			if ( imp0 > btScalar(0.0) )
 			{
 			} else
 			{
-				imp0 = 0.f;
+				imp0 = btScalar(0.);
 			}
 		}
 	}
 	else
 	{
-		imp0 = 0.f;
+		imp0 = btScalar(0.);
 
 		imp1 = dv1 / jacB.getDiagonal();
-		if ( imp1 <= 0.0f )
+		if ( imp1 <= btScalar(0.0) )
 		{
-			imp1 = 0.f;
+			imp1 = btScalar(0.);
 			// now imp0>0 imp1<0
 			imp0 = dv0 / jacA.getDiagonal();
-			if ( imp0 > 0.0f )
+			if ( imp0 > btScalar(0.0) )
 			{
 			} else
 			{
-				imp0 = 0.f;
+				imp0 = btScalar(0.);
 			}
 		} else
 		{

src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp

@@ -24,18 +24,18 @@ btTypedConstraint::btTypedConstraint()
 m_userConstraintId(-1),
 m_rbA(s_fixed),
 m_rbB(s_fixed),
-m_appliedImpulse(0.f)
+m_appliedImpulse(btScalar(0.))
 {
-	s_fixed.setMassProps(0.f,btVector3(0.f,0.f,0.f));
+	s_fixed.setMassProps(btScalar(0.),btVector3(btScalar(0.),btScalar(0.),btScalar(0.)));
 }
 btTypedConstraint::btTypedConstraint(btRigidBody& rbA)
 : m_userConstraintType(-1),
 m_userConstraintId(-1),
 m_rbA(rbA),
 m_rbB(s_fixed),
-m_appliedImpulse(0.f)
+m_appliedImpulse(btScalar(0.))
 {
-		s_fixed.setMassProps(0.f,btVector3(0.f,0.f,0.f));
+		s_fixed.setMassProps(btScalar(0.),btVector3(btScalar(0.),btScalar(0.),btScalar(0.)));
 
 }
 
@@ -45,9 +45,9 @@ btTypedConstraint::btTypedConstraint(btRigidBody& rbA,btRigidBody& rbB)
 m_userConstraintId(-1),
 m_rbA(rbA),
 m_rbB(rbB),
-m_appliedImpulse(0.f)
+m_appliedImpulse(btScalar(0.))
 {
-		s_fixed.setMassProps(0.f,btVector3(0.f,0.f,0.f));
+		s_fixed.setMassProps(btScalar(0.),btVector3(btScalar(0.),btScalar(0.),btScalar(0.)));
 
 }
 

src/BulletDynamics/ConstraintSolver/btTypedConstraint.h

@@ -29,7 +29,7 @@ class btTypedConstraint
 protected:
 	btRigidBody&	m_rbA;
 	btRigidBody&	m_rbB;
-	float	m_appliedImpulse;
+	btScalar	m_appliedImpulse;
 
 
 public:
@@ -81,7 +81,7 @@ public:
 	{
 		return m_userConstraintId;
 	}
-	float	getAppliedImpulse()
+	btScalar	getAppliedImpulse()
 	{
 		return m_appliedImpulse;
 	}

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp

@@ -63,7 +63,7 @@ btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btDispatcher* dispatcher,btOver
 m_constraintSolver(constraintSolver? constraintSolver: new btSequentialImpulseConstraintSolver),
 m_debugDrawer(0),
 m_gravity(0,-10,0),
-m_localTime(1.f/60.f),
+m_localTime(btScalar(1.)/btScalar(60.)),
 m_profileTimings(0)
 {
 	m_islandManager = new btSimulationIslandManager();
@@ -81,7 +81,7 @@ btDiscreteDynamicsWorld::~btDiscreteDynamicsWorld()
 		 delete m_constraintSolver;
 }
 
-void	btDiscreteDynamicsWorld::saveKinematicState(float timeStep)
+void	btDiscreteDynamicsWorld::saveKinematicState(btScalar timeStep)
 {
 
 	for (unsigned int i=0;i<m_collisionObjects.size();i++)
@@ -115,22 +115,22 @@ void	btDiscreteDynamicsWorld::synchronizeMotionStates()
 			btCollisionObject* colObj = m_collisionObjects[i];
 			if (getDebugDrawer() && getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe)
 			{
-				btVector3 color(255.f,255.f,255.f);
+				btVector3 color(btScalar(255.),btScalar(255.),btScalar(255.));
 				switch(colObj->getActivationState())
 				{
 				case  ACTIVE_TAG:
-					color = btVector3(255.f,255.f,255.f); break;
+					color = btVector3(btScalar(255.),btScalar(255.),btScalar(255.)); break;
 				case ISLAND_SLEEPING:
-					color =  btVector3(0.f,255.f,0.f);break;
+					color =  btVector3(btScalar(0.),btScalar(255.),btScalar(0.));break;
 				case WANTS_DEACTIVATION:
-					color = btVector3(0.f,255.f,255.f);break;
+					color = btVector3(btScalar(0.),btScalar(255.),btScalar(255.));break;
 				case DISABLE_DEACTIVATION:
-					color = btVector3(255.f,0.f,0.f);break;
+					color = btVector3(btScalar(255.),btScalar(0.),btScalar(0.));break;
 				case DISABLE_SIMULATION:
-					color = btVector3(255.f,255.f,0.f);break;
+					color = btVector3(btScalar(255.),btScalar(255.),btScalar(0.));break;
 				default:
 					{
-						color = btVector3(255.f,0.f,0.f);
+						color = btVector3(btScalar(255.),btScalar(0.),btScalar(0.));
 					}
 				};
 
@@ -188,7 +188,7 @@ void	btDiscreteDynamicsWorld::synchronizeMotionStates()
 }
 
 
-int	btDiscreteDynamicsWorld::stepSimulation( float timeStep,int maxSubSteps, float fixedTimeStep)
+int	btDiscreteDynamicsWorld::stepSimulation( btScalar timeStep,int maxSubSteps, btScalar fixedTimeStep)
 {
 	int numSimulationSubSteps = 0;
 
@@ -243,7 +243,7 @@ int	btDiscreteDynamicsWorld::stepSimulation( float timeStep,int maxSubSteps, flo
 	return numSimulationSubSteps;
 }
 
-void	btDiscreteDynamicsWorld::internalSingleStepSimulation(float timeStep)
+void	btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
 {
 	
 	startProfiling(timeStep);
@@ -326,7 +326,7 @@ void	btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body)
 }
 
 
-void	btDiscreteDynamicsWorld::updateVehicles(float timeStep)
+void	btDiscreteDynamicsWorld::updateVehicles(btScalar timeStep)
 {
 	BEGIN_PROFILE("updateVehicles");
 
@@ -338,7 +338,7 @@ void	btDiscreteDynamicsWorld::updateVehicles(float timeStep)
 	END_PROFILE("updateVehicles");
 }
 
-void	btDiscreteDynamicsWorld::updateActivationState(float timeStep)
+void	btDiscreteDynamicsWorld::updateActivationState(btScalar timeStep)
 {
 	BEGIN_PROFILE("updateActivationState");
 
@@ -548,11 +548,11 @@ void	btDiscreteDynamicsWorld::calculateSimulationIslands()
 static void DrawAabb(btIDebugDraw* debugDrawer,const btVector3& from,const btVector3& to,const btVector3& color)
 {
 
-	btVector3 halfExtents = (to-from)* 0.5f;
-	btVector3 center = (to+from) *0.5f;
+	btVector3 halfExtents = (to-from)* btScalar(0.5);
+	btVector3 center = (to+from) *btScalar(0.5);
 	int i,j;
 
-	btVector3 edgecoord(1.f,1.f,1.f),pa,pb;
+	btVector3 edgecoord(btScalar(1.),btScalar(1.),btScalar(1.)),pa,pb;
 	for (i=0;i<4;i++)
 	{
 		for (j=0;j<3;j++)
@@ -562,16 +562,16 @@ static void DrawAabb(btIDebugDraw* debugDrawer,const btVector3& from,const btVec
 			pa+=center;
 
 			int othercoord = j%3;
-			edgecoord[othercoord]*=-1.f;
+			edgecoord[othercoord]*=btScalar(-1.);
 			pb = btVector3(edgecoord[0]*halfExtents[0], edgecoord[1]*halfExtents[1],	
 				edgecoord[2]*halfExtents[2]);
 			pb+=center;
 
 			debugDrawer->drawLine(pa,pb,color);
 		}
-		edgecoord = btVector3(-1.f,-1.f,-1.f);
+		edgecoord = btVector3(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		if (i<3)
-			edgecoord[i]*=-1.f;
+			edgecoord[i]*=btScalar(-1.);
 	}
 
 
@@ -597,7 +597,7 @@ void	btDiscreteDynamicsWorld::updateAabbs()
 				btSimpleBroadphase* bp = (btSimpleBroadphase*)m_broadphasePairCache;
 
 				//moving objects should be moderately sized, probably something wrong if not
-				if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < 1e12f))
+				if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < btScalar(1e12)))
 				{
 					bp->setAabb(body->getBroadphaseHandle(),minAabb,maxAabb);
 				} else
@@ -630,7 +630,7 @@ void	btDiscreteDynamicsWorld::updateAabbs()
 	END_PROFILE("updateAabbs");
 }
 
-void	btDiscreteDynamicsWorld::integrateTransforms(float timeStep)
+void	btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep)
 {
 	BEGIN_PROFILE("integrateTransforms");
 	btTransform predictedTrans;
@@ -652,7 +652,7 @@ void	btDiscreteDynamicsWorld::integrateTransforms(float timeStep)
 
 
 
-void	btDiscreteDynamicsWorld::predictUnconstraintMotion(float timeStep)
+void	btDiscreteDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
 {
 	BEGIN_PROFILE("predictUnconstraintMotion");
 	for (unsigned int i=0;i<m_collisionObjects.size();i++)
@@ -676,7 +676,7 @@ void	btDiscreteDynamicsWorld::predictUnconstraintMotion(float timeStep)
 }
 
 
-void	btDiscreteDynamicsWorld::startProfiling(float timeStep)
+void	btDiscreteDynamicsWorld::startProfiling(btScalar timeStep)
 {
 	#ifdef USE_QUICKPROF
 
@@ -771,7 +771,7 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 		case SPHERE_SHAPE_PROXYTYPE:
 			{
 				const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
-				float radius = sphereShape->getMargin();//radius doesn't include the margin, so draw with margin
+				btScalar radius = sphereShape->getMargin();//radius doesn't include the margin, so draw with margin
 				btVector3 start = worldTransform.getOrigin();
 				getDebugDrawer()->drawLine(start,start+worldTransform.getBasis() * btVector3(radius,0,0),color);
 				getDebugDrawer()->drawLine(start,start+worldTransform.getBasis() * btVector3(0,radius,0),color);
@@ -783,13 +783,13 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 		case CONE_SHAPE_PROXYTYPE:
 			{
 				const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
-				float radius = coneShape->getRadius();//+coneShape->getMargin();
-				float height = coneShape->getHeight();//+coneShape->getMargin();
+				btScalar radius = coneShape->getRadius();//+coneShape->getMargin();
+				btScalar height = coneShape->getHeight();//+coneShape->getMargin();
 				btVector3 start = worldTransform.getOrigin();
-				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(0.f,0.f,0.5f*height),start+worldTransform.getBasis() * btVector3(radius,0.f,-0.5f*height),color);
-				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(0.f,0.f,0.5f*height),start+worldTransform.getBasis() * btVector3(-radius,0.f,-0.5f*height),color);
-				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(0.f,0.f,0.5f*height),start+worldTransform.getBasis() * btVector3(0.f,radius,-0.5f*height),color);
-				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(0.f,0.f,0.5f*height),start+worldTransform.getBasis() * btVector3(0.f,-radius,-0.5f*height),color);
+				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(btScalar(0.),btScalar(0.),btScalar(0.5)*height),start+worldTransform.getBasis() * btVector3(radius,btScalar(0.),btScalar(-0.5)*height),color);
+				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(btScalar(0.),btScalar(0.),btScalar(0.5)*height),start+worldTransform.getBasis() * btVector3(-radius,btScalar(0.),btScalar(-0.5)*height),color);
+				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(btScalar(0.),btScalar(0.),btScalar(0.5)*height),start+worldTransform.getBasis() * btVector3(btScalar(0.),radius,btScalar(-0.5)*height),color);
+				getDebugDrawer()->drawLine(start+worldTransform.getBasis() * btVector3(btScalar(0.),btScalar(0.),btScalar(0.5)*height),start+worldTransform.getBasis() * btVector3(btScalar(0.),-radius,btScalar(-0.5)*height),color);
 				break;
 
 			}
@@ -797,8 +797,8 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 			{
 				const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
 				int upAxis = cylinder->getUpAxis();
-				float radius = cylinder->getRadius();
-				float halfHeight = cylinder->getHalfExtents()[upAxis];
+				btScalar radius = cylinder->getRadius();
+				btScalar halfHeight = cylinder->getHalfExtents()[upAxis];
 				btVector3 start = worldTransform.getOrigin();
 				btVector3	offsetHeight(0,0,0);
 				offsetHeight[upAxis] = halfHeight;
@@ -814,12 +814,12 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
 				{
 					btTriangleMeshShape* concaveMesh = (btTriangleMeshShape*) shape;
-					//btVector3 aabbMax(1e30f,1e30f,1e30f);
-					//btVector3 aabbMax(100,100,100);//1e30f,1e30f,1e30f);
+					//btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+					//btVector3 aabbMax(100,100,100);//btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
 					//todo pass camera, for some culling
-					btVector3 aabbMax(1e30f,1e30f,1e30f);
-					btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
+					btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+					btVector3 aabbMin(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
 
 					DebugDrawcallback drawCallback(getDebugDrawer(),worldTransform,color);
 					concaveMesh->processAllTriangles(&drawCallback,aabbMin,aabbMax);
@@ -830,8 +830,8 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform,
 				{
 					btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*) shape;
 					//todo: pass camera for some culling			
-					btVector3 aabbMax(1e30f,1e30f,1e30f);
-					btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
+					btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+					btVector3 aabbMin(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
 					//DebugDrawcallback drawCallback;
 					DebugDrawcallback drawCallback(getDebugDrawer(),worldTransform,color);
 					convexMesh->getStridingMesh()->InternalProcessAllTriangles(&drawCallback,aabbMin,aabbMax);

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h

@@ -47,7 +47,7 @@ protected:
 	btVector3	m_gravity;
 
 	//for variable timesteps
-	float	m_localTime;
+	btScalar	m_localTime;
 	//for variable timesteps
 
 	bool	m_ownsIslandManager;
@@ -60,25 +60,25 @@ protected:
 
 	int	m_profileTimings;
 
-	void	predictUnconstraintMotion(float timeStep);
+	void	predictUnconstraintMotion(btScalar timeStep);
 	
-	void	integrateTransforms(float timeStep);
+	void	integrateTransforms(btScalar timeStep);
 		
 	void	calculateSimulationIslands();
 
 	void	solveConstraints(btContactSolverInfo& solverInfo);
 	
-	void	updateActivationState(float timeStep);
+	void	updateActivationState(btScalar timeStep);
 
-	void	updateVehicles(float timeStep);
+	void	updateVehicles(btScalar timeStep);
 
-	void	startProfiling(float timeStep);
+	void	startProfiling(btScalar timeStep);
 
-	virtual void	internalSingleStepSimulation( float timeStep);
+	virtual void	internalSingleStepSimulation( btScalar timeStep);
 
 	void	synchronizeMotionStates();
 
-	void	saveKinematicState(float timeStep);
+	void	saveKinematicState(btScalar timeStep);
 
 
 public:
@@ -90,7 +90,7 @@ public:
 	virtual ~btDiscreteDynamicsWorld();
 
 	///if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
-	virtual int	stepSimulation( float timeStep,int maxSubSteps=1, float fixedTimeStep=1.f/60.f);
+	virtual int	stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
 
 	virtual void	updateAabbs();
 

src/BulletDynamics/Dynamics/btDynamicsWorld.h

@@ -39,7 +39,7 @@ class btDynamicsWorld : public btCollisionWorld
 		
 		///stepSimulation proceeds the simulation over timeStep units
 		///if maxSubSteps > 0, it will interpolate time steps
-		virtual int		stepSimulation( float timeStep,int maxSubSteps=1, float fixedTimeStep=1.f/60.f)=0;
+		virtual int		stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))=0;
 			
 		virtual void	updateAabbs() = 0;
 				

src/BulletDynamics/Dynamics/btRigidBody.cpp

@@ -19,25 +19,25 @@ subject to the following restrictions:
 #include <LinearMath/btTransformUtil.h>
 #include <LinearMath/btMotionState.h>
 
-float gLinearAirDamping = 1.f;
+btScalar gLinearAirDamping = btScalar(1.);
 //'temporarily' global variables
-float	gDeactivationTime = 2.f;
+btScalar	gDeactivationTime = btScalar(2.);
 bool	gDisableDeactivation = false;
 
-float gLinearSleepingThreshold = 0.8f;
-float gAngularSleepingThreshold = 1.0f;
+btScalar gLinearSleepingThreshold = btScalar(0.8);
+btScalar gAngularSleepingThreshold = btScalar(1.0);
 static int uniqueId = 0;
 
-btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution)
+btRigidBody::btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution)
 : 
-	m_gravity(0.0f, 0.0f, 0.0f),
-	m_totalForce(0.0f, 0.0f, 0.0f),
-	m_totalTorque(0.0f, 0.0f, 0.0f),
-	m_linearVelocity(0.0f, 0.0f, 0.0f),
-	m_angularVelocity(0.f,0.f,0.f),
-	m_angularFactor(1.f),
-	m_linearDamping(0.f),
-	m_angularDamping(0.5f),
+	m_gravity(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_totalForce(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_totalTorque(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_linearVelocity(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_angularVelocity(btScalar(0.),btScalar(0.),btScalar(0.)),
+	m_angularFactor(btScalar(1.)),
+	m_linearDamping(btScalar(0.)),
+	m_angularDamping(btScalar(0.5)),
 	m_optionalMotionState(motionState),
 	m_contactSolverType(0),
 	m_frictionSolverType(0)
@@ -72,15 +72,15 @@ btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShap
 }
 
 #ifdef OBSOLETE_MOTIONSTATE_LESS
-btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisionShape* collisionShape,const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution)
+btRigidBody::btRigidBody( btScalar mass,const btTransform& worldTransform,btCollisionShape* collisionShape,const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution)
 : 
-	m_gravity(0.0f, 0.0f, 0.0f),
-	m_totalForce(0.0f, 0.0f, 0.0f),
-	m_totalTorque(0.0f, 0.0f, 0.0f),
-	m_linearVelocity(0.0f, 0.0f, 0.0f),
-	m_angularVelocity(0.f,0.f,0.f),
-	m_linearDamping(0.f),
-	m_angularDamping(0.5f),
+	m_gravity(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_totalForce(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_totalTorque(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_linearVelocity(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
+	m_angularVelocity(btScalar(0.),btScalar(0.),btScalar(0.)),
+	m_linearDamping(btScalar(0.)),
+	m_angularDamping(btScalar(0.5)),
 	m_optionalMotionState(0),
 	m_contactSolverType(0),
 	m_frictionSolverType(0)
@@ -115,11 +115,11 @@ btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisi
 //Bullet 2.20b has experimental damping code to reduce jitter just before objects fall asleep/deactivate
 //doesn't work very well yet (value 0 disabled this damping)
 //note there this influences deactivation thresholds!
-float gClippedAngvelThresholdSqr = 0.01f;
-float	gClippedLinearThresholdSqr = 0.01f;
+btScalar gClippedAngvelThresholdSqr = btScalar(0.01);
+btScalar	gClippedLinearThresholdSqr = btScalar(0.01);
 #endif //EXPERIMENTAL_JITTER_REMOVAL
 
-float	gJitterVelocityDampingFactor = 1.f;
+btScalar	gJitterVelocityDampingFactor = btScalar(1.);
 
 void btRigidBody::predictIntegratedTransform(btScalar timeStep,btTransform& predictedTransform) 
 {
@@ -144,7 +144,7 @@ void btRigidBody::predictIntegratedTransform(btScalar timeStep,btTransform& pred
 void			btRigidBody::saveKinematicState(btScalar timeStep)
 {
 	//todo: clamp to some (user definable) safe minimum timestep, to limit maximum angular/linear velocities
-	if (timeStep != 0.f)
+	if (timeStep != btScalar(0.))
 	{
 		//if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform
 		if (getMotionState())
@@ -169,9 +169,9 @@ void	btRigidBody::getAabb(btVector3& aabbMin,btVector3& aabbMax) const
 
 void btRigidBody::setGravity(const btVector3& acceleration) 
 {
-	if (m_inverseMass != 0.0f)
+	if (m_inverseMass != btScalar(0.0))
 	{
-		m_gravity = acceleration * (1.0f / m_inverseMass);
+		m_gravity = acceleration * (btScalar(1.0) / m_inverseMass);
 	}
 }
 
@@ -182,8 +182,8 @@ void btRigidBody::setGravity(const btVector3& acceleration)
 
 void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping)
 {
-	m_linearDamping = GEN_clamped(lin_damping, 0.0f, 1.0f);
-	m_angularDamping = GEN_clamped(ang_damping, 0.0f, 1.0f);
+	m_linearDamping = GEN_clamped(lin_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
+	m_angularDamping = GEN_clamped(ang_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
 }
 
 
@@ -198,36 +198,36 @@ void btRigidBody::applyForces(btScalar step)
 	
 	applyCentralForce(m_gravity);	
 	
-	m_linearVelocity *= GEN_clamped((1.f - step * gLinearAirDamping * m_linearDamping), 0.0f, 1.0f);
-	m_angularVelocity *= GEN_clamped((1.f - step * m_angularDamping), 0.0f, 1.0f);
+	m_linearVelocity *= GEN_clamped((btScalar(1.) - step * gLinearAirDamping * m_linearDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
+	m_angularVelocity *= GEN_clamped((btScalar(1.) - step * m_angularDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
 
 #define FORCE_VELOCITY_DAMPING 1
 #ifdef FORCE_VELOCITY_DAMPING
-	float speed = m_linearVelocity.length();
+	btScalar speed = m_linearVelocity.length();
 	if (speed < m_linearDamping)
 	{
-		float dampVel = 0.005f;
+		btScalar dampVel = btScalar(0.005);
 		if (speed > dampVel)
 		{
 			btVector3 dir = m_linearVelocity.normalized();
 			m_linearVelocity -=  dir * dampVel;
 		} else
 		{
-			m_linearVelocity.setValue(0.f,0.f,0.f);
+			m_linearVelocity.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 		}
 	}
 
-	float angSpeed = m_angularVelocity.length();
+	btScalar angSpeed = m_angularVelocity.length();
 	if (angSpeed < m_angularDamping)
 	{
-		float angDampVel = 0.005f;
+		btScalar angDampVel = btScalar(0.005);
 		if (angSpeed > angDampVel)
 		{
 			btVector3 dir = m_angularVelocity.normalized();
 			m_angularVelocity -=  dir * angDampVel;
 		} else
 		{
-			m_angularVelocity.setValue(0.f,0.f,0.f);
+			m_angularVelocity.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 		}
 	}
 #endif //FORCE_VELOCITY_DAMPING
@@ -242,19 +242,19 @@ void btRigidBody::proceedToTransform(const btTransform& newTrans)
 
 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
 {
-	if (mass == 0.f)
+	if (mass == btScalar(0.))
 	{
 		m_collisionFlags |= btCollisionObject::CF_STATIC_OBJECT;
-		m_inverseMass = 0.f;
+		m_inverseMass = btScalar(0.);
 	} else
 	{
 		m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT);
-		m_inverseMass = 1.0f / mass;
+		m_inverseMass = btScalar(1.0) / mass;
 	}
 	
-	m_invInertiaLocal.setValue(inertia[0] != 0.0f ? 1.0f / inertia[0]: 0.0f,
-				   inertia[1] != 0.0f ? 1.0f / inertia[1]: 0.0f,
-				   inertia[2] != 0.0f ? 1.0f / inertia[2]: 0.0f);
+	m_invInertiaLocal.setValue(inertia[0] != btScalar(0.0) ? btScalar(1.0) / inertia[0]: btScalar(0.0),
+				   inertia[1] != btScalar(0.0) ? btScalar(1.0) / inertia[1]: btScalar(0.0),
+				   inertia[2] != btScalar(0.0) ? btScalar(1.0) / inertia[2]: btScalar(0.0));
 
 }
 
@@ -276,7 +276,7 @@ void btRigidBody::integrateVelocities(btScalar step)
 
 #define MAX_ANGVEL SIMD_HALF_PI
 	/// clamp angular velocity. collision calculations will fail on higher angular velocities	
-	float angvel = m_angularVelocity.length();
+	btScalar angvel = m_angularVelocity.length();
 	if (angvel*step > MAX_ANGVEL)
 	{
 		m_angularVelocity *= (MAX_ANGVEL/step) /angvel;

src/BulletDynamics/Dynamics/btRigidBody.h

@@ -29,13 +29,13 @@ class btMotionState;
 
 
 
-extern float gLinearAirDamping;
+extern btScalar gLinearAirDamping;
 extern bool gUseEpa;
 
-extern float gDeactivationTime;
+extern btScalar gDeactivationTime;
 extern bool gDisableDeactivation;
-extern float gLinearSleepingThreshold;
-extern float gAngularSleepingThreshold;
+extern btScalar gLinearSleepingThreshold;
+extern btScalar gAngularSleepingThreshold;
 
 
 /// btRigidBody class for btRigidBody Dynamics
@@ -65,10 +65,10 @@ public:
 
 #ifdef OBSOLETE_MOTIONSTATE_LESS
 	//not supported, please use btMotionState
-	btRigidBody(float mass, const btTransform& worldTransform, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f);
+	btRigidBody(btScalar mass, const btTransform& worldTransform, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=btScalar(0.),btScalar angularDamping=btScalar(0.),btScalar friction=btScalar(0.5),btScalar restitution=btScalar(0.));
 #endif //OBSOLETE_MOTIONSTATE_LESS
 
-	btRigidBody(float mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f);
+	btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=btScalar(0.),btScalar angularDamping=btScalar(0.),btScalar friction=btScalar(0.5),btScalar restitution=btScalar(0.));
 
 	void			proceedToTransform(const btTransform& newTrans); 
 	
@@ -157,7 +157,7 @@ public:
 	
 	void applyImpulse(const btVector3& impulse, const btVector3& rel_pos) 
 	{
-		if (m_inverseMass != 0.f)
+		if (m_inverseMass != btScalar(0.))
 		{
 			applyCentralImpulse(impulse);
 			if (m_angularFactor)
@@ -168,9 +168,9 @@ public:
 	}
 
 	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
-	inline void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent,float impulseMagnitude)
+	inline void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent,btScalar impulseMagnitude)
 	{
-		if (m_inverseMass != 0.f)
+		if (m_inverseMass != btScalar(0.))
 		{
 			m_linearVelocity += linearComponent*impulseMagnitude;
 			if (m_angularFactor)
@@ -182,8 +182,8 @@ public:
 	
 	void clearForces() 
 	{
-		m_totalForce.setValue(0.0f, 0.0f, 0.0f);
-		m_totalTorque.setValue(0.0f, 0.0f, 0.0f);
+		m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
+		m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
 	}
 	
 	void updateInertiaTensor();    
@@ -238,7 +238,7 @@ public:
 
 
 	
-	inline float computeImpulseDenominator(const btPoint3& pos, const btVector3& normal) const
+	inline btScalar computeImpulseDenominator(const btPoint3& pos, const btVector3& normal) const
 	{
 		btVector3 r0 = pos - getCenterOfMassPosition();
 
@@ -250,13 +250,13 @@ public:
 
 	}
 
-	inline float computeAngularImpulseDenominator(const btVector3& axis) const
+	inline btScalar computeAngularImpulseDenominator(const btVector3& axis) const
 	{
 		btVector3 vec = axis * getInvInertiaTensorWorld();
 		return axis.dot(vec);
 	}
 
-	inline void	updateDeactivation(float timeStep)
+	inline void	updateDeactivation(btScalar timeStep)
 	{
 		if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
 			return;
@@ -267,7 +267,7 @@ public:
 			m_deactivationTime += timeStep;
 		} else
 		{
-			m_deactivationTime=0.f;
+			m_deactivationTime=btScalar(0.);
 			setActivationState(0);
 		}
 
@@ -280,7 +280,7 @@ public:
 			return false;
 
 		//disable deactivation
-		if (gDisableDeactivation || (gDeactivationTime == 0.f))
+		if (gDisableDeactivation || (gDeactivationTime == btScalar(0.)))
 			return false;
 
 		if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
@@ -328,11 +328,11 @@ public:
 	int	m_contactSolverType;
 	int	m_frictionSolverType;
 
-	void	setAngularFactor(float angFac)
+	void	setAngularFactor(btScalar angFac)
 	{
 		m_angularFactor = angFac;
 	}
-	float	getAngularFactor() const
+	btScalar	getAngularFactor() const
 	{
 		return m_angularFactor;
 	}

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp

@@ -41,7 +41,7 @@ btSimpleDynamicsWorld::~btSimpleDynamicsWorld()
 		delete m_constraintSolver;
 }
 
-int		btSimpleDynamicsWorld::stepSimulation( float timeStep,int maxSubSteps, float fixedTimeStep)
+int		btSimpleDynamicsWorld::stepSimulation( btScalar timeStep,int maxSubSteps, btScalar fixedTimeStep)
 {
 	///apply gravity, predict motion
 	predictUnconstraintMotion(timeStep);
@@ -127,7 +127,7 @@ void	btSimpleDynamicsWorld::updateAabbs()
 	}
 }
 
-void	btSimpleDynamicsWorld::integrateTransforms(float timeStep)
+void	btSimpleDynamicsWorld::integrateTransforms(btScalar timeStep)
 {
 	btTransform predictedTrans;
 	for (unsigned int i=0;i<m_collisionObjects.size();i++)
@@ -147,7 +147,7 @@ void	btSimpleDynamicsWorld::integrateTransforms(float timeStep)
 
 
 
-void	btSimpleDynamicsWorld::predictUnconstraintMotion(float timeStep)
+void	btSimpleDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
 {
 	for (unsigned int i=0;i<m_collisionObjects.size();i++)
 	{

src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h

@@ -37,9 +37,9 @@ protected:
 
 	btIDebugDraw*	m_debugDrawer;
 
-	void	predictUnconstraintMotion(float timeStep);
+	void	predictUnconstraintMotion(btScalar timeStep);
 	
-	void	integrateTransforms(float timeStep);
+	void	integrateTransforms(btScalar timeStep);
 		
 	btVector3	m_gravity;
 	
@@ -53,7 +53,7 @@ public:
 	virtual ~btSimpleDynamicsWorld();
 		
 	///maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead
-	virtual int	stepSimulation( float timeStep,int maxSubSteps=1, float fixedTimeStep=1.f/60.f);
+	virtual int	stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
 
 	virtual void	setDebugDrawer(btIDebugDraw*	debugDrawer) 
 	{

src/BulletDynamics/Vehicle/btRaycastVehicle.cpp

@@ -28,7 +28,7 @@ static btRigidBody s_fixedObject( 0,0,0);
 
 btRaycastVehicle::btRaycastVehicle(const btVehicleTuning& tuning,btRigidBody* chassis,	btVehicleRaycaster* raycaster )
 :m_vehicleRaycaster(raycaster),
-m_pitchControl(0.f)
+m_pitchControl(btScalar(0.))
 {
 	m_chassisBody = chassis;
 	m_indexRightAxis = 0;
@@ -40,8 +40,8 @@ m_pitchControl(0.f)
 
 void btRaycastVehicle::defaultInit(const btVehicleTuning& tuning)
 {
-	m_currentVehicleSpeedKmHour = 0.f;
-	m_steeringValue = 0.f;
+	m_currentVehicleSpeedKmHour = btScalar(0.);
+	m_steeringValue = btScalar(0.);
 	
 }
 
@@ -105,7 +105,7 @@ void	btRaycastVehicle::updateWheelTransform( int wheelIndex , bool interpolatedT
 //	up.normalize();
 
 	//rotate around steering over de wheelAxleWS
-	float steering = wheel.m_steering;
+	btScalar steering = wheel.m_steering;
 	
 	btQuaternion steeringOrn(up,steering);//wheel.m_steering);
 	btMatrix3x3 steeringMat(steeringOrn);
@@ -133,11 +133,11 @@ void btRaycastVehicle::resetSuspension()
 	{
 			btWheelInfo& wheel = m_wheelInfo[i];
 			wheel.m_raycastInfo.m_suspensionLength = wheel.getSuspensionRestLength();
-			wheel.m_suspensionRelativeVelocity = 0.0f;
+			wheel.m_suspensionRelativeVelocity = btScalar(0.0);
 			
 			wheel.m_raycastInfo.m_contactNormalWS = - wheel.m_raycastInfo.m_wheelDirectionWS;
-			//wheel_info.setContactFriction(0.0f);
-			wheel.m_clippedInvContactDotSuspension = 1.0f;
+			//wheel_info.setContactFriction(btScalar(0.0));
+			wheel.m_clippedInvContactDotSuspension = btScalar(1.0);
 	}
 }
 
@@ -170,7 +170,7 @@ btScalar btRaycastVehicle::rayCast(btWheelInfo& wheel)
 	wheel.m_raycastInfo.m_contactPointWS = source + rayvector;
 	const btVector3& target = wheel.m_raycastInfo.m_contactPointWS;
 
-	btScalar param = 0.f;
+	btScalar param = btScalar(0.);
 	
 	btVehicleRaycaster::btVehicleRaycasterResult	rayResults;
 
@@ -195,8 +195,8 @@ btScalar btRaycastVehicle::rayCast(btWheelInfo& wheel)
 		wheel.m_raycastInfo.m_suspensionLength = hitDistance - wheel.m_wheelsRadius;
 		//clamp on max suspension travel
 
-		float  minSuspensionLength = wheel.getSuspensionRestLength() - wheel.m_maxSuspensionTravelCm*0.01f;
-		float maxSuspensionLength = wheel.getSuspensionRestLength()+ wheel.m_maxSuspensionTravelCm*0.01f;
+		btScalar  minSuspensionLength = wheel.getSuspensionRestLength() - wheel.m_maxSuspensionTravelCm*btScalar(0.01);
+		btScalar maxSuspensionLength = wheel.getSuspensionRestLength()+ wheel.m_maxSuspensionTravelCm*btScalar(0.01);
 		if (wheel.m_raycastInfo.m_suspensionLength < minSuspensionLength)
 		{
 			wheel.m_raycastInfo.m_suspensionLength = minSuspensionLength;
@@ -217,14 +217,14 @@ btScalar btRaycastVehicle::rayCast(btWheelInfo& wheel)
 
 		btScalar projVel = wheel.m_raycastInfo.m_contactNormalWS.dot( chassis_velocity_at_contactPoint );
 
-		if ( denominator >= -0.1f)
+		if ( denominator >= btScalar(-0.1))
 		{
-			wheel.m_suspensionRelativeVelocity = 0.0f;
-			wheel.m_clippedInvContactDotSuspension = 1.0f / 0.1f;
+			wheel.m_suspensionRelativeVelocity = btScalar(0.0);
+			wheel.m_clippedInvContactDotSuspension = btScalar(1.0) / btScalar(0.1);
 		}
 		else
 		{
-			btScalar inv = -1.f / denominator;
+			btScalar inv = btScalar(-1.) / denominator;
 			wheel.m_suspensionRelativeVelocity = projVel * inv;
 			wheel.m_clippedInvContactDotSuspension = inv;
 		}
@@ -233,9 +233,9 @@ btScalar btRaycastVehicle::rayCast(btWheelInfo& wheel)
 	{
 		//put wheel info as in rest position
 		wheel.m_raycastInfo.m_suspensionLength = wheel.getSuspensionRestLength();
-		wheel.m_suspensionRelativeVelocity = 0.0f;
+		wheel.m_suspensionRelativeVelocity = btScalar(0.0);
 		wheel.m_raycastInfo.m_contactNormalWS = - wheel.m_raycastInfo.m_wheelDirectionWS;
-		wheel.m_clippedInvContactDotSuspension = 1.0f;
+		wheel.m_clippedInvContactDotSuspension = btScalar(1.0);
 	}
 
 	return depth;
@@ -267,7 +267,7 @@ void btRaycastVehicle::updateVehicle( btScalar step )
 	}
 
 
-	m_currentVehicleSpeedKmHour = 3.6f * getRigidBody()->getLinearVelocity().length();
+	m_currentVehicleSpeedKmHour = btScalar(3.6) * getRigidBody()->getLinearVelocity().length();
 	
 	const btTransform& chassisTrans = getChassisWorldTransform();
 
@@ -276,9 +276,9 @@ void btRaycastVehicle::updateVehicle( btScalar step )
 		chassisTrans.getBasis()[1][m_indexForwardAxis],
 		chassisTrans.getBasis()[2][m_indexForwardAxis]);
 
-	if (forwardW.dot(getRigidBody()->getLinearVelocity()) < 0.f)
+	if (forwardW.dot(getRigidBody()->getLinearVelocity()) < btScalar(0.))
 	{
-		m_currentVehicleSpeedKmHour *= -1.f;
+		m_currentVehicleSpeedKmHour *= btScalar(-1.);
 	}
 
 	//
@@ -300,9 +300,9 @@ void btRaycastVehicle::updateVehicle( btScalar step )
 		//apply suspension force
 		btWheelInfo& wheel = m_wheelInfo[i];
 		
-		float suspensionForce = wheel.m_wheelsSuspensionForce;
+		btScalar suspensionForce = wheel.m_wheelsSuspensionForce;
 		
-		float gMaxSuspensionForce = 6000.f;
+		btScalar gMaxSuspensionForce = btScalar(6000.);
 		if (suspensionForce > gMaxSuspensionForce)
 		{
 			suspensionForce = gMaxSuspensionForce;
@@ -347,7 +347,7 @@ void btRaycastVehicle::updateVehicle( btScalar step )
 			wheel.m_rotation += wheel.m_deltaRotation;
 		}
 		
-		wheel.m_deltaRotation *= 0.99f;//damping of rotation when not in contact
+		wheel.m_deltaRotation *= btScalar(0.99);//damping of rotation when not in contact
 
 	}
 
@@ -394,7 +394,7 @@ btWheelInfo&	btRaycastVehicle::getWheelInfo(int index)
 	return m_wheelInfo[index];
 }
 
-void btRaycastVehicle::setBrake(float brake,int wheelIndex)
+void btRaycastVehicle::setBrake(btScalar brake,int wheelIndex)
 {
 	btAssert((wheelIndex >= 0) && (wheelIndex < 	getNumWheels()));
 	getWheelInfo(wheelIndex).m_brake;
@@ -404,7 +404,7 @@ void btRaycastVehicle::setBrake(float brake,int wheelIndex)
 void	btRaycastVehicle::updateSuspension(btScalar deltaTime)
 {
 
-	btScalar chassisMass = 1.f / m_chassisBody->getInvMass();
+	btScalar chassisMass = btScalar(1.) / m_chassisBody->getInvMass();
 	
 	for (int w_it=0; w_it<getNumWheels(); w_it++)
 	{
@@ -429,7 +429,7 @@ void	btRaycastVehicle::updateSuspension(btScalar deltaTime)
 				btScalar projected_rel_vel = wheel_info.m_suspensionRelativeVelocity;
 				{
 					btScalar	susp_damping;
-					if ( projected_rel_vel < 0.0f )
+					if ( projected_rel_vel < btScalar(0.0) )
 					{
 						susp_damping = wheel_info.m_wheelsDampingCompression;
 					}
@@ -443,20 +443,20 @@ void	btRaycastVehicle::updateSuspension(btScalar deltaTime)
 
 			// RESULT
 			wheel_info.m_wheelsSuspensionForce = force * chassisMass;
-			if (wheel_info.m_wheelsSuspensionForce < 0.f)
+			if (wheel_info.m_wheelsSuspensionForce < btScalar(0.))
 			{
-				wheel_info.m_wheelsSuspensionForce = 0.f;
+				wheel_info.m_wheelsSuspensionForce = btScalar(0.);
 			}
 		}
 		else
 		{
-			wheel_info.m_wheelsSuspensionForce = 0.0f;
+			wheel_info.m_wheelsSuspensionForce = btScalar(0.0);
 		}
 	}
 
 }
 
-float sideFrictionStiffness2 = 1.0f;
+btScalar sideFrictionStiffness2 = btScalar(1.0);
 void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 {
 
@@ -481,8 +481,8 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 			class btRigidBody* groundObject = (class btRigidBody*) wheelInfo.m_raycastInfo.m_groundObject;
 			if (groundObject)
 				numWheelsOnGround++;
-			sideImpulse[i] = 0.f;
-			forwardImpulse[i] = 0.f;
+			sideImpulse[i] = btScalar(0.);
+			forwardImpulse[i] = btScalar(0.);
 
 		}
 	
@@ -517,7 +517,7 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 				
 					resolveSingleBilateral(*m_chassisBody, wheelInfo.m_raycastInfo.m_contactPointWS,
 							  *groundObject, wheelInfo.m_raycastInfo.m_contactPointWS,
-							  0.f, axle[i],sideImpulse[i],timeStep);
+							  btScalar(0.), axle[i],sideImpulse[i],timeStep);
 
 					sideImpulse[i] *= sideFrictionStiffness2;
 						
@@ -527,7 +527,7 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 			}
 		}
 
-	btScalar sideFactor = 1.f;
+	btScalar sideFactor = btScalar(1.);
 	btScalar fwdFactor = 0.5;
 
 	bool sliding = false;
@@ -538,12 +538,12 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 			class btRigidBody* groundObject = (class btRigidBody*) wheelInfo.m_raycastInfo.m_groundObject;
 
 
-			forwardImpulse[wheel] = 0.f;
-			m_wheelInfo[wheel].m_skidInfo= 1.f;
+			forwardImpulse[wheel] = btScalar(0.);
+			m_wheelInfo[wheel].m_skidInfo= btScalar(1.);
 
 			if (groundObject)
 			{
-				m_wheelInfo[wheel].m_skidInfo= 1.f;
+				m_wheelInfo[wheel].m_skidInfo= btScalar(1.);
 				
 				btScalar maximp = wheelInfo.m_wheelsSuspensionForce * timeStep * wheelInfo.m_frictionSlip;
 				btScalar maximpSide = maximp;
@@ -552,10 +552,10 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 
 				forwardImpulse[wheel] = wheelInfo.m_engineForce* timeStep;
 
-				float x = (forwardImpulse[wheel] ) * fwdFactor;
-				float y = (sideImpulse[wheel] ) * sideFactor;
+				btScalar x = (forwardImpulse[wheel] ) * fwdFactor;
+				btScalar y = (sideImpulse[wheel] ) * sideFactor;
 				
-				float impulseSquared = (x*x + y*y);
+				btScalar impulseSquared = (x*x + y*y);
 
 				if (impulseSquared > maximpSquared)
 				{
@@ -577,9 +577,9 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 		{
 			for (int wheel = 0;wheel < getNumWheels(); wheel++)
 			{
-				if (sideImpulse[wheel] != 0.f)
+				if (sideImpulse[wheel] != btScalar(0.))
 				{
-					if (m_wheelInfo[wheel].m_skidInfo< 1.f)
+					if (m_wheelInfo[wheel].m_skidInfo< btScalar(1.))
 					{
 						forwardImpulse[wheel] *=	m_wheelInfo[wheel].m_skidInfo;
 						sideImpulse[wheel] *= m_wheelInfo[wheel].m_skidInfo;
@@ -597,11 +597,11 @@ void	btRaycastVehicle::updateFriction(btScalar	timeStep)
 				btVector3 rel_pos = wheelInfo.m_raycastInfo.m_contactPointWS - 
 						m_chassisBody->getCenterOfMassPosition();
 
-				if (forwardImpulse[wheel] != 0.f)
+				if (forwardImpulse[wheel] != btScalar(0.))
 				{
 					m_chassisBody->applyImpulse(forwardWS[wheel]*(forwardImpulse[wheel]),rel_pos);
 				}
-				if (sideImpulse[wheel] != 0.f)
+				if (sideImpulse[wheel] != btScalar(0.))
 				{
 					class btRigidBody* groundObject = (class btRigidBody*) m_wheelInfo[wheel].m_raycastInfo.m_groundObject;
 

src/BulletDynamics/Vehicle/btRaycastVehicle.h

@@ -29,18 +29,18 @@ public:
 			public:
 
 			btVehicleTuning()
-				:m_suspensionStiffness(5.88f),
-				m_suspensionCompression(0.83f),
-				m_suspensionDamping(0.88f),
-				m_maxSuspensionTravelCm(500.f),
-				m_frictionSlip(10.5f)
+				:m_suspensionStiffness(btScalar(5.88)),
+				m_suspensionCompression(btScalar(0.83)),
+				m_suspensionDamping(btScalar(0.88)),
+				m_maxSuspensionTravelCm(btScalar(500.)),
+				m_frictionSlip(btScalar(10.5))
 			{
 			}
-			float	m_suspensionStiffness;
-			float	m_suspensionCompression;
-			float	m_suspensionDamping;
-			float	m_maxSuspensionTravelCm;
-			float	m_frictionSlip;
+			btScalar	m_suspensionStiffness;
+			btScalar	m_suspensionCompression;
+			btScalar	m_suspensionDamping;
+			btScalar	m_maxSuspensionTravelCm;
+			btScalar	m_frictionSlip;
 
 		};
 private:
@@ -48,9 +48,9 @@ private:
 	btScalar	m_tau;
 	btScalar	m_damping;
 	btVehicleRaycaster*	m_vehicleRaycaster;
-	float		m_pitchControl;
-	float	m_steeringValue; 
-	float m_currentVehicleSpeedKmHour;
+	btScalar		m_pitchControl;
+	btScalar	m_steeringValue; 
+	btScalar m_currentVehicleSpeedKmHour;
 
 	btRigidBody* m_chassisBody;
 
@@ -105,9 +105,9 @@ public:
 	void	updateWheelTransformsWS(btWheelInfo& wheel , bool interpolatedTransform = true);
 
 	
-	void setBrake(float brake,int wheelIndex);
+	void setBrake(btScalar brake,int wheelIndex);
 
-	void	setPitchControl(float pitch)
+	void	setPitchControl(btScalar pitch)
 	{
 		m_pitchControl = pitch;
 	}