Back to index

supertuxkart  0.5+dfsg1
Classes | Public Member Functions | Static Public Member Functions | Protected Attributes
btCollisionWorld Class Reference

CollisionWorld is interface and container for the collision detection. More...

#include <btCollisionWorld.h>

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

List of all members.

Classes

struct  ClosestConvexResultCallback
struct  ClosestRayResultCallback
struct  ConvexResultCallback
 RayResultCallback is used to report new raycast results. More...
struct  LocalConvexResult
struct  LocalRayResult
struct  LocalShapeInfo
 LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart. More...
struct  RayResultCallback
 RayResultCallback is used to report new raycast results. More...

Public Member Functions

 btCollisionWorld (btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
virtual ~btCollisionWorld ()
btBroadphaseInterfacegetBroadphase ()
btOverlappingPairCachegetPairCache ()
btDispatchergetDispatcher ()
virtual void updateAabbs ()
virtual void setDebugDrawer (btIDebugDraw *debugDrawer)
virtual btIDebugDrawgetDebugDrawer ()
int getNumCollisionObjects () const
void rayTest (const btVector3 &rayFromWorld, const btVector3 &rayToWorld, RayResultCallback &resultCallback, short int collisionFilterMask=-1)
 rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
void convexSweepTest (const btConvexShape *castShape, const btTransform &from, const btTransform &to, ConvexResultCallback &resultCallback, short int collisionFilterMask=-1)
void addCollisionObject (btCollisionObject *collisionObject, short int collisionFilterGroup=1, short int collisionFilterMask=1)
btCollisionObjectArraygetCollisionObjectArray ()
const btCollisionObjectArraygetCollisionObjectArray () const
void removeCollisionObject (btCollisionObject *collisionObject)
virtual void performDiscreteCollisionDetection ()
btDispatcherInfogetDispatchInfo ()

Static Public Member Functions

static void rayTestSingle (const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, RayResultCallback &resultCallback, short int collisionFilterMask=-1)
 rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. This allows more customization.
static void objectQuerySingle (const btConvexShape *castShape, const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, ConvexResultCallback &resultCallback, short int collisionFilterMask=-1)
 objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.

Protected Attributes

btAlignedObjectArray
< btCollisionObject * > 
m_collisionObjects
btDispatcherm_dispatcher1
btDispatcherInfo m_dispatchInfo
btStackAllocm_stackAlloc
btBroadphaseInterfacem_broadphasePairCache
btIDebugDrawm_debugDrawer

Detailed Description

CollisionWorld is interface and container for the collision detection.

Definition at line 79 of file btCollisionWorld.h.


Class Documentation

struct btCollisionWorld::LocalShapeInfo

LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart.

Definition at line 137 of file btCollisionWorld.h.

Class Members
int m_shapePart
int m_triangleIndex

Constructor & Destructor Documentation

btCollisionWorld::btCollisionWorld ( btDispatcher dispatcher,
btBroadphaseInterface broadphasePairCache,
btCollisionConfiguration collisionConfiguration 
)

Definition at line 42 of file btCollisionWorld.cpp.

Here is the call graph for this function:

Definition at line 52 of file btCollisionWorld.cpp.

{

       //clean up remaining objects
       int i;
       for (i=0;i<m_collisionObjects.size();i++)
       {
              btCollisionObject* collisionObject= m_collisionObjects[i];
              
              btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
              if (bp)
              {
                     //
                     // only clear the cached algorithms
                     //
                     getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp,m_dispatcher1);
                     getBroadphase()->destroyProxy(bp,m_dispatcher1);
              }
       }


}

Here is the call graph for this function:


Member Function Documentation

void btCollisionWorld::addCollisionObject ( btCollisionObject *  collisionObject,
short int  collisionFilterGroup = 1,
short int  collisionFilterMask = 1 
)

Definition at line 84 of file btCollisionWorld.cpp.

{

       //check that the object isn't already added
              btAssert( m_collisionObjects.findLinearSearch(collisionObject)  == m_collisionObjects.size());

              m_collisionObjects.push_back(collisionObject);

              //calculate new AABB
              btTransform trans = collisionObject->getWorldTransform();

              btVector3     minAabb;
              btVector3     maxAabb;
              collisionObject->getCollisionShape()->getAabb(trans,minAabb,maxAabb);

              int type = collisionObject->getCollisionShape()->getShapeType();
              collisionObject->setBroadphaseHandle( getBroadphase()->createProxy(
                     minAabb,
                     maxAabb,
                     type,
                     collisionObject,
                     collisionFilterGroup,
                     collisionFilterMask,
                     m_dispatcher1,0
                     ))     ;

              



}

Here is the call graph for this function:

Here is the caller graph for this function:

void btCollisionWorld::convexSweepTest ( const btConvexShape *  castShape,
const btTransform from,
const btTransform to,
ConvexResultCallback resultCallback,
short int  collisionFilterMask = -1 
)

go over all objects, and if the ray intersects their aabb + cast shape aabb,

Definition at line 618 of file btCollisionWorld.cpp.

{
       btTransform   convexFromTrans,convexToTrans;
       convexFromTrans = convexFromWorld;
       convexToTrans = convexToWorld;
       btVector3 castShapeAabbMin, castShapeAabbMax;
       /* Compute AABB that encompasses angular movement */
       {
              btVector3 linVel, angVel;
              btTransformUtil::calculateVelocity (convexFromTrans, convexToTrans, 1.0, linVel, angVel);
              btTransform R;
              R.setIdentity ();
              R.setRotation (convexFromTrans.getRotation());
              castShape->calculateTemporalAabb (R, linVel, angVel, 1.0, castShapeAabbMin, castShapeAabbMax);
       }

       // do a ray-shape query using convexCaster (CCD)
       int i;
       for (i=0;i<m_collisionObjects.size();i++)
       {
              btCollisionObject*   collisionObject= m_collisionObjects[i];
              //only perform raycast if filterMask matches
              if(collisionObject->getBroadphaseHandle()->m_collisionFilterGroup & collisionFilterMask) { 
                     //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
                     btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
                     collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
                     AabbExpand (collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
                     btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
                     btVector3 hitNormal;
                     if (btRayAabb(convexFromWorld.getOrigin(),convexToWorld.getOrigin(),collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
                     {
                            objectQuerySingle(castShape, convexFromTrans,convexToTrans,
                                   collisionObject,
                                          collisionObject->getCollisionShape(),
                                          collisionObject->getWorldTransform(),
                                          resultCallback);
                     }      
              }
       }

}

Here is the call graph for this function:

Definition at line 106 of file btCollisionWorld.h.

       {
              return m_broadphasePairCache;
       }

Here is the caller graph for this function:

Definition at line 333 of file btCollisionWorld.h.

       {
              return m_collisionObjects;
       }

Here is the caller graph for this function:

Definition at line 338 of file btCollisionWorld.h.

       {
              return m_collisionObjects;
       }
virtual btIDebugDraw* btCollisionWorld::getDebugDrawer ( ) [inline, virtual]

Definition at line 129 of file btCollisionWorld.h.

       {
              return m_debugDrawer;
       }

Here is the caller graph for this function:

Definition at line 117 of file btCollisionWorld.h.

       {
              return m_dispatcher1;
       }

Here is the caller graph for this function:

Definition at line 348 of file btCollisionWorld.h.

       {
              return m_dispatchInfo;
       }

Here is the caller graph for this function:

Definition at line 301 of file btCollisionWorld.h.

       {
              return int(m_collisionObjects.size());
       }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 111 of file btCollisionWorld.h.

Here is the call graph for this function:

Here is the caller graph for this function:

void btCollisionWorld::objectQuerySingle ( const btConvexShape *  castShape,
const btTransform rayFromTrans,
const btTransform rayToTrans,
btCollisionObject *  collisionObject,
const btCollisionShape collisionShape,
const btTransform colObjWorldTransform,
ConvexResultCallback resultCallback,
short int  collisionFilterMask = -1 
) [static]

objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.

Definition at line 393 of file btCollisionWorld.cpp.

{
       if (collisionShape->isConvex())
       {
              btConvexCast::CastResult castResult;
              castResult.m_fraction = btScalar(1.);//??

              btConvexShape* convexShape = (btConvexShape*) collisionShape;
              btVoronoiSimplexSolver      simplexSolver;
              btContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0);

              if (convexCaster.calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
              {
                     //add hit
                     if (castResult.m_normal.length2() > btScalar(0.0001))
                     {                                  
                            if (castResult.m_fraction < resultCallback.m_closestHitFraction)
                            {
                                   castResult.m_normal.normalize();
                                   btCollisionWorld::LocalConvexResult localConvexResult
                                                        (
                                                               collisionObject, 
                                                               0,
                                                               castResult.m_normal,
                                                               castResult.m_hitPoint,
                                                               castResult.m_fraction
                                                        );

                                   bool normalInWorldSpace = true;
                                   resultCallback.AddSingleResult(localConvexResult, normalInWorldSpace);

                            }
                     }
              }
       } else {
              if (collisionShape->isConcave())
              {
                     if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                     {
                            btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
                            btTransform worldTocollisionObject = colObjWorldTransform.inverse();
                            btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
                            btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
                            // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
                            btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());

                            //ConvexCast::CastResult
                            struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback 
                            {
                                   btCollisionWorld::ConvexResultCallback* m_resultCallback;
                                   btCollisionObject*   m_collisionObject;
                                   btTriangleMeshShape* m_triangleMesh;

                                   BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
                                          btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld):
                                          btTriangleConvexcastCallback(castShape, from,to, triangleToWorld),
                                                 m_resultCallback(resultCallback),
                                                 m_collisionObject(collisionObject),
                                                 m_triangleMesh(triangleMesh)
                                          {
                                          }


                                   virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
                                   {
                                          btCollisionWorld::LocalShapeInfo   shapeInfo;
                                          shapeInfo.m_shapePart = partId;
                                          shapeInfo.m_triangleIndex = triangleIndex;
                                          if (hitFraction <= m_resultCallback->m_closestHitFraction)
                                          {

                                                 btCollisionWorld::LocalConvexResult convexResult
                                                 (m_collisionObject, 
                                                        &shapeInfo,
                                                        hitNormalLocal,
                                                        hitPointLocal,
                                                        hitFraction);
                                                 
                                                 bool   normalInWorldSpace = true;

                                   
                                                 return m_resultCallback->AddSingleResult(convexResult,normalInWorldSpace);
                                          }
                                          return hitFraction;
                                   }

                            };

                            BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,triangleMesh, colObjWorldTransform);
                            tccb.m_hitFraction = resultCallback.m_closestHitFraction;
                            btVector3 boxMinLocal, boxMaxLocal;
                            castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
                            triangleMesh->performConvexcast(&tccb,convexFromLocal,convexToLocal,boxMinLocal, boxMaxLocal);
                     } else
                     {
                            btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
                            btTransform worldTocollisionObject = colObjWorldTransform.inverse();
                            btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
                            btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
                            // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
                            btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());

                            //ConvexCast::CastResult
                            struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback 
                            {
                                   btCollisionWorld::ConvexResultCallback* m_resultCallback;
                                   btCollisionObject*   m_collisionObject;
                                   btTriangleMeshShape* m_triangleMesh;

                                   BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
                                          btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld):
                                          btTriangleConvexcastCallback(castShape, from,to, triangleToWorld),
                                                 m_resultCallback(resultCallback),
                                                 m_collisionObject(collisionObject),
                                                 m_triangleMesh(triangleMesh)
                                          {
                                          }


                                   virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
                                   {
                                          btCollisionWorld::LocalShapeInfo   shapeInfo;
                                          shapeInfo.m_shapePart = partId;
                                          shapeInfo.m_triangleIndex = triangleIndex;
                                          if (hitFraction <= m_resultCallback->m_closestHitFraction)
                                          {

                                                 btCollisionWorld::LocalConvexResult convexResult
                                                 (m_collisionObject, 
                                                        &shapeInfo,
                                                        hitNormalLocal,
                                                        hitPointLocal,
                                                        hitFraction);
                                                 
                                                 bool   normalInWorldSpace = false;

                                                 return m_resultCallback->AddSingleResult(convexResult,normalInWorldSpace);
                                          }
                                          return hitFraction;
                                   }

                            };

                            BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,triangleMesh, colObjWorldTransform);
                            tccb.m_hitFraction = resultCallback.m_closestHitFraction;
                            btVector3 boxMinLocal, boxMaxLocal;
                            castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
                            
                            btVector3 rayAabbMinLocal = convexFromLocal;
                            rayAabbMinLocal.setMin(convexToLocal);
                            btVector3 rayAabbMaxLocal = convexFromLocal;
                            rayAabbMaxLocal.setMax(convexToLocal);
                            rayAabbMinLocal += boxMinLocal;
                            rayAabbMaxLocal += boxMaxLocal;
                            triangleMesh->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
                     }
              } else {
                     //todo: use AABB tree or other BVH acceleration structure!
                     if (collisionShape->isCompound())
                     {
                            const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
                            int i=0;
                            for (i=0;i<compoundShape->getNumChildShapes();i++)
                            {
                                   btTransform childTrans = compoundShape->getChildTransform(i);
                                   const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
                                   btTransform childWorldTrans = colObjWorldTransform * childTrans;
                                   objectQuerySingle(castShape, convexFromTrans,convexToTrans,
                                          collisionObject,
                                          childCollisionShape,
                                          childWorldTrans,
                                          resultCallback, collisionFilterMask);
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 159 of file btCollisionWorld.cpp.

{
       BT_PROFILE("performDiscreteCollisionDetection");

       btDispatcherInfo& dispatchInfo = getDispatchInfo();

       updateAabbs();

       {
              m_broadphasePairCache->calculateOverlappingPairs(m_dispatcher1);
       }


       btDispatcher* dispatcher = getDispatcher();
       {
              BT_PROFILE("dispatchAllCollisionPairs");
              if (dispatcher)
                     dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1);
       }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void btCollisionWorld::rayTest ( const btVector3 rayFromWorld,
const btVector3 rayToWorld,
RayResultCallback resultCallback,
short int  collisionFilterMask = -1 
)

rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.

go over all objects, and if the ray intersects their aabb, do a ray-shape query using convexCaster (CCD)

terminate further ray tests, once the closestHitFraction reached zero

Definition at line 575 of file btCollisionWorld.cpp.

{

       
       btTransform   rayFromTrans,rayToTrans;
       rayFromTrans.setIdentity();
       rayFromTrans.setOrigin(rayFromWorld);
       rayToTrans.setIdentity();
       
       rayToTrans.setOrigin(rayToWorld);

       
       int i;
       for (i=0;i<m_collisionObjects.size();i++)
       {
              if (resultCallback.m_closestHitFraction == btScalar(0.f))
                     break;

              btCollisionObject*   collisionObject= m_collisionObjects[i];
              //only perform raycast if filterMask matches
              if(collisionObject->getBroadphaseHandle()->m_collisionFilterGroup & collisionFilterMask) { 
                     //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
                     btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
                     collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);

                     btScalar hitLambda = resultCallback.m_closestHitFraction;
                     btVector3 hitNormal;
                     if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
                     {
                            rayTestSingle(rayFromTrans,rayToTrans,
                                   collisionObject,
                                          collisionObject->getCollisionShape(),
                                          collisionObject->getWorldTransform(),
                                          resultCallback);
                     }      
              }
              
       }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void btCollisionWorld::rayTestSingle ( const btTransform rayFromTrans,
const btTransform rayToTrans,
btCollisionObject *  collisionObject,
const btCollisionShape collisionShape,
const btTransform colObjWorldTransform,
RayResultCallback resultCallback,
short int  collisionFilterMask = -1 
) [static]

rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. This allows more customization.

optimized version for btBvhTriangleMeshShape

Definition at line 211 of file btCollisionWorld.cpp.

{
       btSphereShape pointShape(btScalar(0.0));
       pointShape.setMargin(0.f);
       const btConvexShape* castShape = &pointShape;

       if (collisionShape->isConvex())
       {
              btConvexCast::CastResult castResult;
              castResult.m_fraction = resultCallback.m_closestHitFraction;

              btConvexShape* convexShape = (btConvexShape*) collisionShape;
              btVoronoiSimplexSolver      simplexSolver;
#define USE_SUBSIMPLEX_CONVEX_CAST 1
#ifdef USE_SUBSIMPLEX_CONVEX_CAST
              btSubsimplexConvexCast convexCaster(castShape,convexShape,&simplexSolver);
#else
              //btGjkConvexCast    convexCaster(castShape,convexShape,&simplexSolver);
              //btContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0);
#endif //#USE_SUBSIMPLEX_CONVEX_CAST
                     
              if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
              {
                     //add hit
                     if (castResult.m_normal.length2() > btScalar(0.0001))
                     {                           
                            if (castResult.m_fraction < resultCallback.m_closestHitFraction)
                            {
#ifdef USE_SUBSIMPLEX_CONVEX_CAST
                                   //rotate normal into worldspace
                                   castResult.m_normal = rayFromTrans.getBasis() * castResult.m_normal;
#endif //USE_SUBSIMPLEX_CONVEX_CAST

                                   castResult.m_normal.normalize();
                                   btCollisionWorld::LocalRayResult localRayResult
                                          (
                                                 collisionObject, 
                                                 0,
                                                 castResult.m_normal,
                                                 castResult.m_fraction
                                          );

                                   bool normalInWorldSpace = true;
                                   resultCallback.AddSingleResult(localRayResult, normalInWorldSpace);

                            }
                     }
              }
       } else {
              if (collisionShape->isConcave())
              {
                     if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
                     {
                            btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
                            btTransform worldTocollisionObject = colObjWorldTransform.inverse();
                            btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
                            btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();

                            //ConvexCast::CastResult
                            struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback 
                            {
                                   btCollisionWorld::RayResultCallback* m_resultCallback;
                                   btCollisionObject*   m_collisionObject;
                                   btTriangleMeshShape* m_triangleMesh;

                                   BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
                                          btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape*    triangleMesh):
                                          btTriangleRaycastCallback(from,to),
                                                 m_resultCallback(resultCallback),
                                                 m_collisionObject(collisionObject),
                                                 m_triangleMesh(triangleMesh)
                                          {
                                          }


                                   virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
                                   {
                                          btCollisionWorld::LocalShapeInfo   shapeInfo;
                                          shapeInfo.m_shapePart = partId;
                                          shapeInfo.m_triangleIndex = triangleIndex;
                                          
                                          btCollisionWorld::LocalRayResult rayResult
                                          (m_collisionObject, 
                                                 &shapeInfo,
                                                 hitNormalLocal,
                                                 hitFraction);
                                          
                                          bool   normalInWorldSpace = false;
                                          return m_resultCallback->AddSingleResult(rayResult,normalInWorldSpace);
                                   }

                            };

                            BridgeTriangleRaycastCallback rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,triangleMesh);
                            rcb.m_hitFraction = resultCallback.m_closestHitFraction;
                            triangleMesh->performRaycast(&rcb,rayFromLocal,rayToLocal);
                     } else
                     {
                            btTriangleMeshShape* triangleMesh = (btTriangleMeshShape*)collisionShape;
                            
                            btTransform worldTocollisionObject = colObjWorldTransform.inverse();

                            btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
                            btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();

                            //ConvexCast::CastResult

                            struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback 
                            {
                                   btCollisionWorld::RayResultCallback* m_resultCallback;
                                   btCollisionObject*   m_collisionObject;
                                   btTriangleMeshShape* m_triangleMesh;

                                   BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
                                          btCollisionWorld::RayResultCallback* resultCallback, btCollisionObject* collisionObject,btTriangleMeshShape*    triangleMesh):
                                          btTriangleRaycastCallback(from,to),
                                                 m_resultCallback(resultCallback),
                                                 m_collisionObject(collisionObject),
                                                 m_triangleMesh(triangleMesh)
                                          {
                                          }


                                   virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
                                   {
                                          btCollisionWorld::LocalShapeInfo   shapeInfo;
                                          shapeInfo.m_shapePart = partId;
                                          shapeInfo.m_triangleIndex = triangleIndex;
                                          
                                          btCollisionWorld::LocalRayResult rayResult
                                          (m_collisionObject, 
                                                 &shapeInfo,
                                                 hitNormalLocal,
                                                 hitFraction);
                                          
                                          bool   normalInWorldSpace = false;
                                          return m_resultCallback->AddSingleResult(rayResult,normalInWorldSpace);
                                          
                                          
                                   }

                            };


                            BridgeTriangleRaycastCallback      rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,triangleMesh);
                            rcb.m_hitFraction = resultCallback.m_closestHitFraction;

                            btVector3 rayAabbMinLocal = rayFromLocal;
                            rayAabbMinLocal.setMin(rayToLocal);
                            btVector3 rayAabbMaxLocal = rayFromLocal;
                            rayAabbMaxLocal.setMax(rayToLocal);

                            triangleMesh->processAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
                     }
              } else {
                     //todo: use AABB tree or other BVH acceleration structure!
                     if (collisionShape->isCompound())
                     {
                            const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
                            int i=0;
                            for (i=0;i<compoundShape->getNumChildShapes();i++)
                            {
                                   btTransform childTrans = compoundShape->getChildTransform(i);
                                   const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
                                   btTransform childWorldTrans = colObjWorldTransform * childTrans;
                                   rayTestSingle(rayFromTrans,rayToTrans,
                                          collisionObject,
                                          childCollisionShape,
                                          childWorldTrans,
                                          resultCallback, collisionFilterMask);

                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void btCollisionWorld::removeCollisionObject ( btCollisionObject *  collisionObject)

Definition at line 183 of file btCollisionWorld.cpp.

{
       
       
       //bool removeFromBroadphase = false;
       
       {
              
              btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
              if (bp)
              {
                     //
                     // only clear the cached algorithms
                     //
                     getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp,m_dispatcher1);
                     getBroadphase()->destroyProxy(bp,m_dispatcher1);
                     collisionObject->setBroadphaseHandle(0);
              }
       }


       //swapremove
       m_collisionObjects.remove(collisionObject);

}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void btCollisionWorld::setDebugDrawer ( btIDebugDraw debugDrawer) [inline, virtual]

Definition at line 124 of file btCollisionWorld.h.

       {
                     m_debugDrawer = debugDrawer;
       }

Here is the caller graph for this function:

void btCollisionWorld::updateAabbs ( ) [virtual]

Reimplemented in btSimpleDynamicsWorld.

Definition at line 116 of file btCollisionWorld.cpp.

{
       BT_PROFILE("updateAabbs");
       
       btTransform predictedTrans;
       for ( int i=0;i<m_collisionObjects.size();i++)
       {
              btCollisionObject* colObj = m_collisionObjects[i];
              
              //only update aabb of active objects
              if (colObj->isActive())
              {
                     btPoint3 minAabb,maxAabb;
                     colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
                     btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;

                     //moving objects should be moderately sized, probably something wrong if not
                     if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < btScalar(1e12)))
                     {
                            bp->setAabb(colObj->getBroadphaseHandle(),minAabb,maxAabb, m_dispatcher1);
                     } else
                     {
                            //something went wrong, investigate
                            //this assert is unwanted in 3D modelers (danger of loosing work)
                            colObj->setActivationState(DISABLE_SIMULATION);
                            
                            static bool reportMe = true;
                            if (reportMe && m_debugDrawer)
                            {
                                   reportMe = false;
                                   m_debugDrawer->reportErrorWarning("Overflow in AABB, object removed from simulation");
                                   m_debugDrawer->reportErrorWarning("If you can reproduce this, please email bugs@continuousphysics.com\n");
                                   m_debugDrawer->reportErrorWarning("Please include above information, your Platform, version of OS.\n");
                                   m_debugDrawer->reportErrorWarning("Thanks.\n");
                            }
                     }
              }
       }
       
}

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 93 of file btCollisionWorld.h.

Definition at line 85 of file btCollisionWorld.h.

Definition at line 95 of file btCollisionWorld.h.

Definition at line 87 of file btCollisionWorld.h.

Definition at line 89 of file btCollisionWorld.h.

Definition at line 91 of file btCollisionWorld.h.


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