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