Bullet Collision Detection & Physics Library
btCollisionWorld.h
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. 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
76class btConvexShape;
78class btSerializer;
79
82#include "btCollisionObject.h"
86
89{
90
91
92protected:
93
95
97
99
101
103
107
108 void serializeCollisionObjects(btSerializer* serializer);
109
110public:
111
112 //this constructor doesn't own the dispatcher and paircache/broadphase
113 btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
114
115 virtual ~btCollisionWorld();
116
118 {
119 m_broadphasePairCache = pairCache;
120 }
121
123 {
125 }
126
128 {
130 }
131
133 {
135 }
136
137
139 {
140 return m_dispatcher1;
141 }
142
144 {
145 return m_dispatcher1;
146 }
147
149
150 virtual void updateAabbs();
151
154 virtual void computeOverlappingPairs();
155
156
157 virtual void setDebugDrawer(btIDebugDraw* debugDrawer)
158 {
159 m_debugDrawer = debugDrawer;
160 }
161
163 {
164 return m_debugDrawer;
165 }
166
167 virtual void debugDrawWorld();
168
169 virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
170
171
175 {
178
179 //const btCollisionShape* m_shapeTemp;
180 //const btTransform* m_shapeLocalTransform;
181 };
182
184 {
185 LocalRayResult(const btCollisionObject* collisionObject,
186 LocalShapeInfo* localShapeInfo,
187 const btVector3& hitNormalLocal,
188 btScalar hitFraction)
189 :m_collisionObject(collisionObject),
190 m_localShapeInfo(localShapeInfo),
191 m_hitNormalLocal(hitNormalLocal),
192 m_hitFraction(hitFraction)
193 {
194 }
195
200
201 };
202
205 {
210 //@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.
211 unsigned int m_flags;
212
214 {
215 }
216 bool hasHit() const
217 {
218 return (m_collisionObject != 0);
219 }
220
226 //@BP Mod
227 m_flags(0)
228 {
229 }
230
231 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
232 {
233 bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
234 collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
235 return collides;
236 }
237
238
239 virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
240 };
241
243 {
244 ClosestRayResultCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld)
245 :m_rayFromWorld(rayFromWorld),
246 m_rayToWorld(rayToWorld)
247 {
248 }
249
250 btVector3 m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
252
255
256 virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
257 {
258 //caller already does the filter on the m_closestHitFraction
260
263 if (normalInWorldSpace)
264 {
266 } else
267 {
270 }
272 return rayResult.m_hitFraction;
273 }
274 };
275
277 {
278 AllHitsRayResultCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld)
279 :m_rayFromWorld(rayFromWorld),
280 m_rayToWorld(rayToWorld)
281 {
282 }
283
285
286 btVector3 m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
288
292
293 virtual btScalar addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
294 {
296 m_collisionObjects.push_back(rayResult.m_collisionObject);
297 btVector3 hitNormalWorld;
298 if (normalInWorldSpace)
299 {
300 hitNormalWorld = rayResult.m_hitNormalLocal;
301 } else
302 {
304 hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
305 }
306 m_hitNormalWorld.push_back(hitNormalWorld);
307 btVector3 hitPointWorld;
309 m_hitPointWorld.push_back(hitPointWorld);
312 }
313 };
314
315
317 {
318 LocalConvexResult(const btCollisionObject* hitCollisionObject,
319 LocalShapeInfo* localShapeInfo,
320 const btVector3& hitNormalLocal,
321 const btVector3& hitPointLocal,
322 btScalar hitFraction
323 )
324 :m_hitCollisionObject(hitCollisionObject),
325 m_localShapeInfo(localShapeInfo),
326 m_hitNormalLocal(hitNormalLocal),
327 m_hitPointLocal(hitPointLocal),
328 m_hitFraction(hitFraction)
329 {
330 }
331
337 };
338
341 {
345
350 {
351 }
352
354 {
355 }
356
357 bool hasHit() const
358 {
359 return (m_closestHitFraction < btScalar(1.));
360 }
361
362
363
364 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
365 {
366 bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
367 collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
368 return collides;
369 }
370
371 virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
372 };
373
375 {
376 ClosestConvexResultCallback(const btVector3& convexFromWorld,const btVector3& convexToWorld)
377 :m_convexFromWorld(convexFromWorld),
378 m_convexToWorld(convexToWorld),
380 {
381 }
382
383 btVector3 m_convexFromWorld;//used to calculate hitPointWorld from hitFraction
385
389
390 virtual btScalar addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
391 {
392//caller already does the filter on the m_closestHitFraction
394
395 m_closestHitFraction = convexResult.m_hitFraction;
397 if (normalInWorldSpace)
398 {
399 m_hitNormalWorld = convexResult.m_hitNormalLocal;
400 } else
401 {
404 }
405 m_hitPointWorld = convexResult.m_hitPointLocal;
406 return convexResult.m_hitFraction;
407 }
408 };
409
412 {
416
421 {
422 }
423
425 {
426 }
427
428 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
429 {
430 bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
431 collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
432 return collides;
433 }
434
435 virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) = 0;
436 };
437
438
439
441 {
442 return int(m_collisionObjects.size());
443 }
444
447 virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
448
451 void convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const;
452
455 void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
456
459 void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
460
461
465 static void rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
466 btCollisionObject* collisionObject,
467 const btCollisionShape* collisionShape,
468 const btTransform& colObjWorldTransform,
469 RayResultCallback& resultCallback);
470
471 static void rayTestSingleInternal(const btTransform& rayFromTrans,const btTransform& rayToTrans,
472 const btCollisionObjectWrapper* collisionObjectWrap,
473 RayResultCallback& resultCallback);
474
476 static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
477 btCollisionObject* collisionObject,
478 const btCollisionShape* collisionShape,
479 const btTransform& colObjWorldTransform,
480 ConvexResultCallback& resultCallback, btScalar allowedPenetration);
481
482 static void objectQuerySingleInternal(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
483 const btCollisionObjectWrapper* colObjWrap,
484 ConvexResultCallback& resultCallback, btScalar allowedPenetration);
485
486 virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter);
487
489 {
490 return m_collisionObjects;
491 }
492
494 {
495 return m_collisionObjects;
496 }
497
498
499 virtual void removeCollisionObject(btCollisionObject* collisionObject);
500
502
504 {
505 return m_dispatchInfo;
506 }
507
509 {
510 return m_dispatchInfo;
511 }
512
514 {
516 }
517 void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
518 {
519 m_forceUpdateAllAabbs = forceUpdateAllAabbs;
520 }
521
523 virtual void serialize(btSerializer* serializer);
524
525};
526
527
528#endif //BT_COLLISION_WORLD_H
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
#define btAssert(x)
Definition: btScalar.h:131
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
void push_back(const T &_Val)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
virtual btOverlappingPairCache * getOverlappingPairCache()=0
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
btCollisionObject can be used to manage collision detection objects.
btTransform & getWorldTransform()
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
CollisionWorld is interface and container for the collision detection.
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
btDispatcher * getDispatcher()
btDispatcherInfo & getDispatchInfo()
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bulle...
virtual void debugDrawWorld()
btOverlappingPairCache * getPairCache()
static void objectQuerySingleInternal(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionObjectWrapper *colObjWrap, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
virtual btIDebugDraw * getDebugDrawer()
virtual ~btCollisionWorld()
btBroadphaseInterface * m_broadphasePairCache
void updateSingleAabb(btCollisionObject *colObj)
void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
virtual void setDebugDrawer(btIDebugDraw *debugDrawer)
btCollisionWorld(btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
for debug drawing
int getNumCollisionObjects() const
virtual void performDiscreteCollisionDetection()
btCollisionObjectArray & getCollisionObjectArray()
static void rayTestSingleInternal(const btTransform &rayFromTrans, const btTransform &rayToTrans, const btCollisionObjectWrapper *collisionObjectWrap, RayResultCallback &resultCallback)
const btCollisionObjectArray & getCollisionObjectArray() const
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...
bool m_forceUpdateAllAabbs
m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs it is...
const btDispatcherInfo & getDispatchInfo() const
btIDebugDraw * m_debugDrawer
btBroadphaseInterface * getBroadphase()
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....
btDispatcher * m_dispatcher1
void contactPairTest(btCollisionObject *colObjA, btCollisionObject *colObjB, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between two collision objects and calls the resultCall...
const btDispatcher * getDispatcher() const
bool getForceUpdateAllAabbs() const
virtual void debugDrawObject(const btTransform &worldTransform, const btCollisionShape *shape, const btVector3 &color)
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.
void setBroadphase(btBroadphaseInterface *pairCache)
const btBroadphaseInterface * getBroadphase() const
void contactTest(btCollisionObject *colObj, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between colObj against all objects in the btCollisionW...
void serializeCollisionObjects(btSerializer *serializer)
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:32
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:76
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
Definition: btIDebugDraw.h:30
ManifoldContactPoint collects and maintains persistent contactpoints.
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:84
void setInterpolate3(const btVector3 &v0, const btVector3 &v1, btScalar rt)
Definition: btVector3.h:503
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
AllHitsRayResultCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld)
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)
btAlignedObjectArray< const btCollisionObject * > m_collisionObjects
btAlignedObjectArray< btScalar > m_hitFractions
btAlignedObjectArray< btVector3 > m_hitPointWorld
btAlignedObjectArray< btVector3 > m_hitNormalWorld
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)
ClosestRayResultCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld)
ContactResultCallback is used to report contact points.
virtual btScalar addSingleResult(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)=0
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
RayResultCallback is used to report new raycast results.
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)=0
const btCollisionObject * m_hitCollisionObject
LocalConvexResult(const btCollisionObject *hitCollisionObject, LocalShapeInfo *localShapeInfo, const btVector3 &hitNormalLocal, const btVector3 &hitPointLocal, btScalar hitFraction)
const btCollisionObject * m_collisionObject
LocalRayResult(const btCollisionObject *collisionObject, LocalShapeInfo *localShapeInfo, const btVector3 &hitNormalLocal, btScalar hitFraction)
LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is avai...
RayResultCallback is used to report new raycast results.
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)=0
const btCollisionObject * m_collisionObject