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

Refactoring: another huge number of changes, renamed methods to start with lower-case.

Browse Source
This commit is contained in:
ejcoumans
2006-09-28 01:11:16 +00:00
parent d0f09040e9
commit 2b1657b1dd
185 changed files with 2103 additions and 2095 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -49,11 +49,11 @@ 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,1.f,linVelA,angVelA);
btTransformUtil::calculateVelocity(fromB,toB,1.f,linVelB,angVelB);
btScalar boundingRadiusA = m_convexA->GetAngularMotionDisc();
btScalar boundingRadiusB = m_convexB->GetAngularMotionDisc();
btScalar boundingRadiusA = m_convexA->getAngularMotionDisc();
btScalar boundingRadiusB = m_convexB->getAngularMotionDisc();
btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;
@@ -80,10 +80,10 @@ bool btContinuousConvexCollision::calcTimeOfImpact(
identityTrans.setIdentity();
btSphereShape raySphere(0.0f);
raySphere.SetMargin(0.f);
raySphere.setMargin(0.f);
// result.DrawCoordSystem(sphereTr);
// result.drawCoordSystem(sphereTr);
btPointCollector pointCollector1;
@@ -93,11 +93,11 @@ bool btContinuousConvexCollision::calcTimeOfImpact(
btGjkPairDetector::ClosestPointInput input;
//we don't use margins during CCD
gjk.SetIgnoreMargin(true);
gjk.setIgnoreMargin(true);
input.m_transformA = fromA;
input.m_transformB = fromB;
gjk.GetClosestPoints(input,pointCollector1,0);
gjk.getClosestPoints(input,pointCollector1,0);
hasResult = pointCollector1.m_hasResult;
c = pointCollector1.m_pointInWorld;
@@ -145,8 +145,8 @@ bool btContinuousConvexCollision::calcTimeOfImpact(
//interpolate to next lambda
btTransform interpolatedTransA,interpolatedTransB,relativeTrans;
btTransformUtil::IntegrateTransform(fromA,linVelA,angVelA,lambda,interpolatedTransA);
btTransformUtil::IntegrateTransform(fromB,linVelB,angVelB,lambda,interpolatedTransB);
btTransformUtil::integrateTransform(fromA,linVelA,angVelA,lambda,interpolatedTransA);
btTransformUtil::integrateTransform(fromB,linVelB,angVelB,lambda,interpolatedTransB);
relativeTrans = interpolatedTransB.inverseTimes(interpolatedTransA);
result.DebugDraw( lambda );
@@ -156,7 +156,7 @@ bool btContinuousConvexCollision::calcTimeOfImpact(
btGjkPairDetector::ClosestPointInput input;
input.m_transformA = interpolatedTransA;
input.m_transformB = interpolatedTransB;
gjk.GetClosestPoints(input,pointCollector,0);
gjk.getClosestPoints(input,pointCollector,0);
if (pointCollector.m_hasResult)
{
if (pointCollector.m_distance < 0.f)

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

@@ -38,7 +38,7 @@ public:
//virtual bool addRayResult(const btVector3& normal,btScalar fraction) = 0;
virtual void DebugDraw(btScalar fraction) {}
virtual void DrawCoordSystem(const btTransform& trans) {}
virtual void drawCoordSystem(const btTransform& trans) {}
CastResult()
:m_fraction(1e30f),

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

@@ -29,7 +29,7 @@ class btConvexPenetrationDepthSolver
public:
virtual ~btConvexPenetrationDepthSolver() {};
virtual bool CalcPenDepth( btSimplexSolverInterface& simplexSolver,
virtual bool calcPenDepth( btSimplexSolverInterface& simplexSolver,
btConvexShape* convexA,btConvexShape* convexB,
const btTransform& transA,const btTransform& transB,
btVector3& v, btPoint3& pa, btPoint3& pb,

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

@@ -35,9 +35,9 @@ struct btDiscreteCollisionDetectorInterface
virtual ~Result(){}
///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;
///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;
};
struct ClosestPointInput
@@ -58,7 +58,7 @@ struct btDiscreteCollisionDetectorInterface
// give either closest points (distance > 0) or penetration (distance)
// the normal always points from B towards A
//
virtual void GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw) = 0;
virtual void getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw) = 0;
btScalar getCollisionMargin() { return 0.2f;}
};
@@ -75,7 +75,7 @@ struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
}
virtual ~btStorageResult() {};
virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
{
if (depth < m_distance)
{

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

@@ -54,8 +54,8 @@ bool btGjkConvexCast::calcTimeOfImpact(
trA.setOrigin(btPoint3(0,0,0));
trB.setOrigin(btPoint3(0,0,0));
convex->SetTransformA(trA);
convex->SetTransformB(trB);
convex->setTransformA(trA);
convex->setTransformB(trB);
@@ -82,13 +82,13 @@ bool btGjkConvexCast::calcTimeOfImpact(
identityTrans.setIdentity();
btSphereShape raySphere(0.0f);
raySphere.SetMargin(0.f);
raySphere.setMargin(0.f);
btTransform sphereTr;
sphereTr.setIdentity();
sphereTr.setOrigin( rayFromLocalA.getOrigin());
result.DrawCoordSystem(sphereTr);
result.drawCoordSystem(sphereTr);
{
btPointCollector pointCollector1;
btGjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);
@@ -96,7 +96,7 @@ bool btGjkConvexCast::calcTimeOfImpact(
btGjkPairDetector::ClosestPointInput input;
input.m_transformA = sphereTr;
input.m_transformB = identityTrans;
gjk.GetClosestPoints(input,pointCollector1,0);
gjk.getClosestPoints(input,pointCollector1,0);
hasResult = pointCollector1.m_hasResult;
c = pointCollector1.m_pointInWorld;
@@ -134,13 +134,13 @@ bool btGjkConvexCast::calcTimeOfImpact(
x = s + lambda * r;
sphereTr.setOrigin( x );
result.DrawCoordSystem(sphereTr);
result.drawCoordSystem(sphereTr);
btPointCollector pointCollector;
btGjkPairDetector gjk(&raySphere,convex,m_simplexSolver,penSolverPtr);
btGjkPairDetector::ClosestPointInput input;
input.m_transformA = sphereTr;
input.m_transformB = identityTrans;
gjk.GetClosestPoints(input,pointCollector,0);
gjk.getClosestPoints(input,pointCollector,0);
if (pointCollector.m_hasResult)
{
if (pointCollector.m_distance < 0.f)

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

@@ -43,14 +43,14 @@ m_index1(-1)
{
}
void btGjkPairDetector::GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
{
btScalar distance=0.f;
btVector3 normalInB(0.f,0.f,0.f);
btVector3 pointOnA,pointOnB;
float marginA = m_minkowskiA->GetMargin();
float marginB = m_minkowskiB->GetMargin();
float marginA = m_minkowskiA->getMargin();
float marginB = m_minkowskiB->getMargin();
//for CCD we don't use margins
if (m_ignoreMargin)
@@ -87,8 +87,8 @@ int curIter = 0;
m_cachedSeparatingAxis.getY(),
m_cachedSeparatingAxis.getZ(),
squaredDistance,
m_minkowskiA->GetShapeType(),
m_minkowskiB->GetShapeType());
m_minkowskiA->getShapeType(),
m_minkowskiB->getShapeType());
#endif
break;
@@ -97,8 +97,8 @@ int curIter = 0;
btVector3 seperatingAxisInA = (-m_cachedSeparatingAxis)* input.m_transformA.getBasis();
btVector3 seperatingAxisInB = m_cachedSeparatingAxis* input.m_transformB.getBasis();
btVector3 pInA = m_minkowskiA->LocalGetSupportingVertexWithoutMargin(seperatingAxisInA);
btVector3 qInB = m_minkowskiB->LocalGetSupportingVertexWithoutMargin(seperatingAxisInB);
btVector3 pInA = m_minkowskiA->localGetSupportingVertexWithoutMargin(seperatingAxisInA);
btVector3 qInB = m_minkowskiB->localGetSupportingVertexWithoutMargin(seperatingAxisInB);
btPoint3 pWorld = input.m_transformA(pInA);
btPoint3 qWorld = input.m_transformB(qInB);
@@ -184,7 +184,7 @@ int curIter = 0;
if (m_penetrationDepthSolver)
{
// Penetration depth case.
isValid = m_penetrationDepthSolver->CalcPenDepth(
isValid = m_penetrationDepthSolver->calcPenDepth(
*m_simplexSolver,
m_minkowskiA,m_minkowskiB,
input.m_transformA,input.m_transformB,
@@ -211,9 +211,9 @@ int curIter = 0;
if (isValid)
{
output.SetShapeIdentifiers(m_partId0,m_index0,m_partId1,m_index1);
output.setShapeIdentifiers(m_partId0,m_index0,m_partId1,m_index1);
output.AddContactPoint(
output.addContactPoint(
normalInB,
pointOnB,
distance);

12
src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h
View File

@@ -53,28 +53,28 @@ public:
btGjkPairDetector(btConvexShape* objectA,btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver* penetrationDepthSolver);
virtual ~btGjkPairDetector() {};
virtual void GetClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw);
virtual void getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw);
void SetMinkowskiA(btConvexShape* minkA)
void setMinkowskiA(btConvexShape* minkA)
{
m_minkowskiA = minkA;
}
void SetMinkowskiB(btConvexShape* minkB)
void setMinkowskiB(btConvexShape* minkB)
{
m_minkowskiB = minkB;
}
void SetCachedSeperatingAxis(const btVector3& seperatingAxis)
void setCachedSeperatingAxis(const btVector3& seperatingAxis)
{
m_cachedSeparatingAxis = seperatingAxis;
}
void SetPenetrationDepthSolver(btConvexPenetrationDepthSolver* penetrationDepthSolver)
void setPenetrationDepthSolver(btConvexPenetrationDepthSolver* penetrationDepthSolver)
{
m_penetrationDepthSolver = penetrationDepthSolver;
}
void SetIgnoreMargin(bool ignoreMargin)
void setIgnoreMargin(bool ignoreMargin)
{
m_ignoreMargin = ignoreMargin;
}

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

@@ -25,9 +25,9 @@ btManifoldContactAddResult::btManifoldContactAddResult(btTransform transA,btTran
}
void btManifoldContactAddResult::AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
void btManifoldContactAddResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
{
if (depth > m_manifoldPtr->GetContactBreakingTreshold())
if (depth > m_manifoldPtr->getContactBreakingTreshold())
return;
@@ -36,10 +36,10 @@ void btManifoldContactAddResult::AddContactPoint(const btVector3& normalOnBInWor
btVector3 localB = m_transBInv(pointInWorld);
btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
int insertIndex = m_manifoldPtr->GetCacheEntry(newPt);
int insertIndex = m_manifoldPtr->getCacheEntry(newPt);
if (insertIndex >= 0)
{
m_manifoldPtr->ReplaceContactPoint(newPt,insertIndex);
m_manifoldPtr->replaceContactPoint(newPt,insertIndex);
} else
{
m_manifoldPtr->AddManifoldPoint(newPt);

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

@@ -30,7 +30,7 @@ public:
btManifoldContactAddResult(btTransform transA,btTransform transB,btPersistentManifold* manifoldPtr);
virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);
virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);
};

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

@@ -54,7 +54,7 @@ class btManifoldPoint
btVector3 m_localPointA;
btVector3 m_localPointB;
btVector3 m_positionWorldOnB;
///m_positionWorldOnA is redundant information, see GetPositionWorldOnA(), but for clarity
///m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
btVector3 m_positionWorldOnA;
btVector3 m_normalWorldOnB;
@@ -67,26 +67,26 @@ class btManifoldPoint
int m_lifeTime;//lifetime of the contactpoint in frames
float GetDistance() const
float getDistance() const
{
return m_distance1;
}
int GetLifeTime() const
int getLifeTime() const
{
return m_lifeTime;
}
btVector3 GetPositionWorldOnA() {
btVector3 getPositionWorldOnA() {
return m_positionWorldOnA;
// return m_positionWorldOnB + m_normalWorldOnB * m_distance1;
}
const btVector3& GetPositionWorldOnB()
const btVector3& getPositionWorldOnB()
{
return m_positionWorldOnB;
}
void SetDistance(float dist)
void setDistance(float dist)
{
m_distance1 = dist;
}

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

@@ -32,10 +32,10 @@ struct MyResult : public btDiscreteCollisionDetectorInterface::Result
float m_depth;
bool m_hasResult;
virtual void SetShapeIdentifiers(int partId0,int index0, int partId1,int index1)
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,float depth)
{
m_normalOnBInWorld = normalOnBInWorld;
m_pointInWorld = pointInWorld;
@@ -92,7 +92,7 @@ btVector3(0.162456f , 0.499995f,0.850654f)
};
bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& simplexSolver,
bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& simplexSolver,
btConvexShape* convexA,btConvexShape* convexB,
const btTransform& transA,const btTransform& transB,
btVector3& v, btPoint3& pa, btPoint3& pb,
@@ -123,8 +123,8 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
seperatingAxisInBBatch[i] = norm * transB.getBasis();
}
convexA->BatchedUnitVectorGetSupportingVertexWithoutMargin(seperatingAxisInABatch,supportVerticesABatch,NUM_UNITSPHERE_POINTS);
convexB->BatchedUnitVectorGetSupportingVertexWithoutMargin(seperatingAxisInBBatch,supportVerticesBBatch,NUM_UNITSPHERE_POINTS);
convexA->batchedUnitVectorGetSupportingVertexWithoutMargin(seperatingAxisInABatch,supportVerticesABatch,NUM_UNITSPHERE_POINTS);
convexB->batchedUnitVectorGetSupportingVertexWithoutMargin(seperatingAxisInBBatch,supportVerticesBBatch,NUM_UNITSPHERE_POINTS);
for (i=0;i<NUM_UNITSPHERE_POINTS;i++)
{
const btVector3& norm = sPenetrationDirections[i];
@@ -153,8 +153,8 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
const btVector3& norm = sPenetrationDirections[i];
seperatingAxisInA = (-norm)* transA.getBasis();
seperatingAxisInB = norm* transB.getBasis();
pInA = convexA->LocalGetSupportingVertexWithoutMargin(seperatingAxisInA);
qInB = convexB->LocalGetSupportingVertexWithoutMargin(seperatingAxisInB);
pInA = convexA->localGetSupportingVertexWithoutMargin(seperatingAxisInA);
qInB = convexB->localGetSupportingVertexWithoutMargin(seperatingAxisInB);
pWorld = transA(pInA);
qWorld = transB(qInB);
w = qWorld - pWorld;
@@ -172,9 +172,9 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
//add the margins
minA += minNorm*convexA->GetMargin();
minB -= minNorm*convexB->GetMargin();
minProj += (convexA->GetMargin() + convexB->GetMargin());
minA += minNorm*convexA->getMargin();
minB -= minNorm*convexB->getMargin();
minProj += (convexA->getMargin() + convexB->getMargin());
@@ -184,11 +184,11 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
if (debugDraw)
{
btVector3 color(0,1,0);
debugDraw->DrawLine(minA,minB,color);
debugDraw->drawLine(minA,minB,color);
color = btVector3 (1,1,1);
btVector3 vec = minB-minA;
float prj2 = minNorm.dot(vec);
debugDraw->DrawLine(minA,minA+(minNorm*minProj),color);
debugDraw->drawLine(minA,minA+(minNorm*minProj),color);
}
#endif //DEBUG_DRAW
@@ -214,7 +214,7 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
input.m_maximumDistanceSquared = 1e30f;//minProj;
MyResult res;
gjkdet.GetClosestPoints(input,res,debugDraw);
gjkdet.getClosestPoints(input,res,debugDraw);
float correctedMinNorm = minProj - res.m_depth;
@@ -233,7 +233,7 @@ bool btMinkowskiPenetrationDepthSolver::CalcPenDepth(btSimplexSolverInterface& s
if (debugDraw)
{
btVector3 color(1,0,0);
debugDraw->DrawLine(pa,pb,color);
debugDraw->drawLine(pa,pb,color);
}
#endif//DEBUG_DRAW

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

@@ -24,7 +24,7 @@ class btMinkowskiPenetrationDepthSolver : public btConvexPenetrationDepthSolver
{
public:
virtual bool CalcPenDepth( btSimplexSolverInterface& simplexSolver,
virtual bool calcPenDepth( btSimplexSolverInterface& simplexSolver,
btConvexShape* convexA,btConvexShape* convexB,
const btTransform& transA,const btTransform& transB,
btVector3& v, btPoint3& pa, btPoint3& pb,

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

@@ -32,12 +32,12 @@ m_index1(0)
}
void btPersistentManifold::ClearManifold()
void btPersistentManifold::clearManifold()
{
int i;
for (i=0;i<m_cachedPoints;i++)
{
ClearUserCache(m_pointCache[i]);
clearUserCache(m_pointCache[i]);
}
m_cachedPoints = 0;
}
@@ -55,7 +55,7 @@ void btPersistentManifold::DebugPersistency()
}
#endif //DEBUG_PERSISTENCY
void btPersistentManifold::ClearUserCache(btManifoldPoint& pt)
void btPersistentManifold::clearUserCache(btManifoldPoint& pt)
{
void* oldPtr = pt.m_userPersistentData;
@@ -70,7 +70,7 @@ void btPersistentManifold::ClearUserCache(btManifoldPoint& pt)
{
occurance++;
if (occurance>1)
printf("error in ClearUserCache\n");
printf("error in clearUserCache\n");
}
}
assert(occurance<=0);
@@ -91,7 +91,7 @@ void btPersistentManifold::ClearUserCache(btManifoldPoint& pt)
}
int btPersistentManifold::SortCachedPoints(const btManifoldPoint& pt)
int btPersistentManifold::sortCachedPoints(const btManifoldPoint& pt)
{
//calculate 4 possible cases areas, and take biggest area
@@ -100,13 +100,13 @@ int btPersistentManifold::SortCachedPoints(const btManifoldPoint& pt)
int maxPenetrationIndex = -1;
#define KEEP_DEEPEST_POINT 1
#ifdef KEEP_DEEPEST_POINT
float maxPenetration = pt.GetDistance();
float maxPenetration = pt.getDistance();
for (int i=0;i<4;i++)
{
if (m_pointCache[i].GetDistance() < maxPenetration)
if (m_pointCache[i].getDistance() < maxPenetration)
{
maxPenetrationIndex = i;
maxPenetration = m_pointCache[i].GetDistance();
maxPenetration = m_pointCache[i].getDistance();
}
}
#endif //KEEP_DEEPEST_POINT
@@ -149,10 +149,10 @@ int btPersistentManifold::SortCachedPoints(const btManifoldPoint& pt)
}
int btPersistentManifold::GetCacheEntry(const btManifoldPoint& newPoint) const
int btPersistentManifold::getCacheEntry(const btManifoldPoint& newPoint) const
{
btScalar shortestDist = GetContactBreakingTreshold() * GetContactBreakingTreshold();
int size = GetNumContacts();
btScalar shortestDist = getContactBreakingTreshold() * getContactBreakingTreshold();
int size = getNumContacts();
int nearestPoint = -1;
for( int i = 0; i < size; i++ )
{
@@ -171,14 +171,14 @@ int btPersistentManifold::GetCacheEntry(const btManifoldPoint& newPoint) const
void btPersistentManifold::AddManifoldPoint(const btManifoldPoint& newPoint)
{
assert(ValidContactDistance(newPoint));
assert(validContactDistance(newPoint));
int insertIndex = GetNumContacts();
int insertIndex = getNumContacts();
if (insertIndex == MANIFOLD_CACHE_SIZE)
{
#if MANIFOLD_CACHE_SIZE >= 4
//sort cache so best points come first, based on area
insertIndex = SortCachedPoints(newPoint);
insertIndex = sortCachedPoints(newPoint);
#else
insertIndex = 0;
#endif
@@ -190,20 +190,20 @@ void btPersistentManifold::AddManifoldPoint(const btManifoldPoint& newPoint)
}
ReplaceContactPoint(newPoint,insertIndex);
replaceContactPoint(newPoint,insertIndex);
}
float btPersistentManifold::GetContactBreakingTreshold() const
float btPersistentManifold::getContactBreakingTreshold() const
{
return gContactBreakingTreshold;
}
void btPersistentManifold::RefreshContactPoints(const btTransform& trA,const btTransform& trB)
void btPersistentManifold::refreshContactPoints(const btTransform& trA,const btTransform& trB)
{
int i;
/// first refresh worldspace positions and distance
for (i=GetNumContacts()-1;i>=0;i--)
for (i=getNumContacts()-1;i>=0;i--)
{
btManifoldPoint &manifoldPoint = m_pointCache[i];
manifoldPoint.m_positionWorldOnA = trA( manifoldPoint.m_localPointA );
@@ -215,23 +215,23 @@ void btPersistentManifold::RefreshContactPoints(const btTransform& trA,const btT
/// then
btScalar distance2d;
btVector3 projectedDifference,projectedPoint;
for (i=GetNumContacts()-1;i>=0;i--)
for (i=getNumContacts()-1;i>=0;i--)
{
btManifoldPoint &manifoldPoint = m_pointCache[i];
//contact becomes invalid when signed distance exceeds margin (projected on contactnormal direction)
if (!ValidContactDistance(manifoldPoint))
if (!validContactDistance(manifoldPoint))
{
RemoveContactPoint(i);
removeContactPoint(i);
} else
{
//contact also becomes invalid when relative movement orthogonal to normal exceeds margin
projectedPoint = manifoldPoint.m_positionWorldOnA - manifoldPoint.m_normalWorldOnB * manifoldPoint.m_distance1;
projectedDifference = manifoldPoint.m_positionWorldOnB - projectedPoint;
distance2d = projectedDifference.dot(projectedDifference);
if (distance2d > GetContactBreakingTreshold()*GetContactBreakingTreshold() )
if (distance2d > getContactBreakingTreshold()*getContactBreakingTreshold() )
{
RemoveContactPoint(i);
removeContactPoint(i);
}
}
}

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

@@ -49,9 +49,9 @@ class btPersistentManifold
/// sort cached points so most isolated points come first
int SortCachedPoints(const btManifoldPoint& pt);
int sortCachedPoints(const btManifoldPoint& pt);
int FindContactPoint(const btManifoldPoint* unUsed, int numUnused,const btManifoldPoint& pt);
int findContactPoint(const btManifoldPoint* unUsed, int numUnused,const btManifoldPoint& pt);
public:
@@ -64,72 +64,72 @@ public:
{
}
inline void* GetBody0() { return m_body0;}
inline void* GetBody1() { return m_body1;}
inline void* getBody0() { return m_body0;}
inline void* getBody1() { return m_body1;}
inline const void* GetBody0() const { return m_body0;}
inline const void* GetBody1() const { return m_body1;}
inline const void* getBody0() const { return m_body0;}
inline const void* getBody1() const { return m_body1;}
void SetBodies(void* body0,void* body1)
void setBodies(void* body0,void* body1)
{
m_body0 = body0;
m_body1 = body1;
}
void ClearUserCache(btManifoldPoint& pt);
void clearUserCache(btManifoldPoint& pt);
#ifdef DEBUG_PERSISTENCY
void DebugPersistency();
#endif //
inline int GetNumContacts() const { return m_cachedPoints;}
inline int getNumContacts() const { return m_cachedPoints;}
inline const btManifoldPoint& GetContactPoint(int index) const
inline const btManifoldPoint& getContactPoint(int index) const
{
ASSERT(index < m_cachedPoints);
return m_pointCache[index];
}
inline btManifoldPoint& GetContactPoint(int index)
inline btManifoldPoint& getContactPoint(int index)
{
ASSERT(index < m_cachedPoints);
return m_pointCache[index];
}
/// todo: get this margin from the current physics / collision environment
float GetContactBreakingTreshold() const;
float getContactBreakingTreshold() const;
int GetCacheEntry(const btManifoldPoint& newPoint) const;
int getCacheEntry(const btManifoldPoint& newPoint) const;
void AddManifoldPoint( const btManifoldPoint& newPoint);
void RemoveContactPoint (int index)
void removeContactPoint (int index)
{
ClearUserCache(m_pointCache[index]);
clearUserCache(m_pointCache[index]);
int lastUsedIndex = GetNumContacts() - 1;
int lastUsedIndex = getNumContacts() - 1;
m_pointCache[index] = m_pointCache[lastUsedIndex];
//get rid of duplicated userPersistentData pointer
m_pointCache[lastUsedIndex].m_userPersistentData = 0;
m_cachedPoints--;
}
void ReplaceContactPoint(const btManifoldPoint& newPoint,int insertIndex)
void replaceContactPoint(const btManifoldPoint& newPoint,int insertIndex)
{
assert(ValidContactDistance(newPoint));
assert(validContactDistance(newPoint));
ClearUserCache(m_pointCache[insertIndex]);
clearUserCache(m_pointCache[insertIndex]);
m_pointCache[insertIndex] = newPoint;
}
bool ValidContactDistance(const btManifoldPoint& pt) const
bool validContactDistance(const btManifoldPoint& pt) const
{
return pt.m_distance1 <= GetContactBreakingTreshold();
return pt.m_distance1 <= getContactBreakingTreshold();
}
/// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
void RefreshContactPoints( const btTransform& trA,const btTransform& trB);
void refreshContactPoints( const btTransform& trA,const btTransform& trB);
void ClearManifold();
void clearManifold();

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

@@ -35,12 +35,12 @@ struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result
{
}
virtual void SetShapeIdentifiers(int partId0,int index0, int partId1,int index1)
virtual void setShapeIdentifiers(int partId0,int index0, int partId1,int index1)
{
//??
}
virtual void AddContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
{
if (depth< m_distance)
{

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

@@ -27,7 +27,7 @@ btTriangleRaycastCallback::btTriangleRaycastCallback(const btVector3& from,const
void btTriangleRaycastCallback::ProcessTriangle(btVector3* triangle,int partId, int triangleIndex)
void btTriangleRaycastCallback::processTriangle(btVector3* triangle,int partId, int triangleIndex)
{
@@ -87,11 +87,11 @@ void btTriangleRaycastCallback::ProcessTriangle(btVector3* triangle,int partId,
if ( dist_a > 0 )
{
m_hitFraction = ReportHit(triangleNormal,distance,partId,triangleIndex);
m_hitFraction = reportHit(triangleNormal,distance,partId,triangleIndex);
}
else
{
m_hitFraction = ReportHit(-triangleNormal,distance,partId,triangleIndex);
m_hitFraction = reportHit(-triangleNormal,distance,partId,triangleIndex);
}
}
}

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

@@ -32,9 +32,9 @@ public:
btTriangleRaycastCallback(const btVector3& from,const btVector3& to);
virtual void ProcessTriangle(btVector3* triangle, int partId, int triangleIndex);
virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
virtual float ReportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex ) = 0;
virtual float reportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex ) = 0;
};

6
src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp
View File

@@ -49,7 +49,7 @@ bool btSubsimplexConvexCast::calcTimeOfImpact(
m_simplexSolver->reset();
convex->SetTransformB(btTransform(rayFromLocalA.getBasis()));
convex->setTransformB(btTransform(rayFromLocalA.getBasis()));
//float radius = 0.01f;
@@ -61,7 +61,7 @@ bool btSubsimplexConvexCast::calcTimeOfImpact(
btVector3 r = -(rayToLocalA.getOrigin()-rayFromLocalA.getOrigin());
btVector3 x = s;
btVector3 v;
btVector3 arbitraryPoint = convex->LocalGetSupportingVertex(r);
btVector3 arbitraryPoint = convex->localGetSupportingVertex(r);
v = x - arbitraryPoint;
@@ -83,7 +83,7 @@ bool btSubsimplexConvexCast::calcTimeOfImpact(
while ( (dist2 > epsilon) && maxIter--)
{
p = convex->LocalGetSupportingVertex( v);
p = convex->localGetSupportingVertex( v);
w = x - p;
float VdotW = v.dot(w);

80
src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp
View File

@@ -44,7 +44,7 @@ void btVoronoiSimplexSolver::removeVertex(int index)
m_simplexPointsQ[index] = m_simplexPointsQ[m_numVertices];
}
void btVoronoiSimplexSolver::ReduceVertices (const btUsageBitfield& usedVerts)
void btVoronoiSimplexSolver::reduceVertices (const btUsageBitfield& usedVerts)
{
if ((numVertices() >= 4) && (!usedVerts.usedVertexD))
removeVertex(3);
@@ -71,7 +71,7 @@ void btVoronoiSimplexSolver::reset()
m_numVertices = 0;
m_needsUpdate = true;
m_lastW = btVector3(1e30f,1e30f,1e30f);
m_cachedBC.Reset();
m_cachedBC.reset();
}
@@ -89,12 +89,12 @@ void btVoronoiSimplexSolver::addVertex(const btVector3& w, const btPoint3& p, co
m_numVertices++;
}
bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
bool btVoronoiSimplexSolver::updateClosestVectorAndPoints()
{
if (m_needsUpdate)
{
m_cachedBC.Reset();
m_cachedBC.reset();
m_needsUpdate = false;
@@ -108,9 +108,9 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
m_cachedP1 = m_simplexPointsP[0];
m_cachedP2 = m_simplexPointsQ[0];
m_cachedV = m_cachedP1-m_cachedP2; //== m_simplexVectorW[0]
m_cachedBC.Reset();
m_cachedBC.SetBarycentricCoordinates(1.f,0.f,0.f,0.f);
m_cachedValidClosest = m_cachedBC.IsValid();
m_cachedBC.reset();
m_cachedBC.setBarycentricCoordinates(1.f,0.f,0.f,0.f);
m_cachedValidClosest = m_cachedBC.isValid();
break;
};
case 2:
@@ -144,16 +144,16 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
//reduce to 1 point
m_cachedBC.m_usedVertices.usedVertexA = true;
}
m_cachedBC.SetBarycentricCoordinates(1-t,t);
m_cachedBC.setBarycentricCoordinates(1-t,t);
nearest = from + t*v;
m_cachedP1 = m_simplexPointsP[0] + t * (m_simplexPointsP[1] - m_simplexPointsP[0]);
m_cachedP2 = m_simplexPointsQ[0] + t * (m_simplexPointsQ[1] - m_simplexPointsQ[0]);
m_cachedV = m_cachedP1 - m_cachedP2;
ReduceVertices(m_cachedBC.m_usedVertices);
reduceVertices(m_cachedBC.m_usedVertices);
m_cachedValidClosest = m_cachedBC.IsValid();
m_cachedValidClosest = m_cachedBC.isValid();
break;
}
case 3:
@@ -165,7 +165,7 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
const btVector3& b = m_simplexVectorW[1];
const btVector3& c = m_simplexVectorW[2];
ClosestPtPointTriangle(p,a,b,c,m_cachedBC);
closestPtPointTriangle(p,a,b,c,m_cachedBC);
m_cachedP1 = m_simplexPointsP[0] * m_cachedBC.m_barycentricCoords[0] +
m_simplexPointsP[1] * m_cachedBC.m_barycentricCoords[1] +
m_simplexPointsP[2] * m_cachedBC.m_barycentricCoords[2] +
@@ -178,8 +178,8 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
m_cachedV = m_cachedP1-m_cachedP2;
ReduceVertices (m_cachedBC.m_usedVertices);
m_cachedValidClosest = m_cachedBC.IsValid();
reduceVertices (m_cachedBC.m_usedVertices);
m_cachedValidClosest = m_cachedBC.isValid();
break;
}
@@ -194,7 +194,7 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
const btVector3& c = m_simplexVectorW[2];
const btVector3& d = m_simplexVectorW[3];
bool hasSeperation = ClosestPtPointTetrahedron(p,a,b,c,d,m_cachedBC);
bool hasSeperation = closestPtPointTetrahedron(p,a,b,c,d,m_cachedBC);
if (hasSeperation)
{
@@ -210,7 +210,7 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
m_simplexPointsQ[3] * m_cachedBC.m_barycentricCoords[3];
m_cachedV = m_cachedP1-m_cachedP2;
ReduceVertices (m_cachedBC.m_usedVertices);
reduceVertices (m_cachedBC.m_usedVertices);
} else
{
// printf("sub distance got penetration\n");
@@ -227,7 +227,7 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
break;
}
m_cachedValidClosest = m_cachedBC.IsValid();
m_cachedValidClosest = m_cachedBC.isValid();
//closest point origin from tetrahedron
break;
@@ -246,7 +246,7 @@ bool btVoronoiSimplexSolver::UpdateClosestVectorAndPoints()
//return/calculate the closest vertex
bool btVoronoiSimplexSolver::closest(btVector3& v)
{
bool succes = UpdateClosestVectorAndPoints();
bool succes = updateClosestVectorAndPoints();
v = m_cachedV;
return succes;
}
@@ -318,7 +318,7 @@ bool btVoronoiSimplexSolver::emptySimplex() const
void btVoronoiSimplexSolver::compute_points(btPoint3& p1, btPoint3& p2)
{
UpdateClosestVectorAndPoints();
updateClosestVectorAndPoints();
p1 = m_cachedP1;
p2 = m_cachedP2;
@@ -327,7 +327,7 @@ void btVoronoiSimplexSolver::compute_points(btPoint3& p1, btPoint3& p2)
bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c,btSubSimplexClosestResult& result)
bool btVoronoiSimplexSolver::closestPtPointTriangle(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c,btSubSimplexClosestResult& result)
{
result.m_usedVertices.reset();
@@ -341,7 +341,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
{
result.m_closestPointOnSimplex = a;
result.m_usedVertices.usedVertexA = true;
result.SetBarycentricCoordinates(1,0,0);
result.setBarycentricCoordinates(1,0,0);
return true;// a; // barycentric coordinates (1,0,0)
}
@@ -353,7 +353,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
{
result.m_closestPointOnSimplex = b;
result.m_usedVertices.usedVertexB = true;
result.SetBarycentricCoordinates(0,1,0);
result.setBarycentricCoordinates(0,1,0);
return true; // b; // barycentric coordinates (0,1,0)
}
@@ -364,7 +364,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
result.m_closestPointOnSimplex = a + v * ab;
result.m_usedVertices.usedVertexA = true;
result.m_usedVertices.usedVertexB = true;
result.SetBarycentricCoordinates(1-v,v,0);
result.setBarycentricCoordinates(1-v,v,0);
return true;
//return a + v * ab; // barycentric coordinates (1-v,v,0)
}
@@ -377,7 +377,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
{
result.m_closestPointOnSimplex = c;
result.m_usedVertices.usedVertexC = true;
result.SetBarycentricCoordinates(0,0,1);
result.setBarycentricCoordinates(0,0,1);
return true;//c; // barycentric coordinates (0,0,1)
}
@@ -388,7 +388,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
result.m_closestPointOnSimplex = a + w * ac;
result.m_usedVertices.usedVertexA = true;
result.m_usedVertices.usedVertexC = true;
result.SetBarycentricCoordinates(1-w,0,w);
result.setBarycentricCoordinates(1-w,0,w);
return true;
//return a + w * ac; // barycentric coordinates (1-w,0,w)
}
@@ -401,7 +401,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
result.m_closestPointOnSimplex = b + w * (c - b);
result.m_usedVertices.usedVertexB = true;
result.m_usedVertices.usedVertexC = true;
result.SetBarycentricCoordinates(0,1-w,w);
result.setBarycentricCoordinates(0,1-w,w);
return true;
// return b + w * (c - b); // barycentric coordinates (0,1-w,w)
}
@@ -415,7 +415,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
result.m_usedVertices.usedVertexA = true;
result.m_usedVertices.usedVertexB = true;
result.m_usedVertices.usedVertexC = true;
result.SetBarycentricCoordinates(1-v-w,v,w);
result.setBarycentricCoordinates(1-v-w,v,w);
return true;
// return a + ab * v + ac * w; // = u*a + v*b + w*c, u = va * denom = 1.0f - v - w
@@ -427,7 +427,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTriangle(const btPoint3& p, const btP
/// Test if point p and d lie on opposite sides of plane through abc
int btVoronoiSimplexSolver::PointOutsideOfPlane(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d)
int btVoronoiSimplexSolver::pointOutsideOfPlane(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d)
{
btVector3 normal = (b-a).cross(c-a);
@@ -446,7 +446,7 @@ int btVoronoiSimplexSolver::PointOutsideOfPlane(const btPoint3& p, const btPoint
}
bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d, btSubSimplexClosestResult& finalResult)
bool btVoronoiSimplexSolver::closestPtPointTetrahedron(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d, btSubSimplexClosestResult& finalResult)
{
btSubSimplexClosestResult tempResult;
@@ -458,10 +458,10 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
finalResult.m_usedVertices.usedVertexC = true;
finalResult.m_usedVertices.usedVertexD = true;
int pointOutsideABC = PointOutsideOfPlane(p, a, b, c, d);
int pointOutsideACD = PointOutsideOfPlane(p, a, c, d, b);
int pointOutsideADB = PointOutsideOfPlane(p, a, d, b, c);
int pointOutsideBDC = PointOutsideOfPlane(p, b, d, c, a);
int pointOutsideABC = pointOutsideOfPlane(p, a, b, c, d);
int pointOutsideACD = pointOutsideOfPlane(p, a, c, d, b);
int pointOutsideADB = pointOutsideOfPlane(p, a, d, b, c);
int pointOutsideBDC = pointOutsideOfPlane(p, b, d, c, a);
if (pointOutsideABC < 0 || pointOutsideACD < 0 || pointOutsideADB < 0 || pointOutsideBDC < 0)
{
@@ -479,7 +479,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
// If point outside face abc then compute closest point on abc
if (pointOutsideABC)
{
ClosestPtPointTriangle(p, a, b, c,tempResult);
closestPtPointTriangle(p, a, b, c,tempResult);
btPoint3 q = tempResult.m_closestPointOnSimplex;
float sqDist = (q - p).dot( q - p);
@@ -492,7 +492,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA;
finalResult.m_usedVertices.usedVertexB = tempResult.m_usedVertices.usedVertexB;
finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexC;
finalResult.SetBarycentricCoordinates(
finalResult.setBarycentricCoordinates(
tempResult.m_barycentricCoords[VERTA],
tempResult.m_barycentricCoords[VERTB],
tempResult.m_barycentricCoords[VERTC],
@@ -506,7 +506,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
// Repeat test for face acd
if (pointOutsideACD)
{
ClosestPtPointTriangle(p, a, c, d,tempResult);
closestPtPointTriangle(p, a, c, d,tempResult);
btPoint3 q = tempResult.m_closestPointOnSimplex;
//convert result bitmask!
@@ -519,7 +519,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA;
finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexB;
finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexC;
finalResult.SetBarycentricCoordinates(
finalResult.setBarycentricCoordinates(
tempResult.m_barycentricCoords[VERTA],
0,
tempResult.m_barycentricCoords[VERTB],
@@ -533,7 +533,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
if (pointOutsideADB)
{
ClosestPtPointTriangle(p, a, d, b,tempResult);
closestPtPointTriangle(p, a, d, b,tempResult);
btPoint3 q = tempResult.m_closestPointOnSimplex;
//convert result bitmask!
@@ -546,7 +546,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA;
finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexB;
finalResult.m_usedVertices.usedVertexB = tempResult.m_usedVertices.usedVertexC;
finalResult.SetBarycentricCoordinates(
finalResult.setBarycentricCoordinates(
tempResult.m_barycentricCoords[VERTA],
tempResult.m_barycentricCoords[VERTC],
0,
@@ -560,7 +560,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
if (pointOutsideBDC)
{
ClosestPtPointTriangle(p, b, d, c,tempResult);
closestPtPointTriangle(p, b, d, c,tempResult);
btPoint3 q = tempResult.m_closestPointOnSimplex;
//convert result bitmask!
float sqDist = (q - p).dot( q - p);
@@ -573,7 +573,7 @@ bool btVoronoiSimplexSolver::ClosestPtPointTetrahedron(const btPoint3& p, const
finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexB;
finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexC;
finalResult.SetBarycentricCoordinates(
finalResult.setBarycentricCoordinates(
0,
tempResult.m_barycentricCoords[VERTA],
tempResult.m_barycentricCoords[VERTC],

18
src/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h
View File

@@ -58,13 +58,13 @@ struct btSubSimplexClosestResult
float m_barycentricCoords[4];
bool m_degenerate;
void Reset()
void reset()
{
m_degenerate = false;
SetBarycentricCoordinates();
setBarycentricCoordinates();
m_usedVertices.reset();
}
bool IsValid()
bool isValid()
{
bool valid = (m_barycentricCoords[0] >= 0.f) &&
(m_barycentricCoords[1] >= 0.f) &&
@@ -74,7 +74,7 @@ struct btSubSimplexClosestResult
return valid;
}
void SetBarycentricCoordinates(float a=0.f,float b=0.f,float c=0.f,float d=0.f)
void setBarycentricCoordinates(float a=0.f,float b=0.f,float c=0.f,float d=0.f)
{
m_barycentricCoords[0] = a;
m_barycentricCoords[1] = b;
@@ -113,12 +113,12 @@ public:
bool m_needsUpdate;
void removeVertex(int index);
void ReduceVertices (const btUsageBitfield& usedVerts);
bool UpdateClosestVectorAndPoints();
void reduceVertices (const btUsageBitfield& usedVerts);
bool updateClosestVectorAndPoints();
bool ClosestPtPointTetrahedron(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d, btSubSimplexClosestResult& finalResult);
int PointOutsideOfPlane(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d);
bool ClosestPtPointTriangle(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c,btSubSimplexClosestResult& result);
bool closestPtPointTetrahedron(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d, btSubSimplexClosestResult& finalResult);
int pointOutsideOfPlane(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c, const btPoint3& d);
bool closestPtPointTriangle(const btPoint3& p, const btPoint3& a, const btPoint3& b, const btPoint3& c,btSubSimplexClosestResult& result);
public: