Bullet Collision Detection & Physics Library
btCompoundCollisionAlgorithm.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
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
23#include "btManifoldResult.h"
25
27
29 : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap),
30 m_isSwapped(isSwapped),
31 m_sharedManifold(ci.m_manifold)
32{
33 m_ownsManifold = false;
34
35 const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
36 btAssert(colObjWrap->getCollisionShape()->isCompound());
37
38 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
40
41 preallocateChildAlgorithms(body0Wrap, body1Wrap);
42}
43
45{
46 const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
47 const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
48 btAssert(colObjWrap->getCollisionShape()->isCompound());
49
50 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
51
52 int numChildren = compoundShape->getNumChildShapes();
53 int i;
54
55 m_childCollisionAlgorithms.resize(numChildren);
56 for (i = 0; i < numChildren; i++)
57 {
58 if (compoundShape->getDynamicAabbTree())
59 {
61 }
62 else
63 {
64 const btCollisionShape* childShape = compoundShape->getChildShape(i);
65
66 btCollisionObjectWrapper childWrap(colObjWrap, childShape, colObjWrap->getCollisionObject(), colObjWrap->getWorldTransform(), -1, i); //wrong child trans, but unused (hopefully)
68
69 btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithmsContact;
70 btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithmsClosestPoints;
71 }
72 }
73}
74
76{
77 int numChildren = m_childCollisionAlgorithms.size();
78 int i;
79 for (i = 0; i < numChildren; i++)
80 {
82 {
83 m_childCollisionAlgorithms[i]->~btCollisionAlgorithm();
85 }
86 }
87}
88
90{
92}
93
95{
96public:
104
105 btCompoundLeafCallback(const btCollisionObjectWrapper* compoundObjWrap, const btCollisionObjectWrapper* otherObjWrap, btDispatcher* dispatcher, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut, btCollisionAlgorithm** childCollisionAlgorithms, btPersistentManifold* sharedManifold)
106 : m_compoundColObjWrap(compoundObjWrap), m_otherObjWrap(otherObjWrap), m_dispatcher(dispatcher), m_dispatchInfo(dispatchInfo), m_resultOut(resultOut), m_childCollisionAlgorithms(childCollisionAlgorithms), m_sharedManifold(sharedManifold)
107 {
108 }
109
110 void ProcessChildShape(const btCollisionShape* childShape, int index)
111 {
112 btAssert(index >= 0);
113 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->getCollisionShape());
114 btAssert(index < compoundShape->getNumChildShapes());
115
117 {
119 return;
120 }
121
122 //backup
124
125 const btTransform& childTrans = compoundShape->getChildTransform(index);
126 btTransform newChildWorldTrans = orgTrans * childTrans;
127
128 //perform an AABB check first
129 btVector3 aabbMin0, aabbMax0;
130 childShape->getAabb(newChildWorldTrans, aabbMin0, aabbMax0);
131
133 aabbMin0 -= extendAabb;
134 aabbMax0 += extendAabb;
135
136 btVector3 aabbMin1, aabbMax1;
138
139
140 if (TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1))
141 {
142 btCollisionObjectWrapper compoundWrap(this->m_compoundColObjWrap, childShape, m_compoundColObjWrap->getCollisionObject(), newChildWorldTrans, childTrans, -1, index);
143
144 btCollisionAlgorithm* algo = 0;
145 bool allocatedAlgorithm = false;
146
148 {
150 allocatedAlgorithm = true;
151 }
152 else
153 {
154 //the contactpoint is still projected back using the original inverted worldtrans
155 if (!m_childCollisionAlgorithms[index])
156 {
158 }
159 algo = m_childCollisionAlgorithms[index];
160 }
161
162 const btCollisionObjectWrapper* tmpWrap = 0;
163
166 {
167 tmpWrap = m_resultOut->getBody0Wrap();
168 m_resultOut->setBody0Wrap(&compoundWrap);
170 }
171 else
172 {
173 tmpWrap = m_resultOut->getBody1Wrap();
174 m_resultOut->setBody1Wrap(&compoundWrap);
176 }
177
179
180#if 0
182 {
183 btVector3 worldAabbMin,worldAabbMax;
184 m_dispatchInfo.m_debugDraw->drawAabb(aabbMin0,aabbMax0,btVector3(1,1,1));
185 m_dispatchInfo.m_debugDraw->drawAabb(aabbMin1,aabbMax1,btVector3(1,1,1));
186 }
187#endif
188
190 {
191 m_resultOut->setBody0Wrap(tmpWrap);
192 }
193 else
194 {
195 m_resultOut->setBody1Wrap(tmpWrap);
196 }
197 if (allocatedAlgorithm)
198 {
199 algo->~btCollisionAlgorithm();
201 }
202 }
203 }
204 void Process(const btDbvtNode* leaf)
205 {
206 int index = leaf->dataAsInt;
207
208 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->getCollisionShape());
209 const btCollisionShape* childShape = compoundShape->getChildShape(index);
210
211#if 0
213 {
214 btVector3 worldAabbMin,worldAabbMax;
216 btTransformAabb(leaf->volume.Mins(),leaf->volume.Maxs(),0.,orgTrans,worldAabbMin,worldAabbMax);
217 m_dispatchInfo.m_debugDraw->drawAabb(worldAabbMin,worldAabbMax,btVector3(1,0,0));
218 }
219#endif
220
221 ProcessChildShape(childShape, index);
222 }
223};
224
226{
227 const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
228 const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
229
230 btAssert(colObjWrap->getCollisionShape()->isCompound());
231 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
232
235 if (compoundShape->getUpdateRevision() != m_compoundShapeRevision)
236 {
239
240 preallocateChildAlgorithms(body0Wrap, body1Wrap);
242 }
243
244 if (m_childCollisionAlgorithms.size() == 0)
245 return;
246
247 const btDbvt* tree = compoundShape->getDynamicAabbTree();
248 //use a dynamic aabb tree to cull potential child-overlaps
249 btCompoundLeafCallback callback(colObjWrap, otherObjWrap, m_dispatcher, dispatchInfo, resultOut, &m_childCollisionAlgorithms[0], m_sharedManifold);
250
254 {
255 int i;
257 for (i = 0; i < m_childCollisionAlgorithms.size(); i++)
258 {
260 {
261 m_childCollisionAlgorithms[i]->getAllContactManifolds(manifoldArray);
262 for (int m = 0; m < manifoldArray.size(); m++)
263 {
264 if (manifoldArray[m]->getNumContacts())
265 {
267 resultOut->refreshContactPoints();
268 resultOut->setPersistentManifold(0); //??necessary?
269 }
270 }
272 }
273 }
274 }
275
276 if (tree)
277 {
278 btVector3 localAabbMin, localAabbMax;
279 btTransform otherInCompoundSpace;
280 otherInCompoundSpace = colObjWrap->getWorldTransform().inverse() * otherObjWrap->getWorldTransform();
281 otherObjWrap->getCollisionShape()->getAabb(otherInCompoundSpace, localAabbMin, localAabbMax);
283 localAabbMin -= extraExtends;
284 localAabbMax += extraExtends;
285
286 const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(localAabbMin, localAabbMax);
287 //process all children, that overlap with the given AABB bounds
288 tree->collideTVNoStackAlloc(tree->m_root, bounds, stack2, callback);
289 }
290 else
291 {
292 //iterate over all children, perform an AABB check inside ProcessChildShape
293 int numChildren = m_childCollisionAlgorithms.size();
294 int i;
295 for (i = 0; i < numChildren; i++)
296 {
297 callback.ProcessChildShape(compoundShape->getChildShape(i), i);
298 }
299 }
300
301 {
302 //iterate over all children, perform an AABB check inside ProcessChildShape
303 int numChildren = m_childCollisionAlgorithms.size();
304 int i;
306 const btCollisionShape* childShape = 0;
307 btTransform orgTrans;
308
309 btTransform newChildWorldTrans;
310 btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1;
311
312 for (i = 0; i < numChildren; i++)
313 {
315 {
316 childShape = compoundShape->getChildShape(i);
317 //if not longer overlapping, remove the algorithm
318 orgTrans = colObjWrap->getWorldTransform();
319
320 const btTransform& childTrans = compoundShape->getChildTransform(i);
321 newChildWorldTrans = orgTrans * childTrans;
322
323 //perform an AABB check first
324 childShape->getAabb(newChildWorldTrans, aabbMin0, aabbMax0);
325 otherObjWrap->getCollisionShape()->getAabb(otherObjWrap->getWorldTransform(), aabbMin1, aabbMax1);
326
327 if (!TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1))
328 {
329 m_childCollisionAlgorithms[i]->~btCollisionAlgorithm();
332 }
333 }
334 }
335 }
336}
337
339{
340 btAssert(0);
341 //needs to be fixed, using btCollisionObjectWrapper and NOT modifying internal data structures
342 btCollisionObject* colObj = m_isSwapped ? body1 : body0;
343 btCollisionObject* otherObj = m_isSwapped ? body0 : body1;
344
346
347 btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
348
349 //We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
350 //If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
351 //given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
352 //determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
353 //then use each overlapping node AABB against Tree0
354 //and vise versa.
355
356 btScalar hitFraction = btScalar(1.);
357
358 int numChildren = m_childCollisionAlgorithms.size();
359 int i;
360 btTransform orgTrans;
361 btScalar frac;
362 for (i = 0; i < numChildren; i++)
363 {
364 //btCollisionShape* childShape = compoundShape->getChildShape(i);
365
366 //backup
367 orgTrans = colObj->getWorldTransform();
368
369 const btTransform& childTrans = compoundShape->getChildTransform(i);
370 //btTransform newChildWorldTrans = orgTrans*childTrans ;
371 colObj->setWorldTransform(orgTrans * childTrans);
372
373 //btCollisionShape* tmpShape = colObj->getCollisionShape();
374 //colObj->internalSetTemporaryCollisionShape( childShape );
375 frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut);
376 if (frac < hitFraction)
377 {
378 hitFraction = frac;
379 }
380 //revert back
381 //colObj->internalSetTemporaryCollisionShape( tmpShape);
382 colObj->setWorldTransform(orgTrans);
383 }
384 return hitFraction;
385}
bool TestAabbAgainstAabb2(const btVector3 &aabbMin1, const btVector3 &aabbMax1, const btVector3 &aabbMin2, const btVector3 &aabbMax2)
conservative test for overlap between two aabbs
Definition: btAabbUtil2.h:43
void btTransformAabb(const btVector3 &halfExtents, btScalar margin, const btTransform &t, btVector3 &aabbMinOut, btVector3 &aabbMaxOut)
Definition: btAabbUtil2.h:172
btShapePairCallback gCompoundChildShapePairCallback
bool(* btShapePairCallback)(const btCollisionShape *pShape0, const btCollisionShape *pShape1)
static btDbvtVolume bounds(btDbvtNode **leaves, int count)
Definition: btDbvt.cpp:299
@ BT_CLOSEST_POINT_ALGORITHMS
Definition: btDispatcher.h:71
@ BT_CONTACT_POINT_ALGORITHMS
Definition: btDispatcher.h:70
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:99
#define btAssert(x)
Definition: btScalar.h:153
This class is not enabled yet (work-in-progress) to more aggressively activate objects.
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
int size() const
return the number of elements in the array
void resize(int newsize, const T &fillData=T())
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btCollisionObject can be used to manage collision detection objects.
btTransform & getWorldTransform()
void setWorldTransform(const btTransform &worldTrans)
const btCollisionShape * getCollisionShape() const
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
bool isCompound() const
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
class btPersistentManifold * m_sharedManifold
btAlignedObjectArray< btCollisionAlgorithm * > m_childCollisionAlgorithms
btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
void preallocateChildAlgorithms(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
btCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, bool isSwapped)
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
btCollisionShape * getChildShape(int index)
btTransform & getChildTransform(int index)
int getUpdateRevision() const
const btDbvt * getDynamicAabbTree() const
int getNumChildShapes() const
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
virtual void freeCollisionAlgorithm(void *ptr)=0
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold, ebtDispatcherQueryType queryType)=0
virtual int getDebugMode() const =0
virtual void drawAabb(const btVector3 &from, const btVector3 &to, const btVector3 &color)
Definition: btIDebugDraw.h:135
btManifoldResult is a helper class to manage contact results.
virtual void setShapeIdentifiersA(int partId0, int index0)
setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material comb...
void setBody0Wrap(const btCollisionObjectWrapper *obj0Wrap)
const btCollisionObjectWrapper * getBody1Wrap() const
void setBody1Wrap(const btCollisionObjectWrapper *obj1Wrap)
void setPersistentManifold(btPersistentManifold *manifoldPtr)
const btCollisionObject * getBody0Internal() const
virtual void setShapeIdentifiersB(int partId1, int index1)
btScalar m_closestPointDistanceThreshold
const btCollisionObjectWrapper * getBody0Wrap() const
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:182
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
const btCollisionShape * getCollisionShape() const
const btCollisionObject * getCollisionObject() const
const btTransform & getWorldTransform() const
const btCollisionObjectWrapper * m_otherObjWrap
void ProcessChildShape(const btCollisionShape *childShape, int index)
btPersistentManifold * m_sharedManifold
btCompoundLeafCallback(const btCollisionObjectWrapper *compoundObjWrap, const btCollisionObjectWrapper *otherObjWrap, btDispatcher *dispatcher, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut, btCollisionAlgorithm **childCollisionAlgorithms, btPersistentManifold *sharedManifold)
const btDispatcherInfo & m_dispatchInfo
btCollisionAlgorithm ** m_childCollisionAlgorithms
void Process(const btDbvtNode *leaf)
const btCollisionObjectWrapper * m_compoundColObjWrap
static btDbvtAabbMm FromMM(const btVector3 &mi, const btVector3 &mx)
Definition: btDbvt.h:479
DBVT_INLINE const btVector3 & Mins() const
Definition: btDbvt.h:137
DBVT_INLINE const btVector3 & Maxs() const
Definition: btDbvt.h:138
btDbvtVolume volume
Definition: btDbvt.h:182
int dataAsInt
Definition: btDbvt.h:189
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
Definition: btDbvt.h:229
DBVT_PREFIX void collideTVNoStackAlloc(const btDbvtNode *root, const btDbvtVolume &volume, btNodeStack &stack, DBVT_IPOLICY) const
Definition: btDbvt.h:1189
btDbvtNode * m_root
Definition: btDbvt.h:302
class btIDebugDraw * m_debugDraw
Definition: btDispatcher.h:58