Bullet Collision Detection & Physics Library
btCollisionWorld.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 
72 #ifndef BT_COLLISION_WORLD_H
73 #define BT_COLLISION_WORLD_H
74 
75 class btCollisionShape;
76 class btConvexShape;
78 class btSerializer;
79 
80 #include "LinearMath/btVector3.h"
81 #include "LinearMath/btTransform.h"
82 #include "btCollisionObject.h"
83 #include "btCollisionDispatcher.h"
86 
89 {
90 
91 
92 protected:
93 
95 
97 
99 
101 
103 
107 
108  void serializeCollisionObjects(btSerializer* serializer);
109 
110  void serializeContactManifolds(btSerializer* serializer);
111 
112 
113 public:
114 
115  //this constructor doesn't own the dispatcher and paircache/broadphase
116  btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
117 
118  virtual ~btCollisionWorld();
119 
121  {
122  m_broadphasePairCache = pairCache;
123  }
124 
126  {
127  return m_broadphasePairCache;
128  }
129 
131  {
132  return m_broadphasePairCache;
133  }
134 
136  {
137  return m_broadphasePairCache->getOverlappingPairCache();
138  }
139 
140 
142  {
143  return m_dispatcher1;
144  }
145 
147  {
148  return m_dispatcher1;
149  }
150 
151  void updateSingleAabb(btCollisionObject* colObj);
152 
153  virtual void updateAabbs();
154 
157  virtual void computeOverlappingPairs();
158 
159 
160  virtual void setDebugDrawer(btIDebugDraw* debugDrawer)
161  {
162  m_debugDrawer = debugDrawer;
163  }
164 
166  {
167  return m_debugDrawer;
168  }
169 
170  virtual void debugDrawWorld();
171 
172  virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
173 
174 
178  {
181 
182  //const btCollisionShape* m_shapeTemp;
183  //const btTransform* m_shapeLocalTransform;
184  };
185 
187  {
188  LocalRayResult(const btCollisionObject* collisionObject,
189  LocalShapeInfo* localShapeInfo,
190  const btVector3& hitNormalLocal,
191  btScalar hitFraction)
192  :m_collisionObject(collisionObject),
193  m_localShapeInfo(localShapeInfo),
194  m_hitNormalLocal(hitNormalLocal),
195  m_hitFraction(hitFraction)
196  {
197  }
198 
203 
204  };
205 
208  {
213  //@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.
214  unsigned int m_flags;
215 
217  {
218  }
219  bool hasHit() const
220  {
221  return (m_collisionObject != 0);
222  }
223 
225  :m_closestHitFraction(btScalar(1.)),
226  m_collisionObject(0),
227  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
228  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
229  //@BP Mod
230  m_flags(0)
231  {
232  }
233 
234  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
235  {
236  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
237  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
238  return collides;
239  }
240 
241 
242  virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
243  };
244 
246  {
247  ClosestRayResultCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld)
248  :m_rayFromWorld(rayFromWorld),
249  m_rayToWorld(rayToWorld)
250  {
251  }
252 
253  btVector3 m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
255 
258 
259  virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
260  {
261  //caller already does the filter on the m_closestHitFraction
262  btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
263 
264  m_closestHitFraction = rayResult.m_hitFraction;
265  m_collisionObject = rayResult.m_collisionObject;
266  if (normalInWorldSpace)
267  {
268  m_hitNormalWorld = rayResult.m_hitNormalLocal;
269  } else
270  {
272  m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
273  }
274  m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
275  return rayResult.m_hitFraction;
276  }
277  };
278 
280  {
281  AllHitsRayResultCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld)
282  :m_rayFromWorld(rayFromWorld),
283  m_rayToWorld(rayToWorld)
284  {
285  }
286 
288 
289  btVector3 m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
291 
295 
296  virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
297  {
298  m_collisionObject = rayResult.m_collisionObject;
299  m_collisionObjects.push_back(rayResult.m_collisionObject);
300  btVector3 hitNormalWorld;
301  if (normalInWorldSpace)
302  {
303  hitNormalWorld = rayResult.m_hitNormalLocal;
304  } else
305  {
307  hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
308  }
309  m_hitNormalWorld.push_back(hitNormalWorld);
310  btVector3 hitPointWorld;
311  hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
312  m_hitPointWorld.push_back(hitPointWorld);
313  m_hitFractions.push_back(rayResult.m_hitFraction);
314  return m_closestHitFraction;
315  }
316  };
317 
318 
320  {
321  LocalConvexResult(const btCollisionObject* hitCollisionObject,
322  LocalShapeInfo* localShapeInfo,
323  const btVector3& hitNormalLocal,
324  const btVector3& hitPointLocal,
325  btScalar hitFraction
326  )
327  :m_hitCollisionObject(hitCollisionObject),
328  m_localShapeInfo(localShapeInfo),
329  m_hitNormalLocal(hitNormalLocal),
330  m_hitPointLocal(hitPointLocal),
331  m_hitFraction(hitFraction)
332  {
333  }
334 
340  };
341 
344  {
348 
350  :m_closestHitFraction(btScalar(1.)),
351  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
352  m_collisionFilterMask(btBroadphaseProxy::AllFilter)
353  {
354  }
355 
357  {
358  }
359 
360  bool hasHit() const
361  {
362  return (m_closestHitFraction < btScalar(1.));
363  }
364 
365 
366 
367  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
368  {
369  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
370  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
371  return collides;
372  }
373 
374  virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
375  };
376 
378  {
379  ClosestConvexResultCallback(const btVector3& convexFromWorld,const btVector3& convexToWorld)
380  :m_convexFromWorld(convexFromWorld),
381  m_convexToWorld(convexToWorld),
382  m_hitCollisionObject(0)
383  {
384  }
385 
386  btVector3 m_convexFromWorld;//used to calculate hitPointWorld from hitFraction
388 
392 
393  virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
394  {
395 //caller already does the filter on the m_closestHitFraction
396  btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
397 
398  m_closestHitFraction = convexResult.m_hitFraction;
399  m_hitCollisionObject = convexResult.m_hitCollisionObject;
400  if (normalInWorldSpace)
401  {
402  m_hitNormalWorld = convexResult.m_hitNormalLocal;
403  } else
404  {
406  m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
407  }
408  m_hitPointWorld = convexResult.m_hitPointLocal;
409  return convexResult.m_hitFraction;
410  }
411  };
412 
415  {
419 
421  :m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
422  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
423  m_closestDistanceThreshold(0)
424  {
425  }
426 
428  {
429  }
430 
431  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
432  {
433  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
434  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
435  return collides;
436  }
437 
438  virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) = 0;
439  };
440 
441 
442 
444  {
445  return int(m_collisionObjects.size());
446  }
447 
450  virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
451 
454  void convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const;
455 
458  void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
459 
462  void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
463 
464 
468  static void rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
469  btCollisionObject* collisionObject,
470  const btCollisionShape* collisionShape,
471  const btTransform& colObjWorldTransform,
472  RayResultCallback& resultCallback);
473 
474  static void rayTestSingleInternal(const btTransform& rayFromTrans,const btTransform& rayToTrans,
475  const btCollisionObjectWrapper* collisionObjectWrap,
476  RayResultCallback& resultCallback);
477 
479  static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
480  btCollisionObject* collisionObject,
481  const btCollisionShape* collisionShape,
482  const btTransform& colObjWorldTransform,
483  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
484 
485  static void objectQuerySingleInternal(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
486  const btCollisionObjectWrapper* colObjWrap,
487  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
488 
489  virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter);
490 
491  virtual void refreshBroadphaseProxy(btCollisionObject* collisionObject);
492 
493 
495  {
496  return m_collisionObjects;
497  }
498 
500  {
501  return m_collisionObjects;
502  }
503 
504 
505  virtual void removeCollisionObject(btCollisionObject* collisionObject);
506 
507  virtual void performDiscreteCollisionDetection();
508 
510  {
511  return m_dispatchInfo;
512  }
513 
515  {
516  return m_dispatchInfo;
517  }
518 
520  {
521  return m_forceUpdateAllAabbs;
522  }
523  void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
524  {
525  m_forceUpdateAllAabbs = forceUpdateAllAabbs;
526  }
527 
529  virtual void serialize(btSerializer* serializer);
530 
531 };
532 
533 
534 #endif //BT_COLLISION_WORLD_H
void serializeCollisionObjects(btSerializer *serializer)
void push_back(const T &_Val)
void serializeContactManifolds(btSerializer *serializer)
LocalRayResult(const btCollisionObject *collisionObject, LocalShapeInfo *localShapeInfo, const btVector3 &hitNormalLocal, btScalar hitFraction)
virtual void rayTest(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, RayResultCallback &resultCallback) const
rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback This ...
virtual void updateAabbs()
btDispatcherInfo m_dispatchInfo
btCollisionWorld(btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
for debug drawing
bool m_forceUpdateAllAabbs
m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs it is...
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
#define btAssert(x)
Definition: btScalar.h:131
btOverlappingPairCache * getPairCache()
ContactResultCallback is used to report contact points.
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
const btCollisionObject * m_collisionObject
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btCollisionObjectArray & getCollisionObjectArray()
RayResultCallback is used to report new raycast results.
int getNumCollisionObjects() const
ManifoldContactPoint collects and maintains persistent contactpoints.
btDispatcher * m_dispatcher1
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)
static void rayTestSingleInternal(const btTransform &rayFromTrans, const btTransform &rayToTrans, const btCollisionObjectWrapper *collisionObjectWrap, RayResultCallback &resultCallback)
virtual void computeOverlappingPairs()
the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSi...
The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape...
Definition: btConvexShape.h:31
The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
const btCollisionObject * m_hitCollisionObject
virtual btOverlappingPairCache * getOverlappingPairCache()=0
virtual void setDebugDrawer(btIDebugDraw *debugDrawer)
btTransform & getWorldTransform()
void setBroadphase(btBroadphaseInterface *pairCache)
const btDispatcher * getDispatcher() const
int size() const
return the number of elements in the array
btIDebugDraw * m_debugDrawer
const btCollisionObjectArray & getCollisionObjectArray() const
virtual btIDebugDraw * getDebugDrawer()
void contactPairTest(btCollisionObject *colObjA, btCollisionObject *colObjB, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between two collision objects and calls the resultCall...
void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
btAlignedObjectArray< btScalar > m_hitFractions
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
virtual void debugDrawObject(const btTransform &worldTransform, const btCollisionShape *shape, const btVector3 &color)
void contactTest(btCollisionObject *colObj, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between colObj against all objects in the btCollisionW...
btCollisionObject can be used to manage collision detection objects.
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
static void rayTestSingle(const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, RayResultCallback &resultCallback)
rayTestSingle performs a raycast call and calls the resultCallback.
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
Definition: btIDebugDraw.h:29
LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is avai...
virtual void removeCollisionObject(btCollisionObject *collisionObject)
const btCollisionObject * m_collisionObject
btAlignedObjectArray< btVector3 > m_hitNormalWorld
virtual ~btCollisionWorld()
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
btDispatcher * getDispatcher()
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bulle...
const btBroadphaseInterface * getBroadphase() const
static void objectQuerySingle(const btConvexShape *castShape, const btTransform &rayFromTrans, const btTransform &rayToTrans, btCollisionObject *collisionObject, const btCollisionShape *collisionShape, const btTransform &colObjWorldTransform, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btBroadphaseInterface * getBroadphase()
CollisionWorld is interface and container for the collision detection.
btDispatcherInfo & getDispatchInfo()
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
btAlignedObjectArray< btVector3 > m_hitPointWorld
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
virtual void performDiscreteCollisionDetection()
btAlignedObjectArray< const btCollisionObject * > m_collisionObjects
virtual void refreshBroadphaseProxy(btCollisionObject *collisionObject)
btBroadphaseInterface * m_broadphasePairCache
bool getForceUpdateAllAabbs() const
const btDispatcherInfo & getDispatchInfo() const
LocalConvexResult(const btCollisionObject *hitCollisionObject, LocalShapeInfo *localShapeInfo, const btVector3 &hitNormalLocal, const btVector3 &hitPointLocal, btScalar hitFraction)
void updateSingleAabb(btCollisionObject *colObj)
void convexSweepTest(const btConvexShape *castShape, const btTransform &from, const btTransform &to, ConvexResultCallback &resultCallback, btScalar allowedCcdPenetration=btScalar(0.)) const
convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultC...
RayResultCallback is used to report new raycast results.
virtual void debugDrawWorld()
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
void setInterpolate3(const btVector3 &v0, const btVector3 &v1, btScalar rt)
Definition: btVector3.h:503
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)
static void objectQuerySingleInternal(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionObjectWrapper *colObjWrap, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
ClosestRayResultCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
AllHitsRayResultCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld)