Back to index

supertuxkart  0.5+dfsg1
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes
btSphereBoxCollisionAlgorithm Class Reference

btSphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response. More...

#include <btSphereBoxCollisionAlgorithm.h>

Inheritance diagram for btSphereBoxCollisionAlgorithm:
Inheritance graph
[legend]
Collaboration diagram for btSphereBoxCollisionAlgorithm:
Collaboration graph
[legend]

List of all members.

Classes

struct  CreateFunc

Public Member Functions

 btSphereBoxCollisionAlgorithm (btPersistentManifold *mf, const btCollisionAlgorithmConstructionInfo &ci, btCollisionObject *col0, btCollisionObject *col1, bool isSwapped)
virtual ~btSphereBoxCollisionAlgorithm ()
virtual void processCollision (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)
btScalar getSpherePenetration (btCollisionObject *boxObj, btVector3 &v3PointOnBox, btVector3 &v3PointOnSphere, const btVector3 &v3SphereCenter, btScalar fRadius, const btVector3 &aabbMin, const btVector3 &aabbMax)

Protected Member Functions

int getDispatcherId ()

Protected Attributes

btDispatcherm_dispatcher

Private Attributes

bool m_ownManifold
btPersistentManifold * m_manifoldPtr
bool m_isSwapped

Detailed Description

btSphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response.

Definition at line 29 of file btSphereBoxCollisionAlgorithm.h.


Constructor & Destructor Documentation

btSphereBoxCollisionAlgorithm::btSphereBoxCollisionAlgorithm ( btPersistentManifold *  mf,
const btCollisionAlgorithmConstructionInfo ci,
btCollisionObject *  col0,
btCollisionObject *  col1,
bool  isSwapped 
)

Definition at line 23 of file btSphereBoxCollisionAlgorithm.cpp.

: btCollisionAlgorithm(ci),
m_ownManifold(false),
m_manifoldPtr(mf),
m_isSwapped(isSwapped)
{
       btCollisionObject* sphereObj = m_isSwapped? col1 : col0;
       btCollisionObject* boxObj = m_isSwapped? col0 : col1;
       
       if (!m_manifoldPtr && m_dispatcher->needsCollision(sphereObj,boxObj))
       {
              m_manifoldPtr = m_dispatcher->getNewManifold(sphereObj,boxObj);
              m_ownManifold = true;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 40 of file btSphereBoxCollisionAlgorithm.cpp.

Here is the call graph for this function:


Member Function Documentation

btScalar btSphereBoxCollisionAlgorithm::calculateTimeOfImpact ( btCollisionObject *  body0,
btCollisionObject *  body1,
const btDispatcherInfo dispatchInfo,
btManifoldResult resultOut 
) [virtual]

Implements btCollisionAlgorithm.

Definition at line 93 of file btSphereBoxCollisionAlgorithm.cpp.

{
       (void)resultOut;
       (void)dispatchInfo;
       (void)col0;
       (void)col1;

       //not yet
       return btScalar(1.);
}
int btCollisionAlgorithm::getDispatcherId ( ) [protected, inherited]
btScalar btSphereBoxCollisionAlgorithm::getSphereDistance ( btCollisionObject *  boxObj,
btVector3 v3PointOnBox,
btVector3 v3PointOnSphere,
const btVector3 v3SphereCenter,
btScalar  fRadius 
)

Definition at line 105 of file btSphereBoxCollisionAlgorithm.cpp.

{

       btScalar margins;
       btVector3 bounds[2];
       btBoxShape* boxShape= (btBoxShape*)boxObj->getCollisionShape();
       
       bounds[0] = -boxShape->getHalfExtentsWithoutMargin();
       bounds[1] = boxShape->getHalfExtentsWithoutMargin();

       margins = boxShape->getMargin();//also add sphereShape margin?

       const btTransform&   m44T = boxObj->getWorldTransform();

       btVector3     boundsVec[2];
       btScalar      fPenetration;

       boundsVec[0] = bounds[0];
       boundsVec[1] = bounds[1];

       btVector3     marginsVec( margins, margins, margins );

       // add margins
       bounds[0] += marginsVec;
       bounds[1] -= marginsVec;


       btVector3     tmp, prel, n[6], normal, v3P;
       btScalar   fSep = btScalar(10000000.0), fSepThis;

       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);
       
       bool   bFound = false;

       v3P = prel;

       for (int i=0;i<6;i++)
       {
              int j = i<3? 0:1;
              if ( (fSepThis = ((v3P-bounds[j]) .dot(n[i]))) > btScalar(0.0) )
              {
                     v3P = v3P - n[i]*fSepThis;         
                     bFound = true;
              }
       }
       
       //

       if ( bFound )
       {
              bounds[0] = boundsVec[0];
              bounds[1] = boundsVec[1];

              normal = (prel - v3P).normalize();
              pointOnBox = v3P + normal*margins;
              v3PointOnSphere = prel - normal*fRadius;

              if ( ((v3PointOnSphere - pointOnBox) .dot (normal)) > btScalar(0.0) )
              {
                     return btScalar(1.0);
              }

              // transform back in world space
              tmp = m44T( pointOnBox);
              pointOnBox    = tmp;
              tmp  = m44T( v3PointOnSphere);            
              v3PointOnSphere = tmp;
              btScalar fSeps2 = (pointOnBox-v3PointOnSphere).length2();
              
              //if this fails, fallback into deeper penetration case, below
              if (fSeps2 > SIMD_EPSILON)
              {
                     fSep = - btSqrt(fSeps2);
                     normal = (pointOnBox-v3PointOnSphere);
                     normal *= btScalar(1.)/fSep;
              }

              return fSep;
       }

       // Deep penetration case

       fPenetration = getSpherePenetration( boxObj,pointOnBox, v3PointOnSphere, sphereCenter, fRadius,bounds[0],bounds[1] );

       bounds[0] = boundsVec[0];
       bounds[1] = boundsVec[1];

       if ( fPenetration <= btScalar(0.0) )
              return (fPenetration-margins);
       else
              return btScalar(1.0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration ( btCollisionObject *  boxObj,
btVector3 v3PointOnBox,
btVector3 v3PointOnSphere,
const btVector3 v3SphereCenter,
btScalar  fRadius,
const btVector3 aabbMin,
const btVector3 aabbMax 
)

Definition at line 208 of file btSphereBoxCollisionAlgorithm.cpp.

{

       btVector3 bounds[2];

       bounds[0] = aabbMin;
       bounds[1] = aabbMax;

       btVector3     p0, tmp, prel, n[6], normal;
       btScalar   fSep = btScalar(-10000000.0), fSepThis;

       // set p0 and normal to a default value to shup up GCC
       p0.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
       normal.setValue(btScalar(0.), btScalar(0.), btScalar(0.));

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

       // convert  point in local space
       prel = m44T.invXform( sphereCenter);


       for (int i=0;i<6;i++)
       {
              int j = i<3 ? 0:1;
              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];
                     fSep = fSepThis;
              }
       }

       pointOnBox = prel - normal*(normal.dot((prel-p0)));
       v3PointOnSphere = pointOnBox + normal*fSep;

       // transform back in world space
       tmp  = m44T( pointOnBox);          
       pointOnBox    = tmp;
       tmp  = m44T( v3PointOnSphere);            v3PointOnSphere = tmp;
       normal = (pointOnBox-v3PointOnSphere).normalize();

       return fSep;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void btSphereBoxCollisionAlgorithm::processCollision ( btCollisionObject *  body0,
btCollisionObject *  body1,
const btDispatcherInfo dispatchInfo,
btManifoldResult resultOut 
) [virtual]

report a contact. internally this will be kept persistent, and contact reduction is done

Implements btCollisionAlgorithm.

Definition at line 51 of file btSphereBoxCollisionAlgorithm.cpp.

{
       (void)dispatchInfo;
       (void)resultOut;
       if (!m_manifoldPtr)
              return;

       btCollisionObject* sphereObj = m_isSwapped? body1 : body0;
       btCollisionObject* boxObj = m_isSwapped? body0 : body1;


       btSphereShape* sphere0 = (btSphereShape*)sphereObj->getCollisionShape();

       btVector3 normalOnSurfaceB;
       btVector3 pOnBox,pOnSphere;
       btVector3 sphereCenter = sphereObj->getWorldTransform().getOrigin();
       btScalar radius = sphere0->getRadius();
       
       btScalar dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);

       resultOut->setPersistentManifold(m_manifoldPtr);

       if (dist < SIMD_EPSILON)
       {
              btVector3 normalOnSurfaceB = (pOnBox- pOnSphere).normalize();


              resultOut->addContactPoint(normalOnSurfaceB,pOnBox,dist);
              
       }

       if (m_ownManifold)
       {
              if (m_manifoldPtr->getNumContacts())
              {
                     resultOut->refreshContactPoints();
              }
       }

}

Here is the call graph for this function:


Member Data Documentation

Definition at line 57 of file btCollisionAlgorithm.h.

Definition at line 33 of file btSphereBoxCollisionAlgorithm.h.

btPersistentManifold* btSphereBoxCollisionAlgorithm::m_manifoldPtr [private]

Definition at line 32 of file btSphereBoxCollisionAlgorithm.h.

Definition at line 31 of file btSphereBoxCollisionAlgorithm.h.


The documentation for this class was generated from the following files: