From df9230327cbac30c05132c128fa9df47d5c9cd57 Mon Sep 17 00:00:00 2001 From: ejcoumans Date: Sat, 16 Dec 2006 05:51:30 +0000 Subject: [PATCH] Contribution to add optional double precision floating point support. Define BT_USE_DOUBLE_PRECISION for all involved libraries/apps. --- Demos/BasicDemo/BasicDemo.cpp | 20 ++-- Demos/BspDemo/BspConverter.cpp | 13 ++- Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp | 2 +- Demos/CollisionDemo/CollisionDemo.cpp | 2 +- .../CollisionInterfaceDemo.cpp | 2 +- Demos/ConcaveDemo/ConcavePhysicsDemo.cpp | 2 +- .../ContinuousConvexCollisionDemo.cpp | 2 +- .../EPAPenDepthDemo/PenetrationTestBullet.cpp | 21 +++- .../LinearConvexCastDemo.cpp | 2 +- .../MovingConcaveDemo/ConcavePhysicsDemo.cpp | 4 +- Demos/OpenGL/DebugCastResult.h | 25 +++-- Demos/OpenGL/DemoApplication.cpp | 2 +- Demos/OpenGL/GLDebugDrawer.cpp | 2 +- Demos/OpenGL/GLDebugDrawer.h | 2 +- Demos/OpenGL/GL_ShapeDrawer.cpp | 23 ++-- Demos/OpenGL/GL_ShapeDrawer.h | 2 +- Demos/OpenGL/GL_Simplex1to4.cpp | 9 +- Demos/OpenGL/GL_Simplex1to4.h | 2 +- Demos/OpenGL/GlutStuff.h | 12 ++ Demos/SimplexDemo/SimplexDemo.cpp | 2 +- Demos/VehicleDemo/VehicleDemo.cpp | 4 +- .../BoxBoxCollisionAlgorithm.cpp | 2 +- .../BoxBoxCollisionAlgorithm.h | 2 +- .../btConcaveConcaveCollisionAlgorithm.cpp | 2 +- .../btConcaveConcaveCollisionAlgorithm.h | 2 +- Extras/quickstep/OdeConstraintSolver.cpp | 2 +- Extras/quickstep/OdeConstraintSolver.h | 2 +- .../BroadphaseCollision/btAxisSweep3.cpp | 2 +- .../btCollisionAlgorithm.h | 4 +- .../BroadphaseCollision/btDispatcher.h | 10 +- .../SphereTriangleDetector.cpp | 47 ++++---- .../SphereTriangleDetector.h | 2 +- .../btCollisionDispatcher.cpp | 4 +- .../CollisionDispatch/btCollisionObject.cpp | 10 +- .../CollisionDispatch/btCollisionObject.h | 32 +++--- .../CollisionDispatch/btCollisionWorld.cpp | 10 +- .../CollisionDispatch/btCollisionWorld.h | 14 +-- .../btCompoundCollisionAlgorithm.cpp | 6 +- .../btCompoundCollisionAlgorithm.h | 2 +- .../btConvexConcaveCollisionAlgorithm.cpp | 26 ++--- .../btConvexConcaveCollisionAlgorithm.h | 6 +- .../btConvexConvexAlgorithm.cpp | 12 +- .../btConvexConvexAlgorithm.h | 2 +- .../btEmptyCollisionAlgorithm.cpp | 4 +- .../btEmptyCollisionAlgorithm.h | 2 +- .../CollisionDispatch/btManifoldResult.cpp | 4 +- .../CollisionDispatch/btManifoldResult.h | 2 +- .../btSimulationIslandManager.cpp | 6 +- .../btSphereBoxCollisionAlgorithm.cpp | 48 ++++---- .../btSphereBoxCollisionAlgorithm.h | 2 +- .../btSphereSphereCollisionAlgorithm.cpp | 6 +- .../btSphereSphereCollisionAlgorithm.h | 2 +- .../btSphereTriangleCollisionAlgorithm.cpp | 6 +- .../btSphereTriangleCollisionAlgorithm.h | 2 +- .../CollisionShapes/btBoxShape.cpp | 14 +-- .../CollisionShapes/btBoxShape.h | 42 +++---- .../btBvhTriangleMeshShape.cpp | 2 +- .../CollisionShapes/btCollisionMargin.h | 2 +- .../CollisionShapes/btCollisionShape.cpp | 26 ++--- .../CollisionShapes/btCollisionShape.h | 6 +- .../CollisionShapes/btCompoundShape.cpp | 26 ++--- .../CollisionShapes/btCompoundShape.h | 4 +- .../CollisionShapes/btConcaveShape.cpp | 2 +- .../CollisionShapes/btConcaveShape.h | 6 +- .../CollisionShapes/btConeShape.cpp | 16 +-- .../CollisionShapes/btConeShape.h | 22 ++-- .../CollisionShapes/btConvexHullShape.cpp | 16 +-- .../CollisionShapes/btConvexHullShape.h | 4 +- .../CollisionShapes/btConvexShape.cpp | 12 +- .../CollisionShapes/btConvexShape.h | 4 +- .../btConvexTriangleMeshShape.cpp | 20 ++-- .../CollisionShapes/btCylinderShape.cpp | 12 +- .../CollisionShapes/btCylinderShape.h | 10 +- .../btHeightfieldTerrainShape.cpp | 12 +- .../CollisionShapes/btMinkowskiSumShape.cpp | 2 +- .../CollisionShapes/btMinkowskiSumShape.h | 2 +- .../CollisionShapes/btMultiSphereShape.cpp | 22 ++-- .../CollisionShapes/btOptimizedBvh.cpp | 34 +++--- .../btPolyhedralConvexShape.cpp | 20 ++-- .../CollisionShapes/btSphereShape.cpp | 8 +- .../CollisionShapes/btSphereShape.h | 4 +- .../CollisionShapes/btStaticPlaneShape.cpp | 14 +-- .../btStridingMeshInterface.cpp | 14 +-- .../CollisionShapes/btStridingMeshInterface.h | 2 +- .../btTriangleIndexVertexArray.cpp | 2 +- .../btTriangleIndexVertexArray.h | 4 +- .../CollisionShapes/btTriangleMeshShape.cpp | 16 +-- .../CollisionShapes/btTriangleShape.h | 4 +- .../btContinuousConvexCollision.cpp | 36 +++--- .../NarrowPhaseCollision/btConvexCast.h | 2 +- .../btDiscreteCollisionDetectorInterface.h | 8 +- .../NarrowPhaseCollision/btGjkConvexCast.cpp | 16 +-- .../btGjkEpaPenetrationDepthSolver.cpp | 2 +- .../btGjkPairDetector.cpp | 36 +++--- .../NarrowPhaseCollision/btManifoldPoint.h | 14 +-- .../btMinkowskiPenetrationDepthSolver.cpp | 104 +++++++++--------- .../btPersistentManifold.cpp | 8 +- .../btPersistentManifold.h | 4 +- .../NarrowPhaseCollision/btPointCollector.h | 4 +- .../btRaycastCallback.cpp | 24 ++-- .../NarrowPhaseCollision/btRaycastCallback.h | 4 +- .../btSubSimplexConvexCast.cpp | 20 ++-- .../btVoronoiSimplexSolver.cpp | 82 +++++++------- .../btVoronoiSimplexSolver.h | 12 +- .../ConstraintSolver/btConstraintSolver.h | 4 +- .../ConstraintSolver/btContactConstraint.cpp | 76 ++++++------- .../ConstraintSolver/btContactConstraint.h | 44 ++++---- .../ConstraintSolver/btContactSolverInfo.h | 30 ++--- .../btGeneric6DofConstraint.cpp | 62 +++++------ .../ConstraintSolver/btHingeConstraint.cpp | 32 +++--- .../ConstraintSolver/btJacobianEntry.h | 14 +-- .../btPoint2PointConstraint.cpp | 4 +- .../btPoint2PointConstraint.h | 8 +- .../btSequentialImpulseConstraintSolver.cpp | 54 ++++----- .../btSequentialImpulseConstraintSolver.h | 8 +- .../btSolve2LinearConstraint.cpp | 42 +++---- .../ConstraintSolver/btTypedConstraint.cpp | 12 +- .../ConstraintSolver/btTypedConstraint.h | 4 +- .../Dynamics/btDiscreteDynamicsWorld.cpp | 76 ++++++------- .../Dynamics/btDiscreteDynamicsWorld.h | 18 +-- src/BulletDynamics/Dynamics/btDynamicsWorld.h | 2 +- src/BulletDynamics/Dynamics/btRigidBody.cpp | 88 +++++++-------- src/BulletDynamics/Dynamics/btRigidBody.h | 36 +++--- .../Dynamics/btSimpleDynamicsWorld.cpp | 6 +- .../Dynamics/btSimpleDynamicsWorld.h | 6 +- .../Vehicle/btRaycastVehicle.cpp | 86 +++++++-------- src/BulletDynamics/Vehicle/btRaycastVehicle.h | 30 ++--- .../Vehicle/btVehicleRaycaster.h | 2 +- src/BulletDynamics/Vehicle/btWheelInfo.cpp | 12 +- src/BulletDynamics/Vehicle/btWheelInfo.h | 20 ++-- src/LinearMath/btAabbUtil2.h | 6 +- src/LinearMath/btGeometryUtil.cpp | 36 +++--- src/LinearMath/btGeometryUtil.h | 6 +- src/LinearMath/btIDebugDraw.h | 2 +- src/LinearMath/btMatrix3x3.h | 4 +- src/LinearMath/btQuadWord.h | 10 +- src/LinearMath/btQuaternion.h | 2 +- src/LinearMath/btScalar.h | 33 ++++-- src/LinearMath/btTransform.h | 2 +- src/LinearMath/btTransformUtil.h | 24 ++-- src/LinearMath/btVector3.h | 10 +- 141 files changed, 1091 insertions(+), 1042 deletions(-) diff --git a/Demos/BasicDemo/BasicDemo.cpp b/Demos/BasicDemo/BasicDemo.cpp index 393797da8..cbf7a8f51 100644 --- a/Demos/BasicDemo/BasicDemo.cpp +++ b/Demos/BasicDemo/BasicDemo.cpp @@ -19,13 +19,13 @@ subject to the following restrictions: //#define CHECK_MEMORY_LEAKS 1 int gNumObjects = 120; -#define HALF_EXTENTS 1.f +#define HALF_EXTENTS btScalar(1.) #include "btBulletDynamicsCommon.h" #include "LinearMath/btIDebugDraw.h" #include "GLDebugDrawer.h" #include //printf debugging -float deltaTime = 1.f/60.f; -float gCollisionMargin = 0.05f; +btScalar deltaTime = btScalar(1./60.); +btScalar gCollisionMargin = btScalar(0.05); #include "BasicDemo.h" #include "GL_ShapeDrawer.h" #include "GlutStuff.h" @@ -58,7 +58,7 @@ int main(int argc,char** argv) BasicDemo ccdDemo; ccdDemo.initPhysics(); - ccdDemo.setCameraDistance(50.f); + ccdDemo.setCameraDistance(btScalar(50.)); #ifdef CHECK_MEMORY_LEAKS ccdDemo.exitPhysics(); @@ -161,9 +161,9 @@ void BasicDemo::initPhysics() //static ground #ifdef USE_GROUND_BOX - btCollisionShape* groundShape = new btBoxShape(btVector3(50.f,50.f,50.f)); + btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.))); #else - btCollisionShape* groundShape = new btSphereShape(50.f); + btCollisionShape* groundShape = new btSphereShape(btScalar(50.)); #endif//USE_GROUND_BOX m_collisionShapes.push_back(groundShape); @@ -171,10 +171,10 @@ void BasicDemo::initPhysics() btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-50,0)); - localCreateRigidBody(0.f,groundTransform,groundShape); + localCreateRigidBody(btScalar(0.),groundTransform,groundShape); //create a few dynamic sphere rigidbodies (re-using the same sphere shape) - btCollisionShape* sphereShape = new btSphereShape(1.f); + btCollisionShape* sphereShape = new btSphereShape(btScalar(1.)); m_collisionShapes.push_back(sphereShape); int i; @@ -193,8 +193,8 @@ void BasicDemo::initPhysics() row*2*HALF_EXTENTS+HALF_EXTENTS,0); trans.setOrigin(pos); - //btRigidBody* body = localCreateRigidBody(1.f,trans,sphereShape); - localCreateRigidBody(1.f,trans,sphereShape); + //btRigidBody* body = localCreateRigidBody(btScalar(1.),trans,sphereShape); + localCreateRigidBody(btScalar(1.),trans,sphereShape); } clientResetScene(); diff --git a/Demos/BspDemo/BspConverter.cpp b/Demos/BspDemo/BspConverter.cpp index 6cb6255a0..9b4d94137 100644 --- a/Demos/BspDemo/BspConverter.cpp +++ b/Demos/BspDemo/BspConverter.cpp @@ -21,20 +21,24 @@ subject to the following restrictions: void BspConverter::convertBsp(BspLoader& bspLoader,float scaling) { { - btVector3 playerStart (0.f, 0.f, 100.f); + + float playstartf[3] = {0,0,100}; - if (bspLoader.findVectorByName(&playerStart[0],"info_player_start")) + if (bspLoader.findVectorByName(&playstartf[0],"info_player_start")) { printf("found playerstart\n"); } else { - if (bspLoader.findVectorByName(&playerStart[0],"info_player_deathmatch")) + if (bspLoader.findVectorByName(&playstartf[0],"info_player_deathmatch")) { printf("found deatchmatch start\n"); } } + btVector3 playerStart (playstartf[0],playstartf[1],playstartf[2]); + + playerStart[2] += 20.f; //start a bit higher playerStart *= scaling; @@ -113,6 +117,7 @@ void BspConverter::convertBsp(BspLoader& bspLoader,float scaling) if ( strcmp( cl, "" ) ) { //its not empty so ... + /* //lookup the target position for the jumppad: const BSPEntity* targetentity = bspLoader.getEntityByValue( "targetname" , cl ); if (targetentity) @@ -122,6 +127,8 @@ void BspConverter::convertBsp(BspLoader& bspLoader,float scaling) } } + */ + cl = bspLoader.getValueForKey(&entity,"model"); if ( strcmp( cl, "" ) ) { diff --git a/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp b/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp index e5af3e90a..dfdb39e6a 100644 --- a/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp +++ b/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp @@ -153,7 +153,7 @@ void customNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& GLDebugDrawer debugDrawer; //experimental jitter damping (1 = no damping, 0 = total damping once motion below threshold) -extern float gJitterVelocityDampingFactor; +extern btScalar gJitterVelocityDampingFactor; int main(int argc,char** argv) { diff --git a/Demos/CollisionDemo/CollisionDemo.cpp b/Demos/CollisionDemo/CollisionDemo.cpp index 0b7fb238b..050a61a4e 100644 --- a/Demos/CollisionDemo/CollisionDemo.cpp +++ b/Demos/CollisionDemo/CollisionDemo.cpp @@ -217,7 +217,7 @@ void CollisionDemo::displayCallback(void) { //GL_ShapeDrawer::drawCoordSystem(); - float m[16]; + btScalar m[16]; int i; // btGjkPairDetector convexConvex(shapePtr[0],shapePtr[1],&sGjkSimplexSolver,0); diff --git a/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp b/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp index 2c0d317e5..97b0d493e 100644 --- a/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp +++ b/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp @@ -156,7 +156,7 @@ void CollisionInterfaceDemo::displayCallback(void) { //GL_ShapeDrawer::drawCoordSystem(); - float m[16]; + btScalar m[16]; diff --git a/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp b/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp index f9fec487e..26b17e39c 100644 --- a/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp +++ b/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp @@ -147,7 +147,7 @@ void ConcaveDemo::initPhysics() btTriangleIndexVertexArray* indexVertexArrays = new btTriangleIndexVertexArray(totalTriangles, gIndices, indexStride, - totalVerts,(float*) &gVertices[0].x(),vertStride); + totalVerts,(btScalar*) &gVertices[0].x(),vertStride); btCollisionShape* trimeshShape = new btBvhTriangleMeshShape(indexVertexArrays); diff --git a/Demos/ContinuousConvexCollision/ContinuousConvexCollisionDemo.cpp b/Demos/ContinuousConvexCollision/ContinuousConvexCollisionDemo.cpp index 441ab491c..b6af8c93f 100644 --- a/Demos/ContinuousConvexCollision/ContinuousConvexCollisionDemo.cpp +++ b/Demos/ContinuousConvexCollision/ContinuousConvexCollisionDemo.cpp @@ -146,7 +146,7 @@ void btContinuousConvexCollisionDemo::displayCallback(void) { //GL_ShapeDrawer::drawCoordSystem(); - float m[16]; + btScalar m[16]; int i; /*for (i=0;i #endif @@ -48,20 +49,20 @@ struct btDebugCastResult : public btConvexCast::CastResult virtual void drawCoordSystem(const btTransform& tr) { - float m[16]; + btScalar m[16]; tr.getOpenGLMatrix(m); glPushMatrix(); - glLoadMatrixf(m); + btglLoadMatrix(m); glBegin(GL_LINES); - glColor3f(1, 0, 0); - glVertex3d(0, 0, 0); - glVertex3d(1, 0, 0); - glColor3f(0, 1, 0); - glVertex3d(0, 0, 0); - glVertex3d(0, 1, 0); - glColor3f(0, 0, 1); - glVertex3d(0, 0, 0); - glVertex3d(0, 0, 1); + btglColor3(1, 0, 0); + btglVertex3(0, 0, 0); + btglVertex3(1, 0, 0); + btglColor3(0, 1, 0); + btglVertex3(0, 0, 0); + btglVertex3(0, 1, 0); + btglColor3(0, 0, 1); + btglVertex3(0, 0, 0); + btglVertex3(0, 0, 1); glEnd(); glPopMatrix(); } @@ -69,7 +70,7 @@ struct btDebugCastResult : public btConvexCast::CastResult virtual void DebugDraw(btScalar fraction) { - float m[16]; + btScalar m[16]; btTransform hitTrans; btTransformUtil::integrateTransform(m_fromTrans,m_linVel,m_angVel,fraction,hitTrans); hitTrans.getOpenGLMatrix(m); diff --git a/Demos/OpenGL/DemoApplication.cpp b/Demos/OpenGL/DemoApplication.cpp index 1010ce7dd..15344b41f 100644 --- a/Demos/OpenGL/DemoApplication.cpp +++ b/Demos/OpenGL/DemoApplication.cpp @@ -708,7 +708,7 @@ void DemoApplication::renderme() { updateCamera(); - float m[16]; + btScalar m[16]; if (m_dynamicsWorld) { diff --git a/Demos/OpenGL/GLDebugDrawer.cpp b/Demos/OpenGL/GLDebugDrawer.cpp index 0945dfe68..1994fbaea 100644 --- a/Demos/OpenGL/GLDebugDrawer.cpp +++ b/Demos/OpenGL/GLDebugDrawer.cpp @@ -40,7 +40,7 @@ void GLDebugDrawer::setDebugMode(int debugMode) } -void GLDebugDrawer::drawContactPoint(const btVector3& pointOnB,const btVector3& normalOnB,float distance,int lifeTime,const btVector3& color) +void GLDebugDrawer::drawContactPoint(const btVector3& pointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color) { if (m_debugMode & btIDebugDraw::DBG_DrawContactPoints) { diff --git a/Demos/OpenGL/GLDebugDrawer.h b/Demos/OpenGL/GLDebugDrawer.h index 9bb49b200..96451cc1f 100644 --- a/Demos/OpenGL/GLDebugDrawer.h +++ b/Demos/OpenGL/GLDebugDrawer.h @@ -17,7 +17,7 @@ public: virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& color); - virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,float distance,int lifeTime,const btVector3& color); + virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color); virtual void setDebugMode(int debugMode); diff --git a/Demos/OpenGL/GL_ShapeDrawer.cpp b/Demos/OpenGL/GL_ShapeDrawer.cpp index e4892744e..7003e9c1b 100644 --- a/Demos/OpenGL/GL_ShapeDrawer.cpp +++ b/Demos/OpenGL/GL_ShapeDrawer.cpp @@ -26,6 +26,7 @@ subject to the following restrictions: #include #endif +#include "GlutStuff.h" #include "GL_ShapeDrawer.h" #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" #include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" @@ -145,8 +146,8 @@ void OGL_displaylist_clean() void OGL_displaylist_register_shape(btCollisionShape * shape) { - 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)); GlDisplaylistDrawcallback drawCallback; TRIMESH_KEY dlist; @@ -257,12 +258,12 @@ public: }; -void GL_ShapeDrawer::drawOpenGL(float* m, const btCollisionShape* shape, const btVector3& color,int debugMode) +void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, const btVector3& color,int debugMode) { glPushMatrix(); - glMultMatrixf(m); + btglMultMatrix(m); if (shape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE) { @@ -271,7 +272,7 @@ void GL_ShapeDrawer::drawOpenGL(float* m, const btCollisionShape* shape, const b { btTransform childTrans = compoundShape->getChildTransform(i); const btCollisionShape* colShape = compoundShape->getChildShape(i); - float childMat[16]; + btScalar childMat[16]; childTrans.getOpenGLMatrix(childMat); drawOpenGL(childMat,colShape,color,debugMode); } @@ -471,12 +472,12 @@ void GL_ShapeDrawer::drawOpenGL(float* m, const btCollisionShape* shape, const b // if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) { btConcaveShape* 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)); GlDrawcallback drawCallback; drawCallback.m_wireframe = (debugMode & btIDebugDraw::DBG_DrawWireframe)!=0; @@ -496,8 +497,8 @@ void GL_ShapeDrawer::drawOpenGL(float* m, const btCollisionShape* shape, const b 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)); TriangleGlDrawcallback drawCallback; convexMesh->getStridingMesh()->InternalProcessAllTriangles(&drawCallback,aabbMin,aabbMax); diff --git a/Demos/OpenGL/GL_ShapeDrawer.h b/Demos/OpenGL/GL_ShapeDrawer.h index 57e495b68..f6dc09e74 100644 --- a/Demos/OpenGL/GL_ShapeDrawer.h +++ b/Demos/OpenGL/GL_ShapeDrawer.h @@ -23,7 +23,7 @@ class GL_ShapeDrawer { public: - static void drawOpenGL(float* m, const btCollisionShape* shape, const btVector3& color,int debugMode); + static void drawOpenGL(btScalar* m, const btCollisionShape* shape, const btVector3& color,int debugMode); static void drawCoordSystem(); }; diff --git a/Demos/OpenGL/GL_Simplex1to4.cpp b/Demos/OpenGL/GL_Simplex1to4.cpp index ece211b25..5adf2e485 100644 --- a/Demos/OpenGL/GL_Simplex1to4.cpp +++ b/Demos/OpenGL/GL_Simplex1to4.cpp @@ -26,6 +26,7 @@ subject to the following restrictions: #else #include #endif +#include "GlutStuff.h" #include "LinearMath/btTransform.h" GL_Simplex1to4::GL_Simplex1to4() @@ -36,7 +37,7 @@ GL_Simplex1to4::GL_Simplex1to4() /// /// Debugging method calcClosest calculates the closest point to the origin, using m_simplexSolver /// -void GL_Simplex1to4::calcClosest(float* m) +void GL_Simplex1to4::calcClosest(btScalar* m) { btTransform tr; tr.setFromOpenGLMatrix(m); @@ -62,9 +63,9 @@ void GL_Simplex1to4::calcClosest(float* m) //draw v? glDisable(GL_LIGHTING); glBegin(GL_LINES); - glColor3f(1.f, 0.f, 0.f); - glVertex3f(0.f, 0.f, 0.f); - glVertex3f(v.x(),v.y(),v.z()); + btglColor3(1.f, 0.f, 0.f); + btglVertex3(0.f, 0.f, 0.f); + btglVertex3(v.x(),v.y(),v.z()); glEnd(); glEnable(GL_LIGHTING); diff --git a/Demos/OpenGL/GL_Simplex1to4.h b/Demos/OpenGL/GL_Simplex1to4.h index 286e17c20..c75e3573b 100644 --- a/Demos/OpenGL/GL_Simplex1to4.h +++ b/Demos/OpenGL/GL_Simplex1to4.h @@ -29,7 +29,7 @@ class GL_Simplex1to4 : public btBU_Simplex1to4 GL_Simplex1to4(); - void calcClosest(float* m); + void calcClosest(btScalar* m); void setSimplexSolver(btSimplexSolverInterface* simplexSolver) { m_simplexSolver = simplexSolver; diff --git a/Demos/OpenGL/GlutStuff.h b/Demos/OpenGL/GlutStuff.h index 03f5fc488..1ee2ba7d1 100644 --- a/Demos/OpenGL/GlutStuff.h +++ b/Demos/OpenGL/GlutStuff.h @@ -19,4 +19,16 @@ class DemoApplication; int glutmain(int argc, char **argv,int width,int height,const char* title,DemoApplication* demoApp); +#if defined(BT_USE_DOUBLE_PRECISION) +#define btglLoadMatrix glLoadMatrixd +#define btglMultMatrix glMultMatrixd +#define btglColor3 glColor3d +#define btglVertex3 glVertex3d +#else +#define btglLoadMatrix glLoadMatrixf +#define btglMultMatrix glMultMatrixf +#define btglColor3 glColor3f +#define btglVertex3 glVertex3d +#endif + #endif //GLUT_STUFF_H diff --git a/Demos/SimplexDemo/SimplexDemo.cpp b/Demos/SimplexDemo/SimplexDemo.cpp index f5d7c49b4..2551eb6d5 100644 --- a/Demos/SimplexDemo/SimplexDemo.cpp +++ b/Demos/SimplexDemo/SimplexDemo.cpp @@ -73,7 +73,7 @@ void SimplexDemo::displayCallback() GL_ShapeDrawer::drawCoordSystem(); - float m[16]; + btScalar m[16]; int i; for (i=0;i 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 ); diff --git a/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h b/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h index abd189f94..db1378999 100644 --- a/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h +++ b/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); diff --git a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp b/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp index c78ed408e..d1e5a447c 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp +++ b/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, } } -} \ No newline at end of file +} diff --git a/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp b/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp index 13fa0b5ba..7b6f06627 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp +++ b/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.); } } diff --git a/src/BulletCollision/CollisionDispatch/btCollisionObject.h b/src/BulletCollision/CollisionDispatch/btCollisionObject.h index 9a0129ac2..c68a01be7 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionObject.h +++ b/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; } diff --git a/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp b/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp index fa1561973..b1b1a8b61 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp +++ b/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)) { diff --git a/src/BulletCollision/CollisionDispatch/btCollisionWorld.h b/src/BulletCollision/CollisionDispatch/btCollisionWorld.h index bd09d8c4d..700d5d803 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.h +++ b/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 diff --git a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp index 43887d26a..2f96c2e13 100644 --- a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp +++ b/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 (fracm_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(m_convexBody->getCollisionShape()); //CollisionShape* triangleShape = static_cast(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.); } diff --git a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h b/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h index afcb38c94..8df1b0f48 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h +++ b/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(); diff --git a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp index 31023b9d9..27a85bae2 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp +++ b/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 diff --git a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h index ccfe6d5b8..d27ef1a1b 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h +++ b/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); diff --git a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp index 9bc106564..7849e5c84 100644 --- a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp +++ b/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.); } diff --git a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h b/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h index e0e136250..f537a024d 100644 --- a/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h +++ b/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 { diff --git a/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp b/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp index cd22f3dd9..975101d3b 100644 --- a/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp +++ b/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 diff --git a/src/BulletCollision/CollisionDispatch/btManifoldResult.h b/src/BulletCollision/CollisionDispatch/btManifoldResult.h index 3d70689e3..3beda95a9 100644 --- a/src/BulletCollision/CollisionDispatch/btManifoldResult.h +++ b/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); diff --git a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp index 31bb54774..2233b34a9 100644 --- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp +++ b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp @@ -33,7 +33,7 @@ void btSimulationIslandManager::findUnions(btDispatcher* dispatcher) for (int i=0;igetNumManifolds();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(manifold->getBody0()); const btCollisionObject* colObj1 = static_cast(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 diff --git a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp index 03622cf7a..364373bf3 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp +++ b/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]; diff --git a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h b/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h index ec0ae7a23..83cf52c43 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h +++ b/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 ); diff --git a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp index 799ce7a44..0f911a6ef 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp +++ b/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.); } diff --git a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h b/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h index 425c6739e..488a159f3 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h +++ b/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(); diff --git a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp index 0c3474b59..1439c1614 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp +++ b/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.); } diff --git a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h b/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h index 73254096c..26d9f4d9b 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h +++ b/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(); diff --git a/src/BulletCollision/CollisionShapes/btBoxShape.cpp b/src/BulletCollision/CollisionShapes/btBoxShape.cpp index b5f80de45..0c464e46b 100644 --- a/src/BulletCollision/CollisionShapes/btBoxShape.cpp +++ b/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); } diff --git a/src/BulletCollision/CollisionShapes/btBoxShape.h b/src/BulletCollision/CollisionShapes/btBoxShape.h index ee451a9b6..6398ecfad 100644 --- a/src/BulletCollision/CollisionShapes/btBoxShape.h +++ b/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 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(); diff --git a/src/BulletCollision/CollisionShapes/btCollisionShape.h b/src/BulletCollision/CollisionShapes/btCollisionShape.h index 7b2a00a1c..ba9ba6121 100644 --- a/src/BulletCollision/CollisionShapes/btCollisionShape.h +++ b/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; }; diff --git a/src/BulletCollision/CollisionShapes/btCompoundShape.cpp b/src/BulletCollision/CollisionShapes/btCompoundShape.cpp index 88ae8c7df..a4712b3e9 100644 --- a/src/BulletCollision/CollisionShapes/btCompoundShape.cpp +++ b/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); } diff --git a/src/BulletCollision/CollisionShapes/btCompoundShape.h b/src/BulletCollision/CollisionShapes/btCompoundShape.h index 84188bc8b..85687f615 100644 --- a/src/BulletCollision/CollisionShapes/btCompoundShape.h +++ b/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; } diff --git a/src/BulletCollision/CollisionShapes/btConcaveShape.cpp b/src/BulletCollision/CollisionShapes/btConcaveShape.cpp index 7cd35a918..5103500a0 100644 --- a/src/BulletCollision/CollisionShapes/btConcaveShape.cpp +++ b/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.)) { } diff --git a/src/BulletCollision/CollisionShapes/btConcaveShape.h b/src/BulletCollision/CollisionShapes/btConcaveShape.h index 2bbba88bc..17c4353d2 100644 --- a/src/BulletCollision/CollisionShapes/btConcaveShape.h +++ b/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; } diff --git a/src/BulletCollision/CollisionShapes/btConeShape.cpp b/src/BulletCollision/CollisionShapes/btConeShape.cpp index 46232b318..207b3024b 100644 --- a/src/BulletCollision/CollisionShapes/btConeShape.cpp +++ b/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; diff --git a/src/BulletCollision/CollisionShapes/btConeShape.h b/src/BulletCollision/CollisionShapes/btConeShape.h index 52d925fe7..dba17d495 100644 --- a/src/BulletCollision/CollisionShapes/btConeShape.h +++ b/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)); diff --git a/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp b/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp index 5af6e5f03..97cd6f3bf 100644 --- a/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp +++ b/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 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) { diff --git a/src/BulletCollision/CollisionShapes/btConvexShape.cpp b/src/BulletCollision/CollisionShapes/btConvexShape.cpp index 9537235ff..d89f9869a 100644 --- a/src/BulletCollision/CollisionShapes/btConvexShape.cpp +++ b/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; diff --git a/src/BulletCollision/CollisionShapes/btConvexShape.h b/src/BulletCollision/CollisionShapes/btConvexShape.h index 0de334b35..d9f211cd2 100644 --- a/src/BulletCollision/CollisionShapes/btConvexShape.h +++ b/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; } diff --git a/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp b/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp index d54410bed..b6b68b1db 100644 --- a/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp +++ b/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;iInternalProcessAllTriangles(&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; diff --git a/src/BulletCollision/CollisionShapes/btCylinderShape.cpp b/src/BulletCollision/CollisionShapes/btCylinderShape.cpp index 16b263474..2e8af6820 100644 --- a/src/BulletCollision/CollisionShapes/btCylinderShape.cpp +++ b/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; diff --git a/src/BulletCollision/CollisionShapes/btCylinderShape.h b/src/BulletCollision/CollisionShapes/btCylinderShape.h index bb0e4298a..01837d191 100644 --- a/src/BulletCollision/CollisionShapes/btCylinderShape.h +++ b/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(); } diff --git a/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp b/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp index 6462ad55a..877d547ae 100644 --- a/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp +++ b/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) diff --git a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp b/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp index 4bf8c478a..cb5a42cd5 100644 --- a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp +++ b/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(); } diff --git a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h b/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h index e974f57a4..51472f7df 100644 --- a/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h +++ b/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;} diff --git a/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp b/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp index fde4d95da..6015a6180 100644 --- a/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp +++ b/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;iInternalProcessAllTriangles(&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 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;iinternalProcessTriangleIndex(triangle,part,gfxindex); } @@ -65,11 +65,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde for (gfxindex=0;gfxindexinternalProcessTriangleIndex(triangle,part,gfxindex); } diff --git a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h index 830cbb282..e0c9a7c21 100644 --- a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h +++ b/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.)) { } diff --git a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp b/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp index 7400d372b..2a5b2bece 100644 --- a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp +++ b/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; diff --git a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h b/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h index 3ec827c03..e90302040 100644 --- a/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h +++ b/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) { diff --git a/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp b/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp index cd2bf7261..39e798a7b 100644 --- a/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp +++ b/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); diff --git a/src/BulletCollision/CollisionShapes/btTriangleShape.h b/src/BulletCollision/CollisionShapes/btTriangleShape.h index 3284a599e..6663b126c 100644 --- a/src/BulletCollision/CollisionShapes/btTriangleShape.h +++ b/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.); } diff --git a/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp b/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp index ae3ce42e7..2c565734e 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp +++ b/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.)) { } } diff --git a/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h b/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h index 4258d829c..f6b327398 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h +++ b/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) { } diff --git a/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h b/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h index e9db97d1b..07d6911a7 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h +++ b/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) { diff --git a/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp b/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp index bf465b618..93edffeaf 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp +++ b/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; diff --git a/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp b/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp index bc932dd55..f9a4b5410 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp +++ b/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, diff --git a/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp b/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp index 0ce04dcfa..c6e7dadc1 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp +++ b/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)) { diff --git a/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h b/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h index 48c5545ca..c7163ba53 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h +++ b/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; } diff --git a/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp b/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp index de6749a9b..3750afde0 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp +++ b/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) diff --git a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp b/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp index ee2be1630..08cb3ed33 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp +++ b/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp @@ -18,7 +18,7 @@ subject to the following restrictions: #include "LinearMath/btTransform.h" #include -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; } diff --git a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h b/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h index c2372b648..503e149e4 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h +++ b/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; diff --git a/src/BulletCollision/NarrowPhaseCollision/btPointCollector.h b/src/BulletCollision/NarrowPhaseCollision/btPointCollector.h index a51e2d5e1..e14bc450a 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btPointCollector.h +++ b/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) { diff --git a/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp b/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp index 88ee00579..31b914677 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp +++ b/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 ) diff --git a/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h b/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h index fbb51d305..87490a345 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h +++ b/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; }; diff --git a/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp b/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp index dc995ca1f..477601936 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp +++ b/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.); } } diff --git a/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp b/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp index 23d66a3bb..ff502512a 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp +++ b/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= 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; diff --git a/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h b/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h index 8b7439969..356d335bc 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h +++ b/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; diff --git a/src/BulletDynamics/ConstraintSolver/btConstraintSolver.h b/src/BulletDynamics/ConstraintSolver/btConstraintSolver.h index ce90f798c..7217eca42 100644 --- a/src/BulletDynamics/ConstraintSolver/btConstraintSolver.h +++ 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; }; diff --git a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp index 1b85a0eea..e75242010 100644 --- a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp +++ b/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.); }; diff --git a/src/BulletDynamics/ConstraintSolver/btContactConstraint.h b/src/BulletDynamics/ConstraintSolver/btContactConstraint.h index d88ba0d8e..3fb089b2b 100644 --- a/src/BulletDynamics/ConstraintSolver/btContactConstraint.h +++ b/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, diff --git a/src/BulletDynamics/ConstraintSolver/btContactSolverInfo.h b/src/BulletDynamics/ConstraintSolver/btContactSolverInfo.h index ed1ba6ac1..c3c73e300 100644 --- a/src/BulletDynamics/ConstraintSolver/btContactSolverInfo.h +++ b/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; }; diff --git a/src/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp index b2132a8d4..e1c7fb168 100644 --- a/src/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp +++ b/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) diff --git a/src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp index f72278e2c..ccd2d9ee8 100644 --- a/src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp +++ b/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; diff --git a/src/BulletDynamics/ConstraintSolver/btJacobianEntry.h b/src/BulletDynamics/ConstraintSolver/btJacobianEntry.h index 384e4f7ba..bfeb24c2d 100644 --- a/src/BulletDynamics/ConstraintSolver/btJacobianEntry.h +++ b/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; } diff --git a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp index d15bdaad7..e2c4c54f1 100644 --- a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp +++ b/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(); diff --git a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h index 8aae8d74c..f56d0811a 100644 --- a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h +++ b/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 diff --git a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp index 94eece73e..6d190db53 100644 --- a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp +++ b/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;igetContactPoint(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.); } diff --git a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h index 0989a86e2..8fb898bab 100644 --- a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h +++ b/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); }; diff --git a/src/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp index edca6c8fa..cb60262ec 100644 --- a/src/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp +++ b/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 { diff --git a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp index cb3fa72d4..a15b3e026 100644 --- a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp +++ b/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.))); } diff --git a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.h b/src/BulletDynamics/ConstraintSolver/btTypedConstraint.h index bc25eaa75..1ece03ec3 100644 --- a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.h +++ b/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; } diff --git a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp index 3825eb963..470770375 100644 --- a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp +++ b/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;igetDebugMode() & 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(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(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(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); diff --git a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h index 9a1676af9..8794d4f51 100644 --- a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h +++ b/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(); diff --git a/src/BulletDynamics/Dynamics/btDynamicsWorld.h b/src/BulletDynamics/Dynamics/btDynamicsWorld.h index 86efba568..8b47d8d07 100644 --- a/src/BulletDynamics/Dynamics/btDynamicsWorld.h +++ b/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; diff --git a/src/BulletDynamics/Dynamics/btRigidBody.cpp b/src/BulletDynamics/Dynamics/btRigidBody.cpp index 705c023d3..a39fdde98 100644 --- a/src/BulletDynamics/Dynamics/btRigidBody.cpp +++ b/src/BulletDynamics/Dynamics/btRigidBody.cpp @@ -19,25 +19,25 @@ subject to the following restrictions: #include #include -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; diff --git a/src/BulletDynamics/Dynamics/btRigidBody.h b/src/BulletDynamics/Dynamics/btRigidBody.h index 43869363c..0951b7fa6 100644 --- a/src/BulletDynamics/Dynamics/btRigidBody.h +++ b/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; } diff --git a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp b/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp index 9e0d37712..d3a059df2 100644 --- a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp +++ b/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= -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 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; diff --git a/src/BulletDynamics/Vehicle/btRaycastVehicle.h b/src/BulletDynamics/Vehicle/btRaycastVehicle.h index 9fd332f43..deb84a053 100644 --- a/src/BulletDynamics/Vehicle/btRaycastVehicle.h +++ b/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; } diff --git a/src/BulletDynamics/Vehicle/btVehicleRaycaster.h b/src/BulletDynamics/Vehicle/btVehicleRaycaster.h index 5f119f2b1..7c830bd86 100644 --- a/src/BulletDynamics/Vehicle/btVehicleRaycaster.h +++ b/src/BulletDynamics/Vehicle/btVehicleRaycaster.h @@ -21,7 +21,7 @@ virtual ~btVehicleRaycaster() } struct btVehicleRaycasterResult { - btVehicleRaycasterResult() :m_distFraction(-1.f){}; + btVehicleRaycasterResult() :m_distFraction(btScalar(-1.)){}; btVector3 m_hitPointInWorld; btVector3 m_hitNormalInWorld; btScalar m_distFraction; diff --git a/src/BulletDynamics/Vehicle/btWheelInfo.cpp b/src/BulletDynamics/Vehicle/btWheelInfo.cpp index dd2a523b9..91b4e8665 100644 --- a/src/BulletDynamics/Vehicle/btWheelInfo.cpp +++ b/src/BulletDynamics/Vehicle/btWheelInfo.cpp @@ -31,14 +31,14 @@ void btWheelInfo::updateWheel(const btRigidBody& chassis,RaycastInfo& raycastInf btVector3 relpos = m_raycastInfo.m_contactPointWS - chassis.getCenterOfMassPosition(); chassis_velocity_at_contactPoint = chassis.getVelocityInLocalPoint( relpos ); btScalar projVel = m_raycastInfo.m_contactNormalWS.dot( chassis_velocity_at_contactPoint ); - if ( project >= -0.1f) + if ( project >= btScalar(-0.1)) { - m_suspensionRelativeVelocity = 0.0f; - m_clippedInvContactDotSuspension = 1.0f / 0.1f; + m_suspensionRelativeVelocity = btScalar(0.0); + m_clippedInvContactDotSuspension = btScalar(1.0) / btScalar(0.1); } else { - btScalar inv = -1.f / project; + btScalar inv = btScalar(-1.) / project; m_suspensionRelativeVelocity = projVel * inv; m_clippedInvContactDotSuspension = inv; } @@ -48,8 +48,8 @@ void btWheelInfo::updateWheel(const btRigidBody& chassis,RaycastInfo& raycastInf else // Not in contact : position wheel in a nice (rest length) position { m_raycastInfo.m_suspensionLength = this->getSuspensionRestLength(); - m_suspensionRelativeVelocity = 0.0f; + m_suspensionRelativeVelocity = btScalar(0.0); m_raycastInfo.m_contactNormalWS = -m_raycastInfo.m_wheelDirectionWS; - m_clippedInvContactDotSuspension = 1.0f; + m_clippedInvContactDotSuspension = btScalar(1.0); } } diff --git a/src/BulletDynamics/Vehicle/btWheelInfo.h b/src/BulletDynamics/Vehicle/btWheelInfo.h index 2bd8c1867..a785fd0bd 100644 --- a/src/BulletDynamics/Vehicle/btWheelInfo.h +++ b/src/BulletDynamics/Vehicle/btWheelInfo.h @@ -25,10 +25,10 @@ struct btWheelInfoConstructionInfo btScalar m_maxSuspensionTravelCm; btScalar m_wheelRadius; - float m_suspensionStiffness; - float m_wheelsDampingCompression; - float m_wheelsDampingRelaxation; - float m_frictionSlip; + btScalar m_suspensionStiffness; + btScalar m_wheelsDampingCompression; + btScalar m_wheelsDampingRelaxation; + btScalar m_frictionSlip; bool m_bIsFrontWheel; }; @@ -92,12 +92,12 @@ struct btWheelInfo m_wheelDirectionCS = ci.m_wheelDirectionCS; m_wheelAxleCS = ci.m_wheelAxleCS; m_frictionSlip = ci.m_frictionSlip; - m_steering = 0.f; - m_engineForce = 0.f; - m_rotation = 0.f; - m_deltaRotation = 0.f; - m_brake = 0.f; - m_rollInfluence = 0.1f; + m_steering = btScalar(0.); + m_engineForce = btScalar(0.); + m_rotation = btScalar(0.); + m_deltaRotation = btScalar(0.); + m_brake = btScalar(0.); + m_rollInfluence = btScalar(0.1); m_bIsFrontWheel = ci.m_bIsFrontWheel; } diff --git a/src/LinearMath/btAabbUtil2.h b/src/LinearMath/btAabbUtil2.h index 2eacb8e24..e97c4fba8 100644 --- a/src/LinearMath/btAabbUtil2.h +++ b/src/LinearMath/btAabbUtil2.h @@ -73,8 +73,8 @@ SIMD_FORCE_INLINE bool btRayAabb(const btVector3& rayFrom, const btVector3& aabbMax, btScalar& param, btVector3& normal) { - btVector3 aabbHalfExtent = (aabbMax-aabbMin)* 0.5f; - btVector3 aabbCenter = (aabbMax+aabbMin)* 0.5f; + btVector3 aabbHalfExtent = (aabbMax-aabbMin)* btScalar(0.5); + btVector3 aabbCenter = (aabbMax+aabbMin)* btScalar(0.5); btVector3 source = rayFrom - aabbCenter; btVector3 target = rayTo - aabbCenter; int sourceOutcode = btOutcode(source,aabbHalfExtent); @@ -110,7 +110,7 @@ SIMD_FORCE_INLINE bool btRayAabb(const btVector3& rayFrom, } bit<<=1; } - normSign = -1.f; + normSign = btScalar(-1.); } if (lambda_enter <= lambda_exit) { diff --git a/src/LinearMath/btGeometryUtil.cpp b/src/LinearMath/btGeometryUtil.cpp index ef3798b4c..8fc5d3963 100644 --- a/src/LinearMath/btGeometryUtil.cpp +++ b/src/LinearMath/btGeometryUtil.cpp @@ -16,14 +16,14 @@ subject to the following restrictions: #include "btGeometryUtil.h" -bool btGeometryUtil::isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, float margin) +bool btGeometryUtil::isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, btScalar margin) { int numbrushes = planeEquations.size(); for (int i=0;i0.f) + btScalar dist = btScalar(N1.dot(point))+btScalar(N1[3])-margin; + if (dist>btScalar(0.)) { return false; } @@ -33,14 +33,14 @@ bool btGeometryUtil::isPointInsidePlanes(const btAlignedObjectArray& } -bool btGeometryUtil::areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, float margin) +bool btGeometryUtil::areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, btScalar margin) { int numvertices = vertices.size(); for (int i=0;i0.f) + btScalar dist = btScalar(planeNormal.dot(N1))+btScalar(planeNormal[3])-margin; + if (dist>btScalar(0.)) { return false; } @@ -54,7 +54,7 @@ bool notExist(const btVector3& planeEquation,const btAlignedObjectArray 0.999f) + if (planeEquation.dot(N1) > btScalar(0.999)) { return false; } @@ -83,11 +83,11 @@ void btGeometryUtil::getPlaneEquationsFromVertices(btAlignedObjectArray 0.0001f) + if (planeEquation.length2() > btScalar(0.0001)) { planeEquation.normalize(); if (notExist(planeEquation,planeEquationsOut)) @@ -95,13 +95,13 @@ void btGeometryUtil::getPlaneEquationsFromVertices(btAlignedObjectArray 0.0001f ) && - ( n3n1.length2() > 0.0001f ) && - ( n1n2.length2() > 0.0001f ) ) + if ( ( n2n3.length2() > btScalar(0.0001) ) && + ( n3n1.length2() > btScalar(0.0001) ) && + ( n1n2.length2() > btScalar(0.0001) ) ) { //point P out of 3 plane equations: @@ -143,10 +143,10 @@ void btGeometryUtil::getVerticesFromPlaneEquations(const btAlignedObjectArray 0.000001f) + btScalar quotient = (N1.dot(n2n3)); + if (btFabs(quotient) > btScalar(0.000001)) { - quotient = -1.f / quotient; + quotient = btScalar(-1.) / quotient; n2n3 *= N1[3]; n3n1 *= N2[3]; n1n2 *= N3[3]; @@ -156,7 +156,7 @@ void btGeometryUtil::getVerticesFromPlaneEquations(const btAlignedObjectArray& planeEquations , btAlignedObjectArray& verticesOut ); - static bool isInside(const btAlignedObjectArray& vertices, const btVector3& planeNormal, float margin); + static bool isInside(const btAlignedObjectArray& vertices, const btVector3& planeNormal, btScalar margin); - static bool isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, float margin); + static bool isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, btScalar margin); - static bool areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, float margin); + static bool areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, btScalar margin); }; diff --git a/src/LinearMath/btIDebugDraw.h b/src/LinearMath/btIDebugDraw.h index 86db735ce..66c0135ab 100644 --- a/src/LinearMath/btIDebugDraw.h +++ b/src/LinearMath/btIDebugDraw.h @@ -56,7 +56,7 @@ class btIDebugDraw virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& color)=0; - virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,float distance,int lifeTime,const btVector3& color)=0; + virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color)=0; virtual void setDebugMode(int debugMode) =0; diff --git a/src/LinearMath/btMatrix3x3.h b/src/LinearMath/btMatrix3x3.h index c3cc90a82..c3a45b7f5 100644 --- a/src/LinearMath/btMatrix3x3.h +++ b/src/LinearMath/btMatrix3x3.h @@ -323,8 +323,8 @@ class btMatrix3x3 { { btVector3 co(cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)); btScalar det = (*this)[0].dot(co); - assert(det != btScalar(0.0f)); - btScalar s = btScalar(1.0f) / det; + assert(det != btScalar(0.0)); + btScalar s = btScalar(1.0) / det; return btMatrix3x3(co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s, co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s, co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s); diff --git a/src/LinearMath/btQuadWord.h b/src/LinearMath/btQuadWord.h index 4331b6682..5e8025179 100644 --- a/src/LinearMath/btQuadWord.h +++ b/src/LinearMath/btQuadWord.h @@ -40,11 +40,11 @@ ATTRIBUTE_ALIGNED16 (class btQuadWord) SIMD_FORCE_INLINE const btScalar& getZ() const { return m_z; } - SIMD_FORCE_INLINE void setX(float x) { m_x = x;}; + SIMD_FORCE_INLINE void setX(btScalar x) { m_x = x;}; - SIMD_FORCE_INLINE void setY(float y) { m_y = y;}; + SIMD_FORCE_INLINE void setY(btScalar y) { m_y = y;}; - SIMD_FORCE_INLINE void setZ(float z) { m_z = z;}; + SIMD_FORCE_INLINE void setZ(btScalar z) { m_z = z;}; SIMD_FORCE_INLINE const btScalar& x() const { return m_x; } @@ -79,14 +79,14 @@ ATTRIBUTE_ALIGNED16 (class btQuadWord) } SIMD_FORCE_INLINE btQuadWord() : - m_x(0.f),m_y(0.f),m_z(0.f),m_unusedW(0.f) + m_x(btScalar(0.)),m_y(btScalar(0.)),m_z(btScalar(0.)),m_unusedW(btScalar(0.)) { } SIMD_FORCE_INLINE btQuadWord(const btScalar& x, const btScalar& y, const btScalar& z) :m_x(x),m_y(y),m_z(z) //todo, remove this in release/simd ? - ,m_unusedW(0.f) + ,m_unusedW(btScalar(0.)) { } diff --git a/src/LinearMath/btQuaternion.h b/src/LinearMath/btQuaternion.h index aec25a549..3fd98a983 100644 --- a/src/LinearMath/btQuaternion.h +++ b/src/LinearMath/btQuaternion.h @@ -150,7 +150,7 @@ public: btScalar getAngle() const { - btScalar s = 2.f * btAcos(m_unusedW); + btScalar s = btScalar(2.) * btAcos(m_unusedW); return s; } diff --git a/src/LinearMath/btScalar.h b/src/LinearMath/btScalar.h index dd76fb2de..499202d75 100644 --- a/src/LinearMath/btScalar.h +++ b/src/LinearMath/btScalar.h @@ -50,14 +50,23 @@ subject to the following restrictions: #define btAssert assert #endif - - -typedef float btScalar; - -///older compilers (gcc 3.x) and Sun needs double versions of srqt etc. -///exclude Apple Intel (it's assumed to be a Macbook or newer Intel Dual Core processor) +/// older compilers (gcc 3.x) and Sun needs double version of sqrt etc. +/// exclude Apple Intel (i's assumed to be a Macbook or new Intel Dual Core Processor) #if defined (__sun) || defined (__sun__) || defined (__sparc) || (defined (__APPLE__) && ! defined (__i386__)) //use slow double float precision operation on those platforms +#ifndef BT_USE_DOUBLE_PRECISION +#define BT_FORCE_DOUBLE_FUNCTIONS +#endif +#endif + +#if defined(BT_USE_DOUBLE_PRECISION) +typedef double btScalar; +#else +typedef float btScalar; +#endif + + +#if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS) SIMD_FORCE_INLINE btScalar btSqrt(btScalar x) { return sqrt(x); } SIMD_FORCE_INLINE btScalar btFabs(btScalar x) { return fabs(x); } @@ -90,11 +99,11 @@ SIMD_FORCE_INLINE btScalar btPow(btScalar x,btScalar y) { return powf(x,y); } #endif -#define SIMD_2_PI 6.283185307179586232f -#define SIMD_PI (SIMD_2_PI * btScalar(0.5f)) -#define SIMD_HALF_PI (SIMD_2_PI * btScalar(0.25f)) -#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0f)) -#define SIMD_DEGS_PER_RAD (btScalar(360.0f) / SIMD_2_PI) +#define SIMD_2_PI btScalar(6.283185307179586232) +#define SIMD_PI (SIMD_2_PI * btScalar(0.5)) +#define SIMD_HALF_PI (SIMD_2_PI * btScalar(0.25)) +#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0)) +#define SIMD_DEGS_PER_RAD (btScalar(360.0) / SIMD_2_PI) #define SIMD_EPSILON FLT_EPSILON #define SIMD_INFINITY FLT_MAX @@ -117,7 +126,7 @@ SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2f(x, y) */ SIMD_FORCE_INLINE int btIsNegative(btScalar x) { - return x < 0.0f ? 1 : 0; + return x < btScalar(0.0) ? 1 : 0; } SIMD_FORCE_INLINE btScalar btRadians(btScalar x) { return x * SIMD_RADS_PER_DEG; } diff --git a/src/LinearMath/btTransform.h b/src/LinearMath/btTransform.h index 3f9a48407..e1a37aabd 100644 --- a/src/LinearMath/btTransform.h +++ b/src/LinearMath/btTransform.h @@ -99,7 +99,7 @@ public: m[12] = m_origin[0]; m[13] = m_origin[1]; m[14] = m_origin[2]; - m[15] = btScalar(1.0f); + m[15] = btScalar(1.0); } SIMD_FORCE_INLINE void setOrigin(const btVector3& origin) diff --git a/src/LinearMath/btTransformUtil.h b/src/LinearMath/btTransformUtil.h index 39fa830f4..766dc012b 100644 --- a/src/LinearMath/btTransformUtil.h +++ b/src/LinearMath/btTransformUtil.h @@ -17,19 +17,19 @@ subject to the following restrictions: #define SIMD_TRANSFORM_UTIL_H #include "LinearMath/btTransform.h" -#define ANGULAR_MOTION_THRESHOLD 0.5f*SIMD_HALF_PI +#define ANGULAR_MOTION_THRESHOLD btScalar(0.5)*SIMD_HALF_PI #define SIMDSQRT12 btScalar(0.7071067811865475244008443621048490) -#define btRecipSqrt(x) ((float)(1.0f/btSqrt(float(x)))) /* reciprocal square root */ +#define btRecipSqrt(x) ((btScalar)(btScalar(1.0)/btSqrt(btScalar(x)))) /* reciprocal square root */ inline btVector3 btAabbSupport(const btVector3& halfExtents,const btVector3& supportDir) { - return btVector3(supportDir.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(), - supportDir.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(), - supportDir.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); + return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(), + supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(), + supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); } @@ -75,7 +75,7 @@ public: // #define QUATERNION_DERIVATIVE #ifdef QUATERNION_DERIVATIVE btQuaternion orn = curTrans.getRotation(); - orn += (angvel * orn) * (timeStep * 0.5f); + orn += (angvel * orn) * (timeStep * btScalar(0.5)); orn.normalize(); #else //exponential map @@ -87,17 +87,17 @@ public: fAngle = ANGULAR_MOTION_THRESHOLD / timeStep; } - if ( fAngle < 0.001f ) + if ( fAngle < btScalar(0.001) ) { // use Taylor's expansions of sync function - axis = angvel*( 0.5f*timeStep-(timeStep*timeStep*timeStep)*(0.020833333333f)*fAngle*fAngle ); + axis = angvel*( btScalar(0.5)*timeStep-(timeStep*timeStep*timeStep)*(btScalar(0.020833333333))*fAngle*fAngle ); } else { // sync(fAngle) = sin(c*fAngle)/t - axis = angvel*( btSin(0.5f*fAngle*timeStep)/fAngle ); + axis = angvel*( btSin(btScalar(0.5)*fAngle*timeStep)/fAngle ); } - btQuaternion dorn (axis.x(),axis.y(),axis.z(),btCos( fAngle*timeStep*0.5f )); + btQuaternion dorn (axis.x(),axis.y(),axis.z(),btCos( fAngle*timeStep*btScalar(0.5) )); btQuaternion orn0 = curTrans.getRotation(); btQuaternion predictedOrn = dorn * orn0; @@ -130,11 +130,11 @@ public: angle = dorn.getAngle(); axis = btVector3(dorn.x(),dorn.y(),dorn.z()); - axis[3] = 0.f; + axis[3] = btScalar(0.); //check for axis length btScalar len = axis.length2(); if (len < SIMD_EPSILON*SIMD_EPSILON) - axis = btVector3(1.f,0.f,0.f); + axis = btVector3(btScalar(1.),btScalar(0.),btScalar(0.)); else axis /= btSqrt(len); } diff --git a/src/LinearMath/btVector3.h b/src/LinearMath/btVector3.h index 5a35652ec..8d8d396ef 100644 --- a/src/LinearMath/btVector3.h +++ b/src/LinearMath/btVector3.h @@ -31,7 +31,7 @@ public: SIMD_FORCE_INLINE btVector3(const btScalar& x, const btScalar& y, const btScalar& z) - :btQuadWord(x,y,z,0.f) + :btQuadWord(x,y,z,btScalar(0.)) { } @@ -148,7 +148,7 @@ public: SIMD_FORCE_INLINE void setInterpolate3(const btVector3& v0, const btVector3& v1, btScalar rt) { - btScalar s = 1.0f - rt; + btScalar s = btScalar(1.0) - rt; m_x = s * v0[0] + rt * v1.x(); m_y = s * v0[1] + rt * v1.y(); m_z = s * v0[2] + rt * v1.z(); @@ -327,13 +327,13 @@ public: - float getW() const { return m_unusedW;} + btScalar getW() const { return m_unusedW;} SIMD_FORCE_INLINE int maxAxis4() const { int maxIndex = -1; - float maxVal = -1e30f; + btScalar maxVal = btScalar(-1e30); if (m_x > maxVal) { maxIndex = 0; @@ -366,7 +366,7 @@ public: SIMD_FORCE_INLINE int minAxis4() const { int minIndex = -1; - float minVal = 1e30f; + btScalar minVal = btScalar(1e30); if (m_x < minVal) { minIndex = 0;