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

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