Bullet Collision Detection & Physics Library
btDiscreteDynamicsWorld.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
17
18//collision detection
26
27//rigidbody & constraints
39
42
46
48
49#if 0
52int startHit=2;
53int firstHit=startHit;
54#endif
55
57{
58 int islandId;
59
60 const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
61 const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
62 islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
63 return islandId;
64}
65
67{
68public:
69 bool operator()(const btTypedConstraint* lhs, const btTypedConstraint* rhs) const
70 {
71 int rIslandId0, lIslandId0;
72 rIslandId0 = btGetConstraintIslandId(rhs);
73 lIslandId0 = btGetConstraintIslandId(lhs);
74 return lIslandId0 < rIslandId0;
75 }
76};
77
79{
86
90
92 btConstraintSolver* solver,
93 btStackAlloc* stackAlloc,
94 btDispatcher* dispatcher)
95 : m_solverInfo(NULL),
96 m_solver(solver),
99 m_debugDrawer(NULL),
100 m_dispatcher(dispatcher)
101 {
102 }
103
105 {
106 btAssert(0);
107 (void)other;
108 return *this;
109 }
110
111 SIMD_FORCE_INLINE void setup(btContactSolverInfo* solverInfo, btTypedConstraint** sortedConstraints, int numConstraints, btIDebugDraw* debugDrawer)
112 {
113 btAssert(solverInfo);
114 m_solverInfo = solverInfo;
115 m_sortedConstraints = sortedConstraints;
116 m_numConstraints = numConstraints;
117 m_debugDrawer = debugDrawer;
118 m_bodies.resize(0);
120 m_constraints.resize(0);
121 }
122
123 virtual void processIsland(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifolds, int numManifolds, int islandId)
124 {
125 if (islandId < 0)
126 {
128 m_solver->solveGroup(bodies, numBodies, manifolds, numManifolds, &m_sortedConstraints[0], m_numConstraints, *m_solverInfo, m_debugDrawer, m_dispatcher);
129 }
130 else
131 {
132 //also add all non-contact constraints/joints for this island
133 btTypedConstraint** startConstraint = 0;
134 int numCurConstraints = 0;
135 int i;
136
137 //find the first constraint for this island
138 for (i = 0; i < m_numConstraints; i++)
139 {
141 {
142 startConstraint = &m_sortedConstraints[i];
143 break;
144 }
145 }
146 //count the number of constraints in this island
147 for (; i < m_numConstraints; i++)
148 {
150 {
151 numCurConstraints++;
152 }
153 }
154
156 {
157 m_solver->solveGroup(bodies, numBodies, manifolds, numManifolds, startConstraint, numCurConstraints, *m_solverInfo, m_debugDrawer, m_dispatcher);
158 }
159 else
160 {
161 for (i = 0; i < numBodies; i++)
162 m_bodies.push_back(bodies[i]);
163 for (i = 0; i < numManifolds; i++)
164 m_manifolds.push_back(manifolds[i]);
165 for (i = 0; i < numCurConstraints; i++)
166 m_constraints.push_back(startConstraint[i]);
168 {
170 }
171 else
172 {
173 //printf("deferred\n");
174 }
175 }
176 }
177 }
179 {
180 btCollisionObject** bodies = m_bodies.size() ? &m_bodies[0] : 0;
181 btPersistentManifold** manifold = m_manifolds.size() ? &m_manifolds[0] : 0;
182 btTypedConstraint** constraints = m_constraints.size() ? &m_constraints[0] : 0;
183
184 m_solver->solveGroup(bodies, m_bodies.size(), manifold, m_manifolds.size(), constraints, m_constraints.size(), *m_solverInfo, m_debugDrawer, m_dispatcher);
185 m_bodies.resize(0);
187 m_constraints.resize(0);
188 }
189};
190
192 : btDynamicsWorld(dispatcher, pairCache, collisionConfiguration),
193 m_sortedConstraints(),
194 m_solverIslandCallback(NULL),
195 m_constraintSolver(constraintSolver),
196 m_gravity(0, -10, 0),
197 m_localTime(0),
198 m_fixedTimeStep(0),
199 m_synchronizeAllMotionStates(false),
200 m_applySpeculativeContactRestitution(false),
201 m_profileTimings(0),
202 m_latencyMotionStateInterpolation(true)
203
204{
206 {
210 }
211 else
212 {
214 }
215
216 {
217 void* mem = btAlignedAlloc(sizeof(btSimulationIslandManager), 16);
219 }
220
221 m_ownsIslandManager = true;
222
223 {
224 void* mem = btAlignedAlloc(sizeof(InplaceSolverIslandCallback), 16);
226 }
227}
228
230{
231 //only delete it when we created it
233 {
236 }
238 {
239 m_solverIslandCallback->~InplaceSolverIslandCallback();
241 }
243 {
246 }
247}
248
250{
254 for (int i = 0; i < m_collisionObjects.size(); i++)
255 {
257 btRigidBody* body = btRigidBody::upcast(colObj);
258 if (body && body->getActivationState() != ISLAND_SLEEPING)
259 {
260 if (body->isKinematicObject())
261 {
262 //to calculate velocities next frame
263 body->saveKinematicState(timeStep);
264 }
265 }
266 }
267}
268
270{
271 BT_PROFILE("debugDrawWorld");
272
274
275 bool drawConstraints = false;
276 if (getDebugDrawer())
277 {
278 int mode = getDebugDrawer()->getDebugMode();
280 {
281 drawConstraints = true;
282 }
283 }
284 if (drawConstraints)
285 {
286 for (int i = getNumConstraints() - 1; i >= 0; i--)
287 {
288 btTypedConstraint* constraint = getConstraint(i);
289 debugDrawConstraint(constraint);
290 }
291 }
292
294 {
295 int i;
296
297 if (getDebugDrawer() && getDebugDrawer()->getDebugMode())
298 {
299 for (i = 0; i < m_actions.size(); i++)
300 {
301 m_actions[i]->debugDraw(m_debugDrawer);
302 }
303 }
304 }
305 if (getDebugDrawer())
307}
308
310{
312 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
313 {
315 //need to check if next line is ok
316 //it might break backward compatibility (people applying forces on sleeping objects get never cleared and accumulate on wake-up
317 body->clearForces();
318 }
319}
320
323{
325 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
326 {
328 if (body->isActive())
329 {
330 body->applyGravity();
331 }
332 }
333}
334
336{
337 btAssert(body);
338
339 if (body->getMotionState() && !body->isStaticOrKinematicObject())
340 {
341 //we need to call the update at least once, even for sleeping objects
342 //otherwise the 'graphics' transform never updates properly
344 //if (body->getActivationState() != ISLAND_SLEEPING)
345 {
346 btTransform interpolatedTransform;
350 interpolatedTransform);
351 body->getMotionState()->setWorldTransform(interpolatedTransform);
352 }
353 }
354}
355
357{
358 // BT_PROFILE("synchronizeMotionStates");
360 {
361 //iterate over all collision objects
362 for (int i = 0; i < m_collisionObjects.size(); i++)
363 {
365 btRigidBody* body = btRigidBody::upcast(colObj);
366 if (body)
368 }
369 }
370 else
371 {
372 //iterate over all active rigid bodies
373 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
374 {
376 if (body->isActive())
378 }
379 }
380}
381
382int btDiscreteDynamicsWorld::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep)
383{
384 startProfiling(timeStep);
385
386 int numSimulationSubSteps = 0;
387
388 if (maxSubSteps)
389 {
390 //fixed timestep with interpolation
391 m_fixedTimeStep = fixedTimeStep;
392 m_localTime += timeStep;
393 if (m_localTime >= fixedTimeStep)
394 {
395 numSimulationSubSteps = int(m_localTime / fixedTimeStep);
396 m_localTime -= numSimulationSubSteps * fixedTimeStep;
397 }
398 }
399 else
400 {
401 //variable timestep
402 fixedTimeStep = timeStep;
404 m_fixedTimeStep = 0;
405 if (btFuzzyZero(timeStep))
406 {
407 numSimulationSubSteps = 0;
408 maxSubSteps = 0;
409 }
410 else
411 {
412 numSimulationSubSteps = 1;
413 maxSubSteps = 1;
414 }
415 }
416
417 //process some debugging flags
418 if (getDebugDrawer())
419 {
420 btIDebugDraw* debugDrawer = getDebugDrawer();
422 }
423 if (numSimulationSubSteps)
424 {
425 //clamp the number of substeps, to prevent simulation grinding spiralling down to a halt
426 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps;
427
428 saveKinematicState(fixedTimeStep * clampedSimulationSteps);
429
430 applyGravity();
431
432 for (int i = 0; i < clampedSimulationSteps; i++)
433 {
434 internalSingleStepSimulation(fixedTimeStep);
436 }
437 }
438 else
439 {
441 }
442
443 clearForces();
444
445#ifndef BT_NO_PROFILE
446 CProfileManager::Increment_Frame_Counter();
447#endif //BT_NO_PROFILE
448
449 return numSimulationSubSteps;
450}
451
453{
454 BT_PROFILE("internalSingleStepSimulation");
455
457 {
458 (*m_internalPreTickCallback)(this, timeStep);
459 }
460
463
464 btDispatcherInfo& dispatchInfo = getDispatchInfo();
465
466 dispatchInfo.m_timeStep = timeStep;
467 dispatchInfo.m_stepCount = 0;
468 dispatchInfo.m_debugDraw = getDebugDrawer();
469
470 createPredictiveContacts(timeStep);
471
474
476
477 getSolverInfo().m_timeStep = timeStep;
478
481
483
485
486 integrateTransforms(timeStep);
487
489 updateActions(timeStep);
490
491 updateActivationState(timeStep);
492
493 if (0 != m_internalTickCallback)
494 {
495 (*m_internalTickCallback)(this, timeStep);
496 }
497}
498
500{
501 m_gravity = gravity;
502 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
503 {
505 if (body->isActive() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
506 {
507 body->setGravity(gravity);
508 }
509 }
510}
511
513{
514 return m_gravity;
515}
516
517void btDiscreteDynamicsWorld::addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup, int collisionFilterMask)
518{
519 btCollisionWorld::addCollisionObject(collisionObject, collisionFilterGroup, collisionFilterMask);
520}
521
523{
524 btRigidBody* body = btRigidBody::upcast(collisionObject);
525 if (body)
526 removeRigidBody(body);
527 else
529}
530
532{
533 m_nonStaticRigidBodies.remove(body);
535}
536
538{
540 {
541 body->setGravity(m_gravity);
542 }
543
544 if (body->getCollisionShape())
545 {
546 if (!body->isStaticObject())
547 {
548 m_nonStaticRigidBodies.push_back(body);
549 }
550 else
551 {
553 }
554
555 bool isDynamic = !(body->isStaticObject() || body->isKinematicObject());
556 int collisionFilterGroup = isDynamic ? int(btBroadphaseProxy::DefaultFilter) : int(btBroadphaseProxy::StaticFilter);
557 int collisionFilterMask = isDynamic ? int(btBroadphaseProxy::AllFilter) : int(btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
558
559 addCollisionObject(body, collisionFilterGroup, collisionFilterMask);
560 }
561}
562
564{
566 {
567 body->setGravity(m_gravity);
568 }
569
570 if (body->getCollisionShape())
571 {
572 if (!body->isStaticObject())
573 {
574 m_nonStaticRigidBodies.push_back(body);
575 }
576 else
577 {
579 }
580 addCollisionObject(body, group, mask);
581 }
582}
583
585{
586 BT_PROFILE("updateActions");
587
588 for (int i = 0; i < m_actions.size(); i++)
589 {
590 m_actions[i]->updateAction(this, timeStep);
591 }
592}
593
595{
596 BT_PROFILE("updateActivationState");
597
598 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
599 {
601 if (body)
602 {
603 body->updateDeactivation(timeStep);
604
605 if (body->wantsSleeping())
606 {
607 if (body->isStaticOrKinematicObject())
608 {
610 }
611 else
612 {
613 if (body->getActivationState() == ACTIVE_TAG)
615 if (body->getActivationState() == ISLAND_SLEEPING)
616 {
617 body->setAngularVelocity(btVector3(0, 0, 0));
618 body->setLinearVelocity(btVector3(0, 0, 0));
619 }
620 }
621 }
622 else
623 {
626 }
627 }
628 }
629}
630
631void btDiscreteDynamicsWorld::addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies)
632{
633 m_constraints.push_back(constraint);
634 //Make sure the two bodies of a type constraint are different (possibly add this to the btTypedConstraint constructor?)
635 btAssert(&constraint->getRigidBodyA() != &constraint->getRigidBodyB());
636
637 if (disableCollisionsBetweenLinkedBodies)
638 {
639 constraint->getRigidBodyA().addConstraintRef(constraint);
640 constraint->getRigidBodyB().addConstraintRef(constraint);
641 }
642}
643
645{
646 m_constraints.remove(constraint);
647 constraint->getRigidBodyA().removeConstraintRef(constraint);
648 constraint->getRigidBodyB().removeConstraintRef(constraint);
649}
650
652{
653 m_actions.push_back(action);
654}
655
657{
658 m_actions.remove(action);
659}
660
662{
663 addAction(vehicle);
664}
665
667{
668 removeAction(vehicle);
669}
670
672{
673 addAction(character);
674}
675
677{
678 removeAction(character);
679}
680
682{
683 BT_PROFILE("solveConstraints");
684
685 m_sortedConstraints.resize(m_constraints.size());
686 int i;
687 for (i = 0; i < getNumConstraints(); i++)
688 {
690 }
691
692 // btAssert(0);
693
695
696 btTypedConstraint** constraintsPtr = getNumConstraints() ? &m_sortedConstraints[0] : 0;
697
698 m_solverIslandCallback->setup(&solverInfo, constraintsPtr, m_sortedConstraints.size(), getDebugDrawer());
700
703
705
707}
708
710{
711 BT_PROFILE("calculateSimulationIslands");
712
714
715 {
716 //merge islands based on speculative contact manifolds too
717 for (int i = 0; i < this->m_predictiveManifolds.size(); i++)
718 {
720
721 const btCollisionObject* colObj0 = manifold->getBody0();
722 const btCollisionObject* colObj1 = manifold->getBody1();
723
724 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
725 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
726 {
727 getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
728 }
729 }
730 }
731
732 {
733 int i;
734 int numConstraints = int(m_constraints.size());
735 for (i = 0; i < numConstraints; i++)
736 {
737 btTypedConstraint* constraint = m_constraints[i];
738 if (constraint->isEnabled())
739 {
740 const btRigidBody* colObj0 = &constraint->getRigidBodyA();
741 const btRigidBody* colObj1 = &constraint->getRigidBodyB();
742
743 if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
744 ((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
745 {
746 getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
747 }
748 }
749 }
750 }
751
752 //Store the island id in each body
754}
755
757{
758public:
763
764public:
766 m_me(me),
768 m_pairCache(pairCache),
769 m_dispatcher(dispatcher)
770 {
771 }
772
773 virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace)
774 {
775 if (convexResult.m_hitCollisionObject == m_me)
776 return 1.0f;
777
778 //ignore result if there is no contact response
779 if (!convexResult.m_hitCollisionObject->hasContactResponse())
780 return 1.0f;
781
782 btVector3 linVelA, linVelB;
784 linVelB = btVector3(0, 0, 0); //toB.getOrigin()-fromB.getOrigin();
785
786 btVector3 relativeVelocity = (linVelA - linVelB);
787 //don't report time of impact for motion away from the contact normal (or causes minor penetration)
788 if (convexResult.m_hitNormalLocal.dot(relativeVelocity) >= -m_allowedPenetration)
789 return 1.f;
790
791 return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
792 }
793
794 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
795 {
796 //don't collide with itself
797 if (proxy0->m_clientObject == m_me)
798 return false;
799
801 if (!ClosestConvexResultCallback::needsCollision(proxy0))
802 return false;
803
805
806 if (!m_dispatcher->needsCollision(m_me, otherObj))
807 return false;
808
809 //call needsResponse, see http://code.google.com/p/bullet/issues/detail?id=179
810 if (m_dispatcher->needsResponse(m_me, otherObj))
811 {
812#if 0
815 btBroadphasePair* collisionPair = m_pairCache->findPair(m_me->getBroadphaseHandle(),proxy0);
816 if (collisionPair)
817 {
818 if (collisionPair->m_algorithm)
819 {
820 manifoldArray.resize(0);
821 collisionPair->m_algorithm->getAllContactManifolds(manifoldArray);
822 for (int j=0;j<manifoldArray.size();j++)
823 {
824 btPersistentManifold* manifold = manifoldArray[j];
825 if (manifold->getNumContacts()>0)
826 return false;
827 }
828 }
829 }
830#endif
831 return true;
832 }
833
834 return false;
835 }
836};
837
840
842{
843 btTransform predictedTrans;
844 for (int i = 0; i < numBodies; i++)
845 {
846 btRigidBody* body = bodies[i];
847 body->setHitFraction(1.f);
848
849 if (body->isActive() && (!body->isStaticOrKinematicObject()))
850 {
851 body->predictIntegratedTransform(timeStep, predictedTrans);
852
853 btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).length2();
854
856 {
857 BT_PROFILE("predictive convexSweepTest");
858 if (body->getCollisionShape()->isConvex())
859 {
861#ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY
862 class StaticOnlyCallback : public btClosestNotMeConvexResultCallback
863 {
864 public:
865 StaticOnlyCallback(btCollisionObject* me, const btVector3& fromA, const btVector3& toA, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) : btClosestNotMeConvexResultCallback(me, fromA, toA, pairCache, dispatcher)
866 {
867 }
868
869 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
870 {
872 if (!otherObj->isStaticOrKinematicObject())
873 return false;
875 }
876 };
877
878 StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
879#else
880 btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
881#endif
882 //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
883 btSphereShape tmpSphere(body->getCcdSweptSphereRadius()); //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
884 sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
885
886 sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
887 sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask;
888 btTransform modifiedPredictedTrans = predictedTrans;
889 modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
890
891 convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
892 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
893 {
894 btVector3 distVec = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()) * sweepResults.m_closestHitFraction;
895 btScalar distance = distVec.dot(-sweepResults.m_hitNormalWorld);
896
897 btPersistentManifold* manifold = m_dispatcher1->getNewManifold(body, sweepResults.m_hitCollisionObject);
901
902 btVector3 worldPointB = body->getWorldTransform().getOrigin() + distVec;
903 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB;
904
905 btManifoldPoint newPoint(btVector3(0, 0, 0), localPointB, sweepResults.m_hitNormalWorld, distance);
906
907 bool isPredictive = true;
908 int index = manifold->addManifoldPoint(newPoint, isPredictive);
909 btManifoldPoint& pt = manifold->getContactPoint(index);
911 pt.m_combinedFriction = gCalculateCombinedFrictionCallback(body, sweepResults.m_hitCollisionObject);
913 pt.m_positionWorldOnB = worldPointB;
914 }
915 }
916 }
917 }
918 }
919}
920
922{
923 BT_PROFILE("release predictive contact manifolds");
924
925 for (int i = 0; i < m_predictiveManifolds.size(); i++)
926 {
928 this->m_dispatcher1->releaseManifold(manifold);
929 }
931}
932
934{
935 BT_PROFILE("createPredictiveContacts");
937 if (m_nonStaticRigidBodies.size() > 0)
938 {
940 }
941}
942
944{
945 btTransform predictedTrans;
946 for (int i = 0; i < numBodies; i++)
947 {
948 btRigidBody* body = bodies[i];
949 body->setHitFraction(1.f);
950
951 if (body->isActive() && (!body->isStaticOrKinematicObject()))
952 {
953 body->predictIntegratedTransform(timeStep, predictedTrans);
954
955 btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).length2();
956
958 {
959 BT_PROFILE("CCD motion clamping");
960 if (body->getCollisionShape()->isConvex())
961 {
963#ifdef USE_STATIC_ONLY
964 class StaticOnlyCallback : public btClosestNotMeConvexResultCallback
965 {
966 public:
967 StaticOnlyCallback(btCollisionObject* me, const btVector3& fromA, const btVector3& toA, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) : btClosestNotMeConvexResultCallback(me, fromA, toA, pairCache, dispatcher)
968 {
969 }
970
971 virtual bool needsCollision(btBroadphaseProxy* proxy0) const
972 {
974 if (!otherObj->isStaticOrKinematicObject())
975 return false;
977 }
978 };
979
980 StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
981#else
982 btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
983#endif
984 //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
985 btSphereShape tmpSphere(body->getCcdSweptSphereRadius()); //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
986 sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
987
988 sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
989 sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask;
990 btTransform modifiedPredictedTrans = predictedTrans;
991 modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
992
993 convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
994 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
995 {
996 //printf("clamped integration to hit fraction = %f\n",fraction);
997 body->setHitFraction(sweepResults.m_closestHitFraction);
998 body->predictIntegratedTransform(timeStep * body->getHitFraction(), predictedTrans);
999 body->setHitFraction(0.f);
1000 body->proceedToTransform(predictedTrans);
1001
1002#if 0
1003 btVector3 linVel = body->getLinearVelocity();
1004
1006 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1007 if (linVel.length2()>maxSpeedSqr)
1008 {
1009 linVel.normalize();
1010 linVel*= maxSpeed;
1011 body->setLinearVelocity(linVel);
1012 btScalar ms2 = body->getLinearVelocity().length2();
1013 body->predictIntegratedTransform(timeStep, predictedTrans);
1014
1015 btScalar sm2 = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).length2();
1017 printf("sm2=%f\n",sm2);
1018 }
1019#else
1020
1021 //don't apply the collision response right now, it will happen next frame
1022 //if you really need to, you can uncomment next 3 lines. Note that is uses zero restitution.
1023 //btScalar appliedImpulse = 0.f;
1024 //btScalar depth = 0.f;
1025 //appliedImpulse = resolveSingleCollision(body,(btCollisionObject*)sweepResults.m_hitCollisionObject,sweepResults.m_hitPointWorld,sweepResults.m_hitNormalWorld,getSolverInfo(), depth);
1026
1027#endif
1028
1029 continue;
1030 }
1031 }
1032 }
1033
1034 body->proceedToTransform(predictedTrans);
1035 }
1036 }
1037}
1038
1040{
1041 BT_PROFILE("integrateTransforms");
1042 if (m_nonStaticRigidBodies.size() > 0)
1043 {
1045 }
1046
1049 {
1050 BT_PROFILE("apply speculative contact restitution");
1051 for (int i = 0; i < m_predictiveManifolds.size(); i++)
1052 {
1056
1057 for (int p = 0; p < manifold->getNumContacts(); p++)
1058 {
1059 const btManifoldPoint& pt = manifold->getContactPoint(p);
1060 btScalar combinedRestitution = gCalculateCombinedRestitutionCallback(body0, body1);
1061
1062 if (combinedRestitution > 0 && pt.m_appliedImpulse != 0.f)
1063 //if (pt.getDistance()>0 && combinedRestitution>0 && pt.m_appliedImpulse != 0.f)
1064 {
1065 btVector3 imp = -pt.m_normalWorldOnB * pt.m_appliedImpulse * combinedRestitution;
1066
1067 const btVector3& pos1 = pt.getPositionWorldOnA();
1068 const btVector3& pos2 = pt.getPositionWorldOnB();
1069
1070 btVector3 rel_pos0 = pos1 - body0->getWorldTransform().getOrigin();
1071 btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
1072
1073 if (body0)
1074 body0->applyImpulse(imp, rel_pos0);
1075 if (body1)
1076 body1->applyImpulse(-imp, rel_pos1);
1077 }
1078 }
1079 }
1080 }
1081}
1082
1084{
1085 BT_PROFILE("predictUnconstraintMotion");
1086 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
1087 {
1089 if (!body->isStaticOrKinematicObject())
1090 {
1091 //don't integrate/update velocities here, it happens in the constraint solver
1092
1093 body->applyDamping(timeStep);
1094
1096 }
1097 }
1098}
1099
1101{
1102 (void)timeStep;
1103
1104#ifndef BT_NO_PROFILE
1105 CProfileManager::Reset();
1106#endif //BT_NO_PROFILE
1107}
1108
1110{
1111 bool drawFrames = (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawConstraints) != 0;
1113 btScalar dbgDrawSize = constraint->getDbgDrawSize();
1114 if (dbgDrawSize <= btScalar(0.f))
1115 {
1116 return;
1117 }
1118
1119 switch (constraint->getConstraintType())
1120 {
1122 {
1124 btTransform tr;
1125 tr.setIdentity();
1126 btVector3 pivot = p2pC->getPivotInA();
1127 pivot = p2pC->getRigidBodyA().getCenterOfMassTransform() * pivot;
1128 tr.setOrigin(pivot);
1129 getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1130 // that ideally should draw the same frame
1131 pivot = p2pC->getPivotInB();
1132 pivot = p2pC->getRigidBodyB().getCenterOfMassTransform() * pivot;
1133 tr.setOrigin(pivot);
1134 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1135 }
1136 break;
1138 {
1139 btHingeConstraint* pHinge = (btHingeConstraint*)constraint;
1140 btTransform tr = pHinge->getRigidBodyA().getCenterOfMassTransform() * pHinge->getAFrame();
1141 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1142 tr = pHinge->getRigidBodyB().getCenterOfMassTransform() * pHinge->getBFrame();
1143 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1144 btScalar minAng = pHinge->getLowerLimit();
1145 btScalar maxAng = pHinge->getUpperLimit();
1146 if (minAng == maxAng)
1147 {
1148 break;
1149 }
1150 bool drawSect = true;
1151 if (!pHinge->hasLimit())
1152 {
1153 minAng = btScalar(0.f);
1154 maxAng = SIMD_2_PI;
1155 drawSect = false;
1156 }
1157 if (drawLimits)
1158 {
1159 btVector3& center = tr.getOrigin();
1160 btVector3 normal = tr.getBasis().getColumn(2);
1161 btVector3 axis = tr.getBasis().getColumn(0);
1162 getDebugDrawer()->drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng, btVector3(0, 0, 0), drawSect);
1163 }
1164 }
1165 break;
1167 {
1168 btConeTwistConstraint* pCT = (btConeTwistConstraint*)constraint;
1170 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1171 tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame();
1172 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1173 if (drawLimits)
1174 {
1175 //const btScalar length = btScalar(5);
1176 const btScalar length = dbgDrawSize;
1177 static int nSegments = 8 * 4;
1178 btScalar fAngleInRadians = btScalar(2. * 3.1415926) * (btScalar)(nSegments - 1) / btScalar(nSegments);
1179 btVector3 pPrev = pCT->GetPointForAngle(fAngleInRadians, length);
1180 pPrev = tr * pPrev;
1181 for (int i = 0; i < nSegments; i++)
1182 {
1183 fAngleInRadians = btScalar(2. * 3.1415926) * (btScalar)i / btScalar(nSegments);
1184 btVector3 pCur = pCT->GetPointForAngle(fAngleInRadians, length);
1185 pCur = tr * pCur;
1186 getDebugDrawer()->drawLine(pPrev, pCur, btVector3(0, 0, 0));
1187
1188 if (i % (nSegments / 8) == 0)
1189 getDebugDrawer()->drawLine(tr.getOrigin(), pCur, btVector3(0, 0, 0));
1190
1191 pPrev = pCur;
1192 }
1193 btScalar tws = pCT->getTwistSpan();
1194 btScalar twa = pCT->getTwistAngle();
1195 bool useFrameB = (pCT->getRigidBodyB().getInvMass() > btScalar(0.f));
1196 if (useFrameB)
1197 {
1198 tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame();
1199 }
1200 else
1201 {
1202 tr = pCT->getRigidBodyA().getCenterOfMassTransform() * pCT->getAFrame();
1203 }
1204 btVector3 pivot = tr.getOrigin();
1205 btVector3 normal = tr.getBasis().getColumn(0);
1206 btVector3 axis1 = tr.getBasis().getColumn(1);
1207 getDebugDrawer()->drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa - tws, -twa + tws, btVector3(0, 0, 0), true);
1208 }
1209 }
1210 break;
1212 case D6_CONSTRAINT_TYPE:
1213 {
1216 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1217 tr = p6DOF->getCalculatedTransformB();
1218 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1219 if (drawLimits)
1220 {
1221 tr = p6DOF->getCalculatedTransformA();
1222 const btVector3& center = p6DOF->getCalculatedTransformB().getOrigin();
1223 btVector3 up = tr.getBasis().getColumn(2);
1224 btVector3 axis = tr.getBasis().getColumn(0);
1225 btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit;
1226 btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit;
1227 btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit;
1228 btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit;
1229 getDebugDrawer()->drawSpherePatch(center, up, axis, dbgDrawSize * btScalar(.9f), minTh, maxTh, minPs, maxPs, btVector3(0, 0, 0));
1230 axis = tr.getBasis().getColumn(1);
1231 btScalar ay = p6DOF->getAngle(1);
1232 btScalar az = p6DOF->getAngle(2);
1233 btScalar cy = btCos(ay);
1234 btScalar sy = btSin(ay);
1235 btScalar cz = btCos(az);
1236 btScalar sz = btSin(az);
1237 btVector3 ref;
1238 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1239 ref[1] = -sz * axis[0] + cz * axis[1];
1240 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1241 tr = p6DOF->getCalculatedTransformB();
1242 btVector3 normal = -tr.getBasis().getColumn(0);
1243 btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit;
1244 btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit;
1245 if (minFi > maxFi)
1246 {
1247 getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -SIMD_PI, SIMD_PI, btVector3(0, 0, 0), false);
1248 }
1249 else if (minFi < maxFi)
1250 {
1251 getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, btVector3(0, 0, 0), true);
1252 }
1253 tr = p6DOF->getCalculatedTransformA();
1256 getDebugDrawer()->drawBox(bbMin, bbMax, tr, btVector3(0, 0, 0));
1257 }
1258 }
1259 break;
1262 {
1263 {
1266 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1267 tr = p6DOF->getCalculatedTransformB();
1268 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1269 if (drawLimits)
1270 {
1271 tr = p6DOF->getCalculatedTransformA();
1272 const btVector3& center = p6DOF->getCalculatedTransformB().getOrigin();
1273 btVector3 up = tr.getBasis().getColumn(2);
1274 btVector3 axis = tr.getBasis().getColumn(0);
1275 btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit;
1276 btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit;
1277 if (minTh <= maxTh)
1278 {
1279 btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit;
1280 btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit;
1281 getDebugDrawer()->drawSpherePatch(center, up, axis, dbgDrawSize * btScalar(.9f), minTh, maxTh, minPs, maxPs, btVector3(0, 0, 0));
1282 }
1283 axis = tr.getBasis().getColumn(1);
1284 btScalar ay = p6DOF->getAngle(1);
1285 btScalar az = p6DOF->getAngle(2);
1286 btScalar cy = btCos(ay);
1287 btScalar sy = btSin(ay);
1288 btScalar cz = btCos(az);
1289 btScalar sz = btSin(az);
1290 btVector3 ref;
1291 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2];
1292 ref[1] = -sz * axis[0] + cz * axis[1];
1293 ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2];
1294 tr = p6DOF->getCalculatedTransformB();
1295 btVector3 normal = -tr.getBasis().getColumn(0);
1296 btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit;
1297 btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit;
1298 if (minFi > maxFi)
1299 {
1300 getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -SIMD_PI, SIMD_PI, btVector3(0, 0, 0), false);
1301 }
1302 else if (minFi < maxFi)
1303 {
1304 getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, btVector3(0, 0, 0), true);
1305 }
1306 tr = p6DOF->getCalculatedTransformA();
1309 getDebugDrawer()->drawBox(bbMin, bbMax, tr, btVector3(0, 0, 0));
1310 }
1311 }
1312 break;
1313 }
1315 {
1316 btSliderConstraint* pSlider = (btSliderConstraint*)constraint;
1317 btTransform tr = pSlider->getCalculatedTransformA();
1318 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1319 tr = pSlider->getCalculatedTransformB();
1320 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1321 if (drawLimits)
1322 {
1324 btVector3 li_min = tr * btVector3(pSlider->getLowerLinLimit(), 0.f, 0.f);
1325 btVector3 li_max = tr * btVector3(pSlider->getUpperLinLimit(), 0.f, 0.f);
1326 getDebugDrawer()->drawLine(li_min, li_max, btVector3(0, 0, 0));
1327 btVector3 normal = tr.getBasis().getColumn(0);
1328 btVector3 axis = tr.getBasis().getColumn(1);
1329 btScalar a_min = pSlider->getLowerAngLimit();
1330 btScalar a_max = pSlider->getUpperAngLimit();
1331 const btVector3& center = pSlider->getCalculatedTransformB().getOrigin();
1332 getDebugDrawer()->drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max, btVector3(0, 0, 0), true);
1333 }
1334 }
1335 break;
1336 default:
1337 break;
1338 }
1339 return;
1340}
1341
1343{
1345 {
1347 }
1348 m_ownsConstraintSolver = false;
1349 m_constraintSolver = solver;
1351}
1352
1354{
1355 return m_constraintSolver;
1356}
1357
1359{
1360 return int(m_constraints.size());
1361}
1363{
1364 return m_constraints[index];
1365}
1367{
1368 return m_constraints[index];
1369}
1370
1372{
1373 int i;
1374 //serialize all collision objects
1375 for (i = 0; i < m_collisionObjects.size(); i++)
1376 {
1379 {
1380 int len = colObj->calculateSerializeBufferSize();
1381 btChunk* chunk = serializer->allocate(len, 1);
1382 const char* structType = colObj->serialize(chunk->m_oldPtr, serializer);
1383 serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, colObj);
1384 }
1385 }
1386
1387 for (i = 0; i < m_constraints.size(); i++)
1388 {
1389 btTypedConstraint* constraint = m_constraints[i];
1390 int size = constraint->calculateSerializeBufferSize();
1391 btChunk* chunk = serializer->allocate(size, 1);
1392 const char* structType = constraint->serialize(chunk->m_oldPtr, serializer);
1393 serializer->finalizeChunk(chunk, structType, BT_CONSTRAINT_CODE, constraint);
1394 }
1395}
1396
1398{
1399#ifdef BT_USE_DOUBLE_PRECISION
1400 int len = sizeof(btDynamicsWorldDoubleData);
1401 btChunk* chunk = serializer->allocate(len, 1);
1403#else //BT_USE_DOUBLE_PRECISION
1404 int len = sizeof(btDynamicsWorldFloatData);
1405 btChunk* chunk = serializer->allocate(len, 1);
1407#endif //BT_USE_DOUBLE_PRECISION
1408
1409 memset(worldInfo, 0x00, len);
1410
1411 m_gravity.serialize(worldInfo->m_gravity);
1412 worldInfo->m_solverInfo.m_tau = getSolverInfo().m_tau;
1416
1419 worldInfo->m_solverInfo.m_sor = getSolverInfo().m_sor;
1420 worldInfo->m_solverInfo.m_erp = getSolverInfo().m_erp;
1421
1422 worldInfo->m_solverInfo.m_erp2 = getSolverInfo().m_erp2;
1426
1431
1436
1438
1439
1440#ifdef BT_USE_DOUBLE_PRECISION
1441 const char* structType = "btDynamicsWorldDoubleData";
1442#else //BT_USE_DOUBLE_PRECISION
1443 const char* structType = "btDynamicsWorldFloatData";
1444#endif //BT_USE_DOUBLE_PRECISION
1445 serializer->finalizeChunk(chunk, structType, BT_DYNAMICSWORLD_CODE, worldInfo);
1446}
1447
1449{
1450 serializer->startSerialization();
1451
1452 serializeDynamicsWorldInfo(serializer);
1453
1454 serializeCollisionObjects(serializer);
1455
1456 serializeRigidBodies(serializer);
1457
1458 serializeContactManifolds(serializer);
1459
1460 serializer->finishSerialization();
1461}
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
#define ACTIVE_TAG
#define DISABLE_DEACTIVATION
#define WANTS_DEACTIVATION
#define ISLAND_SLEEPING
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
int btGetConstraintIslandId(const btTypedConstraint *lhs)
int gNumClampedCcdMotions
internal debugging variable. this value shouldn't be too high
CalculateCombinedCallback gCalculateCombinedFrictionCallback
CalculateCombinedCallback gCalculateCombinedRestitutionCallback
btScalar length(const btQuaternion &q)
Return the length of a quaternion.
Definition: btQuaternion.h:895
#define BT_PROFILE(name)
Definition: btQuickprof.h:198
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
@ BT_DISABLE_WORLD_GRAVITY
Definition: btRigidBody.h:41
#define SIMD_PI
Definition: btScalar.h:526
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btScalar btSin(btScalar x)
Definition: btScalar.h:499
#define SIMD_FORCE_INLINE
Definition: btScalar.h:98
btScalar btCos(btScalar x)
Definition: btScalar.h:498
bool btFuzzyZero(btScalar x)
Definition: btScalar.h:572
#define SIMD_2_PI
Definition: btScalar.h:527
#define btAssert(x)
Definition: btScalar.h:153
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:112
#define BT_DYNAMICSWORLD_CODE
Definition: btSerializer.h:121
#define BT_CONSTRAINT_CODE
Definition: btSerializer.h:113
void btMutexLock(btSpinMutex *mutex)
Definition: btThreads.h:70
void btMutexUnlock(btSpinMutex *mutex)
Definition: btThreads.h:79
@ SLIDER_CONSTRAINT_TYPE
@ CONETWIST_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
@ HINGE_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
@ D6_CONSTRAINT_TYPE
Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWor...
int size() const
return the number of elements in the array
void resize(int newsize, const T &fillData=T())
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
void push_back(const T &_Val)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
void * m_oldPtr
Definition: btSerializer.h:52
btClosestNotMeConvexResultCallback(btCollisionObject *me, const btVector3 &fromA, const btVector3 &toA, btOverlappingPairCache *pairCache, btDispatcher *dispatcher)
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace)
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)=0
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
btCollisionObject can be used to manage collision detection objects.
bool isStaticOrKinematicObject() const
btScalar getHitFraction() const
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTransform & getWorldTransform()
btBroadphaseProxy * getBroadphaseHandle()
int getInternalType() const
reserved for Bullet internal usage
bool hasContactResponse() const
bool isStaticObject() const
void setActivationState(int newState) const
virtual int calculateSerializeBufferSize() const
bool isKinematicObject() const
const btTransform & getInterpolationWorldTransform() const
int getIslandTag() const
const btVector3 & getInterpolationAngularVelocity() const
btScalar getCcdMotionThreshold() const
void setHitFraction(btScalar hitFraction)
int getActivationState() const
btScalar getCcdSquareMotionThreshold() const
const btVector3 & getInterpolationLinearVelocity() const
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
bool isConvex() const
CollisionWorld is interface and container for the collision detection.
btDispatcher * getDispatcher()
btDispatcherInfo & getDispatchInfo()
virtual void debugDrawWorld()
virtual btIDebugDraw * getDebugDrawer()
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
int getNumCollisionObjects() const
virtual void performDiscreteCollisionDetection()
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...
btIDebugDraw * m_debugDrawer
btDispatcher * m_dispatcher1
void serializeContactManifolds(btSerializer *serializer)
const btBroadphaseInterface * getBroadphase() const
void serializeCollisionObjects(btSerializer *serializer)
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
const btRigidBody & getRigidBodyB() const
const btTransform & getBFrame() const
btScalar getTwistAngle() const
const btRigidBody & getRigidBodyA() const
btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const
const btTransform & getAFrame() const
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
virtual void prepareSolve(int, int)
virtual btScalar solveGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifold, int numManifolds, btTypedConstraint **constraints, int numConstraints, const btContactSolverInfo &info, class btIDebugDraw *debugDrawer, btDispatcher *dispatcher)=0
solve a group of constraints
void updateActions(btScalar timeStep)
virtual void removeAction(btActionInterface *)
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
void integrateTransformsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void setGravity(const btVector3 &gravity)
virtual void removeConstraint(btTypedConstraint *constraint)
virtual void integrateTransforms(btScalar timeStep)
void synchronizeSingleMotionState(btRigidBody *body)
this can be useful to synchronize a single rigid body -> graphics object
void createPredictiveContactsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void addVehicle(btActionInterface *vehicle)
obsolete, use addAction instead
virtual btConstraintSolver * getConstraintSolver()
virtual void serialize(btSerializer *serializer)
Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see B...
void serializeRigidBodies(btSerializer *serializer)
virtual void internalSingleStepSimulation(btScalar timeStep)
virtual void addRigidBody(btRigidBody *body)
virtual void removeRigidBody(btRigidBody *body)
virtual btTypedConstraint * getConstraint(int index)
void serializeDynamicsWorldInfo(btSerializer *serializer)
virtual void addAction(btActionInterface *)
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
btDiscreteDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete thos...
virtual void setConstraintSolver(btConstraintSolver *solver)
virtual int stepSimulation(btScalar timeStep, int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
virtual void saveKinematicState(btScalar timeStep)
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
virtual void addCharacter(btActionInterface *character)
obsolete, use addAction instead
virtual btVector3 getGravity() const
InplaceSolverIslandCallback * m_solverIslandCallback
virtual void applyGravity()
apply gravity, call this once per timestep
btSimulationIslandManager * m_islandManager
virtual void createPredictiveContacts(btScalar timeStep)
btAlignedObjectArray< btTypedConstraint * > m_constraints
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
btAlignedObjectArray< btActionInterface * > m_actions
virtual void removeCharacter(btActionInterface *character)
obsolete, use removeAction instead
btSimulationIslandManager * getSimulationIslandManager()
virtual void updateActivationState(btScalar timeStep)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::StaticFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter)
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
btConstraintSolver * m_constraintSolver
virtual void debugDrawConstraint(btTypedConstraint *constraint)
btCollisionWorld * getCollisionWorld()
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
virtual void solveConstraints(btContactSolverInfo &solverInfo)
virtual void predictUnconstraintMotion(btScalar timeStep)
virtual void removeVehicle(btActionInterface *vehicle)
obsolete, use removeAction instead
void startProfiling(btScalar timeStep)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
virtual void releaseManifold(btPersistentManifold *manifold)=0
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
btContactSolverInfo & getSolverInfo()
btInternalTickCallback m_internalTickCallback
btInternalTickCallback m_internalPreTickCallback
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B.
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion.
const btTransform & getCalculatedTransformA() const
Gets the global transform of the offset for body A.
btScalar getAngle(int axis_index) const
Get the relative Euler angle.
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the limit informacion.
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
const btTransform & getCalculatedTransformA() const
const btTransform & getCalculatedTransformB() const
btScalar getAngle(int axis_index) const
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
const btRigidBody & getRigidBodyB() const
const btTransform & getAFrame() const
btScalar getUpperLimit() const
const btTransform & getBFrame() const
btScalar getLowerLimit() const
const btRigidBody & getRigidBodyA() const
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
Definition: btIDebugDraw.h:27
virtual void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)=0
virtual void drawArc(const btVector3 &center, const btVector3 &normal, const btVector3 &axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, const btVector3 &color, bool drawSect, btScalar stepDegrees=btScalar(10.f))
Definition: btIDebugDraw.h:171
virtual void flushLines()
Definition: btIDebugDraw.h:468
virtual void drawTransform(const btTransform &transform, btScalar orthoLen)
Definition: btIDebugDraw.h:163
virtual int getDebugMode() const =0
virtual void drawBox(const btVector3 &bbMin, const btVector3 &bbMax, const btVector3 &color)
Definition: btIDebugDraw.h:304
virtual void drawSpherePatch(const btVector3 &center, const btVector3 &up, const btVector3 &axis, btScalar radius, btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3 &color, btScalar stepDegrees=btScalar(10.f), bool drawCenter=true)
Definition: btIDebugDraw.h:196
@ DBG_DrawConstraintLimits
Definition: btIDebugDraw.h:67
ManifoldContactPoint collects and maintains persistent contactpoints.
btScalar m_combinedRestitution
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
const btVector3 & getPositionWorldOnB() const
const btVector3 & getPositionWorldOnA() const
btScalar m_appliedImpulse
btVector3 m_normalWorldOnB
btScalar m_combinedFriction
btVector3 m_positionWorldOnB
btVector3 getColumn(int i) const
Get a column of the matrix as a vector.
Definition: btMatrix3x3.h:140
virtual void setWorldTransform(const btTransform &worldTrans)=0
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=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
const btCollisionObject * getBody1() const
int addManifoldPoint(const btManifoldPoint &newPoint, bool isPredictive=false)
point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocke...
const btVector3 & getPivotInB() const
const btVector3 & getPivotInA() const
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:60
void applyGravity()
bool wantsSleeping()
Definition: btRigidBody.h:469
void addConstraintRef(btTypedConstraint *c)
void clearForces()
Definition: btRigidBody.h:380
int getFlags() const
Definition: btRigidBody.h:561
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
btScalar getInvMass() const
Definition: btRigidBody.h:263
void updateDeactivation(btScalar timeStep)
Definition: btRigidBody.h:452
void setGravity(const btVector3 &acceleration)
void proceedToTransform(const btTransform &newTrans)
const btTransform & getCenterOfMassTransform() const
Definition: btRigidBody.h:394
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:242
void saveKinematicState(btScalar step)
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
Definition: btRigidBody.h:326
btMotionState * getMotionState()
Definition: btRigidBody.h:502
void removeConstraintRef(btTypedConstraint *c)
void setAngularVelocity(const btVector3 &ang_vel)
Definition: btRigidBody.h:413
void setLinearVelocity(const btVector3 &lin_vel)
Definition: btRigidBody.h:407
const btBroadphaseProxy * getBroadphaseProxy() const
Definition: btRigidBody.h:488
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
Definition: btRigidBody.h:189
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:398
btScalar m_hiLimit
joint limit
btScalar m_loLimit
limit_parameters
The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (...
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void finishSerialization()=0
virtual void startSerialization()=0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
SimulationIslandManager creates and handles simulation islands, using btUnionFind.
virtual void storeIslandActivationState(btCollisionWorld *world)
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
const btTransform & getCalculatedTransformB() const
const btTransform & getCalculatedTransformA() const
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) const
The btSphereShape implements an implicit sphere, centered around a local origin with radius.
Definition: btSphereShape.h:25
The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
Definition: btStackAlloc.h:35
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:108
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:166
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:113
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:146
void setBasis(const btMatrix3x3 &basis)
Set the rotational element by btMatrix3x3.
Definition: btTransform.h:154
btVector3 m_lowerLimit
the constraint lower limits
btVector3 m_upperLimit
the constraint upper limits
TypedConstraint is the baseclass for Bullet constraints and vehicles.
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTypedConstraintType getConstraintType() const
bool isEnabled() const
const btRigidBody & getRigidBodyA() const
const btRigidBody & getRigidBodyB() const
virtual int calculateSerializeBufferSize() const
void unite(int p, int q)
Definition: btUnionFind.h:76
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:229
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:251
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1317
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:303
btAlignedObjectArray< btCollisionObject * > m_bodies
InplaceSolverIslandCallback(btConstraintSolver *solver, btStackAlloc *stackAlloc, btDispatcher *dispatcher)
btAlignedObjectArray< btTypedConstraint * > m_constraints
btAlignedObjectArray< btPersistentManifold * > m_manifolds
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
btTypedConstraint ** m_sortedConstraints
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btIDebugDraw *debugDrawer)
The btBroadphasePair class contains a pair of aabb-overlapping objects.
btCollisionAlgorithm * m_algorithm
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
const btCollisionObject * m_hitCollisionObject
btScalar m_singleAxisRollingFrictionThreshold
double m_singleAxisRollingFrictionThreshold
it is only used for 'explicit' version of gyroscopic force
btScalar m_timeStep
Definition: btDispatcher.h:53
btScalar m_allowedCcdPenetration
Definition: btDispatcher.h:62
class btIDebugDraw * m_debugDraw
Definition: btDispatcher.h:58
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btContactSolverInfoDoubleData m_solverInfo
btVector3DoubleData m_gravity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64