Bullet Collision Detection & Physics Library: btCollisionWorld.cpp Source File

Bullet Collision Detection & Physics Library

btCollisionWorld.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
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 #include "btCollisionWorld.h"
17 #include "btCollisionDispatcher.h"
18 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
19 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
20 #include "BulletCollision/CollisionShapes/btConvexShape.h"
21 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
22 #include "BulletCollision/CollisionShapes/btSphereShape.h" //for raycasting
23 #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" //for raycasting
24 #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
25 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
26 #include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
27 #include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h"
28 #include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h"
29 #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
30 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
31 #include "BulletCollision/BroadphaseCollision/btDbvt.h"
32 #include "LinearMath/btAabbUtil2.h"
33 #include "LinearMath/btQuickprof.h"
34 #include "LinearMath/btSerializer.h"
35 #include "BulletCollision/CollisionShapes/btConvexPolyhedron.h"
36 #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
37
38 //#define DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
39
40
41 //#define USE_BRUTEFORCE_RAYBROADPHASE 1
42 //RECALCULATE_AABB is slower, but benefit is that you don't need to call 'stepSimulation' or 'updateAabbs' before using a rayTest
43 //#define RECALCULATE_AABB_RAYCAST 1
44
45 //When the user doesn't provide dispatcher or broadphase, create basic versions (and delete them in destructor)
46 #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
47 #include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"
48 #include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h"
49
50
52
53 //for debug rendering
54 #include "BulletCollision/CollisionShapes/btBoxShape.h"
55 #include "BulletCollision/CollisionShapes/btCapsuleShape.h"
56 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
57 #include "BulletCollision/CollisionShapes/btConeShape.h"
58 #include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h"
59 #include "BulletCollision/CollisionShapes/btCylinderShape.h"
60 #include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
61 #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h"
62 #include "BulletCollision/CollisionShapes/btSphereShape.h"
63 #include "BulletCollision/CollisionShapes/btTriangleCallback.h"
64 #include "BulletCollision/CollisionShapes/btTriangleMeshShape.h"
65 #include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
66
67
68
69 btCollisionWorld::btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache, btCollisionConfiguration* collisionConfiguration)
70 :m_dispatcher1(dispatcher),
71 m_broadphasePairCache(pairCache),
72 m_debugDrawer(0),
73 m_forceUpdateAllAabbs(true)
74 {
75 }
76
77
78 btCollisionWorld::~btCollisionWorld()
79 {
80
81 //clean up remaining objects
82 int i;
83 for (i=0;i<m_collisionObjects.size();i++)
84 {
85 btCollisionObject* collisionObject= m_collisionObjects[i];
86
87 btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
88 if (bp)
89 {
90 //
91 // only clear the cached algorithms
92 //
93 getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp,m_dispatcher1);
94 getBroadphase()->destroyProxy(bp,m_dispatcher1);
95 collisionObject->setBroadphaseHandle(0);
96 }
97 }
98
99
100 }
101
102
103
104
105
106
107
108
109
110
111 void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup,short int collisionFilterMask)
112 {
113
114 btAssert(collisionObject);
115
116 //check that the object isn't already added
117 btAssert( m_collisionObjects.findLinearSearch(collisionObject) == m_collisionObjects.size());
118
119 m_collisionObjects.push_back(collisionObject);
120
121 //calculate new AABB
122 btTransform trans = collisionObject->getWorldTransform();
123
124 btVector3 minAabb;
125 btVector3 maxAabb;
126 collisionObject->getCollisionShape()->getAabb(trans,minAabb,maxAabb);
127
128 int type = collisionObject->getCollisionShape()->getShapeType();
129 collisionObject->setBroadphaseHandle( getBroadphase()->createProxy(
130 minAabb,
131 maxAabb,
132 type,
133 collisionObject,
134 collisionFilterGroup,
135 collisionFilterMask,
136 m_dispatcher1,0
137 )) ;
138
139
140
141
142
143 }
144
145
146
147 void btCollisionWorld::updateSingleAabb(btCollisionObject* colObj)
148 {
149 btVector3 minAabb,maxAabb;
150 colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
151 //need to increase the aabb for contact thresholds
152 btVector3 contactThreshold(gContactBreakingThreshold,gContactBreakingThreshold,gContactBreakingThreshold);
153 minAabb -= contactThreshold;
154 maxAabb += contactThreshold;
155
156 if(getDispatchInfo().m_useContinuous && colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
157 {
158 btVector3 minAabb2,maxAabb2;
159 colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(),minAabb2,maxAabb2);
160 minAabb2 -= contactThreshold;
161 maxAabb2 += contactThreshold;
162 minAabb.setMin(minAabb2);
163 maxAabb.setMax(maxAabb2);
164 }
165
166 btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;
167
168 //moving objects should be moderately sized, probably something wrong if not
169 if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < btScalar(1e12)))
170 {
171 bp->setAabb(colObj->getBroadphaseHandle(),minAabb,maxAabb, m_dispatcher1);
172 } else
173 {
174 //something went wrong, investigate
175 //this assert is unwanted in 3D modelers (danger of loosing work)
176 colObj->setActivationState(DISABLE_SIMULATION);
177
178 static bool reportMe = true;
179 if (reportMe && m_debugDrawer)
180 {
181 reportMe = false;
182 m_debugDrawer->reportErrorWarning("Overflow in AABB, object removed from simulation");
183 m_debugDrawer->reportErrorWarning("If you can reproduce this, please email bugs@continuousphysics.com\n");
184 m_debugDrawer->reportErrorWarning("Please include above information, your Platform, version of OS.\n");
185 m_debugDrawer->reportErrorWarning("Thanks.\n");
186 }
187 }
188 }
189
190 void btCollisionWorld::updateAabbs()
191 {
192 BT_PROFILE("updateAabbs");
193
194 btTransform predictedTrans;
195 for ( int i=0;i<m_collisionObjects.size();i++)
196 {
197 btCollisionObject* colObj = m_collisionObjects[i];
198
199 //only update aabb of active objects
200 if (m_forceUpdateAllAabbs || colObj->isActive())
201 {
202 updateSingleAabb(colObj);
203 }
204 }
205 }
206
207
208 void btCollisionWorld::computeOverlappingPairs()
209 {
210 BT_PROFILE("calculateOverlappingPairs");
211 m_broadphasePairCache->calculateOverlappingPairs(m_dispatcher1);
212 }
213
214 void btCollisionWorld::performDiscreteCollisionDetection()
215 {
216 BT_PROFILE("performDiscreteCollisionDetection");
217
218 btDispatcherInfo& dispatchInfo = getDispatchInfo();
219
220 updateAabbs();
221
222 computeOverlappingPairs();
223
224 btDispatcher* dispatcher = getDispatcher();
225 {
226 BT_PROFILE("dispatchAllCollisionPairs");
227 if (dispatcher)
228 dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1);
229 }
230
231 }
232
233
234
235 void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
236 {
237
238
239 //bool removeFromBroadphase = false;
240
241 {
242
243 btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
244 if (bp)
245 {
246 //
247 // only clear the cached algorithms
248 //
249 getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp,m_dispatcher1);
250 getBroadphase()->destroyProxy(bp,m_dispatcher1);
251 collisionObject->setBroadphaseHandle(0);
252 }
253 }
254
255
256 //swapremove
257 m_collisionObjects.remove(collisionObject);
258
259 }
260
261
262 void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
263 btCollisionObject* collisionObject,
264 const btCollisionShape* collisionShape,
265 const btTransform& colObjWorldTransform,
266 RayResultCallback& resultCallback)
267 {
268 btCollisionObjectWrapper colObWrap(0,collisionShape,collisionObject,colObjWorldTransform,-1,-1);
269 btCollisionWorld::rayTestSingleInternal(rayFromTrans,rayToTrans,&colObWrap,resultCallback);
270 }
271
272 void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans,const btTransform& rayToTrans,
273 const btCollisionObjectWrapper* collisionObjectWrap,
274 RayResultCallback& resultCallback)
275 {
276 btSphereShape pointShape(btScalar(0.0));
277 pointShape.setMargin(0.f);
278 const btConvexShape* castShape = &pointShape;
279 const btCollisionShape* collisionShape = collisionObjectWrap->getCollisionShape();
280 const btTransform& colObjWorldTransform = collisionObjectWrap->getWorldTransform();
281
282 if (collisionShape->isConvex())
283 {
284 // BT_PROFILE("rayTestConvex");
285 btConvexCast::CastResult castResult;
286 castResult.m_fraction = resultCallback.m_closestHitFraction;
287
288 btConvexShape* convexShape = (btConvexShape*) collisionShape;
289 btVoronoiSimplexSolver simplexSolver;
290 btSubsimplexConvexCast subSimplexConvexCaster(castShape,convexShape,&simplexSolver);
291
292 btGjkConvexCast gjkConvexCaster(castShape,convexShape,&simplexSolver);
293
294 //btContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0);
295
296 btConvexCast* convexCasterPtr = 0;
297 //use kF_UseSubSimplexConvexCastRaytest by default
298 if (resultCallback.m_flags & btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest)
299 convexCasterPtr = &gjkConvexCaster;
300 else
301 convexCasterPtr = &subSimplexConvexCaster;
302
303 btConvexCast& convexCaster = *convexCasterPtr;
304
305 if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
306 {
307 //add hit
308 if (castResult.m_normal.length2() > btScalar(0.0001))
309 {
310 if (castResult.m_fraction < resultCallback.m_closestHitFraction)
311 {
312 //todo: figure out what this is about. When is rayFromTest.getBasis() not identity?
313 #ifdef USE_SUBSIMPLEX_CONVEX_CAST
314 //rotate normal into worldspace
315 castResult.m_normal = rayFromTrans.getBasis() * castResult.m_normal;
316 #endif //USE_SUBSIMPLEX_CONVEX_CAST
317
318 castResult.m_normal.normalize();
319 btCollisionWorld::LocalRayResult localRayResult
320 (
321 collisionObjectWrap->getCollisionObject(),
322 0,
323 castResult.m_normal,
324 castResult.m_fraction
325 );
326
327 bool normalInWorldSpace = true;
328 resultCallback.addSingleResult(localRayResult, normalInWorldSpace);
329
330 }
331 }
332 }
333 } else {
334 if (collisionShape->isConcave())
335 {
336
337 //ConvexCast::CastResult
338 struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback
339 {
340 btCollisionWorld::RayResultCallback* m_resultCallback;
341 const btCollisionObject* m_collisionObject;
342 const btConcaveShape* m_triangleMesh;
343
344 btTransform m_colObjWorldTransform;
345
346 BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
347 btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject,const btConcaveShape* triangleMesh,const btTransform& colObjWorldTransform):
348 //@BP Mod
349 btTriangleRaycastCallback(from,to, resultCallback->m_flags),
350 m_resultCallback(resultCallback),
351 m_collisionObject(collisionObject),
352 m_triangleMesh(triangleMesh),
353 m_colObjWorldTransform(colObjWorldTransform)
354 {
355 }
356
357
358 virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
359 {
360 btCollisionWorld::LocalShapeInfo shapeInfo;
361 shapeInfo.m_shapePart = partId;
362 shapeInfo.m_triangleIndex = triangleIndex;
363
364 btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal;
365
366 btCollisionWorld::LocalRayResult rayResult
367 (m_collisionObject,
368 &shapeInfo,
369 hitNormalWorld,
370 hitFraction);
371
372 bool normalInWorldSpace = true;
373 return m_resultCallback->addSingleResult(rayResult,normalInWorldSpace);
374 }
375
376 };
377
378 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
379 btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
380 btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();
381
382 // BT_PROFILE("rayTestConcave");
383 if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
384 {
386 btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
387
388 BridgeTriangleRaycastCallback rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObjectWrap->getCollisionObject(),triangleMesh,colObjWorldTransform);
389 rcb.m_hitFraction = resultCallback.m_closestHitFraction;
390 triangleMesh->performRaycast(&rcb,rayFromLocal,rayToLocal);
391 }
392 else
393 {
394 //generic (slower) case
395 btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
396
397 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
398
399 btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
400 btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();
401
402 //ConvexCast::CastResult
403
404 struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback
405 {
406 btCollisionWorld::RayResultCallback* m_resultCallback;
407 const btCollisionObject* m_collisionObject;
408 btConcaveShape* m_triangleMesh;
409
410 btTransform m_colObjWorldTransform;
411
412 BridgeTriangleRaycastCallback( const btVector3& from,const btVector3& to,
413 btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject,btConcaveShape* triangleMesh, const btTransform& colObjWorldTransform):
414 //@BP Mod
415 btTriangleRaycastCallback(from,to, resultCallback->m_flags),
416 m_resultCallback(resultCallback),
417 m_collisionObject(collisionObject),
418 m_triangleMesh(triangleMesh),
419 m_colObjWorldTransform(colObjWorldTransform)
420 {
421 }
422
423
424 virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
425 {
426 btCollisionWorld::LocalShapeInfo shapeInfo;
427 shapeInfo.m_shapePart = partId;
428 shapeInfo.m_triangleIndex = triangleIndex;
429
430 btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal;
431
432 btCollisionWorld::LocalRayResult rayResult
433 (m_collisionObject,
434 &shapeInfo,
435 hitNormalWorld,
436 hitFraction);
437
438 bool normalInWorldSpace = true;
439 return m_resultCallback->addSingleResult(rayResult,normalInWorldSpace);
440 }
441
442 };
443
444
445 BridgeTriangleRaycastCallback rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObjectWrap->getCollisionObject(),concaveShape, colObjWorldTransform);
446 rcb.m_hitFraction = resultCallback.m_closestHitFraction;
447
448 btVector3 rayAabbMinLocal = rayFromLocal;
449 rayAabbMinLocal.setMin(rayToLocal);
450 btVector3 rayAabbMaxLocal = rayFromLocal;
451 rayAabbMaxLocal.setMax(rayToLocal);
452
453 concaveShape->processAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
454 }
455 } else {
456 // BT_PROFILE("rayTestCompound");
457 if (collisionShape->isCompound())
458 {
459 struct LocalInfoAdder2 : public RayResultCallback
460 {
461 RayResultCallback* m_userCallback;
462 int m_i;
463
464 LocalInfoAdder2 (int i, RayResultCallback *user)
465 : m_userCallback(user), m_i(i)
466 {
467 m_closestHitFraction = m_userCallback->m_closestHitFraction;
468 m_flags = m_userCallback->m_flags;
469 }
470 virtual bool needsCollision(btBroadphaseProxy* p) const
471 {
472 return m_userCallback->needsCollision(p);
473 }
474
475 virtual btScalar addSingleResult (btCollisionWorld::LocalRayResult &r, bool b)
476 {
477 btCollisionWorld::LocalShapeInfo shapeInfo;
478 shapeInfo.m_shapePart = -1;
479 shapeInfo.m_triangleIndex = m_i;
480 if (r.m_localShapeInfo == NULL)
481 r.m_localShapeInfo = &shapeInfo;
482
483 const btScalar result = m_userCallback->addSingleResult(r, b);
484 m_closestHitFraction = m_userCallback->m_closestHitFraction;
485 return result;
486 }
487 };
488
489 struct RayTester : btDbvt::ICollide
490 {
491 const btCollisionObject* m_collisionObject;
492 const btCompoundShape* m_compoundShape;
493 const btTransform& m_colObjWorldTransform;
494 const btTransform& m_rayFromTrans;
495 const btTransform& m_rayToTrans;
496 RayResultCallback& m_resultCallback;
497
498 RayTester(const btCollisionObject* collisionObject,
499 const btCompoundShape* compoundShape,
500 const btTransform& colObjWorldTransform,
501 const btTransform& rayFromTrans,
502 const btTransform& rayToTrans,
503 RayResultCallback& resultCallback):
504 m_collisionObject(collisionObject),
505 m_compoundShape(compoundShape),
506 m_colObjWorldTransform(colObjWorldTransform),
507 m_rayFromTrans(rayFromTrans),
508 m_rayToTrans(rayToTrans),
509 m_resultCallback(resultCallback)
510 {
511
512 }
513
514 void ProcessLeaf(int i)
515 {
516 const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(i);
517 const btTransform& childTrans = m_compoundShape->getChildTransform(i);
518 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
519
520 btCollisionObjectWrapper tmpOb(0,childCollisionShape,m_collisionObject,childWorldTrans,-1,i);
521 // replace collision shape so that callback can determine the triangle
522
523
524
525 LocalInfoAdder2 my_cb(i, &m_resultCallback);
526
527 rayTestSingleInternal(
528 m_rayFromTrans,
529 m_rayToTrans,
530 &tmpOb,
531 my_cb);
532
533 }
534
535 void Process(const btDbvtNode* leaf)
536 {
537 ProcessLeaf(leaf->dataAsInt);
538 }
539 };
540
541 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
542 const btDbvt* dbvt = compoundShape->getDynamicAabbTree();
543
544
545 RayTester rayCB(
546 collisionObjectWrap->getCollisionObject(),
547 compoundShape,
548 colObjWorldTransform,
549 rayFromTrans,
550 rayToTrans,
551 resultCallback);
552 #ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
553 if (dbvt)
554 {
555 btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin();
556 btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin();
557 btDbvt::rayTest(dbvt->m_root, localRayFrom , localRayTo, rayCB);
558 }
559 else
560 #endif //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
561 {
562 for (int i = 0, n = compoundShape->getNumChildShapes(); i < n; ++i)
563 {
564 rayCB.ProcessLeaf(i);
565 }
566 }
567 }
568 }
569 }
570 }
571
572 void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
573 btCollisionObject* collisionObject,
574 const btCollisionShape* collisionShape,
575 const btTransform& colObjWorldTransform,
576 ConvexResultCallback& resultCallback, btScalar allowedPenetration)
577 {
578 btCollisionObjectWrapper tmpOb(0,collisionShape,collisionObject,colObjWorldTransform,-1,-1);
579 btCollisionWorld::objectQuerySingleInternal(castShape,convexFromTrans,convexToTrans,&tmpOb,resultCallback,allowedPenetration);
580 }
581
582 void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
583 const btCollisionObjectWrapper* colObjWrap,
584 ConvexResultCallback& resultCallback, btScalar allowedPenetration)
585 {
586 const btCollisionShape* collisionShape = colObjWrap->getCollisionShape();
587 const btTransform& colObjWorldTransform = colObjWrap->getWorldTransform();
588
589 if (collisionShape->isConvex())
590 {
591 //BT_PROFILE("convexSweepConvex");
592 btConvexCast::CastResult castResult;
593 castResult.m_allowedPenetration = allowedPenetration;
594 castResult.m_fraction = resultCallback.m_closestHitFraction;//btScalar(1.);//??
595
596 btConvexShape* convexShape = (btConvexShape*) collisionShape;
597 btVoronoiSimplexSolver simplexSolver;
598 btGjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver;
599
600 btContinuousConvexCollision convexCaster1(castShape,convexShape,&simplexSolver,&gjkEpaPenetrationSolver);
601 //btGjkConvexCast convexCaster2(castShape,convexShape,&simplexSolver);
602 //btSubsimplexConvexCast convexCaster3(castShape,convexShape,&simplexSolver);
603
604 btConvexCast* castPtr = &convexCaster1;
605
606
607
608 if (castPtr->calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
609 {
610 //add hit
611 if (castResult.m_normal.length2() > btScalar(0.0001))
612 {
613 if (castResult.m_fraction < resultCallback.m_closestHitFraction)
614 {
615 castResult.m_normal.normalize();
616 btCollisionWorld::LocalConvexResult localConvexResult
617 (
618 colObjWrap->getCollisionObject(),
619 0,
620 castResult.m_normal,
621 castResult.m_hitPoint,
622 castResult.m_fraction
623 );
624
625 bool normalInWorldSpace = true;
626 resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
627
628 }
629 }
630 }
631 } else {
632 if (collisionShape->isConcave())
633 {
634 if (collisionShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
635 {
636 //BT_PROFILE("convexSweepbtBvhTriangleMesh");
637 btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
638 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
639 btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
640 btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
641 // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
642 btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());
643
644 //ConvexCast::CastResult
645 struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
646 {
647 btCollisionWorld::ConvexResultCallback* m_resultCallback;
648 const btCollisionObject* m_collisionObject;
649 btTriangleMeshShape* m_triangleMesh;
650
651 BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
652 btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject,btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld):
653 btTriangleConvexcastCallback(castShape, from,to, triangleToWorld, triangleMesh->getMargin()),
654 m_resultCallback(resultCallback),
655 m_collisionObject(collisionObject),
656 m_triangleMesh(triangleMesh)
657 {
658 }
659
660
661 virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
662 {
663 btCollisionWorld::LocalShapeInfo shapeInfo;
664 shapeInfo.m_shapePart = partId;
665 shapeInfo.m_triangleIndex = triangleIndex;
666 if (hitFraction <= m_resultCallback->m_closestHitFraction)
667 {
668
669 btCollisionWorld::LocalConvexResult convexResult
670 (m_collisionObject,
671 &shapeInfo,
672 hitNormalLocal,
673 hitPointLocal,
674 hitFraction);
675
676 bool normalInWorldSpace = true;
677
678
679 return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
680 }
681 return hitFraction;
682 }
683
684 };
685
686 BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,colObjWrap->getCollisionObject(),triangleMesh, colObjWorldTransform);
687 tccb.m_hitFraction = resultCallback.m_closestHitFraction;
688 tccb.m_allowedPenetration = allowedPenetration;
689 btVector3 boxMinLocal, boxMaxLocal;
690 castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
691 triangleMesh->performConvexcast(&tccb,convexFromLocal,convexToLocal,boxMinLocal, boxMaxLocal);
692 } else
693 {
694 if (collisionShape->getShapeType()==STATIC_PLANE_PROXYTYPE)
695 {
696 btConvexCast::CastResult castResult;
697 castResult.m_allowedPenetration = allowedPenetration;
698 castResult.m_fraction = resultCallback.m_closestHitFraction;
699 btStaticPlaneShape* planeShape = (btStaticPlaneShape*) collisionShape;
700 btContinuousConvexCollision convexCaster1(castShape,planeShape);
701 btConvexCast* castPtr = &convexCaster1;
702
703 if (castPtr->calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
704 {
705 //add hit
706 if (castResult.m_normal.length2() > btScalar(0.0001))
707 {
708 if (castResult.m_fraction < resultCallback.m_closestHitFraction)
709 {
710 castResult.m_normal.normalize();
711 btCollisionWorld::LocalConvexResult localConvexResult
712 (
713 colObjWrap->getCollisionObject(),
714 0,
715 castResult.m_normal,
716 castResult.m_hitPoint,
717 castResult.m_fraction
718 );
719
720 bool normalInWorldSpace = true;
721 resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
722 }
723 }
724 }
725
726 } else
727 {
728 //BT_PROFILE("convexSweepConcave");
729 btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
730 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
731 btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
732 btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
733 // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
734 btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());
735
736 //ConvexCast::CastResult
737 struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
738 {
739 btCollisionWorld::ConvexResultCallback* m_resultCallback;
740 const btCollisionObject* m_collisionObject;
741 btConcaveShape* m_triangleMesh;
742
743 BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
744 btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject,btConcaveShape* triangleMesh, const btTransform& triangleToWorld):
745 btTriangleConvexcastCallback(castShape, from,to, triangleToWorld, triangleMesh->getMargin()),
746 m_resultCallback(resultCallback),
747 m_collisionObject(collisionObject),
748 m_triangleMesh(triangleMesh)
749 {
750 }
751
752
753 virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
754 {
755 btCollisionWorld::LocalShapeInfo shapeInfo;
756 shapeInfo.m_shapePart = partId;
757 shapeInfo.m_triangleIndex = triangleIndex;
758 if (hitFraction <= m_resultCallback->m_closestHitFraction)
759 {
760
761 btCollisionWorld::LocalConvexResult convexResult
762 (m_collisionObject,
763 &shapeInfo,
764 hitNormalLocal,
765 hitPointLocal,
766 hitFraction);
767
768 bool normalInWorldSpace = true;
769
770 return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
771 }
772 return hitFraction;
773 }
774
775 };
776
777 BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,colObjWrap->getCollisionObject(),concaveShape, colObjWorldTransform);
778 tccb.m_hitFraction = resultCallback.m_closestHitFraction;
779 tccb.m_allowedPenetration = allowedPenetration;
780 btVector3 boxMinLocal, boxMaxLocal;
781 castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
782
783 btVector3 rayAabbMinLocal = convexFromLocal;
784 rayAabbMinLocal.setMin(convexToLocal);
785 btVector3 rayAabbMaxLocal = convexFromLocal;
786 rayAabbMaxLocal.setMax(convexToLocal);
787 rayAabbMinLocal += boxMinLocal;
788 rayAabbMaxLocal += boxMaxLocal;
789 concaveShape->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
790 }
791 }
792 } else {
793 if (collisionShape->isCompound())
794 {
795 struct btCompoundLeafCallback : btDbvt::ICollide
796 {
797 btCompoundLeafCallback(
798 const btCollisionObjectWrapper* colObjWrap,
799 const btConvexShape* castShape,
800 const btTransform& convexFromTrans,
801 const btTransform& convexToTrans,
802 btScalar allowedPenetration,
803 const btCompoundShape* compoundShape,
804 const btTransform& colObjWorldTransform,
805 ConvexResultCallback& resultCallback)
806 :
807 m_colObjWrap(colObjWrap),
808 m_castShape(castShape),
809 m_convexFromTrans(convexFromTrans),
810 m_convexToTrans(convexToTrans),
811 m_allowedPenetration(allowedPenetration),
812 m_compoundShape(compoundShape),
813 m_colObjWorldTransform(colObjWorldTransform),
814 m_resultCallback(resultCallback) {
815 }
816
817 const btCollisionObjectWrapper* m_colObjWrap;
818 const btConvexShape* m_castShape;
819 const btTransform& m_convexFromTrans;
820 const btTransform& m_convexToTrans;
821 btScalar m_allowedPenetration;
822 const btCompoundShape* m_compoundShape;
823 const btTransform& m_colObjWorldTransform;
824 ConvexResultCallback& m_resultCallback;
825
826 public:
827
828 void ProcessChild(int index, const btTransform& childTrans, const btCollisionShape* childCollisionShape)
829 {
830 btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
831
832 struct LocalInfoAdder : public ConvexResultCallback {
833 ConvexResultCallback* m_userCallback;
834 int m_i;
835
836 LocalInfoAdder(int i, ConvexResultCallback *user)
837 : m_userCallback(user), m_i(i)
838 {
839 m_closestHitFraction = m_userCallback->m_closestHitFraction;
840 }
841 virtual bool needsCollision(btBroadphaseProxy* p) const
842 {
843 return m_userCallback->needsCollision(p);
844 }
845 virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& r, bool b)
846 {
847 btCollisionWorld::LocalShapeInfo shapeInfo;
848 shapeInfo.m_shapePart = -1;
849 shapeInfo.m_triangleIndex = m_i;
850 if (r.m_localShapeInfo == NULL)
851 r.m_localShapeInfo = &shapeInfo;
852 const btScalar result = m_userCallback->addSingleResult(r, b);
853 m_closestHitFraction = m_userCallback->m_closestHitFraction;
854 return result;
855
856 }
857 };
858
859 LocalInfoAdder my_cb(index, &m_resultCallback);
860
861 btCollisionObjectWrapper tmpObj(m_colObjWrap, childCollisionShape, m_colObjWrap->getCollisionObject(), childWorldTrans, -1, index);
862
863 objectQuerySingleInternal(m_castShape, m_convexFromTrans, m_convexToTrans, &tmpObj, my_cb, m_allowedPenetration);
864 }
865
866 void Process(const btDbvtNode* leaf)
867 {
868 // Processing leaf node
869 int index = leaf->dataAsInt;
870
871 btTransform childTrans = m_compoundShape->getChildTransform(index);
872 const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(index);
873
874 ProcessChild(index, childTrans, childCollisionShape);
875 }
876 };
877
878 BT_PROFILE("convexSweepCompound");
879 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
880
881 btVector3 fromLocalAabbMin, fromLocalAabbMax;
882 btVector3 toLocalAabbMin, toLocalAabbMax;
883
884 castShape->getAabb(colObjWorldTransform.inverse() * convexFromTrans, fromLocalAabbMin, fromLocalAabbMax);
885 castShape->getAabb(colObjWorldTransform.inverse() * convexToTrans, toLocalAabbMin, toLocalAabbMax);
886
887 fromLocalAabbMin.setMin(toLocalAabbMin);
888 fromLocalAabbMax.setMax(toLocalAabbMax);
889
890 btCompoundLeafCallback callback(colObjWrap, castShape, convexFromTrans, convexToTrans,
891 allowedPenetration, compoundShape, colObjWorldTransform, resultCallback);
892
893 const btDbvt* tree = compoundShape->getDynamicAabbTree();
894 if (tree) {
895 const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(fromLocalAabbMin, fromLocalAabbMax);
896 tree->collideTV(tree->m_root, bounds, callback);
897 } else {
898 int i;
899 for (i=0;i<compoundShape->getNumChildShapes();i++)
900 {
901 const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
902 btTransform childTrans = compoundShape->getChildTransform(i);
903 callback.ProcessChild(i, childTrans, childCollisionShape);
904 }
905 }
906 }
907 }
908 }
909 }
910
911
912 struct btSingleRayCallback : public btBroadphaseRayCallback
913 {
914
915 btVector3 m_rayFromWorld;
916 btVector3 m_rayToWorld;
917 btTransform m_rayFromTrans;
918 btTransform m_rayToTrans;
919 btVector3 m_hitNormal;
920
921 const btCollisionWorld* m_world;
922 btCollisionWorld::RayResultCallback& m_resultCallback;
923
924 btSingleRayCallback(const btVector3& rayFromWorld,const btVector3& rayToWorld,const btCollisionWorld* world,btCollisionWorld::RayResultCallback& resultCallback)
925 :m_rayFromWorld(rayFromWorld),
926 m_rayToWorld(rayToWorld),
927 m_world(world),
928 m_resultCallback(resultCallback)
929 {
930 m_rayFromTrans.setIdentity();
931 m_rayFromTrans.setOrigin(m_rayFromWorld);
932 m_rayToTrans.setIdentity();
933 m_rayToTrans.setOrigin(m_rayToWorld);
934
935 btVector3 rayDir = (rayToWorld-rayFromWorld);
936
937 rayDir.normalize ();
939 m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
940 m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
941 m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
942 m_signs[0] = m_rayDirectionInverse[0] < 0.0;
943 m_signs[1] = m_rayDirectionInverse[1] < 0.0;
944 m_signs[2] = m_rayDirectionInverse[2] < 0.0;
945
946 m_lambda_max = rayDir.dot(m_rayToWorld-m_rayFromWorld);
947
948 }
949
950
951
952 virtual bool process(const btBroadphaseProxy* proxy)
953 {
955 if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
956 return false;
957
958 btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
959
960 //only perform raycast if filterMask matches
961 if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
962 {
963 //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
964 //btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
965 #if 0
966 #ifdef RECALCULATE_AABB
967 btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
968 collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
969 #else
970 //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
971 const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
972 const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
973 #endif
974 #endif
975 //btScalar hitLambda = m_resultCallback.m_closestHitFraction;
976 //culling already done by broadphase
977 //if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal))
978 {
979 m_world->rayTestSingle(m_rayFromTrans,m_rayToTrans,
980 collisionObject,
981 collisionObject->getCollisionShape(),
982 collisionObject->getWorldTransform(),
983 m_resultCallback);
984 }
985 }
986 return true;
987 }
988 };
989
990 void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
991 {
992 //BT_PROFILE("rayTest");
995 btSingleRayCallback rayCB(rayFromWorld,rayToWorld,this,resultCallback);
996
997 #ifndef USE_BRUTEFORCE_RAYBROADPHASE
998 m_broadphasePairCache->rayTest(rayFromWorld,rayToWorld,rayCB);
999 #else
1000 for (int i=0;i<this->getNumCollisionObjects();i++)
1001 {
1002 rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
1003 }
1004 #endif //USE_BRUTEFORCE_RAYBROADPHASE
1005
1006 }
1007
1008
1009 struct btSingleSweepCallback : public btBroadphaseRayCallback
1010 {
1011
1012 btTransform m_convexFromTrans;
1013 btTransform m_convexToTrans;
1014 btVector3 m_hitNormal;
1015 const btCollisionWorld* m_world;
1016 btCollisionWorld::ConvexResultCallback& m_resultCallback;
1017 btScalar m_allowedCcdPenetration;
1018 const btConvexShape* m_castShape;
1019
1020
1021 btSingleSweepCallback(const btConvexShape* castShape, const btTransform& convexFromTrans,const btTransform& convexToTrans,const btCollisionWorld* world,btCollisionWorld::ConvexResultCallback& resultCallback,btScalar allowedPenetration)
1022 :m_convexFromTrans(convexFromTrans),
1023 m_convexToTrans(convexToTrans),
1024 m_world(world),
1025 m_resultCallback(resultCallback),
1026 m_allowedCcdPenetration(allowedPenetration),
1027 m_castShape(castShape)
1028 {
1029 btVector3 unnormalizedRayDir = (m_convexToTrans.getOrigin()-m_convexFromTrans.getOrigin());
1030 btVector3 rayDir = unnormalizedRayDir.normalized();
1032 m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
1033 m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
1034 m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
1035 m_signs[0] = m_rayDirectionInverse[0] < 0.0;
1036 m_signs[1] = m_rayDirectionInverse[1] < 0.0;
1037 m_signs[2] = m_rayDirectionInverse[2] < 0.0;
1038
1039 m_lambda_max = rayDir.dot(unnormalizedRayDir);
1040
1041 }
1042
1043 virtual bool process(const btBroadphaseProxy* proxy)
1044 {
1046 if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
1047 return false;
1048
1049 btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
1050
1051 //only perform raycast if filterMask matches
1052 if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
1053 //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
1054 m_world->objectQuerySingle(m_castShape, m_convexFromTrans,m_convexToTrans,
1055 collisionObject,
1056 collisionObject->getCollisionShape(),
1057 collisionObject->getWorldTransform(),
1058 m_resultCallback,
1059 m_allowedCcdPenetration);
1060 }
1061
1062 return true;
1063 }
1064 };
1065
1066
1067
1068 void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const
1069 {
1070
1071 BT_PROFILE("convexSweepTest");
1075
1076
1077
1078 btTransform convexFromTrans,convexToTrans;
1079 convexFromTrans = convexFromWorld;
1080 convexToTrans = convexToWorld;
1081 btVector3 castShapeAabbMin, castShapeAabbMax;
1082 /* Compute AABB that encompasses angular movement */
1083 {
1084 btVector3 linVel, angVel;
1085 btTransformUtil::calculateVelocity (convexFromTrans, convexToTrans, 1.0f, linVel, angVel);
1086 btVector3 zeroLinVel;
1087 zeroLinVel.setValue(0,0,0);
1088 btTransform R;
1089 R.setIdentity ();
1090 R.setRotation (convexFromTrans.getRotation());
1091 castShape->calculateTemporalAabb (R, zeroLinVel, angVel, 1.0f, castShapeAabbMin, castShapeAabbMax);
1092 }
1093
1094 #ifndef USE_BRUTEFORCE_RAYBROADPHASE
1095
1096 btSingleSweepCallback convexCB(castShape,convexFromWorld,convexToWorld,this,resultCallback,allowedCcdPenetration);
1097
1098 m_broadphasePairCache->rayTest(convexFromTrans.getOrigin(),convexToTrans.getOrigin(),convexCB,castShapeAabbMin,castShapeAabbMax);
1099
1100 #else
1101 // do a ray-shape query using convexCaster (CCD)
1103 int i;
1104 for (i=0;i<m_collisionObjects.size();i++)
1105 {
1106 btCollisionObject* collisionObject= m_collisionObjects[i];
1107 //only perform raycast if filterMask matches
1108 if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
1109 //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
1110 btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
1111 collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
1112 AabbExpand (collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
1113 btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
1114 btVector3 hitNormal;
1115 if (btRayAabb(convexFromWorld.getOrigin(),convexToWorld.getOrigin(),collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
1116 {
1117 objectQuerySingle(castShape, convexFromTrans,convexToTrans,
1118 collisionObject,
1119 collisionObject->getCollisionShape(),
1120 collisionObject->getWorldTransform(),
1121 resultCallback,
1122 allowedCcdPenetration);
1123 }
1124 }
1125 }
1126 #endif //USE_BRUTEFORCE_RAYBROADPHASE
1127 }
1128
1129
1130
1131 struct btBridgedManifoldResult : public btManifoldResult
1132 {
1133
1134 btCollisionWorld::ContactResultCallback& m_resultCallback;
1135
1136 btBridgedManifoldResult( const btCollisionObjectWrapper* obj0Wrap,const btCollisionObjectWrapper* obj1Wrap,btCollisionWorld::ContactResultCallback& resultCallback )
1137 :btManifoldResult(obj0Wrap,obj1Wrap),
1138 m_resultCallback(resultCallback)
1139 {
1140 }
1141
1142 virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
1143 {
1144 bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
1145 btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
1146 btVector3 localA;
1147 btVector3 localB;
1148 if (isSwapped)
1149 {
1150 localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA );
1151 localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
1152 } else
1153 {
1154 localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA );
1155 localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
1156 }
1157
1158 btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
1159 newPt.m_positionWorldOnA = pointA;
1160 newPt.m_positionWorldOnB = pointInWorld;
1161
1162 //BP mod, store contact triangles.
1163 if (isSwapped)
1164 {
1165 newPt.m_partId0 = m_partId1;
1166 newPt.m_partId1 = m_partId0;
1167 newPt.m_index0 = m_index1;
1168 newPt.m_index1 = m_index0;
1169 } else
1170 {
1171 newPt.m_partId0 = m_partId0;
1172 newPt.m_partId1 = m_partId1;
1173 newPt.m_index0 = m_index0;
1174 newPt.m_index1 = m_index1;
1175 }
1176
1177 //experimental feature info, for per-triangle material etc.
1178 const btCollisionObjectWrapper* obj0Wrap = isSwapped? m_body1Wrap : m_body0Wrap;
1179 const btCollisionObjectWrapper* obj1Wrap = isSwapped? m_body0Wrap : m_body1Wrap;
1180 m_resultCallback.addSingleResult(newPt,obj0Wrap,newPt.m_partId0,newPt.m_index0,obj1Wrap,newPt.m_partId1,newPt.m_index1);
1181
1182 }
1183
1184 };
1185
1186
1187
1188 struct btSingleContactCallback : public btBroadphaseAabbCallback
1189 {
1190
1191 btCollisionObject* m_collisionObject;
1192 btCollisionWorld* m_world;
1193 btCollisionWorld::ContactResultCallback& m_resultCallback;
1194
1195
1196 btSingleContactCallback(btCollisionObject* collisionObject, btCollisionWorld* world,btCollisionWorld::ContactResultCallback& resultCallback)
1197 :m_collisionObject(collisionObject),
1198 m_world(world),
1199 m_resultCallback(resultCallback)
1200 {
1201 }
1202
1203 virtual bool process(const btBroadphaseProxy* proxy)
1204 {
1205 btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
1206 if (collisionObject == m_collisionObject)
1207 return true;
1208
1209 //only perform raycast if filterMask matches
1210 if(m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
1211 {
1212 btCollisionObjectWrapper ob0(0,m_collisionObject->getCollisionShape(),m_collisionObject,m_collisionObject->getWorldTransform(),-1,-1);
1213 btCollisionObjectWrapper ob1(0,collisionObject->getCollisionShape(),collisionObject,collisionObject->getWorldTransform(),-1,-1);
1214
1215 btCollisionAlgorithm* algorithm = m_world->getDispatcher()->findAlgorithm(&ob0,&ob1);
1216 if (algorithm)
1217 {
1218 btBridgedManifoldResult contactPointResult(&ob0,&ob1, m_resultCallback);
1219 //discrete collision detection query
1220
1221 algorithm->processCollision(&ob0,&ob1, m_world->getDispatchInfo(),&contactPointResult);
1222
1223 algorithm->~btCollisionAlgorithm();
1224 m_world->getDispatcher()->freeCollisionAlgorithm(algorithm);
1225 }
1226 }
1227 return true;
1228 }
1229 };
1230
1231
1234 void btCollisionWorld::contactTest( btCollisionObject* colObj, ContactResultCallback& resultCallback)
1235 {
1236 btVector3 aabbMin,aabbMax;
1237 colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(),aabbMin,aabbMax);
1238 btSingleContactCallback contactCB(colObj,this,resultCallback);
1239
1240 m_broadphasePairCache->aabbTest(aabbMin,aabbMax,contactCB);
1241 }
1242
1243
1246 void btCollisionWorld::contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback)
1247 {
1248 btCollisionObjectWrapper obA(0,colObjA->getCollisionShape(),colObjA,colObjA->getWorldTransform(),-1,-1);
1249 btCollisionObjectWrapper obB(0,colObjB->getCollisionShape(),colObjB,colObjB->getWorldTransform(),-1,-1);
1250
1251 btCollisionAlgorithm* algorithm = getDispatcher()->findAlgorithm(&obA,&obB);
1252 if (algorithm)
1253 {
1254 btBridgedManifoldResult contactPointResult(&obA,&obB, resultCallback);
1255 //discrete collision detection query
1256 algorithm->processCollision(&obA,&obB, getDispatchInfo(),&contactPointResult);
1257
1258 algorithm->~btCollisionAlgorithm();
1259 getDispatcher()->freeCollisionAlgorithm(algorithm);
1260 }
1261
1262 }
1263
1264
1265
1266
1267 class DebugDrawcallback : public btTriangleCallback, public btInternalTriangleIndexCallback
1268 {
1269 btIDebugDraw* m_debugDrawer;
1270 btVector3 m_color;
1271 btTransform m_worldTrans;
1272
1273 public:
1274
1275 DebugDrawcallback(btIDebugDraw* debugDrawer,const btTransform& worldTrans,const btVector3& color) :
1276 m_debugDrawer(debugDrawer),
1277 m_color(color),
1278 m_worldTrans(worldTrans)
1279 {
1280 }
1281
1282 virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int triangleIndex)
1283 {
1284 processTriangle(triangle,partId,triangleIndex);
1285 }
1286
1287 virtual void processTriangle(btVector3* triangle,int partId, int triangleIndex)
1288 {
1289 (void)partId;
1290 (void)triangleIndex;
1291
1292 btVector3 wv0,wv1,wv2;
1293 wv0 = m_worldTrans*triangle[0];
1294 wv1 = m_worldTrans*triangle[1];
1295 wv2 = m_worldTrans*triangle[2];
1296 btVector3 center = (wv0+wv1+wv2)*btScalar(1./3.);
1297
1298 if (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawNormals )
1299 {
1300 btVector3 normal = (wv1-wv0).cross(wv2-wv0);
1301 normal.normalize();
1302 btVector3 normalColor(1,1,0);
1303 m_debugDrawer->drawLine(center,center+normal,normalColor);
1304 }
1305 m_debugDrawer->drawLine(wv0,wv1,m_color);
1306 m_debugDrawer->drawLine(wv1,wv2,m_color);
1307 m_debugDrawer->drawLine(wv2,wv0,m_color);
1308 }
1309 };
1310
1311
1312 void btCollisionWorld::debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color)
1313 {
1314 // Draw a small simplex at the center of the object
1315 if (getDebugDrawer() && getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawFrames)
1316 {
1317 getDebugDrawer()->drawTransform(worldTransform,1);
1318 }
1319
1320 if (shape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE)
1321 {
1322 const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
1323 for (int i=compoundShape->getNumChildShapes()-1;i>=0;i--)
1324 {
1325 btTransform childTrans = compoundShape->getChildTransform(i);
1326 const btCollisionShape* colShape = compoundShape->getChildShape(i);
1327 debugDrawObject(worldTransform*childTrans,colShape,color);
1328 }
1329
1330 } else
1331 {
1332
1333 switch (shape->getShapeType())
1334 {
1335
1336 case BOX_SHAPE_PROXYTYPE:
1337 {
1338 const btBoxShape* boxShape = static_cast<const btBoxShape*>(shape);
1339 btVector3 halfExtents = boxShape->getHalfExtentsWithMargin();
1340 getDebugDrawer()->drawBox(-halfExtents,halfExtents,worldTransform,color);
1341 break;
1342 }
1343
1344 case SPHERE_SHAPE_PROXYTYPE:
1345 {
1346 const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
1347 btScalar radius = sphereShape->getMargin();//radius doesn't include the margin, so draw with margin
1348
1349 getDebugDrawer()->drawSphere(radius, worldTransform, color);
1350 break;
1351 }
1352 case MULTI_SPHERE_SHAPE_PROXYTYPE:
1353 {
1354 const btMultiSphereShape* multiSphereShape = static_cast<const btMultiSphereShape*>(shape);
1355
1356 btTransform childTransform;
1357 childTransform.setIdentity();
1358
1359 for (int i = multiSphereShape->getSphereCount()-1; i>=0;i--)
1360 {
1361 childTransform.setOrigin(multiSphereShape->getSpherePosition(i));
1362 getDebugDrawer()->drawSphere(multiSphereShape->getSphereRadius(i), worldTransform*childTransform, color);
1363 }
1364
1365 break;
1366 }
1367 case CAPSULE_SHAPE_PROXYTYPE:
1368 {
1369 const btCapsuleShape* capsuleShape = static_cast<const btCapsuleShape*>(shape);
1370
1371 btScalar radius = capsuleShape->getRadius();
1372 btScalar halfHeight = capsuleShape->getHalfHeight();
1373
1374 int upAxis = capsuleShape->getUpAxis();
1375 getDebugDrawer()->drawCapsule(radius, halfHeight, upAxis, worldTransform, color);
1376 break;
1377 }
1378 case CONE_SHAPE_PROXYTYPE:
1379 {
1380 const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
1381 btScalar radius = coneShape->getRadius();//+coneShape->getMargin();
1382 btScalar height = coneShape->getHeight();//+coneShape->getMargin();
1383
1384 int upAxis= coneShape->getConeUpIndex();
1385 getDebugDrawer()->drawCone(radius, height, upAxis, worldTransform, color);
1386 break;
1387
1388 }
1389 case CYLINDER_SHAPE_PROXYTYPE:
1390 {
1391 const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
1392 int upAxis = cylinder->getUpAxis();
1393 btScalar radius = cylinder->getRadius();
1394 btScalar halfHeight = cylinder->getHalfExtentsWithMargin()[upAxis];
1395 getDebugDrawer()->drawCylinder(radius, halfHeight, upAxis, worldTransform, color);
1396 break;
1397 }
1398
1399 case STATIC_PLANE_PROXYTYPE:
1400 {
1401 const btStaticPlaneShape* staticPlaneShape = static_cast<const btStaticPlaneShape*>(shape);
1402 btScalar planeConst = staticPlaneShape->getPlaneConstant();
1403 const btVector3& planeNormal = staticPlaneShape->getPlaneNormal();
1404 getDebugDrawer()->drawPlane(planeNormal, planeConst,worldTransform, color);
1405 break;
1406
1407 }
1408 default:
1409 {
1410
1412 if (shape->isPolyhedral())
1413 {
1414 btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*) shape;
1415
1416 int i;
1417 if (polyshape->getConvexPolyhedron())
1418 {
1419 const btConvexPolyhedron* poly = polyshape->getConvexPolyhedron();
1420 for (i=0;i<poly->m_faces.size();i++)
1421 {
1422 btVector3 centroid(0,0,0);
1423 int numVerts = poly->m_faces[i].m_indices.size();
1424 if (numVerts)
1425 {
1426 int lastV = poly->m_faces[i].m_indices[numVerts-1];
1427 for (int v=0;v<poly->m_faces[i].m_indices.size();v++)
1428 {
1429 int curVert = poly->m_faces[i].m_indices[v];
1430 centroid+=poly->m_vertices[curVert];
1431 getDebugDrawer()->drawLine(worldTransform*poly->m_vertices[lastV],worldTransform*poly->m_vertices[curVert],color);
1432 lastV = curVert;
1433 }
1434 }
1435 centroid*= btScalar(1.f)/btScalar(numVerts);
1436 if (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawNormals)
1437 {
1438 btVector3 normalColor(1,1,0);
1439 btVector3 faceNormal(poly->m_faces[i].m_plane[0],poly->m_faces[i].m_plane[1],poly->m_faces[i].m_plane[2]);
1440 getDebugDrawer()->drawLine(worldTransform*centroid,worldTransform*(centroid+faceNormal),normalColor);
1441 }
1442
1443 }
1444
1445
1446 } else
1447 {
1448 for (i=0;i<polyshape->getNumEdges();i++)
1449 {
1450 btVector3 a,b;
1451 polyshape->getEdge(i,a,b);
1452 btVector3 wa = worldTransform * a;
1453 btVector3 wb = worldTransform * b;
1454 getDebugDrawer()->drawLine(wa,wb,color);
1455 }
1456 }
1457
1458
1459 }
1460
1461 if (shape->isConcave())
1462 {
1463 btConcaveShape* concaveMesh = (btConcaveShape*) shape;
1464
1466 btVector3 aabbMax(btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT));
1467 btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT));
1468
1469 DebugDrawcallback drawCallback(getDebugDrawer(),worldTransform,color);
1470 concaveMesh->processAllTriangles(&drawCallback,aabbMin,aabbMax);
1471
1472 }
1473
1474 if (shape->getShapeType() == CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE)
1475 {
1476 btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*) shape;
1477 //todo: pass camera for some culling
1478 btVector3 aabbMax(btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT));
1479 btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT),btScalar(-BT_LARGE_FLOAT));
1480 //DebugDrawcallback drawCallback;
1481 DebugDrawcallback drawCallback(getDebugDrawer(),worldTransform,color);
1482 convexMesh->getMeshInterface()->InternalProcessAllTriangles(&drawCallback,aabbMin,aabbMax);
1483 }
1484
1485
1486
1487 }
1488
1489 }
1490 }
1491 }
1492
1493
1494 void btCollisionWorld::debugDrawWorld()
1495 {
1496 if (getDebugDrawer())
1497 {
1498 btIDebugDraw::DefaultColors defaultColors = getDebugDrawer()->getDefaultColors();
1499
1500 if ( getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawContactPoints)
1501 {
1502
1503
1504 if (getDispatcher())
1505 {
1506 int numManifolds = getDispatcher()->getNumManifolds();
1507
1508 for (int i=0;i<numManifolds;i++)
1509 {
1510 btPersistentManifold* contactManifold = getDispatcher()->getManifoldByIndexInternal(i);
1511 //btCollisionObject* obA = static_cast<btCollisionObject*>(contactManifold->getBody0());
1512 //btCollisionObject* obB = static_cast<btCollisionObject*>(contactManifold->getBody1());
1513
1514 int numContacts = contactManifold->getNumContacts();
1515 for (int j=0;j<numContacts;j++)
1516 {
1517 btManifoldPoint& cp = contactManifold->getContactPoint(j);
1518 getDebugDrawer()->drawContactPoint(cp.m_positionWorldOnB,cp.m_normalWorldOnB,cp.getDistance(),cp.getLifeTime(),defaultColors.m_contactPoint);
1519 }
1520 }
1521 }
1522 }
1523
1524 if ((getDebugDrawer()->getDebugMode() & (btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawAabb)))
1525 {
1526 int i;
1527
1528 for ( i=0;i<m_collisionObjects.size();i++)
1529 {
1530 btCollisionObject* colObj = m_collisionObjects[i];
1531 if ((colObj->getCollisionFlags() & btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT)==0)
1532 {
1533 if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe))
1534 {
1535 btVector3 color(btScalar(0.4),btScalar(0.4),btScalar(0.4));
1536
1537 switch(colObj->getActivationState())
1538 {
1539 case ACTIVE_TAG:
1540 color = defaultColors.m_activeObject; break;
1541 case ISLAND_SLEEPING:
1542 color = defaultColors.m_deactivatedObject;break;
1543 case WANTS_DEACTIVATION:
1544 color = defaultColors.m_wantsDeactivationObject;break;
1545 case DISABLE_DEACTIVATION:
1546 color = defaultColors.m_disabledDeactivationObject;break;
1547 case DISABLE_SIMULATION:
1548 color = defaultColors.m_disabledSimulationObject;break;
1549 default:
1550 {
1551 color = btVector3(btScalar(.3),btScalar(0.3),btScalar(0.3));
1552 }
1553 };
1554
1555 debugDrawObject(colObj->getWorldTransform(),colObj->getCollisionShape(),color);
1556 }
1557 if (m_debugDrawer && (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
1558 {
1559 btVector3 minAabb,maxAabb;
1560 btVector3 colorvec = defaultColors.m_aabb;
1561 colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
1562 btVector3 contactThreshold(gContactBreakingThreshold,gContactBreakingThreshold,gContactBreakingThreshold);
1563 minAabb -= contactThreshold;
1564 maxAabb += contactThreshold;
1565
1566 btVector3 minAabb2,maxAabb2;
1567
1568 if(getDispatchInfo().m_useContinuous && colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
1569 {
1570 colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(),minAabb2,maxAabb2);
1571 minAabb2 -= contactThreshold;
1572 maxAabb2 += contactThreshold;
1573 minAabb.setMin(minAabb2);
1574 maxAabb.setMax(maxAabb2);
1575 }
1576
1577 m_debugDrawer->drawAabb(minAabb,maxAabb,colorvec);
1578 }
1579 }
1580 }
1581 }
1582 }
1583 }
1584
1585
1586 void btCollisionWorld::serializeCollisionObjects(btSerializer* serializer)
1587 {
1588 int i;
1589
1591 btHashMap<btHashPtr,btCollisionShape*> serializedShapes;
1592
1593 for (i=0;i<m_collisionObjects.size();i++)
1594 {
1595 btCollisionObject* colObj = m_collisionObjects[i];
1596 btCollisionShape* shape = colObj->getCollisionShape();
1597
1598 if (!serializedShapes.find(shape))
1599 {
1600 serializedShapes.insert(shape,shape);
1601 shape->serializeSingleShape(serializer);
1602 }
1603 }
1604
1605 //serialize all collision objects
1606 for (i=0;i<m_collisionObjects.size();i++)
1607 {
1608 btCollisionObject* colObj = m_collisionObjects[i];
1609 if ((colObj->getInternalType() == btCollisionObject::CO_COLLISION_OBJECT) || (colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK))
1610 {
1611 colObj->serializeSingleObject(serializer);
1612 }
1613 }
1614 }
1615
1616
1617 void btCollisionWorld::serialize(btSerializer* serializer)
1618 {
1619
1620 serializer->startSerialization();
1621
1622 serializeCollisionObjects(serializer);
1623
1624 serializer->finishSerialization();
1625 }
1626
btTransform::setOrigin
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:150
btCylinderShape::getHalfExtentsWithMargin
btVector3 getHalfExtentsWithMargin() const
Definition: btCylinderShape.h:36
btSerializer::finishSerialization
virtual void finishSerialization()=0
ACTIVE_TAG
#define ACTIVE_TAG
Definition: btCollisionObject.h:22
btSingleSweepCallback::btSingleSweepCallback
btSingleSweepCallback(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionWorld *world, btCollisionWorld::ConvexResultCallback &resultCallback, btScalar allowedPenetration)
Definition: btCollisionWorld.cpp:1021
btCollisionWorld::serializeCollisionObjects
void serializeCollisionObjects(btSerializer *serializer)
Definition: btCollisionWorld.cpp:1586
btConvexPolyhedron::m_vertices
btAlignedObjectArray< btVector3 > m_vertices
Definition: btConvexPolyhedron.h:46
btIDebugDraw::DBG_DrawAabb
Definition: btIDebugDraw.h:60
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:54
CONE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:43
btConvexTriangleMeshShape
The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good...
Definition: btConvexTriangleMeshShape.h:25
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:274
btMultiSphereShape::getSphereRadius
btScalar getSphereRadius(int index) const
Definition: btMultiSphereShape.h:57
SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:40
BT_LARGE_FLOAT
#define BT_LARGE_FLOAT
Definition: btScalar.h:281
btConvexCast
btConvexCast is an interface for Casting
Definition: btConvexCast.h:27
btCollisionWorld.h
btIDebugDraw::getDefaultColors
virtual DefaultColors getDefaultColors() const
Definition: btIDebugDraw.h:81
btConvexCast::CastResult::m_fraction
btScalar m_fraction
Definition: btConvexCast.h:57
btSingleSweepCallback
Definition: btCollisionWorld.cpp:1009
btDispatcher::findAlgorithm
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold=0)=0
btIDebugDraw::DefaultColors::m_wantsDeactivationObject
btVector3 m_wantsDeactivationObject
Definition: btIDebugDraw.h:37
btManifoldPoint::m_partId1
int m_partId1
Definition: btManifoldPoint.h:109
btCapsuleShape::getRadius
btScalar getRadius() const
Definition: btCapsuleShape.h:84
btCapsuleShape.h
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:650
btBvhTriangleMeshShape::performRaycast
void performRaycast(btTriangleCallback *callback, const btVector3 &raySource, const btVector3 &rayTarget)
Definition: btBvhTriangleMeshShape.cpp:93
btCollisionWorld::LocalConvexResult::m_localShapeInfo
LocalShapeInfo * m_localShapeInfo
Definition: btCollisionWorld.h:333
btCollisionWorld::updateAabbs
virtual void updateAabbs()
Definition: btCollisionWorld.cpp:190
btIDebugDraw::DefaultColors::m_deactivatedObject
btVector3 m_deactivatedObject
Definition: btIDebugDraw.h:36
btTriangleRaycastCallback
Definition: btRaycastCallback.h:24
btCollisionShape::isConvex
bool isConvex() const
Definition: btCollisionShape.h:73
btDbvtAabbMm
Definition: btDbvt.h:131
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition: btAlignedObjectArray.h:463
btCollisionWorld::btCollisionWorld
btCollisionWorld(btDispatcher *dispatcher, btBroadphaseInterface *broadphasePairCache, btCollisionConfiguration *collisionConfiguration)
for debug drawing
Definition: btCollisionWorld.cpp:69
btSingleContactCallback::m_resultCallback
btCollisionWorld::ContactResultCallback & m_resultCallback
Definition: btCollisionWorld.cpp:1193
btIDebugDraw::reportErrorWarning
virtual void reportErrorWarning(const char *warningString)=0
btDispatcher::getManifoldByIndexInternal
virtual btPersistentManifold * getManifoldByIndexInternal(int index)=0
btHashMap::find
const Value * find(const Key &key) const
Definition: btHashMap.h:419
btCollisionWorld::m_forceUpdateAllAabbs
bool m_forceUpdateAllAabbs
m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs it is...
Definition: btCollisionWorld.h:106
btBoxShape.h
btCompoundLeafCallback
Definition: btCompoundCollisionAlgorithm.cpp:95
btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:257
btBroadphaseProxy::m_aabbMax
btVector3 m_aabbMax
Definition: btBroadphaseProxy.h:110
btIDebugDraw::drawLine
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
btDispatcher::dispatchAllCollisionPairs
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &dispatchInfo, btDispatcher *dispatcher)=0
btSerializer::startSerialization
virtual void startSerialization()=0
btIDebugDraw::DefaultColors::m_aabb
btVector3 m_aabb
Definition: btIDebugDraw.h:40
btMultiSphereShape
The btMultiSphereShape represents the convex hull of a collection of spheres.
Definition: btMultiSphereShape.h:28
CAPSULE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:42
btStaticPlaneShape::getPlaneConstant
const btScalar & getPlaneConstant() const
Definition: btStaticPlaneShape.h:55
btStridingMeshInterface::InternalProcessAllTriangles
virtual void InternalProcessAllTriangles(btInternalTriangleIndexCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Definition: btStridingMeshInterface.cpp:25
btIDebugDraw::drawBox
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
Definition: btIDebugDraw.h:306
btCollisionWorld::LocalShapeInfo::m_triangleIndex
int m_triangleIndex
Definition: btCollisionWorld.h:177
btCollisionWorld::addCollisionObject
virtual void addCollisionObject(btCollisionObject *collisionObject, short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, short int collisionFilterMask=btBroadphaseProxy::AllFilter)
Definition: btCollisionWorld.cpp:111
TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:55
btPersistentManifold::getNumContacts
int getNumContacts() const
Definition: btPersistentManifold.h:109
btCapsuleShape
The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned ...
Definition: btCapsuleShape.h:26
btCompoundShape::getDynamicAabbTree
const btDbvt * getDynamicAabbTree() const
Definition: btCompoundShape.h:146
btIDebugDraw::DBG_DrawContactPoints
Definition: btIDebugDraw.h:62
btTransform::setIdentity
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:172
btIDebugDraw::DefaultColors
Definition: btIDebugDraw.h:33
btAssert
#define btAssert(x)
Definition: btScalar.h:114
btIDebugDraw::drawPlane
virtual void drawPlane(const btVector3 &planeNormal, btScalar planeConst, const btTransform &transform, const btVector3 &color)
Definition: btIDebugDraw.h:458
btStaticPlaneShape.h
btTransform::getRotation
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
btCollisionWorld::ContactResultCallback
ContactResultCallback is used to report contact points.
Definition: btCollisionWorld.h:411
btBoxShape::getHalfExtentsWithMargin
btVector3 getHalfExtentsWithMargin() const
Definition: btBoxShape.h:36
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
Definition: btCollisionConfiguration.h:26
CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:34
btCollisionShape::serializeSingleShape
virtual void serializeSingleShape(btSerializer *serializer) const
Definition: btCollisionShape.cpp:113
btRaycastCallback.h
btDbvt
The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes ...
Definition: btDbvt.h:198
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:27
btCylinderShape.h
btCollisionWorld::RayResultCallback
RayResultCallback is used to report new raycast results.
Definition: btCollisionWorld.h:204
btContinuousConvexCollision
btContinuousConvexCollision implements angular and linear time of impact for convex objects...
Definition: btContinuousConvexCollision.h:30
btConeShape.h
btBvhTriangleMeshShape.h
btSphereShape
The btSphereShape implements an implicit sphere, centered around a local origin with radius...
Definition: btSphereShape.h:22
btDbvt::m_root
btDbvtNode * m_root
Definition: btDbvt.h:262
btIDebugDraw::DefaultColors::m_activeObject
btVector3 m_activeObject
Definition: btIDebugDraw.h:35
btSingleRayCallback::m_resultCallback
btCollisionWorld::RayResultCallback & m_resultCallback
Definition: btCollisionWorld.cpp:922
btManifoldPoint
ManifoldContactPoint collects and maintains persistent contactpoints.
Definition: btManifoldPoint.h:48
btSingleSweepCallback::m_world
const btCollisionWorld * m_world
Definition: btCollisionWorld.cpp:1015
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:277
btCollisionWorld::m_dispatcher1
btDispatcher * m_dispatcher1
Definition: btCollisionWorld.h:96
btManifoldResult
btManifoldResult is a helper class to manage contact results.
Definition: btManifoldResult.h:39
btIDebugDraw::DefaultColors::m_disabledSimulationObject
btVector3 m_disabledSimulationObject
Definition: btIDebugDraw.h:39
btDbvt::rayTest
static DBVT_PREFIX void rayTest(const btDbvtNode *root, const btVector3 &rayFrom, const btVector3 &rayTo, DBVT_IPOLICY)
rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thre...
Definition: btDbvt.h:1054
btCollisionWorld::rayTestSingleInternal
static void rayTestSingleInternal(const btTransform &rayFromTrans, const btTransform &rayToTrans, const btCollisionObjectWrapper *collisionObjectWrap, RayResultCallback &resultCallback)
Definition: btCollisionWorld.cpp:272
btCylinderShape::getUpAxis
int getUpAxis() const
Definition: btCylinderShape.h:95
btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObjectWrapper.h:40
BOX_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:31
btCollisionWorld::computeOverlappingPairs
virtual void computeOverlappingPairs()
the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSi...
Definition: btCollisionWorld.cpp:208
btSingleContactCallback::m_collisionObject
btCollisionObject * m_collisionObject
Definition: btCollisionWorld.cpp:1191
btInternalTriangleIndexCallback
Definition: btTriangleCallback.h:32
ISLAND_SLEEPING
#define ISLAND_SLEEPING
Definition: btCollisionObject.h:23
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:202
btIDebugDraw::drawCapsule
virtual void drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform &transform, const btVector3 &color)
Definition: btIDebugDraw.h:337
btCompoundShape::getNumChildShapes
int getNumChildShapes() const
Definition: btCompoundShape.h:85
btCollisionWorld::RayResultCallback::m_closestHitFraction
btScalar m_closestHitFraction
Definition: btCollisionWorld.h:206
btSingleRayCallback::btSingleRayCallback
btSingleRayCallback(const btVector3 &rayFromWorld, const btVector3 &rayToWorld, const btCollisionWorld *world, btCollisionWorld::RayResultCallback &resultCallback)
Definition: btCollisionWorld.cpp:924
btCapsuleShape::getUpAxis
int getUpAxis() const
Definition: btCapsuleShape.h:79
btConcaveShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const =0
btIDebugDraw::drawContactPoint
virtual void drawContactPoint(const btVector3 &PointOnB, const btVector3 &normalOnB, btScalar distance, int lifeTime, const btVector3 &color)=0
btBroadphaseInterface.h
btCollisionShape::getAabb
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...
btConvexShape.h
btHashMap
The btHashMap template class implements a generic and lightweight hashmap.
Definition: btHashMap.h:220
btSerializer
Definition: btSerializer.h:68
btVector3::normalize
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:307
btSingleSweepCallback::m_convexToTrans
btTransform m_convexToTrans
Definition: btCollisionWorld.cpp:1013
btCollisionWorld::getNumCollisionObjects
int getNumCollisionObjects() const
Definition: btCollisionWorld.h:438
btVector3::normalized
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:962
btBridgedManifoldResult
Definition: btCollisionWorld.cpp:1131
btConvexCast::CastResult::m_normal
btVector3 m_normal
Definition: btConvexCast.h:55
btConvexShape
The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape...
Definition: btConvexShape.h:31
btCollisionWorld::ConvexResultCallback::needsCollision
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
Definition: btCollisionWorld.h:364
btGjkConvexCast
GjkConvexCast performs a raycast on a convex object using support mapping.
Definition: btGjkConvexCast.h:30
btPersistentManifold::getContactPoint
const btManifoldPoint & getContactPoint(int index) const
Definition: btPersistentManifold.h:117
btTriangleMeshShape
The btTriangleMeshShape is an internal concave triangle mesh interface. Don&#39;t use this class directly...
Definition: btTriangleMeshShape.h:24
btCollisionObject::CO_FEATHERSTONE_LINK
Definition: btCollisionObject.h:151
btConvexCast::CastResult::m_allowedPenetration
btScalar m_allowedPenetration
Definition: btConvexCast.h:59
btPolyhedralConvexShape::getEdge
virtual void getEdge(int i, btVector3 &pa, btVector3 &pb) const =0
AabbExpand
void AabbExpand(btVector3 &aabbMin, btVector3 &aabbMax, const btVector3 &expansionMin, const btVector3 &expansionMax)
Definition: btAabbUtil2.h:26
btBroadphaseInterface::getOverlappingPairCache
virtual btOverlappingPairCache * getOverlappingPairCache()=0
btCollisionShape::isCompound
bool isCompound() const
Definition: btCollisionShape.h:85
btBvhTriangleMeshShape
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
Definition: btBvhTriangleMeshShape.h:34
DebugDrawcallback::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btCollisionWorld.cpp:1269
btIDebugDraw::DBG_DrawNormals
Definition: btIDebugDraw.h:73
btCollisionWorld::RayResultCallback::addSingleResult
virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace)=0
btMultiSphereShape::getSphereCount
int getSphereCount() const
Definition: btMultiSphereShape.h:47
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:367
CYLINDER_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:45
btManifoldPoint::m_normalWorldOnB
btVector3 m_normalWorldOnB
Definition: btManifoldPoint.h:99
btCapsuleShape::getHalfHeight
btScalar getHalfHeight() const
Definition: btCapsuleShape.h:90
btConvexCast::CastResult
RayResult stores the closest result alternatively, add a callback method to decide about closest/all ...
Definition: btConvexCast.h:36
btManifoldPoint::m_positionWorldOnB
btVector3 m_positionWorldOnB
Definition: btManifoldPoint.h:96
btIDebugDraw::DBG_DrawWireframe
Definition: btIDebugDraw.h:59
btIDebugDraw::drawCone
virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform &transform, const btVector3 &color)
Definition: btIDebugDraw.h:421
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btConvexShape::getAabb
void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb&#39;s default implementation is brute force, expected derived classes to implement a fast dedicat...
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:384
btSimpleBroadphase.h
btConeShape::getConeUpIndex
int getConeUpIndex() const
Definition: btConeShape.h:91
btSingleSweepCallback::m_convexFromTrans
btTransform m_convexFromTrans
Definition: btCollisionWorld.cpp:1012
btVoronoiSimplexSolver
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
Definition: btVoronoiSimplexSolver.h:95
btSingleRayCallback::m_world
const btCollisionWorld * m_world
Definition: btCollisionWorld.cpp:921
btSingleSweepCallback::m_resultCallback
btCollisionWorld::ConvexResultCallback & m_resultCallback
Definition: btCollisionWorld.cpp:1016
btTriangleCallback.h
btCollisionWorld::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btCollisionWorld.h:102
btCollisionWorld::getDebugDrawer
virtual btIDebugDraw * getDebugDrawer()
Definition: btCollisionWorld.h:162
btAabbUtil2.h
btCollisionWorld::contactPairTest
void contactPairTest(btCollisionObject *colObjA, btCollisionObject *colObjB, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between two collision objects and calls the resultCall...
Definition: btCollisionWorld.cpp:1246
btSingleRayCallback::m_rayFromWorld
btVector3 m_rayFromWorld
Definition: btCollisionWorld.cpp:915
btConvexPolyhedron::m_faces
btAlignedObjectArray< btFace > m_faces
Definition: btConvexPolyhedron.h:47
btTriangleCallback
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
Definition: btTriangleCallback.h:24
DebugDrawcallback::DebugDrawcallback
DebugDrawcallback(btIDebugDraw *debugDrawer, const btTransform &worldTrans, const btVector3 &color)
Definition: btCollisionWorld.cpp:1275
btCollisionObject::isStaticObject
bool isStaticObject() const
Definition: btCollisionObject.h:193
btSingleContactCallback::btSingleContactCallback
btSingleContactCallback(btCollisionObject *collisionObject, btCollisionWorld *world, btCollisionWorld::ContactResultCallback &resultCallback)
Definition: btCollisionWorld.cpp:1196
btConeShape
The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y ...
Definition: btConeShape.h:23
btCompoundShape::getChildTransform
btTransform & getChildTransform(int index)
Definition: btCompoundShape.h:99
btOverlappingPairCache::cleanProxyFromPairs
virtual void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)=0
btDbvtAabbMm::FromMM
static btDbvtAabbMm FromMM(const btVector3 &mi, const btVector3 &mx)
Definition: btDbvt.h:425
btCollisionWorld::RayResultCallback::needsCollision
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
Definition: btCollisionWorld.h:231
btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235
btCollisionObjectWrapper::getCollisionObject
const btCollisionObject * getCollisionObject() const
Definition: btCollisionObjectWrapper.h:39
btGjkConvexCast.h
btCollisionObject::CO_RIGID_BODY
Definition: btCollisionObject.h:144
btCollisionObject::CO_COLLISION_OBJECT
Definition: btCollisionObject.h:143
btCollisionWorld::debugDrawObject
virtual void debugDrawObject(const btTransform &worldTransform, const btCollisionShape *shape, const btVector3 &color)
Definition: btCollisionWorld.cpp:1312
btCollisionWorld::contactTest
void contactTest(btCollisionObject *colObj, ContactResultCallback &resultCallback)
contactTest performs a discrete collision test between colObj against all objects in the btCollisionW...
Definition: btCollisionWorld.cpp:1234
btConvexPolyhedron
Definition: btConvexPolyhedron.h:37
btCollisionWorld::RayResultCallback::m_flags
unsigned int m_flags
Definition: btCollisionWorld.h:211
MULTI_SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:41
btBroadphaseRayCallback
Definition: btBroadphaseInterface.h:36
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btTransform::setRotation
void setRotation(const btQuaternion &q)
Set the rotational element by btQuaternion.
Definition: btTransform.h:165
btBroadphaseProxy::m_clientObject
void * m_clientObject
Definition: btBroadphaseProxy.h:103
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
btCollisionConfiguration.h
btSingleRayCallback
Definition: btCollisionWorld.cpp:912
btHashMap::insert
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:269
DISABLE_SIMULATION
#define DISABLE_SIMULATION
Definition: btCollisionObject.h:26
btPolyhedralConvexShape
The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes.
Definition: btPolyhedralConvexShape.h:25
btDbvt::collideTV
DBVT_PREFIX void collideTV(const btDbvtNode *root, const btDbvtVolume &volume, DBVT_IPOLICY) const
Definition: btDbvt.h:935
btCollisionWorld::LocalConvexResult
Definition: btCollisionWorld.h:316
btCollisionWorld::rayTestSingle
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.
Definition: btCollisionWorld.cpp:262
btIDebugDraw
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
Definition: btIDebugDraw.h:29
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:400
btConeShape::getRadius
btScalar getRadius() const
Definition: btConeShape.h:43
btCollisionShape::isConcave
bool isConcave() const
Definition: btCollisionShape.h:81
btCollisionWorld::LocalShapeInfo
LocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is avai...
Definition: btCollisionWorld.h:174
btIDebugDraw::drawAabb
virtual void drawAabb(const btVector3 &from, const btVector3 &to, const btVector3 &color)
Definition: btIDebugDraw.h:137
btCollisionWorld::ContactResultCallback::needsCollision
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
Definition: btCollisionWorld.h:426
btManifoldPoint::m_positionWorldOnA
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity ...
Definition: btManifoldPoint.h:98
btConeShape::getHeight
btScalar getHeight() const
Definition: btConeShape.h:44
btCollisionWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
Definition: btCollisionWorld.cpp:235
btDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)=0
btBvhTriangleMeshShape::performConvexcast
void performConvexcast(btTriangleCallback *callback, const btVector3 &boxSource, const btVector3 &boxTarget, const btVector3 &boxMin, const btVector3 &boxMax)
Definition: btBvhTriangleMeshShape.cpp:162
btCollisionWorld::~btCollisionWorld
virtual ~btCollisionWorld()
Definition: btCollisionWorld.cpp:78
btCollisionWorld::LocalShapeInfo::m_shapePart
int m_shapePart
Definition: btCollisionWorld.h:176
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
Definition: btBroadphaseInterface.h:51
btContinuousConvexCollision.h
btCollisionObjectWrapper.h
btConvexTriangleMeshShape.h
btCollisionWorld::getDispatcher
btDispatcher * getDispatcher()
Definition: btCollisionWorld.h:138
btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest
Definition: btRaycastCallback.h:40
btSingleRayCallback::m_hitNormal
btVector3 m_hitNormal
Definition: btCollisionWorld.cpp:919
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:469
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition: btBroadphaseProxy.h:85
btCollisionWorld::rayTest
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 ...
Definition: btCollisionWorld.cpp:990
DebugDrawcallback::processTriangle
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)
Definition: btCollisionWorld.cpp:1287
btCollisionWorld::ContactResultCallback::addSingleResult
virtual btScalar addSingleResult(btManifoldPoint &cp, const btCollisionObjectWrapper *colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper *colObj1Wrap, int partId1, int index1)=0
btBoxShape
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
Definition: btBoxShape.h:26
btSphereShape::setMargin
virtual void setMargin(btScalar margin)
Definition: btSphereShape.h:58
btCollisionShape.h
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:65
btMultiSphereShape.h
btCollisionWorld::serialize
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bulle...
Definition: btCollisionWorld.cpp:1617
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:155
btCollisionShape::isPolyhedral
bool isPolyhedral() const
Definition: btCollisionShape.h:63
btDispatcher::getNumManifolds
virtual int getNumManifolds() const =0
btDbvt::ICollide
Definition: btDbvt.h:231
BT_PROFILE
#define BT_PROFILE(name)
Definition: btQuickprof.h:203
btCollisionWorld::objectQuerySingle
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.
Definition: btCollisionWorld.cpp:572
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btSubsimplexConvexCast
btSubsimplexConvexCast implements Gino van den Bergens&#39; paper "Ray Casting against bteral Convex Obje...
Definition: btSubSimplexConvexCast.h:28
btManifoldPoint::m_index1
int m_index1
Definition: btManifoldPoint.h:111
btStaticPlaneShape::getPlaneNormal
const btVector3 & getPlaneNormal() const
Definition: btStaticPlaneShape.h:50
btBroadphaseProxy::m_aabbMin
btVector3 m_aabbMin
Definition: btBroadphaseProxy.h:109
btCollisionWorld
CollisionWorld is interface and container for the collision detection.
Definition: btCollisionWorld.h:88
btCollisionWorld::convexSweepTest
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...
Definition: btCollisionWorld.cpp:1068
btSingleContactCallback::process
virtual bool process(const btBroadphaseProxy *proxy)
Definition: btCollisionWorld.cpp:1203
btGjkEpaPenetrationDepthSolver
EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth be...
Definition: btGjkEpaPenetrationDepthSolver.h:24
btCollisionObject::setBroadphaseHandle
void setBroadphaseHandle(btBroadphaseProxy *handle)
Definition: btCollisionObject.h:394
btCollisionWorld::getDispatchInfo
btDispatcherInfo & getDispatchInfo()
Definition: btCollisionWorld.h:501
btCollisionDispatcher.h
btConvexPolyhedron.h
WANTS_DEACTIVATION
#define WANTS_DEACTIVATION
Definition: btCollisionObject.h:24
btConcaveShape
The btConcaveShape class provides an interface for non-moving (static) concave shapes.
Definition: btConcaveShape.h:36
btSubSimplexConvexCast.h
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:479
btIDebugDraw::drawTransform
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
Definition: btIDebugDraw.h:166
btQuickprof.h
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:362
btIDebugDraw::DefaultColors::m_contactPoint
btVector3 m_contactPoint
Definition: btIDebugDraw.h:41
btConvexCast::CastResult::m_hitPoint
btVector3 m_hitPoint
Definition: btConvexCast.h:56
btCylinderShape::getRadius
virtual btScalar getRadius() const
Definition: btCylinderShape.h:107
btIDebugDraw::getDebugMode
virtual int getDebugMode() const =0
btCollisionWorld::m_collisionObjects
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
Definition: btCollisionWorld.h:94
btSingleRayCallback::m_rayToWorld
btVector3 m_rayToWorld
Definition: btCollisionWorld.cpp:916
btCollisionObjectWrapper::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObjectWrapper.h:38
btCollisionObject.h
btCylinderShape
The btCylinderShape class implements a cylinder shape primitive, centered around the origin...
Definition: btCylinderShape.h:24
DISABLE_DEACTIVATION
#define DISABLE_DEACTIVATION
Definition: btCollisionObject.h:25
btSingleSweepCallback::process
virtual bool process(const btBroadphaseProxy *proxy)
Definition: btCollisionWorld.cpp:1043
btDbvtNode::dataAsInt
int dataAsInt
Definition: btDbvt.h:188
btCollisionWorld::performDiscreteCollisionDetection
virtual void performDiscreteCollisionDetection()
Definition: btCollisionWorld.cpp:214
btCollisionObject::serializeSingleObject
virtual void serializeSingleObject(class btSerializer *serializer) const
Definition: btCollisionObject.cpp:118
btCollisionShape::calculateTemporalAabb
void calculateTemporalAabb(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btVector3 &temporalAabbMin, btVector3 &temporalAabbMax) const
calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0...
Definition: btCollisionShape.cpp:60
btCollisionWorld::LocalRayResult::m_localShapeInfo
LocalShapeInfo * m_localShapeInfo
Definition: btCollisionWorld.h:197
btCollisionWorld::m_broadphasePairCache
btBroadphaseInterface * m_broadphasePairCache
Definition: btCollisionWorld.h:100
btCollisionWorld::ConvexResultCallback::m_closestHitFraction
btScalar m_closestHitFraction
Definition: btCollisionWorld.h:342
btBroadphaseInterface::setAabb
virtual void setAabb(btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)=0
COMPOUND_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:71
btSingleSweepCallback::m_allowedCcdPenetration
btScalar m_allowedCcdPenetration
Definition: btCollisionWorld.cpp:1017
btCollisionShape::getShapeType
int getShapeType() const
Definition: btCollisionShape.h:112
btSingleSweepCallback::m_castShape
const btConvexShape * m_castShape
Definition: btCollisionWorld.cpp:1018
btSingleContactCallback::m_world
btCollisionWorld * m_world
Definition: btCollisionWorld.cpp:1192
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:294
btTriangleMeshShape.h
btCollisionWorld::ConvexResultCallback::addSingleResult
virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace)=0
btCollisionWorld::updateSingleAabb
void updateSingleAabb(btCollisionObject *colObj)
Definition: btCollisionWorld.cpp:147
btConcaveShape::getMargin
virtual btScalar getMargin() const
Definition: btConcaveShape.h:50
btCompoundShape
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
Definition: btCompoundShape.h:54
btCompoundShape.h
btVector3::setMax
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
Definition: btVector3.h:619
btDbvt.h
btConvexTriangleMeshShape::getMeshInterface
class btStridingMeshInterface * getMeshInterface()
Definition: btConvexTriangleMeshShape.h:35
btDispatcherInfo
Definition: btDispatcher.h:30
btDbvtNode
Definition: btDbvt.h:178
btStaticPlaneShape
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. ...
Definition: btStaticPlaneShape.h:23
btCollisionWorld::ConvexResultCallback
RayResultCallback is used to report new raycast results.
Definition: btCollisionWorld.h:340
btIDebugDraw::DBG_DrawFrames
Definition: btIDebugDraw.h:74
btBroadphaseAabbCallback
Definition: btBroadphaseInterface.h:29
btBridgedManifoldResult::btBridgedManifoldResult
btBridgedManifoldResult(const btCollisionObjectWrapper *obj0Wrap, const btCollisionObjectWrapper *obj1Wrap, btCollisionWorld::ContactResultCallback &resultCallback)
Definition: btCollisionWorld.cpp:1136
btSingleRayCallback::process
virtual bool process(const btBroadphaseProxy *proxy)
Definition: btCollisionWorld.cpp:952
btCompoundShape::getChildShape
btCollisionShape * getChildShape(int index)
Definition: btCompoundShape.h:90
DebugDrawcallback::internalProcessTriangleIndex
virtual void internalProcessTriangleIndex(btVector3 *triangle, int partId, int triangleIndex)
Definition: btCollisionWorld.cpp:1282
btCollisionWorld::debugDrawWorld
virtual void debugDrawWorld()
Definition: btCollisionWorld.cpp:1494
btPolyhedralConvexShape.h
btSphereShape.h
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:69
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition: btCollisionAlgorithm.h:55
gContactBreakingThreshold
btScalar gContactBreakingThreshold
Definition: btPersistentManifold.cpp:21
btTransformUtil::calculateVelocity
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
Definition: btTransformUtil.h:112
btCollisionObjectWrapper
Definition: btCollisionObjectWrapper.h:17
btIDebugDraw::drawSphere
virtual void drawSphere(btScalar radius, const btTransform &transform, const btVector3 &color)
Definition: btIDebugDraw.h:93
btRayAabb
bool btRayAabb(const btVector3 &rayFrom, const btVector3 &rayTo, const btVector3 &aabbMin, const btVector3 &aabbMax, btScalar &param, btVector3 &normal)
Definition: btAabbUtil2.h:125
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:188
btBroadphaseInterface::destroyProxy
virtual void destroyProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)=0
btBridgedManifoldResult::addContactPoint
virtual void addContactPoint(const btVector3 &normalOnBInWorld, const btVector3 &pointInWorld, btScalar depth)
Definition: btCollisionWorld.cpp:1142
btCollisionWorld::getBroadphase
const btBroadphaseInterface * getBroadphase() const
Definition: btCollisionWorld.h:122
btIDebugDraw::DefaultColors::m_disabledDeactivationObject
btVector3 m_disabledDeactivationObject
Definition: btIDebugDraw.h:38
btSingleContactCallback
Definition: btCollisionWorld.cpp:1188
btBridgedManifoldResult::m_resultCallback
btCollisionWorld::ContactResultCallback & m_resultCallback
Definition: btCollisionWorld.cpp:1134
btCollisionObject::setActivationState
void setActivationState(int newState) const
Definition: btCollisionObject.cpp:56
btSingleRayCallback::m_rayFromTrans
btTransform m_rayFromTrans
Definition: btCollisionWorld.cpp:917
btIDebugDraw::drawCylinder
virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform &transform, const btVector3 &color)
Definition: btIDebugDraw.h:395
btBroadphaseInterface::rayTest
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btBroadphaseRayCallback &rayCallback, const btVector3 &aabbMin=btVector3(0, 0, 0), const btVector3 &aabbMax=btVector3(0, 0, 0))=0
btCollisionWorld::objectQuerySingleInternal
static void objectQuerySingleInternal(const btConvexShape *castShape, const btTransform &convexFromTrans, const btTransform &convexToTrans, const btCollisionObjectWrapper *colObjWrap, ConvexResultCallback &resultCallback, btScalar allowedPenetration)
Definition: btCollisionWorld.cpp:582
btManifoldPoint::getLifeTime
int getLifeTime() const
Definition: btManifoldPoint.h:149
btManifoldPoint::getDistance
btScalar getDistance() const
Definition: btManifoldPoint.h:145
btMultiSphereShape::getSpherePosition
const btVector3 & getSpherePosition(int index) const
Definition: btMultiSphereShape.h:52
DebugDrawcallback::m_color
btVector3 m_color
Definition: btCollisionWorld.cpp:1270
btPolyhedralConvexShape::getConvexPolyhedron
const btConvexPolyhedron * getConvexPolyhedron() const
Definition: btPolyhedralConvexShape.h:46
btManifoldPoint::m_partId0
int m_partId0
Definition: btManifoldPoint.h:108
btCollisionWorld::LocalRayResult
Definition: btCollisionWorld.h:183
btBroadphaseInterface::calculateOverlappingPairs
virtual void calculateOverlappingPairs(btDispatcher *dispatcher)=0
calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during th...
DebugDrawcallback
Definition: btCollisionWorld.cpp:1267
btVector3::setMin
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
Definition: btVector3.h:636
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:279
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:223
btManifoldPoint::m_index0
int m_index0
Definition: btManifoldPoint.h:110
btSphereShape::getMargin
virtual btScalar getMargin() const
Definition: btSphereShape.h:62
bounds
static btDbvtVolume bounds(const tNodeArray &leaves)
Definition: btDbvt.cpp:250
btBroadphaseInterface::aabbTest
virtual void aabbTest(const btVector3 &aabbMin, const btVector3 &aabbMax, btBroadphaseAabbCallback &callback)=0
btSingleSweepCallback::m_hitNormal
btVector3 m_hitNormal
Definition: btCollisionWorld.cpp:1014
btGjkEpaPenetrationDepthSolver.h
btConvexCast::calcTimeOfImpact
virtual bool calcTimeOfImpact(const btTransform &fromA, const btTransform &toA, const btTransform &fromB, const btTransform &toB, CastResult &result)=0
cast a convex against another convex object
DebugDrawcallback::m_worldTrans
btTransform m_worldTrans
Definition: btCollisionWorld.cpp:1271
btTriangleConvexcastCallback
Definition: btRaycastCallback.h:55
btCollisionAlgorithm.h
STATIC_PLANE_PROXYTYPE
Definition: btBroadphaseProxy.h:67
btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT
Definition: btCollisionObject.h:136
btSerializer.h
btSingleRayCallback::m_rayToTrans
btTransform m_rayToTrans
Definition: btCollisionWorld.cpp:918
btPolyhedralConvexShape::getNumEdges
virtual int getNumEdges() const =0