Blender  V3.3
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 
69 #ifndef BT_COLLISION_WORLD_H
70 #define BT_COLLISION_WORLD_H
71 
72 class btCollisionShape;
73 class btConvexShape;
75 class btSerializer;
76 
77 #include "LinearMath/btVector3.h"
78 #include "LinearMath/btTransform.h"
79 #include "btCollisionObject.h"
80 #include "btCollisionDispatcher.h"
83 
86 {
87 protected:
89 
91 
93 
95 
97 
101 
102  void serializeCollisionObjects(btSerializer* serializer);
103 
104  void serializeContactManifolds(btSerializer* serializer);
105 
106 public:
107  //this constructor doesn't own the dispatcher and paircache/broadphase
108  btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
109 
110  virtual ~btCollisionWorld();
111 
113  {
114  m_broadphasePairCache = pairCache;
115  }
116 
118  {
119  return m_broadphasePairCache;
120  }
121 
123  {
124  return m_broadphasePairCache;
125  }
126 
128  {
130  }
131 
133  {
134  return m_dispatcher1;
135  }
136 
138  {
139  return m_dispatcher1;
140  }
141 
142  void updateSingleAabb(btCollisionObject* colObj);
143 
144  virtual void updateAabbs();
145 
148  virtual void computeOverlappingPairs();
149 
150  virtual void setDebugDrawer(btIDebugDraw* debugDrawer)
151  {
152  m_debugDrawer = debugDrawer;
153  }
154 
156  {
157  return m_debugDrawer;
158  }
159 
160  virtual void debugDrawWorld();
161 
162  virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
163 
167  {
170 
171  //const btCollisionShape* m_shapeTemp;
172  //const btTransform* m_shapeLocalTransform;
173  };
174 
176  {
177  LocalRayResult(const btCollisionObject* collisionObject,
178  LocalShapeInfo* localShapeInfo,
179  const btVector3& hitNormalLocal,
180  btScalar hitFraction)
181  : m_collisionObject(collisionObject),
182  m_localShapeInfo(localShapeInfo),
183  m_hitNormalLocal(hitNormalLocal),
184  m_hitFraction(hitFraction)
185  {
186  }
187 
192  };
193 
196  {
201  //@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.
202  unsigned int m_flags;
203 
205  {
206  }
207  bool hasHit() const
208  {
209  return (m_collisionObject != 0);
210  }
211 
217  //@BP Mod
218  m_flags(0)
219  {
220  }
221 
222  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
223  {
224  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
225  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
226  return collides;
227  }
228 
229  virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) = 0;
230  };
231 
233  {
234  ClosestRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
235  : m_rayFromWorld(rayFromWorld),
236  m_rayToWorld(rayToWorld)
237  {
238  }
239 
240  btVector3 m_rayFromWorld; //used to calculate hitPointWorld from hitFraction
242 
245 
246  virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
247  {
248  //caller already does the filter on the m_closestHitFraction
250 
253  if (normalInWorldSpace)
254  {
256  }
257  else
258  {
260  m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
261  }
262  m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
263  return rayResult.m_hitFraction;
264  }
265  };
266 
268  {
269  AllHitsRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
270  : m_rayFromWorld(rayFromWorld),
271  m_rayToWorld(rayToWorld)
272  {
273  }
274 
276 
277  btVector3 m_rayFromWorld; //used to calculate hitPointWorld from hitFraction
279 
283 
284  virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
285  {
288  btVector3 hitNormalWorld;
289  if (normalInWorldSpace)
290  {
291  hitNormalWorld = rayResult.m_hitNormalLocal;
292  }
293  else
294  {
296  hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
297  }
298  m_hitNormalWorld.push_back(hitNormalWorld);
299  btVector3 hitPointWorld;
300  hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
301  m_hitPointWorld.push_back(hitPointWorld);
303  return m_closestHitFraction;
304  }
305  };
306 
308  {
309  LocalConvexResult(const btCollisionObject* hitCollisionObject,
310  LocalShapeInfo* localShapeInfo,
311  const btVector3& hitNormalLocal,
312  const btVector3& hitPointLocal,
313  btScalar hitFraction)
314  : m_hitCollisionObject(hitCollisionObject),
315  m_localShapeInfo(localShapeInfo),
316  m_hitNormalLocal(hitNormalLocal),
317  m_hitPointLocal(hitPointLocal),
318  m_hitFraction(hitFraction)
319  {
320  }
321 
327  };
328 
331  {
335 
340  {
341  }
342 
344  {
345  }
346 
347  bool hasHit() const
348  {
349  return (m_closestHitFraction < btScalar(1.));
350  }
351 
352  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
353  {
354  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
355  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
356  return collides;
357  }
358 
359  virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace) = 0;
360  };
361 
363  {
364  ClosestConvexResultCallback(const btVector3& convexFromWorld, const btVector3& convexToWorld)
365  : m_convexFromWorld(convexFromWorld),
366  m_convexToWorld(convexToWorld),
368  {
369  }
370 
371  btVector3 m_convexFromWorld; //used to calculate hitPointWorld from hitFraction
373 
377 
378  virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace)
379  {
380  //caller already does the filter on the m_closestHitFraction
382 
383  m_closestHitFraction = convexResult.m_hitFraction;
385  if (normalInWorldSpace)
386  {
387  m_hitNormalWorld = convexResult.m_hitNormalLocal;
388  }
389  else
390  {
392  m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis() * convexResult.m_hitNormalLocal;
393  }
394  m_hitPointWorld = convexResult.m_hitPointLocal;
395  return convexResult.m_hitFraction;
396  }
397  };
398 
401  {
405 
410  {
411  }
412 
414  {
415  }
416 
417  virtual bool needsCollision(btBroadphaseProxy* proxy0) const
418  {
419  bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
420  collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
421  return collides;
422  }
423 
424  virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1) = 0;
425  };
426 
428  {
429  return int(m_collisionObjects.size());
430  }
431 
434  virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
435 
438  void convexSweepTest(const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const;
439 
442  void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
443 
446  void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
447 
451  static void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
452  btCollisionObject* collisionObject,
453  const btCollisionShape* collisionShape,
454  const btTransform& colObjWorldTransform,
455  RayResultCallback& resultCallback);
456 
457  static void rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans,
458  const btCollisionObjectWrapper* collisionObjectWrap,
459  RayResultCallback& resultCallback);
460 
462  static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans, const btTransform& rayToTrans,
463  btCollisionObject* collisionObject,
464  const btCollisionShape* collisionShape,
465  const btTransform& colObjWorldTransform,
466  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
467 
468  static void objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans,
469  const btCollisionObjectWrapper* colObjWrap,
470  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
471 
472  virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
473 
474  virtual void refreshBroadphaseProxy(btCollisionObject* collisionObject);
475 
477  {
478  return m_collisionObjects;
479  }
480 
482  {
483  return m_collisionObjects;
484  }
485 
486  virtual void removeCollisionObject(btCollisionObject* collisionObject);
487 
488  virtual void performDiscreteCollisionDetection();
489 
491  {
492  return m_dispatchInfo;
493  }
494 
496  {
497  return m_dispatchInfo;
498  }
499 
501  {
502  return m_forceUpdateAllAabbs;
503  }
504  void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
505  {
506  m_forceUpdateAllAabbs = forceUpdateAllAabbs;
507  }
508 
510  virtual void serialize(btSerializer* serializer);
511 };
512 
513 #endif //BT_COLLISION_WORLD_H
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a color
@ AllFilter
@ DefaultFilter
btBroadphaseProxy
btCollisionObject
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btConvexShape()
not supported on IBM SDK, until we fix the alignment of btVector3
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
#define btAssert(x)
Definition: btScalar.h:295
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btVector3
btVector3 can be used to represent 3D points and vectors. It has an un-used w component to suit 16-by...
Definition: btVector3.h:82
SIMD_FORCE_INLINE int size() const
return the number of elements in the array
SIMD_FORCE_INLINE void push_back(const T &_Val)
virtual btOverlappingPairCache * getOverlappingPairCache()=0
CollisionWorld is interface and container for the collision detection.
virtual void rayTest(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, RayResultCallback &resultCallback) const
virtual void updateAabbs()
btDispatcherInfo m_dispatchInfo
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bulle...
virtual void debugDrawWorld()
const btDispatcher * getDispatcher() const
const btBroadphaseInterface * getBroadphase() const
static void objectQuerySingleInternal(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionObjectWrapper *colObjWrap, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
virtual ~btCollisionWorld()
virtual void refreshBroadphaseProxy(btCollisionObject *collisionObject)
btBroadphaseInterface * m_broadphasePairCache
btCollisionObjectArray & getCollisionObjectArray()
void updateSingleAabb(btCollisionObject *colObj)
void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
const btCollisionObjectArray & getCollisionObjectArray() const
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)
btBroadphaseInterface * getBroadphase()
btDispatcher * getDispatcher()
virtual btIDebugDraw * getDebugDrawer()
btCollisionWorld(btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
for debug drawing
int getNumCollisionObjects() const
btOverlappingPairCache * getPairCache()
virtual void performDiscreteCollisionDetection()
static void rayTestSingleInternal(const btTransform &rayFromTrans, const btTransform &rayToTrans, const btCollisionObjectWrapper *collisionObjectWrap, RayResultCallback &resultCallback)
const btDispatcherInfo & getDispatchInfo() const
void convexSweepTest(const btConvexShape *castShape, const btTransform &from, const btTransform &to, ConvexResultCallback &resultCallback, btScalar allowedCcdPenetration=btScalar(0.)) const
btIDebugDraw * m_debugDrawer
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....
btDispatcherInfo & getDispatchInfo()
btDispatcher * m_dispatcher1
void contactPairTest(btCollisionObject *colObjA, btCollisionObject *colObjB, ContactResultCallback &resultCallback)
void serializeContactManifolds(btSerializer *serializer)
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)
void setBroadphase(btBroadphaseInterface *pairCache)
void contactTest(btCollisionObject *colObj, ContactResultCallback &resultCallback)
void serializeCollisionObjects(btSerializer *serializer)
virtual void computeOverlappingPairs()
StackEntry * from
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)
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