Bullet Collision Detection & Physics Library
btDiscreteDynamicsWorldMt.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 
52 
54 {
55  int i = 0;
56 #if BT_THREADSAFE
57  i = btGetCurrentThreadIndex() % m_solvers.size();
58 #endif // #if BT_THREADSAFE
59  while (true)
60  {
61  ThreadSolver& solver = m_solvers[i];
62  if (solver.mutex.tryLock())
63  {
64  return &solver;
65  }
66  // failed, try the next one
67  i = (i + 1) % m_solvers.size();
68  }
69  return NULL;
70 }
71 
72 void btConstraintSolverPoolMt::init(btConstraintSolver** solvers, int numSolvers)
73 {
75  m_solvers.resize(numSolvers);
76  for (int i = 0; i < numSolvers; ++i)
77  {
78  m_solvers[i].solver = solvers[i];
79  }
80  if (numSolvers > 0)
81  {
82  m_solverType = solvers[0]->getSolverType();
83  }
84 }
85 
86 // create the solvers for me
88 {
90  solvers.reserve(numSolvers);
91  for (int i = 0; i < numSolvers; ++i)
92  {
94  solvers.push_back(solver);
95  }
96  init(&solvers[0], numSolvers);
97 }
98 
99 // pass in fully constructed solvers (destructor will delete them)
101 {
102  init(solvers, numSolvers);
103 }
104 
106 {
107  // delete all solvers
108  for (int i = 0; i < m_solvers.size(); ++i)
109  {
110  ThreadSolver& solver = m_solvers[i];
111  delete solver.solver;
112  solver.solver = NULL;
113  }
114 }
115 
118  int numBodies,
119  btPersistentManifold** manifolds,
120  int numManifolds,
121  btTypedConstraint** constraints,
122  int numConstraints,
123  const btContactSolverInfo& info,
124  btIDebugDraw* debugDrawer,
125  btDispatcher* dispatcher)
126 {
128  ts->solver->solveGroup(bodies, numBodies, manifolds, numManifolds, constraints, numConstraints, info, debugDrawer, dispatcher);
129  ts->mutex.unlock();
130  return 0.0f;
131 }
132 
134 {
135  for (int i = 0; i < m_solvers.size(); ++i)
136  {
137  ThreadSolver& solver = m_solvers[i];
138  solver.mutex.lock();
139  solver.solver->reset();
140  solver.mutex.unlock();
141  }
142 }
143 
147 
149  btBroadphaseInterface* pairCache,
150  btConstraintSolverPoolMt* solverPool,
151  btConstraintSolver* constraintSolverMt,
152  btCollisionConfiguration* collisionConfiguration)
153  : btDiscreteDynamicsWorld(dispatcher, pairCache, solverPool, collisionConfiguration)
154 {
156  {
159  }
160  {
161  void* mem = btAlignedAlloc(sizeof(btSimulationIslandManagerMt), 16);
164  m_islandManager = im;
165  }
166  m_constraintSolverMt = constraintSolverMt;
167 }
168 
170 {
171 }
172 
174 {
175  BT_PROFILE("solveConstraints");
176 
178 
180  btSimulationIslandManagerMt* im = static_cast<btSimulationIslandManagerMt*>(m_islandManager);
182  solverParams.m_solverPool = m_constraintSolver;
183  solverParams.m_solverMt = m_constraintSolverMt;
184  solverParams.m_solverInfo = &solverInfo;
185  solverParams.m_debugDrawer = m_debugDrawer;
186  solverParams.m_dispatcher = getCollisionWorld()->getDispatcher();
188 
190 }
191 
193 {
196 
197  void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
198  {
199  for (int i = iBegin; i < iEnd; ++i)
200  {
201  btRigidBody* body = rigidBodies[i];
202  if (!body->isStaticOrKinematicObject())
203  {
204  //don't integrate/update velocities here, it happens in the constraint solver
205  body->applyDamping(timeStep);
207  }
208  }
209  }
210 };
211 
213 {
214  BT_PROFILE("predictUnconstraintMotion");
215  if (m_nonStaticRigidBodies.size() > 0)
216  {
218  update.timeStep = timeStep;
219  update.rigidBodies = &m_nonStaticRigidBodies[0];
220  int grainSize = 50; // num of iterations per task for task scheduler
221  btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update);
222  }
223 }
224 
226 {
227  BT_PROFILE("createPredictiveContacts");
229  if (m_nonStaticRigidBodies.size() > 0)
230  {
232  update.world = this;
233  update.timeStep = timeStep;
234  update.rigidBodies = &m_nonStaticRigidBodies[0];
235  int grainSize = 50; // num of iterations per task for task scheduler
236  btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update);
237  }
238 }
239 
241 {
242  BT_PROFILE("integrateTransforms");
243  if (m_nonStaticRigidBodies.size() > 0)
244  {
246  update.world = this;
247  update.timeStep = timeStep;
248  update.rigidBodies = &m_nonStaticRigidBodies[0];
249  int grainSize = 50; // num of iterations per task for task scheduler
250  btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update);
251  }
252 }
253 
254 int btDiscreteDynamicsWorldMt::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep)
255 {
256  int numSubSteps = btDiscreteDynamicsWorld::stepSimulation(timeStep, maxSubSteps, fixedTimeStep);
257  if (btITaskScheduler* scheduler = btGetTaskScheduler())
258  {
259  // tell Bullet's threads to sleep, so other threads can run
260  scheduler->sleepWorkerThreadsHint();
261  }
262  return numSubSteps;
263 }
btCollisionWorld::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btCollisionWorld.h:96
btDiscreteDynamicsWorld::m_constraints
btAlignedObjectArray< btTypedConstraint * > m_constraints
Definition: btDiscreteDynamicsWorld.h:47
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:74
btDiscreteDynamicsWorldMt::solveConstraints
virtual void solveConstraints(btContactSolverInfo &solverInfo) BT_OVERRIDE
Definition: btDiscreteDynamicsWorldMt.cpp:173
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:48
btSimulationIslandManagerMt::setMinimumSolverBatchSize
void setMinimumSolverBatchSize(int sz)
Definition: btSimulationIslandManagerMt.h:97
btSimulationIslandManagerMt.h
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:59
btConstraintSolver::reset
virtual void reset()=0
clear internal cached data and reset random seed
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btCollisionShape.h
btRigidBody::predictIntegratedTransform
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
Definition: btRigidBody.cpp:100
btDiscreteDynamicsWorld::m_nonStaticRigidBodies
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
Definition: btDiscreteDynamicsWorld.h:49
btDiscreteDynamicsWorldMt::UpdaterIntegrateTransforms::timeStep
btScalar timeStep
Definition: btDiscreteDynamicsWorldMt.h:107
btContactSolverInfo
Definition: btContactSolverInfo.h:72
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btMotionState.h
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:76
btDiscreteDynamicsWorldMt::integrateTransforms
virtual void integrateTransforms(btScalar timeStep) BT_OVERRIDE
Definition: btDiscreteDynamicsWorldMt.cpp:240
btDiscreteDynamicsWorld::m_islandManager
btSimulationIslandManager * m_islandManager
Definition: btDiscreteDynamicsWorld.h:45
btSimulationIslandManagerMt::SolverParams::m_dispatcher
btDispatcher * m_dispatcher
Definition: btSimulationIslandManagerMt.h:56
BT_OVERRIDE
#define BT_OVERRIDE
Definition: btThreads.h:26
btDiscreteDynamicsWorldMt::predictUnconstraintMotion
virtual void predictUnconstraintMotion(btScalar timeStep) BT_OVERRIDE
Definition: btDiscreteDynamicsWorldMt.cpp:212
btDiscreteDynamicsWorldMt::createPredictiveContacts
virtual void createPredictiveContacts(btScalar timeStep) BT_OVERRIDE
Definition: btDiscreteDynamicsWorldMt.cpp:225
BT_SEQUENTIAL_IMPULSE_SOLVER
Definition: btConstraintSolver.h:34
btGeneric6DofSpring2Constraint.h
btSpinMutex::tryLock
bool tryLock()
Definition: btThreads.cpp:206
btRigidBody.h
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
btDiscreteDynamicsWorld::releasePredictiveContacts
void releasePredictiveContacts()
Definition: btDiscreteDynamicsWorld.cpp:921
btSimulationIslandManagerMt::SolverParams::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btSimulationIslandManagerMt.h:55
btDiscreteDynamicsWorldMt::UpdaterIntegrateTransforms::rigidBodies
btRigidBody ** rigidBodies
Definition: btDiscreteDynamicsWorldMt.h:108
btConstraintSolverPoolMt::m_solverType
btConstraintSolverType m_solverType
Definition: btDiscreteDynamicsWorldMt.h:66
btTransformUtil.h
btSimulationIslandManagerMt::SolverParams::m_solverInfo
btContactSolverInfo * m_solverInfo
Definition: btSimulationIslandManagerMt.h:54
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:205
btDiscreteDynamicsWorldMt::UpdaterIntegrateTransforms::world
btDiscreteDynamicsWorldMt * world
Definition: btDiscreteDynamicsWorldMt.h:109
btConstraintSolverPoolMt::getAndLockThreadSolver
ThreadSolver * getAndLockThreadSolver()
btConstraintSolverPoolMt
Definition: btDiscreteDynamicsWorldMt.cpp:53
btConstraintSolverPoolMt::init
void init(btConstraintSolver **solvers, int numSolvers)
Definition: btDiscreteDynamicsWorldMt.cpp:72
btActionInterface.h
btDiscreteDynamicsWorldMt::UpdaterCreatePredictiveContacts::timeStep
btScalar timeStep
Definition: btDiscreteDynamicsWorldMt.h:94
btConstraintSolver::getSolverType
virtual btConstraintSolverType getSolverType() const =0
btConstraintSolver::solveGroup
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
UpdaterUnconstrainedMotion::forLoop
void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
Definition: btDiscreteDynamicsWorldMt.cpp:197
btConstraintSolverPoolMt::m_solvers
btAlignedObjectArray< ThreadSolver > m_solvers
Definition: btDiscreteDynamicsWorldMt.h:65
btDiscreteDynamicsWorld::getCollisionWorld
btCollisionWorld * getCollisionWorld()
Definition: btDiscreteDynamicsWorld.h:135
btIDebugDraw
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
Definition: btIDebugDraw.h:26
btTypedConstraint.h
btConstraintSolverPoolMt::ThreadSolver::mutex
btSpinMutex mutex
Definition: btDiscreteDynamicsWorldMt.h:62
btSliderConstraint.h
btGetTaskScheduler
btITaskScheduler * btGetTaskScheduler()
Definition: btThreads.cpp:407
UpdaterUnconstrainedMotion::timeStep
btScalar timeStep
Definition: btDiscreteDynamicsWorldMt.cpp:194
btDiscreteDynamicsWorldMt::UpdaterCreatePredictiveContacts::world
btDiscreteDynamicsWorldMt * world
Definition: btDiscreteDynamicsWorldMt.h:96
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:398
btITaskScheduler
Definition: btThreads.h:123
btConstraintSolver::allSolved
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
Definition: btConstraintSolver.h:51
btSpinMutex::lock
void lock()
Definition: btThreads.cpp:196
btCollisionWorld::getNumCollisionObjects
int getNumCollisionObjects() const
Definition: btCollisionWorld.h:427
btSerializer.h
btDiscreteDynamicsWorldMt::m_constraintSolverMt
btConstraintSolver * m_constraintSolverMt
Definition: btDiscreteDynamicsWorldMt.h:86
UpdaterUnconstrainedMotion
Definition: btDiscreteDynamicsWorldMt.cpp:192
btSpinMutex::unlock
void unlock()
Definition: btThreads.cpp:201
btSphereShape.h
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:63
btDiscreteDynamicsWorld::stepSimulation
virtual int stepSimulation(btScalar timeStep, int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
Definition: btDiscreteDynamicsWorld.cpp:382
btSimulationIslandManagerMt::SolverParams::m_solverPool
btConstraintSolver * m_solverPool
Definition: btSimulationIslandManagerMt.h:52
btRigidBody::applyDamping
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
Definition: btRigidBody.cpp:144
btSimulationIslandManagerMt::SolverParams::m_solverMt
btConstraintSolver * m_solverMt
Definition: btSimulationIslandManagerMt.h:53
btSimpleBroadphase.h
btDynamicsWorld::m_solverInfo
btContactSolverInfo m_solverInfo
Definition: btDynamicsWorld.h:49
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition: btAlignedObjectArray.h:45
btSequentialImpulseConstraintSolver.h
btContactSolverInfo.h
btDiscreteDynamicsWorldMt::btDiscreteDynamicsWorldMt
btDiscreteDynamicsWorldMt(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btConstraintSolverPoolMt *solverPool, btConstraintSolver *constraintSolverMt, btCollisionConfiguration *collisionConfiguration)
btDiscreteDynamicsWorldMt
Definition: btDiscreteDynamicsWorldMt.cpp:148
btSimulationIslandManager::~btSimulationIslandManager
virtual ~btSimulationIslandManager()
Definition: btSimulationIslandManager.cpp:31
btParallelFor
void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody &body)
Definition: btThreads.cpp:412
btHingeConstraint.h
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
Definition: btBroadphaseInterface.h:49
btIDebugDraw.h
btSequentialImpulseConstraintSolver
The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (...
Definition: btSequentialImpulseConstraintSolver.h:50
btAlignedObjectArray::reserve
void reserve(int _Count)
Definition: btAlignedObjectArray.h:280
btQuickprof.h
btDiscreteDynamicsWorld::m_constraintSolver
btConstraintSolver * m_constraintSolver
Definition: btDiscreteDynamicsWorld.h:43
btGeneric6DofConstraint.h
btGetCurrentThreadIndex
unsigned int btGetCurrentThreadIndex()
Definition: btThreads.cpp:290
btSimulationIslandManagerMt::buildAndProcessIslands
virtual void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, btAlignedObjectArray< btTypedConstraint * > &constraints, const SolverParams &solverParams)
Definition: btSimulationIslandManagerMt.cpp:623
btSimulationIslandManagerMt
SimulationIslandManagerMt – Multithread capable version of SimulationIslandManager Splits the world u...
Definition: btSimulationIslandManagerMt.h:35
btConstraintSolverPoolMt::ThreadSolver
Definition: btDiscreteDynamicsWorldMt.h:59
btConstraintSolverPoolMt::~btConstraintSolverPoolMt
virtual ~btConstraintSolverPoolMt()
Definition: btDiscreteDynamicsWorldMt.cpp:105
btDiscreteDynamicsWorld::m_ownsIslandManager
bool m_ownsIslandManager
Definition: btDiscreteDynamicsWorld.h:58
btSimulationIslandManagerMt::SolverParams
Definition: btSimulationIslandManagerMt.h:50
btCollisionWorld::getDispatcher
btDispatcher * getDispatcher()
Definition: btCollisionWorld.h:132
btDiscreteDynamicsWorldMt::UpdaterCreatePredictiveContacts::rigidBodies
btRigidBody ** rigidBodies
Definition: btDiscreteDynamicsWorldMt.h:95
btDiscreteDynamicsWorldMt::UpdaterCreatePredictiveContacts
Definition: btDiscreteDynamicsWorldMt.h:92
btIParallelForBody
Definition: btThreads.h:101
btConstraintSolverPoolMt
btConstraintSolverPoolMt - masquerades as a constraint solver, but really it is a threadsafe pool of ...
Definition: btDiscreteDynamicsWorldMt.h:32
btDiscreteDynamicsWorld
btDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete Cc...
Definition: btDiscreteDynamicsWorld.h:36
btContactSolverInfoData::m_minimumSolverBatchSize
int m_minimumSolverBatchSize
Definition: btContactSolverInfo.h:62
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:257
btConstraintSolver::prepareSolve
virtual void prepareSolve(int, int)
Definition: btConstraintSolver.h:46
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
Definition: btCollisionConfiguration.h:26
btConstraintSolverPoolMt::solveGroup
virtual btScalar solveGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, btTypedConstraint **constraints, int numConstraints, const btContactSolverInfo &info, btIDebugDraw *debugDrawer, btDispatcher *dispatcher) BT_OVERRIDE
solve a group of constraints
Definition: btDiscreteDynamicsWorldMt.cpp:117
btDiscreteDynamicsWorldMt::~btDiscreteDynamicsWorldMt
virtual ~btDiscreteDynamicsWorldMt()
Definition: btDiscreteDynamicsWorldMt.cpp:169
UpdaterUnconstrainedMotion::rigidBodies
btRigidBody ** rigidBodies
Definition: btDiscreteDynamicsWorldMt.cpp:195
btContactConstraint.h
btConstraintSolverPoolMt::reset
virtual void reset() BT_OVERRIDE
clear internal cached data and reset random seed
Definition: btDiscreteDynamicsWorldMt.cpp:133
BT_PROFILE
#define BT_PROFILE(name)
Definition: btQuickprof.h:197
btCollisionDispatcher.h
btCollisionAlgorithm.h
btConstraintSolverPoolMt::btConstraintSolverPoolMt
btConstraintSolverPoolMt(int numSolvers)
Definition: btDiscreteDynamicsWorldMt.cpp:87
btDiscreteDynamicsWorldMt::stepSimulation
virtual int stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) BT_OVERRIDE
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
Definition: btDiscreteDynamicsWorldMt.cpp:254
btConstraintSolver
Definition: btConstraintSolver.h:41
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:142
btDiscreteDynamicsWorldMt::UpdaterIntegrateTransforms
Definition: btDiscreteDynamicsWorldMt.h:105
btConeTwistConstraint.h
btPoint2PointConstraint.h
btConstraintSolverPoolMt::ThreadSolver::solver
btConstraintSolver * solver
Definition: btDiscreteDynamicsWorldMt.h:61
btDiscreteDynamicsWorldMt.h