Bullet Collision Detection & Physics Library
btDiscreteDynamicsWorld.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
17 
18 //collision detection
25 #include "LinearMath/btQuickprof.h"
26 
27 //rigidbody & constraints
39 
42 
44 #include "LinearMath/btQuickprof.h"
46 
48 
49 #if 0
52 int startHit=2;
53 int 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 {
68 public:
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),
97  m_sortedConstraints(NULL),
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);
119  m_manifolds.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  {
140  if (btGetConstraintIslandId(m_sortedConstraints[i]) == islandId)
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  {
149  if (btGetConstraintIslandId(m_sortedConstraints[i]) == islandId)
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 
185  m_bodies.resize(0);
186  m_manifolds.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 {
205  if (!m_constraintSolver)
206  {
207  void* mem = btAlignedAlloc(sizeof(btSequentialImpulseConstraintSolver), 16);
209  m_ownsConstraintSolver = true;
210  }
211  else
212  {
213  m_ownsConstraintSolver = false;
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 
382 int 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 
456  if (0 != m_internalPreTickCallback)
457  {
458  (*m_internalPreTickCallback)(this, timeStep);
459  }
460 
462  predictUnconstraintMotion(timeStep);
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 
517 void 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 {
535 }
536 
538 {
539  if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
540  {
541  body->setGravity(m_gravity);
542  }
543 
544  if (body->getCollisionShape())
545  {
546  if (!body->isStaticObject())
547  {
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 
563 void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mask)
564 {
565  if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
566  {
567  body->setGravity(m_gravity);
568  }
569 
570  if (body->getCollisionShape())
571  {
572  if (!body->isStaticObject())
573  {
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 
631 void 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 
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 {
758 public:
763 
764 public:
766  m_me(me),
767  m_allowedPenetration(0.0f),
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 
804  btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject;
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  {
871  btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject;
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);
910  pt.m_combinedRestitution = 0;
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  {
973  btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject;
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();
1016  btScalar smt = body->getCcdSquareMotionThreshold();
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;
1112  bool drawLimits = (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawConstraintLimits) != 0;
1113  btScalar dbgDrawSize = constraint->getDbgDrawSize();
1114  if (dbgDrawSize <= btScalar(0.f))
1115  {
1116  return;
1117  }
1118 
1119  switch (constraint->getConstraintType())
1120  {
1122  {
1123  btPoint2PointConstraint* p2pC = (btPoint2PointConstraint*)constraint;
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;
1137  case HINGE_CONSTRAINT_TYPE:
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  {
1214  btGeneric6DofConstraint* p6DOF = (btGeneric6DofConstraint*)constraint;
1215  btTransform tr = p6DOF->getCalculatedTransformA();
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  {
1265  btTransform tr = p6DOF->getCalculatedTransformA();
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;
1350  m_solverIslandCallback->m_solver = 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 remove(const T &key)
void quickSort(const L &CompareFunc)
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.
const btTransform & getInterpolationWorldTransform() const
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()
const btVector3 & getInterpolationAngularVelocity() const
btBroadphaseProxy * getBroadphaseHandle()
const btVector3 & getInterpolationLinearVelocity() const
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
int getIslandTag() const
btScalar getCcdMotionThreshold() const
void setHitFraction(btScalar hitFraction)
int getActivationState() const
btScalar getCcdSquareMotionThreshold() 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.
virtual void debugDrawWorld()
const btBroadphaseInterface * getBroadphase() const
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
btAlignedObjectArray< btCollisionObject * > m_collisionObjects
btDispatcher * getDispatcher()
virtual btIDebugDraw * getDebugDrawer()
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
btDispatcherInfo & getDispatchInfo()
btDispatcher * m_dispatcher1
void serializeContactManifolds(btSerializer *serializer)
void serializeCollisionObjects(btSerializer *serializer)
btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
btScalar getTwistAngle() const
btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const
const btTransform & getAFrame() const
const btRigidBody & getRigidBodyB() const
const btRigidBody & getRigidBodyA() const
const btTransform & getBFrame() 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)
btSimulationIslandManager * getSimulationIslandManager()
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)
btCollisionWorld * getCollisionWorld()
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
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)
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 btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
btInternalTickCallback m_internalTickCallback
btInternalTickCallback m_internalPreTickCallback
btContactSolverInfo & getSolverInfo()
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion.
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the 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.
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B.
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
const btTransform & getCalculatedTransformB() const
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
btScalar getAngle(int axis_index) const
const btTransform & getCalculatedTransformA() const
hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in lo...
btScalar getUpperLimit() const
btScalar getLowerLimit() const
const btRigidBody & getRigidBodyA() const
const btRigidBody & getRigidBodyB() const
const btTransform & getAFrame() const
const btTransform & getBFrame() 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.
const btVector3 & getPositionWorldOnB() const
btScalar m_combinedRestitution
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
btScalar m_appliedImpulse
const btVector3 & getPositionWorldOnA() const
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 btCollisionObject * getBody1() const
const btCollisionObject * getBody0() const
int addManifoldPoint(const btManifoldPoint &newPoint, bool isPredictive=false)
const btManifoldPoint & getContactPoint(int index) const
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
btMotionState * getMotionState()
Definition: btRigidBody.h:502
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
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 setGravity(const btVector3 &acceleration)
void proceedToTransform(const btTransform &newTrans)
void saveKinematicState(btScalar step)
const btBroadphaseProxy * getBroadphaseProxy() const
Definition: btRigidBody.h:488
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
Definition: btRigidBody.h:326
void removeConstraintRef(btTypedConstraint *c)
const btTransform & getCenterOfMassTransform() const
Definition: btRigidBody.h:394
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:398
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:242
void setAngularVelocity(const btVector3 &ang_vel)
Definition: btRigidBody.h:413
void setLinearVelocity(const btVector3 &lin_vel)
Definition: btRigidBody.h:407
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
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 & getCalculatedTransformA() const
const btTransform & getCalculatedTransformB() 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
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:113
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:166
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
const btRigidBody & getRigidBodyA() const
bool isEnabled() 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
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:303
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
btAlignedObjectArray< btCollisionObject * > m_bodies
InplaceSolverIslandCallback(btConstraintSolver *solver, btStackAlloc *stackAlloc, btDispatcher *dispatcher)
btAlignedObjectArray< btTypedConstraint * > m_constraints
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
btAlignedObjectArray< btPersistentManifold * > m_manifolds
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
btTypedConstraint ** m_sortedConstraints
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