Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source
This commit is contained in:
ejcoumans
2006-12-16 05:51:30 +00:00
parent 39f223fd65
commit df9230327c
141 changed files with 1091 additions and 1042 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
Demos/BasicDemo/BasicDemo.cpp
View File

@@ -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 <stdio.h> //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();

13
Demos/BspDemo/BspConverter.cpp
View File

@@ -21,20 +21,24 @@ subject to the following restrictions:
void BspConverter::convertBsp(BspLoader& bspLoader,float scaling)
{
{
btVector3 playerStart (0.f, 0.f, 100.f);
if (bspLoader.findVectorByName(&playerStart[0],"info_player_start"))
float playstartf[3] = {0,0,100};
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, "" ) ) {

2
Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp
View File

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

2
Demos/CollisionDemo/CollisionDemo.cpp
View File

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

2
Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp
View File

@@ -156,7 +156,7 @@ void CollisionInterfaceDemo::displayCallback(void) {
//GL_ShapeDrawer::drawCoordSystem();
float m[16];
btScalar m[16];

2
Demos/ConcaveDemo/ConcavePhysicsDemo.cpp
View File

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

2
Demos/ContinuousConvexCollision/ContinuousConvexCollisionDemo.cpp
View File

@@ -146,7 +146,7 @@ void btContinuousConvexCollisionDemo::displayCallback(void) {
//GL_ShapeDrawer::drawCoordSystem();
float m[16];
btScalar m[16];
int i;
/*for (i=0;i<numObjects;i++)

21
Demos/EPAPenDepthDemo/PenetrationTestBullet.cpp
View File

@@ -70,7 +70,11 @@ static void DrawLine(const btVector3& p0, const btVector3& p1, const btVector3&
glColor4f(color.x(), color.y(), color.z(), 1.0f);
btVector3 tmp[] = {p0, p1};
glEnableClientState(GL_VERTEX_ARRAY);
#ifndef BT_USE_DOUBLE_PRECISION
glVertexPointer(3, GL_FLOAT, sizeof(btVector3), &tmp[0].x());
#else
glVertexPointer(3, GL_DOUBLE, sizeof(btVector3), &tmp[0].x());
#endif
glDrawArrays(GL_LINES, 0, 2);
glDisableClientState(GL_VERTEX_ARRAY);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
@@ -83,7 +87,11 @@ void DrawTriangle(const btVector3& p0, const btVector3& p1, const btVector3& p2,
glColor4f(color.x(), color.y(), color.z(), 1.0f);
btVector3 tmp[] = {p0, p1, p2};
glEnableClientState(GL_VERTEX_ARRAY);
#ifndef BT_USE_DOUBLE_PRECISION
glVertexPointer(3, GL_FLOAT, sizeof(btVector3), &tmp[0].x());
#else
glVertexPointer(3, GL_DOUBLE, sizeof(btVector3), &tmp[0].x());
#endif
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableClientState(GL_VERTEX_ARRAY);
// glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
@@ -199,10 +207,13 @@ void MyConvex::Render(bool only_wireframe, const btVector3& wire_color) const
const float Scale = 1.0f;
glPushMatrix();
float glmat[16]; //4x4 column major matrix for OpenGL.
btScalar glmat[16]; //4x4 column major matrix for OpenGL.
mTransform.getOpenGLMatrix(glmat);
#ifndef BT_USE_DOUBLE_PRECISION
glMultMatrixf(&(glmat[0]));
#else
glMultMatrixd(&(glmat[0]));
#endif
if(!only_wireframe)
{
btVector3 color(0.0f, 0.5f, 1.0f);
@@ -273,7 +284,7 @@ static float gDepth;
{
}
virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, float depth)
virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth)
{
gNormal = normalOnBInWorld;
gPoint = pointInWorld;
@@ -293,8 +304,8 @@ static bool TestEPA(const MyConvex& hull0, const MyConvex& hull1)
simplexSolver.reset();
btConvexHullShape convexA((float*)hull0.mVerts, hull0.mNbVerts, sizeof(btVector3));
btConvexHullShape convexB((float*)hull1.mVerts, hull1.mNbVerts, sizeof(btVector3));
btConvexHullShape convexA((btScalar*)hull0.mVerts, hull0.mNbVerts, sizeof(btVector3));
btConvexHullShape convexB((btScalar*)hull1.mVerts, hull1.mNbVerts, sizeof(btVector3));
static btGjkEpaPenetrationDepthSolver Solver0;
static btMinkowskiPenetrationDepthSolver Solver1;

2
Demos/GjkConvexCastDemo/LinearConvexCastDemo.cpp
View File

@@ -139,7 +139,7 @@ void LinearConvexCastDemo::displayCallback(void)
//GL_ShapeDrawer::drawCoordSystem();
float m[16];
btScalar m[16];
int i;
for (i=0;i<numObjects;i++)

4
Demos/MovingConcaveDemo/ConcavePhysicsDemo.cpp
View File

@@ -37,7 +37,7 @@ GLDebugDrawer debugDrawer;
//***************************THE FAMOUS BUNNY TRIMESH********************************************//
#define REAL float
#define REAL btScalar
const int NUM_TRIANGLES =902;
const int NUM_VERTICES = 453;
const int NUM_INDICES = NUM_TRIANGLES * 3;
@@ -1487,7 +1487,7 @@ void ConcaveDemo::renderme()
{
updateCamera();
float m[16];
btScalar m[16];
if (m_dynamicsWorld)
{

25
Demos/OpenGL/DebugCastResult.h
View File

@@ -19,6 +19,7 @@ subject to the following restrictions:
#include "BulletCollision/NarrowPhaseCollision/btConvexCast.h"
#include "LinearMath/btTransform.h"
#include "GL_ShapeDrawer.h"
#include "GlutStuff.h"
#ifdef WIN32
#include <windows.h>
#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);

2
Demos/OpenGL/DemoApplication.cpp
View File

@@ -708,7 +708,7 @@ void DemoApplication::renderme()
{
updateCamera();
float m[16];
btScalar m[16];
if (m_dynamicsWorld)
{

2
Demos/OpenGL/GLDebugDrawer.cpp
View File

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

2
Demos/OpenGL/GLDebugDrawer.h
View File

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

23
Demos/OpenGL/GL_ShapeDrawer.cpp
View File

@@ -26,6 +26,7 @@ subject to the following restrictions:
#include <GL/glut.h>
#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);

2
Demos/OpenGL/GL_ShapeDrawer.h
View File

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

9
Demos/OpenGL/GL_Simplex1to4.cpp
View File

@@ -26,6 +26,7 @@ subject to the following restrictions:
#else
#include <GL/gl.h>
#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);

2
Demos/OpenGL/GL_Simplex1to4.h
View File

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

12
Demos/OpenGL/GlutStuff.h
View File

@@ -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

2
Demos/SimplexDemo/SimplexDemo.cpp
View File

@@ -73,7 +73,7 @@ void SimplexDemo::displayCallback()
GL_ShapeDrawer::drawCoordSystem();
float m[16];
btScalar m[16];
int i;
for (i=0;i<numObjects;i++)

4
Demos/VehicleDemo/VehicleDemo.cpp
View File

@@ -183,7 +183,7 @@ const float TRIANGLE_SIZE=20.f;
btTriangleIndexVertexArray* indexVertexArrays = new btTriangleIndexVertexArray(totalTriangles,
gIndices,
indexStride,
totalVerts,(float*) &gVertices[0].x(),vertStride);
totalVerts,(btScalar*) &gVertices[0].x(),vertStride);
groundShape = new btBvhTriangleMeshShape(indexVertexArrays);
@@ -297,7 +297,7 @@ void VehicleDemo::renderme()
updateCamera();
debugDrawer.setDebugMode(getDebugMode());
float m[16];
btScalar m[16];
int i;
btCylinderShapeX wheelShape(btVector3(wheelWidth,wheelRadius,wheelRadius));

2
Extras/AlternativeCollisionAlgorithms/BoxBoxCollisionAlgorithm.cpp
View File

@@ -65,7 +65,7 @@ void BoxBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,btColl
}
float BoxBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
btScalar BoxBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
{
//not yet
return 1.f;

2
Extras/AlternativeCollisionAlgorithms/BoxBoxCollisionAlgorithm.h
View File

@@ -33,7 +33,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);
BoxBoxCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1);

2
Extras/GIMPACTBullet/btConcaveConcaveCollisionAlgorithm.cpp
View File

@@ -471,7 +471,7 @@ void btConcaveConcaveCollisionAlgorithm::processCollision (btCollisionObject* bo
}
float btConcaveConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
btScalar btConcaveConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
{
return 1.f;

2
Extras/GIMPACTBullet/btConcaveConcaveCollisionAlgorithm.h
View File

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

2
Extras/quickstep/OdeConstraintSolver.cpp
View File

@@ -70,7 +70,7 @@ m_erp(0.4f)
//iterative lcp and penalty method
float OdeConstraintSolver::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
btScalar OdeConstraintSolver::solveGroup(btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer)
{
m_CurBody = 0;
m_CurJoint = 0;

2
Extras/quickstep/OdeConstraintSolver.h
View File

@@ -45,7 +45,7 @@ public:
virtual ~OdeConstraintSolver() {}
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);
///setConstraintForceMixing, the cfm adds some positive value to the main diagonal
///This can improve convergence (make matrix positive semidefinite), but it can make the simulation look more 'springy'

2
src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
View File

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

4
src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
View File

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

10
src/BulletCollision/BroadphaseCollision/btDispatcher.h
View File

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

47
src/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp
View File

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

2
src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h
View File

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

2
src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
View File

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

10
src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
View File

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

32
src/BulletCollision/CollisionDispatch/btCollisionObject.h
View File

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

10
src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
View File

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

14
src/BulletCollision/CollisionDispatch/btCollisionWorld.h
View File

@@ -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

6
src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
View File

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

2
src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
View File

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

26
src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
View File

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

6
src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
View File

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

12
src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp
View File

@@ -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

2
src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
View File

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

4
src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp
View File

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

2
src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
View File

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

4
src/BulletCollision/CollisionDispatch/btManifoldResult.cpp
View File

@@ -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

2
src/BulletCollision/CollisionDispatch/btManifoldResult.h
View File

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

6
src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
View File

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

48
src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp
View File

@@ -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];

2
src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h
View File

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

6
src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp
View File

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

2
src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
View File

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

6
src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp
View File

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

2
src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
View File

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

14
src/BulletCollision/CollisionShapes/btBoxShape.cpp
View File

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

42
src/BulletCollision/CollisionShapes/btBoxShape.h
View File

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

2
src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
View File

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

2
src/BulletCollision/CollisionShapes/btCollisionMargin.h
View File

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

26
src/BulletCollision/CollisionShapes/btCollisionShape.cpp
View File

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

6
src/BulletCollision/CollisionShapes/btCollisionShape.h
View File

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

26
src/BulletCollision/CollisionShapes/btCompoundShape.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btCompoundShape.h
View File

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

2
src/BulletCollision/CollisionShapes/btConcaveShape.cpp
View File

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

6
src/BulletCollision/CollisionShapes/btConcaveShape.h
View File

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

16
src/BulletCollision/CollisionShapes/btConeShape.cpp
View File

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

22
src/BulletCollision/CollisionShapes/btConeShape.h
View File

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

16
src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btConvexHullShape.h
View File

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

12
src/BulletCollision/CollisionShapes/btConvexShape.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btConvexShape.h
View File

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

20
src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
View File

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

12
src/BulletCollision/CollisionShapes/btCylinderShape.cpp
View File

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

10
src/BulletCollision/CollisionShapes/btCylinderShape.h
View File

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

12
src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp
View File

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

2
src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
View File

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

2
src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
View File

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

22
src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
View File

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

34
src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
View File

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

20
src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
View File

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

8
src/BulletCollision/CollisionShapes/btSphereShape.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btSphereShape.h
View File

@@ -45,11 +45,11 @@ public:
//debugging
virtual char* getName()const {return "SPHERE";}
virtual void setMargin(float margin)
virtual void setMargin(btScalar margin)
{
btConvexShape::setMargin(margin);
}
virtual float getMargin() const
virtual btScalar getMargin() const
{
//to improve gjk behaviour, use radius+margin as the full margin, so never get into the penetration case
//this means, non-uniform scaling is not supported anymore

14
src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
View File

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

14
src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
View File

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

2
src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
View File

@@ -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.))
{
}

2
src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
View File

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

16
src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
View File

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

4
src/BulletCollision/CollisionShapes/btTriangleShape.h
View File

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

36
src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp
View File

@@ -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.))
{
}
}

2
src/BulletCollision/NarrowPhaseCollision/btConvexCast.h
View File

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

8
src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
View File

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

16
src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp
View File

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

2
src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp
View File

@@ -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,

36
src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp
View File

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

14
src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h
View File

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

104
src/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp
View File

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

8
src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp
View File

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

4
src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h
View File

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

4
src/BulletCollision/NarrowPhaseCollision/btPointCollector.h
View File

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

24
src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp
View File

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

Some files were not shown because too many files have changed in this diff Show More