btCollisionWorld.h

Go to the documentation of this file.
00001 /*
00002 Bullet Continuous Collision Detection and Physics Library
00003 Copyright (c) 2003-2006 Erwin Coumans  http://bulletphysics.com/Bullet/
00004 
00005 This software is provided 'as-is', without any express or implied warranty.
00006 In no event will the authors be held liable for any damages arising from the use of this software.
00007 Permission is granted to anyone to use this software for any purpose, 
00008 including commercial applications, and to alter it and redistribute it freely, 
00009 subject to the following restrictions:
00010 
00011 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
00012 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
00013 3. This notice may not be removed or altered from any source distribution.
00014 */
00015 
00016 
00065 #ifndef BT_COLLISION_WORLD_H
00066 #define BT_COLLISION_WORLD_H
00067 
00068 class btStackAlloc;
00069 class btCollisionShape;
00070 class btConvexShape;
00071 class btBroadphaseInterface;
00072 class btSerializer;
00073 
00074 #include "LinearMath/btVector3.h"
00075 #include "LinearMath/btTransform.h"
00076 #include "btCollisionObject.h"
00077 #include "btCollisionDispatcher.h"
00078 #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
00079 #include "LinearMath/btAlignedObjectArray.h"
00080 
00082 class btCollisionWorld
00083 {
00084 
00085         
00086 protected:
00087 
00088         btAlignedObjectArray<btCollisionObject*>        m_collisionObjects;
00089         
00090         btDispatcher*   m_dispatcher1;
00091 
00092         btDispatcherInfo        m_dispatchInfo;
00093 
00094         btStackAlloc*   m_stackAlloc;
00095 
00096         btBroadphaseInterface*  m_broadphasePairCache;
00097 
00098         btIDebugDraw*   m_debugDrawer;
00099 
00102         bool m_forceUpdateAllAabbs;
00103 
00104         void    serializeCollisionObjects(btSerializer* serializer);
00105 
00106 public:
00107 
00108         //this constructor doesn't own the dispatcher and paircache/broadphase
00109         btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
00110 
00111         virtual ~btCollisionWorld();
00112 
00113         void    setBroadphase(btBroadphaseInterface*    pairCache)
00114         {
00115                 m_broadphasePairCache = pairCache;
00116         }
00117 
00118         const btBroadphaseInterface*    getBroadphase() const
00119         {
00120                 return m_broadphasePairCache;
00121         }
00122 
00123         btBroadphaseInterface*  getBroadphase()
00124         {
00125                 return m_broadphasePairCache;
00126         }
00127 
00128         btOverlappingPairCache* getPairCache()
00129         {
00130                 return m_broadphasePairCache->getOverlappingPairCache();
00131         }
00132 
00133 
00134         btDispatcher*   getDispatcher()
00135         {
00136                 return m_dispatcher1;
00137         }
00138 
00139         const btDispatcher*     getDispatcher() const
00140         {
00141                 return m_dispatcher1;
00142         }
00143 
00144         void    updateSingleAabb(btCollisionObject* colObj);
00145 
00146         virtual void    updateAabbs();
00147 
00150         virtual void    computeOverlappingPairs();
00151 
00152         
00153         virtual void    setDebugDrawer(btIDebugDraw*    debugDrawer)
00154         {
00155                         m_debugDrawer = debugDrawer;
00156         }
00157 
00158         virtual btIDebugDraw*   getDebugDrawer()
00159         {
00160                 return m_debugDrawer;
00161         }
00162 
00163         virtual void    debugDrawWorld();
00164 
00165         virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
00166 
00167 
00170         struct  LocalShapeInfo
00171         {
00172                 int     m_shapePart;
00173                 int     m_triangleIndex;
00174                 
00175                 //const btCollisionShape*       m_shapeTemp;
00176                 //const btTransform*    m_shapeLocalTransform;
00177         };
00178 
00179         struct  LocalRayResult
00180         {
00181                 LocalRayResult(const btCollisionObject* collisionObject, 
00182                         LocalShapeInfo* localShapeInfo,
00183                         const btVector3&                hitNormalLocal,
00184                         btScalar hitFraction)
00185                 :m_collisionObject(collisionObject),
00186                 m_localShapeInfo(localShapeInfo),
00187                 m_hitNormalLocal(hitNormalLocal),
00188                 m_hitFraction(hitFraction)
00189                 {
00190                 }
00191 
00192                 const btCollisionObject*                m_collisionObject;
00193                 LocalShapeInfo*                 m_localShapeInfo;
00194                 btVector3                               m_hitNormalLocal;
00195                 btScalar                                m_hitFraction;
00196 
00197         };
00198 
00200         struct  RayResultCallback
00201         {
00202                 btScalar        m_closestHitFraction;
00203                 const btCollisionObject*                m_collisionObject;
00204                 short int       m_collisionFilterGroup;
00205                 short int       m_collisionFilterMask;
00206                 //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke.
00207                 unsigned int m_flags;
00208 
00209                 virtual ~RayResultCallback()
00210                 {
00211                 }
00212                 bool    hasHit() const
00213                 {
00214                         return (m_collisionObject != 0);
00215                 }
00216 
00217                 RayResultCallback()
00218                         :m_closestHitFraction(btScalar(1.)),
00219                         m_collisionObject(0),
00220                         m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
00221                         m_collisionFilterMask(btBroadphaseProxy::AllFilter),
00222                         //@BP Mod
00223                         m_flags(0)
00224                 {
00225                 }
00226 
00227                 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
00228                 {
00229                         bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
00230                         collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
00231                         return collides;
00232                 }
00233 
00234 
00235                 virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
00236         };
00237 
00238         struct  ClosestRayResultCallback : public RayResultCallback
00239         {
00240                 ClosestRayResultCallback(const btVector3&       rayFromWorld,const btVector3&   rayToWorld)
00241                 :m_rayFromWorld(rayFromWorld),
00242                 m_rayToWorld(rayToWorld)
00243                 {
00244                 }
00245 
00246                 btVector3       m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
00247                 btVector3       m_rayToWorld;
00248 
00249                 btVector3       m_hitNormalWorld;
00250                 btVector3       m_hitPointWorld;
00251                         
00252                 virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
00253                 {
00254                         //caller already does the filter on the m_closestHitFraction
00255                         btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
00256                         
00257                         m_closestHitFraction = rayResult.m_hitFraction;
00258                         m_collisionObject = rayResult.m_collisionObject;
00259                         if (normalInWorldSpace)
00260                         {
00261                                 m_hitNormalWorld = rayResult.m_hitNormalLocal;
00262                         } else
00263                         {
00265                                 m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
00266                         }
00267                         m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
00268                         return rayResult.m_hitFraction;
00269                 }
00270         };
00271 
00272         struct  AllHitsRayResultCallback : public RayResultCallback
00273         {
00274                 AllHitsRayResultCallback(const btVector3&       rayFromWorld,const btVector3&   rayToWorld)
00275                 :m_rayFromWorld(rayFromWorld),
00276                 m_rayToWorld(rayToWorld)
00277                 {
00278                 }
00279 
00280                 btAlignedObjectArray<const btCollisionObject*>          m_collisionObjects;
00281 
00282                 btVector3       m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
00283                 btVector3       m_rayToWorld;
00284 
00285                 btAlignedObjectArray<btVector3> m_hitNormalWorld;
00286                 btAlignedObjectArray<btVector3> m_hitPointWorld;
00287                 btAlignedObjectArray<btScalar> m_hitFractions;
00288                         
00289                 virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
00290                 {
00291                         m_collisionObject = rayResult.m_collisionObject;
00292                         m_collisionObjects.push_back(rayResult.m_collisionObject);
00293                         btVector3 hitNormalWorld;
00294                         if (normalInWorldSpace)
00295                         {
00296                                 hitNormalWorld = rayResult.m_hitNormalLocal;
00297                         } else
00298                         {
00300                                 hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
00301                         }
00302                         m_hitNormalWorld.push_back(hitNormalWorld);
00303                         btVector3 hitPointWorld;
00304                         hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
00305                         m_hitPointWorld.push_back(hitPointWorld);
00306                         m_hitFractions.push_back(rayResult.m_hitFraction);
00307                         return m_closestHitFraction;
00308                 }
00309         };
00310 
00311 
00312         struct LocalConvexResult
00313         {
00314                 LocalConvexResult(const btCollisionObject*      hitCollisionObject, 
00315                         LocalShapeInfo* localShapeInfo,
00316                         const btVector3&                hitNormalLocal,
00317                         const btVector3&                hitPointLocal,
00318                         btScalar hitFraction
00319                         )
00320                 :m_hitCollisionObject(hitCollisionObject),
00321                 m_localShapeInfo(localShapeInfo),
00322                 m_hitNormalLocal(hitNormalLocal),
00323                 m_hitPointLocal(hitPointLocal),
00324                 m_hitFraction(hitFraction)
00325                 {
00326                 }
00327 
00328                 const btCollisionObject*                m_hitCollisionObject;
00329                 LocalShapeInfo*                 m_localShapeInfo;
00330                 btVector3                               m_hitNormalLocal;
00331                 btVector3                               m_hitPointLocal;
00332                 btScalar                                m_hitFraction;
00333         };
00334 
00336         struct  ConvexResultCallback
00337         {
00338                 btScalar        m_closestHitFraction;
00339                 short int       m_collisionFilterGroup;
00340                 short int       m_collisionFilterMask;
00341                 
00342                 ConvexResultCallback()
00343                         :m_closestHitFraction(btScalar(1.)),
00344                         m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
00345                         m_collisionFilterMask(btBroadphaseProxy::AllFilter)
00346                 {
00347                 }
00348 
00349                 virtual ~ConvexResultCallback()
00350                 {
00351                 }
00352                 
00353                 bool    hasHit() const
00354                 {
00355                         return (m_closestHitFraction < btScalar(1.));
00356                 }
00357 
00358                 
00359 
00360                 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
00361                 {
00362                         bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
00363                         collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
00364                         return collides;
00365                 }
00366 
00367                 virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
00368         };
00369 
00370         struct  ClosestConvexResultCallback : public ConvexResultCallback
00371         {
00372                 ClosestConvexResultCallback(const btVector3&    convexFromWorld,const btVector3&        convexToWorld)
00373                 :m_convexFromWorld(convexFromWorld),
00374                 m_convexToWorld(convexToWorld),
00375                 m_hitCollisionObject(0)
00376                 {
00377                 }
00378 
00379                 btVector3       m_convexFromWorld;//used to calculate hitPointWorld from hitFraction
00380                 btVector3       m_convexToWorld;
00381 
00382                 btVector3       m_hitNormalWorld;
00383                 btVector3       m_hitPointWorld;
00384                 const btCollisionObject*        m_hitCollisionObject;
00385                 
00386                 virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
00387                 {
00388 //caller already does the filter on the m_closestHitFraction
00389                         btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
00390                                                 
00391                         m_closestHitFraction = convexResult.m_hitFraction;
00392                         m_hitCollisionObject = convexResult.m_hitCollisionObject;
00393                         if (normalInWorldSpace)
00394                         {
00395                                 m_hitNormalWorld = convexResult.m_hitNormalLocal;
00396                         } else
00397                         {
00399                                 m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
00400                         }
00401                         m_hitPointWorld = convexResult.m_hitPointLocal;
00402                         return convexResult.m_hitFraction;
00403                 }
00404         };
00405 
00407         struct  ContactResultCallback
00408         {
00409                 short int       m_collisionFilterGroup;
00410                 short int       m_collisionFilterMask;
00411                 
00412                 ContactResultCallback()
00413                         :m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
00414                         m_collisionFilterMask(btBroadphaseProxy::AllFilter)
00415                 {
00416                 }
00417 
00418                 virtual ~ContactResultCallback()
00419                 {
00420                 }
00421                 
00422                 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
00423                 {
00424                         bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
00425                         collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
00426                         return collides;
00427                 }
00428 
00429                 virtual btScalar        addSingleResult(btManifoldPoint& cp,    const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) = 0;
00430         };
00431 
00432 
00433 
00434         int     getNumCollisionObjects() const
00435         {
00436                 return int(m_collisionObjects.size());
00437         }
00438 
00441         virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; 
00442 
00445         void    convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback,  btScalar allowedCcdPenetration = btScalar(0.)) const;
00446 
00449         void    contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
00450 
00453         void    contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
00454 
00455 
00459         static void     rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
00460                                           btCollisionObject* collisionObject,
00461                                           const btCollisionShape* collisionShape,
00462                                           const btTransform& colObjWorldTransform,
00463                                           RayResultCallback& resultCallback);
00464 
00465         static void     rayTestSingleInternal(const btTransform& rayFromTrans,const btTransform& rayToTrans,
00466                                           const btCollisionObjectWrapper* collisionObjectWrap,
00467                                           RayResultCallback& resultCallback);
00468 
00470         static void     objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
00471                                           btCollisionObject* collisionObject,
00472                                           const btCollisionShape* collisionShape,
00473                                           const btTransform& colObjWorldTransform,
00474                                           ConvexResultCallback& resultCallback, btScalar        allowedPenetration);
00475 
00476         static void     objectQuerySingleInternal(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
00477                                                                                         const btCollisionObjectWrapper* colObjWrap,
00478                                                                                         ConvexResultCallback& resultCallback, btScalar allowedPenetration);
00479 
00480         virtual void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
00481 
00482         btCollisionObjectArray& getCollisionObjectArray()
00483         {
00484                 return m_collisionObjects;
00485         }
00486 
00487         const btCollisionObjectArray& getCollisionObjectArray() const
00488         {
00489                 return m_collisionObjects;
00490         }
00491 
00492 
00493         virtual void    removeCollisionObject(btCollisionObject* collisionObject);
00494 
00495         virtual void    performDiscreteCollisionDetection();
00496 
00497         btDispatcherInfo& getDispatchInfo()
00498         {
00499                 return m_dispatchInfo;
00500         }
00501 
00502         const btDispatcherInfo& getDispatchInfo() const
00503         {
00504                 return m_dispatchInfo;
00505         }
00506         
00507         bool    getForceUpdateAllAabbs() const
00508         {
00509                 return m_forceUpdateAllAabbs;
00510         }
00511         void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
00512         {
00513                 m_forceUpdateAllAabbs = forceUpdateAllAabbs;
00514         }
00515 
00517         virtual void    serialize(btSerializer* serializer);
00518 
00519 };
00520 
00521 
00522 #endif //BT_COLLISION_WORLD_H