00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
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
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
00176
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
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
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;
00247 btVector3 m_rayToWorld;
00248
00249 btVector3 m_hitNormalWorld;
00250 btVector3 m_hitPointWorld;
00251
00252 virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
00253 {
00254
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;
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;
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
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