From daf350168d968a712fbd8871074c37a0d57cb4cc Mon Sep 17 00:00:00 2001 From: "erwin.coumans" Date: Tue, 3 Feb 2009 01:00:55 +0000 Subject: [PATCH] fix spelling mistake: pertube -> perturbe --- .../btConvexConvexAlgorithm.cpp | 56 +++++++++---------- .../btConvexConvexAlgorithm.h | 14 ++--- .../btConvexPlaneCollisionAlgorithm.cpp | 34 +++++------ .../btConvexPlaneCollisionAlgorithm.h | 20 +++---- 4 files changed, 62 insertions(+), 62 deletions(-) diff --git a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp index e43dc3426..a149c6fe9 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp @@ -51,8 +51,8 @@ subject to the following restrictions: btConvexConvexAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver) { - m_numPertubationIterations = 3; - m_minimumPointsPertubationThreshold = 3; + m_numPerturbationIterations = 3; + m_minimumPointsPerturbationThreshold = 3; m_simplexSolver = simplexSolver; 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), m_simplexSolver(simplexSolver), m_pdSolver(pdSolver), @@ -72,8 +72,8 @@ m_lowLevelOfDetail(false), ,m_sepDistance((static_cast(body0->getCollisionShape()))->getAngularMotionDisc(), (static_cast(body1->getCollisionShape()))->getAngularMotionDisc()), #endif -m_numPertubationIterations(numPertubationIterations), -m_minimumPointsPertubationThreshold(minimumPointsPertubationThreshold) +m_numPerturbationIterations(numPerturbationIterations), +m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold) { (void)body0; (void)body1; @@ -97,20 +97,20 @@ void btConvexConvexAlgorithm ::setLowLevelOfDetail(bool useLowLevel) } -struct btPertubedContactResult : public btManifoldResult +struct btPerturbedContactResult : public btManifoldResult { btManifoldResult* m_originalManifoldResult; btTransform m_transformA; 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_transformA(transformA), m_transformB(transformB) { } - virtual ~ btPertubedContactResult() + virtual ~ btPerturbedContactResult() { } @@ -181,49 +181,49 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw); 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 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized(); 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 - if (resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPertubationThreshold) + //perform perturbation when more then 'm_minimumPointsPerturbationThreshold' points + if (resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPerturbationThreshold) { int i; - bool pertubeA = true; + bool perturbeA = true; const btScalar angleLimit = 0.125f * SIMD_PI; - btScalar pertubeAngle; + btScalar perturbeAngle; btScalar radiusA = min0->getAngularMotionDisc(); btScalar radiusB = min1->getAngularMotionDisc(); if (radiusA < radiusB) { - pertubeAngle = gContactBreakingThreshold /radiusA; - pertubeA = true; + perturbeAngle = gContactBreakingThreshold /radiusA; + perturbeA = true; } else { - pertubeAngle = gContactBreakingThreshold / radiusB; - pertubeA = false; + perturbeAngle = gContactBreakingThreshold / radiusB; + perturbeA = false; } - if ( pertubeAngle > angleLimit ) - pertubeAngle = angleLimit; + if ( perturbeAngle > angleLimit ) + perturbeAngle = angleLimit; - for ( i=0;igetWorldTransform().getBasis()); + input.m_transformA.setBasis( btMatrix3x3(rotq.inverse()*perturbeRot*rotq)*body0->getWorldTransform().getBasis()); } 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); - gjkPairDetector.getClosestPoints(input,pertubedResultOut,dispatchInfo.m_debugDraw); + btPerturbedContactResult perturbedResultOut(resultOut,input.m_transformA,input.m_transformB); + gjkPairDetector.getClosestPoints(input,perturbedResultOut,dispatchInfo.m_debugDraw); btScalar curSepDist = gjkPairDetector.getCachedSeparatingDistance()+dispatchInfo.m_convexConservativeDistanceThreshold; } } diff --git a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h index a1fc0b1db..62dd33eb9 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h +++ b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h @@ -34,7 +34,7 @@ class btConvexPenetrationDepthSolver; ///#define USE_SEPDISTANCE_UTIL2 1 ///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 class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm { @@ -49,8 +49,8 @@ class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm btPersistentManifold* m_manifoldPtr; bool m_lowLevelOfDetail; - int m_numPertubationIterations; - int m_minimumPointsPertubationThreshold; + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; ///cache separating vector to speedup collision detection @@ -58,7 +58,7 @@ class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm 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(); @@ -88,8 +88,8 @@ public: btConvexPenetrationDepthSolver* m_pdSolver; btSimplexSolverInterface* m_simplexSolver; - int m_numPertubationIterations; - int m_minimumPointsPertubationThreshold; + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver); @@ -98,7 +98,7 @@ public: virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1) { 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); } }; diff --git a/src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp index 7ae4c9da8..7bb5910c8 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp @@ -22,13 +22,13 @@ subject to the following restrictions: //#include -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), m_ownManifold(false), m_manifoldPtr(mf), m_isSwapped(isSwapped), -m_numPertubationIterations(numPertubationIterations), -m_minimumPointsPertubationThreshold(minimumPointsPertubationThreshold) +m_numPerturbationIterations(numPerturbationIterations), +m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold) { btCollisionObject* convexObj = m_isSwapped? col1 : col0; 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* planeObj = m_isSwapped? body0: body1; @@ -65,8 +65,8 @@ void btConvexPlaneCollisionAlgorithm::collideSingleContact (const btQuaternion& btTransform convexWorldTransform = convexObj->getWorldTransform(); btTransform convexInPlaneTrans; convexInPlaneTrans= planeObj->getWorldTransform().inverse() * convexWorldTransform; - //now pertube the convex-world transform - convexWorldTransform.getBasis()*=btMatrix3x3(pertubeRot); + //now perturbe the convex-world transform + convexWorldTransform.getBasis()*=btMatrix3x3(perturbeRot); btTransform planeInConvex; planeInConvex= convexWorldTransform.inverse() * planeObj->getWorldTransform(); @@ -106,31 +106,31 @@ void btConvexPlaneCollisionAlgorithm::processCollision (btCollisionObject* body0 const btVector3& planeNormal = planeShape->getPlaneNormal(); 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); collideSingleContact(rotq,body0,body1,dispatchInfo,resultOut); } - if (resultOut->getPersistentManifold()->getNumContacts()getPersistentManifold()->getNumContacts()getAngularMotionDisc(); - pertubeAngle = gContactBreakingThreshold / radius; - if ( pertubeAngle > angleLimit ) - pertubeAngle = angleLimit; + perturbeAngle = gContactBreakingThreshold / radius; + if ( perturbeAngle > angleLimit ) + perturbeAngle = angleLimit; - btQuaternion pertubeRot(v0,pertubeAngle); - for (int i=0;iallocateCollisionAlgorithm(sizeof(btConvexPlaneCollisionAlgorithm)); 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 { - 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); } } };