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

fix spelling mistake: pertube -> perturbe

Browse Source
This commit is contained in:
erwin.coumans
2009-02-03 01:00:55 +00:00
parent 0754876d77
commit daf350168d
4 changed files with 62 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -51,8 +51,8 @@ subject to the following restrictions:
btConvexConvexAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver) btConvexConvexAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
{ {
m_numPertubationIterations = 3; m_numPerturbationIterations = 3;
m_minimumPointsPertubationThreshold = 3; m_minimumPointsPerturbationThreshold = 3;
m_simplexSolver = simplexSolver; m_simplexSolver = simplexSolver;
m_pdSolver = pdSolver; m_pdSolver = pdSolver;
} }
@@ -61,7 +61,7 @@ btConvexConvexAlgorithm::CreateFunc::~CreateFunc()
{ {
} }
btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver,int numPertubationIterations, int minimumPointsPertubationThreshold) btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver,int numPerturbationIterations, int minimumPointsPerturbationThreshold)
: btActivatingCollisionAlgorithm(ci,body0,body1), : btActivatingCollisionAlgorithm(ci,body0,body1),
m_simplexSolver(simplexSolver), m_simplexSolver(simplexSolver),
m_pdSolver(pdSolver), m_pdSolver(pdSolver),
@@ -72,8 +72,8 @@ m_lowLevelOfDetail(false),
,m_sepDistance((static_cast<btConvexShape*>(body0->getCollisionShape()))->getAngularMotionDisc(), ,m_sepDistance((static_cast<btConvexShape*>(body0->getCollisionShape()))->getAngularMotionDisc(),
(static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc()), (static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc()),
#endif #endif
m_numPertubationIterations(numPertubationIterations), m_numPerturbationIterations(numPerturbationIterations),
m_minimumPointsPertubationThreshold(minimumPointsPertubationThreshold) m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold)
{ {
(void)body0; (void)body0;
(void)body1; (void)body1;
@@ -97,20 +97,20 @@ void btConvexConvexAlgorithm ::setLowLevelOfDetail(bool useLowLevel)
} }
struct btPertubedContactResult : public btManifoldResult struct btPerturbedContactResult : public btManifoldResult
{ {
btManifoldResult* m_originalManifoldResult; btManifoldResult* m_originalManifoldResult;
btTransform m_transformA; btTransform m_transformA;
btTransform m_transformB; btTransform m_transformB;
btPertubedContactResult(btManifoldResult* originalResult,const btTransform& transformA,const btTransform& transformB) btPerturbedContactResult(btManifoldResult* originalResult,const btTransform& transformA,const btTransform& transformB)
:m_originalManifoldResult(originalResult), :m_originalManifoldResult(originalResult),
m_transformA(transformA), m_transformA(transformA),
m_transformB(transformB) m_transformB(transformB)
{ {
} }
virtual ~ btPertubedContactResult() virtual ~ btPerturbedContactResult()
{ {
} }
@@ -181,49 +181,49 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw); gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
btScalar sepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold; btScalar sepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold;
//now pertube directions to get multiple contact points //now perturbe directions to get multiple contact points
btVector3 v0,v1; btVector3 v0,v1;
btVector3 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized(); btVector3 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
btPlaneSpace1(sepNormalWorldSpace,v0,v1); btPlaneSpace1(sepNormalWorldSpace,v0,v1);
//now perform 'm_numPertubationIterations' collision queries with the pertubated collision objects //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects
//perform pertubation when more then 'm_minimumPointsPertubationThreshold' points //perform perturbation when more then 'm_minimumPointsPerturbationThreshold' points
if (resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPertubationThreshold) if (resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPerturbationThreshold)
{ {
int i; int i;
bool pertubeA = true; bool perturbeA = true;
const btScalar angleLimit = 0.125f * SIMD_PI; const btScalar angleLimit = 0.125f * SIMD_PI;
btScalar pertubeAngle; btScalar perturbeAngle;
btScalar radiusA = min0->getAngularMotionDisc(); btScalar radiusA = min0->getAngularMotionDisc();
btScalar radiusB = min1->getAngularMotionDisc(); btScalar radiusB = min1->getAngularMotionDisc();
if (radiusA < radiusB) if (radiusA < radiusB)
{ {
pertubeAngle = gContactBreakingThreshold /radiusA; perturbeAngle = gContactBreakingThreshold /radiusA;
pertubeA = true; perturbeA = true;
} else } else
{ {
pertubeAngle = gContactBreakingThreshold / radiusB; perturbeAngle = gContactBreakingThreshold / radiusB;
pertubeA = false; perturbeA = false;
} }
if ( pertubeAngle > angleLimit ) if ( perturbeAngle > angleLimit )
pertubeAngle = angleLimit; perturbeAngle = angleLimit;
for ( i=0;i<m_numPertubationIterations;i++) for ( i=0;i<m_numPerturbationIterations;i++)
{ {
btQuaternion pertubeRot(v0,pertubeAngle); btQuaternion perturbeRot(v0,perturbeAngle);
btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPertubationIterations)); btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPerturbationIterations));
btQuaternion rotq(sepNormalWorldSpace,iterationAngle); btQuaternion rotq(sepNormalWorldSpace,iterationAngle);
if (pertubeA) if (perturbeA)
{ {
input.m_transformA.setBasis( btMatrix3x3(rotq.inverse()*pertubeRot*rotq)*body0->getWorldTransform().getBasis()); input.m_transformA.setBasis( btMatrix3x3(rotq.inverse()*perturbeRot*rotq)*body0->getWorldTransform().getBasis());
} else } else
{ {
input.m_transformB.setBasis( btMatrix3x3(rotq.inverse()*pertubeRot*rotq)*body1->getWorldTransform().getBasis()); input.m_transformB.setBasis( btMatrix3x3(rotq.inverse()*perturbeRot*rotq)*body1->getWorldTransform().getBasis());
} }
btPertubedContactResult pertubedResultOut(resultOut,input.m_transformA,input.m_transformB); btPerturbedContactResult perturbedResultOut(resultOut,input.m_transformA,input.m_transformB);
gjkPairDetector.getClosestPoints(input,pertubedResultOut,dispatchInfo.m_debugDraw); gjkPairDetector.getClosestPoints(input,perturbedResultOut,dispatchInfo.m_debugDraw);
btScalar curSepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold; btScalar curSepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold;
} }
} }

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

@@ -34,7 +34,7 @@ class btConvexPenetrationDepthSolver;
///#define USE_SEPDISTANCE_UTIL2 1 ///#define USE_SEPDISTANCE_UTIL2 1
///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects. ///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects.
///Multiple contact points are calculated by pertubating the orientation of the smallest object orthogonal to the separating normal. ///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888 ///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
{ {
@@ -49,8 +49,8 @@ class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
btPersistentManifold* m_manifoldPtr; btPersistentManifold* m_manifoldPtr;
bool m_lowLevelOfDetail; bool m_lowLevelOfDetail;
int m_numPertubationIterations; int m_numPerturbationIterations;
int m_minimumPointsPertubationThreshold; int m_minimumPointsPerturbationThreshold;
///cache separating vector to speedup collision detection ///cache separating vector to speedup collision detection
@@ -58,7 +58,7 @@ class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
public: public:
btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int numPertubationIterations, int minimumPointsPertubationThreshold); btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold);
virtual ~btConvexConvexAlgorithm(); virtual ~btConvexConvexAlgorithm();
@@ -88,8 +88,8 @@ public:
btConvexPenetrationDepthSolver* m_pdSolver; btConvexPenetrationDepthSolver* m_pdSolver;
btSimplexSolverInterface* m_simplexSolver; btSimplexSolverInterface* m_simplexSolver;
int m_numPertubationIterations; int m_numPerturbationIterations;
int m_minimumPointsPertubationThreshold; int m_minimumPointsPerturbationThreshold;
CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver); CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver);
@@ -98,7 +98,7 @@ public:
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1) virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
{ {
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexAlgorithm)); void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexAlgorithm));
return new(mem) btConvexConvexAlgorithm(ci.m_manifold,ci,body0,body1,m_simplexSolver,m_pdSolver,m_numPertubationIterations,m_minimumPointsPertubationThreshold); return new(mem) btConvexConvexAlgorithm(ci.m_manifold,ci,body0,body1,m_simplexSolver,m_pdSolver,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
} }
}; };

34
src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp
View File

@@ -22,13 +22,13 @@ subject to the following restrictions:
//#include <stdio.h> //#include <stdio.h>
btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPertubationIterations,int minimumPointsPertubationThreshold) btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPerturbationIterations,int minimumPointsPerturbationThreshold)
: btCollisionAlgorithm(ci), : btCollisionAlgorithm(ci),
m_ownManifold(false), m_ownManifold(false),
m_manifoldPtr(mf), m_manifoldPtr(mf),
m_isSwapped(isSwapped), m_isSwapped(isSwapped),
m_numPertubationIterations(numPertubationIterations), m_numPerturbationIterations(numPerturbationIterations),
m_minimumPointsPertubationThreshold(minimumPointsPertubationThreshold) m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold)
{ {
btCollisionObject* convexObj = m_isSwapped? col1 : col0; btCollisionObject* convexObj = m_isSwapped? col1 : col0;
btCollisionObject* planeObj = m_isSwapped? col0 : col1; btCollisionObject* planeObj = m_isSwapped? col0 : col1;
@@ -50,7 +50,7 @@ btConvexPlaneCollisionAlgorithm::~btConvexPlaneCollisionAlgorithm()
} }
} }
void btConvexPlaneCollisionAlgorithm::collideSingleContact (const btQuaternion& pertubeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) void btConvexPlaneCollisionAlgorithm::collideSingleContact (const btQuaternion& perturbeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
{ {
btCollisionObject* convexObj = m_isSwapped? body1 : body0; btCollisionObject* convexObj = m_isSwapped? body1 : body0;
btCollisionObject* planeObj = m_isSwapped? body0: body1; btCollisionObject* planeObj = m_isSwapped? body0: body1;
@@ -65,8 +65,8 @@ void btConvexPlaneCollisionAlgorithm::collideSingleContact (const btQuaternion&
btTransform convexWorldTransform = convexObj->getWorldTransform(); btTransform convexWorldTransform = convexObj->getWorldTransform();
btTransform convexInPlaneTrans; btTransform convexInPlaneTrans;
convexInPlaneTrans= planeObj->getWorldTransform().inverse() * convexWorldTransform; convexInPlaneTrans= planeObj->getWorldTransform().inverse() * convexWorldTransform;
//now pertube the convex-world transform //now perturbe the convex-world transform
convexWorldTransform.getBasis()*=btMatrix3x3(pertubeRot); convexWorldTransform.getBasis()*=btMatrix3x3(perturbeRot);
btTransform planeInConvex; btTransform planeInConvex;
planeInConvex= convexWorldTransform.inverse() * planeObj->getWorldTransform(); planeInConvex= convexWorldTransform.inverse() * planeObj->getWorldTransform();
@@ -106,31 +106,31 @@ void btConvexPlaneCollisionAlgorithm::processCollision (btCollisionObject* body0
const btVector3& planeNormal = planeShape->getPlaneNormal(); const btVector3& planeNormal = planeShape->getPlaneNormal();
const btScalar& planeConstant = planeShape->getPlaneConstant(); const btScalar& planeConstant = planeShape->getPlaneConstant();
//first perform a collision query with the non-pertubated collision objects //first perform a collision query with the non-perturbated collision objects
{ {
btQuaternion rotq(0,0,0,1); btQuaternion rotq(0,0,0,1);
collideSingleContact(rotq,body0,body1,dispatchInfo,resultOut); collideSingleContact(rotq,body0,body1,dispatchInfo,resultOut);
} }
if (resultOut->getPersistentManifold()->getNumContacts()<m_minimumPointsPertubationThreshold) if (resultOut->getPersistentManifold()->getNumContacts()<m_minimumPointsPerturbationThreshold)
{ {
btVector3 v0,v1; btVector3 v0,v1;
btPlaneSpace1(planeNormal,v0,v1); btPlaneSpace1(planeNormal,v0,v1);
//now perform 'm_numPertubationIterations' collision queries with the pertubated collision objects //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects
const btScalar angleLimit = 0.125f * SIMD_PI; const btScalar angleLimit = 0.125f * SIMD_PI;
btScalar pertubeAngle; btScalar perturbeAngle;
btScalar radius = convexShape->getAngularMotionDisc(); btScalar radius = convexShape->getAngularMotionDisc();
pertubeAngle = gContactBreakingThreshold / radius; perturbeAngle = gContactBreakingThreshold / radius;
if ( pertubeAngle > angleLimit ) if ( perturbeAngle > angleLimit )
pertubeAngle = angleLimit; perturbeAngle = angleLimit;
btQuaternion pertubeRot(v0,pertubeAngle); btQuaternion perturbeRot(v0,perturbeAngle);
for (int i=0;i<m_numPertubationIterations;i++) for (int i=0;i<m_numPerturbationIterations;i++)
{ {
btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPertubationIterations)); btScalar iterationAngle = i*(SIMD_2_PI/btScalar(m_numPerturbationIterations));
btQuaternion rotq(planeNormal,iterationAngle); btQuaternion rotq(planeNormal,iterationAngle);
collideSingleContact(rotq.inverse()*pertubeRot*rotq,body0,body1,dispatchInfo,resultOut); collideSingleContact(rotq.inverse()*perturbeRot*rotq,body0,body1,dispatchInfo,resultOut);
} }
} }

20
src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h
View File

@@ -31,18 +31,18 @@ class btConvexPlaneCollisionAlgorithm : public btCollisionAlgorithm
bool m_ownManifold; bool m_ownManifold;
btPersistentManifold* m_manifoldPtr; btPersistentManifold* m_manifoldPtr;
bool m_isSwapped; bool m_isSwapped;
int m_numPertubationIterations; int m_numPerturbationIterations;
int m_minimumPointsPertubationThreshold; int m_minimumPointsPerturbationThreshold;
public: public:
btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPertubationIterations,int minimumPointsPertubationThreshold); btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped, int numPerturbationIterations,int minimumPointsPerturbationThreshold);
virtual ~btConvexPlaneCollisionAlgorithm(); virtual ~btConvexPlaneCollisionAlgorithm();
virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut); virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
void collideSingleContact (const btQuaternion& pertubeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut); void collideSingleContact (const btQuaternion& perturbeRot, btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut); virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
@@ -56,12 +56,12 @@ public:
struct CreateFunc :public btCollisionAlgorithmCreateFunc struct CreateFunc :public btCollisionAlgorithmCreateFunc
{ {
int m_numPertubationIterations; int m_numPerturbationIterations;
int m_minimumPointsPertubationThreshold; int m_minimumPointsPerturbationThreshold;
CreateFunc() CreateFunc()
: m_numPertubationIterations(3), : m_numPerturbationIterations(3),
m_minimumPointsPertubationThreshold(3) m_minimumPointsPerturbationThreshold(3)
{ {
} }
@@ -70,10 +70,10 @@ public:
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexPlaneCollisionAlgorithm)); void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexPlaneCollisionAlgorithm));
if (!m_swapped) if (!m_swapped)
{ {
return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,false,m_numPertubationIterations,m_minimumPointsPertubationThreshold); return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,false,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
} else } else
{ {
return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,true,m_numPertubationIterations,m_minimumPointsPertubationThreshold); return new(mem) btConvexPlaneCollisionAlgorithm(0,ci,body0,body1,true,m_numPerturbationIterations,m_minimumPointsPerturbationThreshold);
} }
} }
}; };