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

Bullet Collision Detection & Physics Library

btDeformableMultiBodyDynamicsWorld.cpp
Go to the documentation of this file.
1 /*
2 Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
3
4 Bullet Continuous Collision Detection and Physics Library
5 Copyright (c) 2019 Google Inc. http://bulletphysics.org
6 This software is provided 'as-is', without any express or implied warranty.
7 In no event will the authors be held liable for any damages arising from the use of this software.
8 Permission is granted to anyone to use this software for any purpose,
9 including commercial applications, and to alter it and redistribute it freely,
10 subject to the following restrictions:
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15
16 /* ====== Overview of the Deformable Algorithm ====== */
17
18 /*
19 A single step of the deformable body simulation contains the following main components:
20 Call internalStepSimulation multiple times, to achieve 240Hz (4 steps of 60Hz).
21 1. Deformable maintaintenance of rest lengths and volume preservation. Forces only depend on position: Update velocity to a temporary state v_{n+1}^* = v_n + explicit_force * dt / mass, where explicit forces include gravity and elastic forces.
22 2. Detect discrete collisions between rigid and deformable bodies at position x_{n+1}^* = x_n + dt * v_{n+1}^*.
23
24 3a. Solve all constraints, including LCP. Contact, position correction due to numerical drift, friction, and anchors for deformable.
25
26 3b. 5 Newton steps (multiple step). Conjugent Gradient solves linear system. Deformable Damping: Then velocities of deformable bodies v_{n+1} are solved in
27 M(v_{n+1} - v_{n+1}^*) = damping_force * dt / mass,
28 by a conjugate gradient solver, where the damping force is implicit and depends on v_{n+1}.
29 Make sure contact constraints are not violated in step b by performing velocity projections as in the paper by Baraff and Witkin https://www.cs.cmu.edu/~baraff/papers/sig98.pdf. Dynamic frictions are treated as a force and added to the rhs of the CG solve, whereas static frictions are treated as constraints similar to contact.
30 4. Position is updated via x_{n+1} = x_n + dt * v_{n+1}.
31
32
33 The algorithm also closely resembles the one in http://physbam.stanford.edu/~fedkiw/papers/stanford2008-03.pdf
34 */
35
36 #include <stdio.h>
37 #include "btDeformableMultiBodyDynamicsWorld.h"
38 #include "DeformableBodyInplaceSolverIslandCallback.h"
39 #include "btDeformableBodySolver.h"
40 #include "LinearMath/btQuickprof.h"
41 #include "btSoftBodyInternals.h"
42 btDeformableMultiBodyDynamicsWorld::btDeformableMultiBodyDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btDeformableMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btDeformableBodySolver* deformableBodySolver)
43 : btMultiBodyDynamicsWorld(dispatcher, pairCache, (btMultiBodyConstraintSolver*)constraintSolver, collisionConfiguration),
44 m_deformableBodySolver(deformableBodySolver),
45 m_solverCallback(0)
46 {
47 m_drawFlags = fDrawFlags::Std;
48 m_drawNodeTree = true;
49 m_drawFaceTree = false;
50 m_drawClusterTree = false;
51 m_sbi.m_broadphase = pairCache;
52 m_sbi.m_dispatcher = dispatcher;
53 m_sbi.m_sparsesdf.Initialize();
54 m_sbi.m_sparsesdf.setDefaultVoxelsz(0.005);
55 m_sbi.m_sparsesdf.Reset();
56
57 m_sbi.air_density = (btScalar)1.2;
58 m_sbi.water_density = 0;
59 m_sbi.water_offset = 0;
60 m_sbi.water_normal = btVector3(0, 0, 0);
61 m_sbi.m_gravity.setValue(0, -9.8, 0);
62 m_internalTime = 0.0;
63 m_implicit = false;
64 m_lineSearch = false;
65 m_useProjection = false;
66 m_ccdIterations = 5;
67 m_solverDeformableBodyIslandCallback = new DeformableBodyInplaceSolverIslandCallback(constraintSolver, dispatcher);
68 }
69
70 btDeformableMultiBodyDynamicsWorld::~btDeformableMultiBodyDynamicsWorld()
71 {
72 delete m_solverDeformableBodyIslandCallback;
73 }
74
75 void btDeformableMultiBodyDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
76 {
77 BT_PROFILE("internalSingleStepSimulation");
78 if (0 != m_internalPreTickCallback)
79 {
80 (*m_internalPreTickCallback)(this, timeStep);
81 }
82 reinitialize(timeStep);
83
84 // add gravity to velocity of rigid and multi bodys
85 applyRigidBodyGravity(timeStep);
86
88 predictUnconstraintMotion(timeStep);
89
91 btMultiBodyDynamicsWorld::performDiscreteCollisionDetection();
92
93 btMultiBodyDynamicsWorld::calculateSimulationIslands();
94
95 beforeSolverCallbacks(timeStep);
96
98 solveConstraints(timeStep);
99
100 afterSolverCallbacks(timeStep);
101
102 performDeformableCollisionDetection();
103
104 applyRepulsionForce(timeStep);
105
106 performGeometricCollisions(timeStep);
107
108 integrateTransforms(timeStep);
109
111 btMultiBodyDynamicsWorld::updateActions(timeStep);
112
113 updateActivationState(timeStep);
114 // End solver-wise simulation step
115 // ///////////////////////////////
116 }
117
118 void btDeformableMultiBodyDynamicsWorld::performDeformableCollisionDetection()
119 {
120 for (int i = 0; i < m_softBodies.size(); ++i)
121 {
122 m_softBodies[i]->m_softSoftCollision = true;
123 }
124
125 for (int i = 0; i < m_softBodies.size(); ++i)
126 {
127 for (int j = i; j < m_softBodies.size(); ++j)
128 {
129 m_softBodies[i]->defaultCollisionHandler(m_softBodies[j]);
130 }
131 }
132
133 for (int i = 0; i < m_softBodies.size(); ++i)
134 {
135 m_softBodies[i]->m_softSoftCollision = false;
136 }
137 }
138
139 void btDeformableMultiBodyDynamicsWorld::updateActivationState(btScalar timeStep)
140 {
141 for (int i = 0; i < m_softBodies.size(); i++)
142 {
143 btSoftBody* psb = m_softBodies[i];
144 psb->updateDeactivation(timeStep);
145 if (psb->wantsSleeping())
146 {
147 if (psb->getActivationState() == ACTIVE_TAG)
148 psb->setActivationState(WANTS_DEACTIVATION);
149 if (psb->getActivationState() == ISLAND_SLEEPING)
150 {
151 psb->setZeroVelocity();
152 }
153 }
154 else
155 {
156 if (psb->getActivationState() != DISABLE_DEACTIVATION)
157 psb->setActivationState(ACTIVE_TAG);
158 }
159 }
160 btMultiBodyDynamicsWorld::updateActivationState(timeStep);
161 }
162
163 void btDeformableMultiBodyDynamicsWorld::applyRepulsionForce(btScalar timeStep)
164 {
165 BT_PROFILE("btDeformableMultiBodyDynamicsWorld::applyRepulsionForce");
166 for (int i = 0; i < m_softBodies.size(); i++)
167 {
168 btSoftBody* psb = m_softBodies[i];
169 if (psb->isActive())
170 {
171 psb->applyRepulsionForce(timeStep, true);
172 }
173 }
174 }
175
176 void btDeformableMultiBodyDynamicsWorld::performGeometricCollisions(btScalar timeStep)
177 {
178 BT_PROFILE("btDeformableMultiBodyDynamicsWorld::performGeometricCollisions");
179 // refit the BVH tree for CCD
180 for (int i = 0; i < m_softBodies.size(); ++i)
181 {
182 btSoftBody* psb = m_softBodies[i];
183 if (psb->isActive())
184 {
185 m_softBodies[i]->updateFaceTree(true, false);
186 m_softBodies[i]->updateNodeTree(true, false);
187 for (int j = 0; j < m_softBodies[i]->m_faces.size(); ++j)
188 {
189 btSoftBody::Face& f = m_softBodies[i]->m_faces[j];
190 f.m_n0 = (f.m_n[1]->m_x - f.m_n[0]->m_x).cross(f.m_n[2]->m_x - f.m_n[0]->m_x);
191 }
192 }
193 }
194
195 // clear contact points & update DBVT
196 for (int r = 0; r < m_ccdIterations; ++r)
197 {
198 for (int i = 0; i < m_softBodies.size(); ++i)
199 {
200 btSoftBody* psb = m_softBodies[i];
201 if (psb->isActive())
202 {
203 // clear contact points in the previous iteration
204 psb->m_faceNodeContacts.clear();
205
206 // update m_q and normals for CCD calculation
207 for (int j = 0; j < psb->m_nodes.size(); ++j)
208 {
209 psb->m_nodes[j].m_q = psb->m_nodes[j].m_x + timeStep * psb->m_nodes[j].m_v;
210 }
211 for (int j = 0; j < psb->m_faces.size(); ++j)
212 {
213 btSoftBody::Face& f = psb->m_faces[j];
214 f.m_n1 = (f.m_n[1]->m_q - f.m_n[0]->m_q).cross(f.m_n[2]->m_q - f.m_n[0]->m_q);
215 f.m_vn = (f.m_n[1]->m_v - f.m_n[0]->m_v).cross(f.m_n[2]->m_v - f.m_n[0]->m_v) * timeStep * timeStep;
216 }
217 }
218 }
219
220 // apply CCD to register new contact points
221 for (int i = 0; i < m_softBodies.size(); ++i)
222 {
223 for (int j = i; j < m_softBodies.size(); ++j)
224 {
225 btSoftBody* psb1 = m_softBodies[i];
226 btSoftBody* psb2 = m_softBodies[j];
227 if (psb1->isActive() && psb2->isActive())
228 {
229 m_softBodies[i]->geometricCollisionHandler(m_softBodies[j]);
230 }
231 }
232 }
233
234 int penetration_count = 0;
235 for (int i = 0; i < m_softBodies.size(); ++i)
236 {
237 btSoftBody* psb = m_softBodies[i];
238 if (psb->isActive())
239 {
240 penetration_count += psb->m_faceNodeContacts.size();
241 }
242 }
243 if (penetration_count == 0)
244 {
245 break;
246 }
247
248 // apply inelastic impulse
249 for (int i = 0; i < m_softBodies.size(); ++i)
250 {
251 btSoftBody* psb = m_softBodies[i];
252 if (psb->isActive())
253 {
254 psb->applyRepulsionForce(timeStep, false);
255 }
256 }
257 }
258 }
259
260 void btDeformableMultiBodyDynamicsWorld::softBodySelfCollision()
261 {
262 BT_PROFILE("btDeformableMultiBodyDynamicsWorld::softBodySelfCollision");
263 for (int i = 0; i < m_softBodies.size(); i++)
264 {
265 btSoftBody* psb = m_softBodies[i];
266 if (psb->isActive())
267 {
268 psb->defaultCollisionHandler(psb);
269 }
270 }
271 }
272
273 void btDeformableMultiBodyDynamicsWorld::positionCorrection(btScalar timeStep)
274 {
275 // correct the position of rigid bodies with temporary velocity generated from split impulse
276 btContactSolverInfo infoGlobal;
277 btVector3 zero(0, 0, 0);
278 for (int i = 0; i < m_nonStaticRigidBodies.size(); ++i)
279 {
280 btRigidBody* rb = m_nonStaticRigidBodies[i];
281 //correct the position/orientation based on push/turn recovery
282 btTransform newTransform;
283 btVector3 pushVelocity = rb->getPushVelocity();
284 btVector3 turnVelocity = rb->getTurnVelocity();
285 if (pushVelocity[0] != 0.f || pushVelocity[1] != 0 || pushVelocity[2] != 0 || turnVelocity[0] != 0.f || turnVelocity[1] != 0 || turnVelocity[2] != 0)
286 {
287 btTransformUtil::integrateTransform(rb->getWorldTransform(), pushVelocity, turnVelocity * infoGlobal.m_splitImpulseTurnErp, timeStep, newTransform);
288 rb->setWorldTransform(newTransform);
289 rb->setPushVelocity(zero);
290 rb->setTurnVelocity(zero);
291 }
292 }
293 }
294
295 void btDeformableMultiBodyDynamicsWorld::integrateTransforms(btScalar timeStep)
296 {
297 BT_PROFILE("integrateTransforms");
298 positionCorrection(timeStep);
299 btMultiBodyDynamicsWorld::integrateTransforms(timeStep);
300 for (int i = 0; i < m_softBodies.size(); ++i)
301 {
302 btSoftBody* psb = m_softBodies[i];
303 for (int j = 0; j < psb->m_nodes.size(); ++j)
304 {
305 btSoftBody::Node& node = psb->m_nodes[j];
306 btScalar maxDisplacement = psb->getWorldInfo()->m_maxDisplacement;
307 btScalar clampDeltaV = maxDisplacement / timeStep;
308 for (int c = 0; c < 3; c++)
309 {
310 if (node.m_v[c] > clampDeltaV)
311 {
312 node.m_v[c] = clampDeltaV;
313 }
314 if (node.m_v[c] < -clampDeltaV)
315 {
316 node.m_v[c] = -clampDeltaV;
317 }
318 }
319 node.m_x = node.m_x + timeStep * (node.m_v + node.m_splitv);
320 node.m_q = node.m_x;
321 node.m_vn = node.m_v;
322 }
323 // enforce anchor constraints
324 for (int j = 0; j < psb->m_deformableAnchors.size(); ++j)
325 {
326 btSoftBody::DeformableNodeRigidAnchor& a = psb->m_deformableAnchors[j];
327 btSoftBody::Node* n = a.m_node;
328 n->m_x = a.m_cti.m_colObj->getWorldTransform() * a.m_local;
329
330 // update multibody anchor info
331 if (a.m_cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
332 {
333 btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(a.m_cti.m_colObj);
334 if (multibodyLinkCol)
335 {
336 btVector3 nrm;
337 const btCollisionShape* shp = multibodyLinkCol->getCollisionShape();
338 const btTransform& wtr = multibodyLinkCol->getWorldTransform();
339 psb->m_worldInfo->m_sparsesdf.Evaluate(
340 wtr.invXform(n->m_x),
341 shp,
342 nrm,
343 0);
344 a.m_cti.m_normal = wtr.getBasis() * nrm;
345 btVector3 normal = a.m_cti.m_normal;
346 btVector3 t1 = generateUnitOrthogonalVector(normal);
347 btVector3 t2 = btCross(normal, t1);
348 btMultiBodyJacobianData jacobianData_normal, jacobianData_t1, jacobianData_t2;
349 findJacobian(multibodyLinkCol, jacobianData_normal, a.m_node->m_x, normal);
350 findJacobian(multibodyLinkCol, jacobianData_t1, a.m_node->m_x, t1);
351 findJacobian(multibodyLinkCol, jacobianData_t2, a.m_node->m_x, t2);
352
353 btScalar* J_n = &jacobianData_normal.m_jacobians[0];
354 btScalar* J_t1 = &jacobianData_t1.m_jacobians[0];
355 btScalar* J_t2 = &jacobianData_t2.m_jacobians[0];
356
357 btScalar* u_n = &jacobianData_normal.m_deltaVelocitiesUnitImpulse[0];
358 btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
359 btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
360
361 btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
362 t1.getX(), t1.getY(), t1.getZ(),
363 t2.getX(), t2.getY(), t2.getZ()); // world frame to local frame
364 const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
365 btMatrix3x3 local_impulse_matrix = (Diagonal(n->m_im) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
366 a.m_c0 = rot.transpose() * local_impulse_matrix * rot;
367 a.jacobianData_normal = jacobianData_normal;
368 a.jacobianData_t1 = jacobianData_t1;
369 a.jacobianData_t2 = jacobianData_t2;
370 a.t1 = t1;
371 a.t2 = t2;
372 }
373 }
374 }
375 psb->interpolateRenderMesh();
376 }
377 }
378
379 void btDeformableMultiBodyDynamicsWorld::solveConstraints(btScalar timeStep)
380 {
381 BT_PROFILE("btDeformableMultiBodyDynamicsWorld::solveConstraints");
382 // save v_{n+1}^* velocity after explicit forces
383 m_deformableBodySolver->backupVelocity();
384
385 // set up constraints among multibodies and between multibodies and deformable bodies
386 setupConstraints();
387
388 // solve contact constraints
389 solveContactConstraints();
390
391 // set up the directions in which the velocity does not change in the momentum solve
392 if (m_useProjection)
393 m_deformableBodySolver->m_objective->m_projection.setProjection();
394 else
395 m_deformableBodySolver->m_objective->m_projection.setLagrangeMultiplier();
396
397 // for explicit scheme, m_backupVelocity = v_{n+1}^*
398 // for implicit scheme, m_backupVelocity = v_n
399 // Here, set dv = v_{n+1} - v_n for nodes in contact
400 m_deformableBodySolver->setupDeformableSolve(m_implicit);
401
402 // At this point, dv should be golden for nodes in contact
403 // proceed to solve deformable momentum equation
404 m_deformableBodySolver->solveDeformableConstraints(timeStep);
405 }
406
407 void btDeformableMultiBodyDynamicsWorld::setupConstraints()
408 {
409 // set up constraints between multibody and deformable bodies
410 m_deformableBodySolver->setConstraints(m_solverInfo);
411
412 // set up constraints among multibodies
413 {
414 sortConstraints();
415 // setup the solver callback
416 btMultiBodyConstraint** sortedMultiBodyConstraints = m_sortedMultiBodyConstraints.size() ? &m_sortedMultiBodyConstraints[0] : 0;
417 btTypedConstraint** constraintsPtr = getNumConstraints() ? &m_sortedConstraints[0] : 0;
418 m_solverDeformableBodyIslandCallback->setup(&m_solverInfo, constraintsPtr, m_sortedConstraints.size(), sortedMultiBodyConstraints, m_sortedMultiBodyConstraints.size(), getDebugDrawer());
419
420 // build islands
421 m_islandManager->buildIslands(getCollisionWorld()->getDispatcher(), getCollisionWorld());
422 }
423 }
424
425 void btDeformableMultiBodyDynamicsWorld::sortConstraints()
426 {
427 m_sortedConstraints.resize(m_constraints.size());
428 int i;
429 for (i = 0; i < getNumConstraints(); i++)
430 {
431 m_sortedConstraints[i] = m_constraints[i];
432 }
433 m_sortedConstraints.quickSort(btSortConstraintOnIslandPredicate2());
434
435 m_sortedMultiBodyConstraints.resize(m_multiBodyConstraints.size());
436 for (i = 0; i < m_multiBodyConstraints.size(); i++)
437 {
438 m_sortedMultiBodyConstraints[i] = m_multiBodyConstraints[i];
439 }
440 m_sortedMultiBodyConstraints.quickSort(btSortMultiBodyConstraintOnIslandPredicate());
441 }
442
443 void btDeformableMultiBodyDynamicsWorld::solveContactConstraints()
444 {
445 // process constraints on each island
446 m_islandManager->processIslands(getCollisionWorld()->getDispatcher(), getCollisionWorld(), m_solverDeformableBodyIslandCallback);
447
448 // process deferred
449 m_solverDeformableBodyIslandCallback->processConstraints();
450 m_constraintSolver->allSolved(m_solverInfo, m_debugDrawer);
451
452 // write joint feedback
453 {
454 for (int i = 0; i < this->m_multiBodies.size(); i++)
455 {
456 btMultiBody* bod = m_multiBodies[i];
457
458 bool isSleeping = false;
459
460 if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
461 {
462 isSleeping = true;
463 }
464 for (int b = 0; b < bod->getNumLinks(); b++)
465 {
466 if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
467 isSleeping = true;
468 }
469
470 if (!isSleeping)
471 {
472 //useless? they get resized in stepVelocities once again (AND DIFFERENTLY)
473 m_scratch_r.resize(bod->getNumLinks() + 1); //multidof? ("Y"s use it and it is used to store qdd)
474 m_scratch_v.resize(bod->getNumLinks() + 1);
475 m_scratch_m.resize(bod->getNumLinks() + 1);
476
477 if (bod->internalNeedsJointFeedback())
478 {
479 if (!bod->isUsingRK4Integration())
480 {
481 if (bod->internalNeedsJointFeedback())
482 {
483 bool isConstraintPass = true;
484 bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(m_solverInfo.m_timeStep, m_scratch_r, m_scratch_v, m_scratch_m, isConstraintPass,
485 getSolverInfo().m_jointFeedbackInWorldSpace,
486 getSolverInfo().m_jointFeedbackInJointFrame);
487 }
488 }
489 }
490 }
491 }
492 }
493
494 for (int i = 0; i < this->m_multiBodies.size(); i++)
495 {
496 btMultiBody* bod = m_multiBodies[i];
497 bod->processDeltaVeeMultiDof2();
498 }
499 }
500
501 void btDeformableMultiBodyDynamicsWorld::addSoftBody(btSoftBody* body, int collisionFilterGroup, int collisionFilterMask)
502 {
503 m_softBodies.push_back(body);
504
505 // Set the soft body solver that will deal with this body
506 // to be the world's solver
507 body->setSoftBodySolver(m_deformableBodySolver);
508
509 btCollisionWorld::addCollisionObject(body,
510 collisionFilterGroup,
511 collisionFilterMask);
512 }
513
514 void btDeformableMultiBodyDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
515 {
516 BT_PROFILE("predictUnconstraintMotion");
517 btMultiBodyDynamicsWorld::predictUnconstraintMotion(timeStep);
518 m_deformableBodySolver->predictMotion(timeStep);
519 }
520
521 void btDeformableMultiBodyDynamicsWorld::reinitialize(btScalar timeStep)
522 {
523 m_internalTime += timeStep;
524 m_deformableBodySolver->setImplicit(m_implicit);
525 m_deformableBodySolver->setLineSearch(m_lineSearch);
526 m_deformableBodySolver->reinitialize(m_softBodies, timeStep);
527 btDispatcherInfo& dispatchInfo = btMultiBodyDynamicsWorld::getDispatchInfo();
528 dispatchInfo.m_timeStep = timeStep;
529 dispatchInfo.m_stepCount = 0;
530 dispatchInfo.m_debugDraw = btMultiBodyDynamicsWorld::getDebugDrawer();
531 btMultiBodyDynamicsWorld::getSolverInfo().m_timeStep = timeStep;
532 if (m_useProjection)
533 {
534 m_deformableBodySolver->m_useProjection = true;
535 m_deformableBodySolver->m_objective->m_projection.m_useStrainLimiting = true;
536 m_deformableBodySolver->m_objective->m_preconditioner = m_deformableBodySolver->m_objective->m_massPreconditioner;
537 }
538 else
539 {
540 m_deformableBodySolver->m_useProjection = false;
541 m_deformableBodySolver->m_objective->m_projection.m_useStrainLimiting = false;
542 m_deformableBodySolver->m_objective->m_preconditioner = m_deformableBodySolver->m_objective->m_KKTPreconditioner;
543 }
544 }
545
546 void btDeformableMultiBodyDynamicsWorld::debugDrawWorld()
547 {
548 btMultiBodyDynamicsWorld::debugDrawWorld();
549
550 for (int i = 0; i < getSoftBodyArray().size(); i++)
551 {
552 btSoftBody* psb = (btSoftBody*)getSoftBodyArray()[i];
553 {
554 btSoftBodyHelpers::DrawFrame(psb, getDebugDrawer());
555 btSoftBodyHelpers::Draw(psb, getDebugDrawer(), getDrawFlags());
556 }
557 }
558 }
559
560 void btDeformableMultiBodyDynamicsWorld::applyRigidBodyGravity(btScalar timeStep)
561 {
562 // Gravity is applied in stepSimulation and then cleared here and then applied here and then cleared here again
563 // so that 1) gravity is applied to velocity before constraint solve and 2) gravity is applied in each substep
564 // when there are multiple substeps
565 btMultiBodyDynamicsWorld::applyGravity();
566 // integrate rigid body gravity
567 for (int i = 0; i < m_nonStaticRigidBodies.size(); ++i)
568 {
569 btRigidBody* rb = m_nonStaticRigidBodies[i];
570 rb->integrateVelocities(timeStep);
571 }
572
573 // integrate multibody gravity
574 {
575 forwardKinematics();
576 clearMultiBodyConstraintForces();
577 {
578 for (int i = 0; i < this->m_multiBodies.size(); i++)
579 {
580 btMultiBody* bod = m_multiBodies[i];
581
582 bool isSleeping = false;
583
584 if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
585 {
586 isSleeping = true;
587 }
588 for (int b = 0; b < bod->getNumLinks(); b++)
589 {
590 if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
591 isSleeping = true;
592 }
593
594 if (!isSleeping)
595 {
596 m_scratch_r.resize(bod->getNumLinks() + 1);
597 m_scratch_v.resize(bod->getNumLinks() + 1);
598 m_scratch_m.resize(bod->getNumLinks() + 1);
599 bool isConstraintPass = false;
600 {
601 if (!bod->isUsingRK4Integration())
602 {
603 bod->computeAccelerationsArticulatedBodyAlgorithmMultiDof(m_solverInfo.m_timeStep,
604 m_scratch_r, m_scratch_v, m_scratch_m, isConstraintPass,
605 getSolverInfo().m_jointFeedbackInWorldSpace,
606 getSolverInfo().m_jointFeedbackInJointFrame);
607 }
608 else
609 {
610 btAssert(" RK4Integration is not supported");
611 }
612 }
613 }
614 }
615 }
616 }
617 clearGravity();
618 }
619
620 void btDeformableMultiBodyDynamicsWorld::clearGravity()
621 {
622 BT_PROFILE("btMultiBody clearGravity");
623 // clear rigid body gravity
624 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
625 {
626 btRigidBody* body = m_nonStaticRigidBodies[i];
627 if (body->isActive())
628 {
629 body->clearGravity();
630 }
631 }
632 // clear multibody gravity
633 for (int i = 0; i < this->m_multiBodies.size(); i++)
634 {
635 btMultiBody* bod = m_multiBodies[i];
636
637 bool isSleeping = false;
638
639 if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
640 {
641 isSleeping = true;
642 }
643 for (int b = 0; b < bod->getNumLinks(); b++)
644 {
645 if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
646 isSleeping = true;
647 }
648
649 if (!isSleeping)
650 {
651 bod->addBaseForce(-m_gravity * bod->getBaseMass());
652
653 for (int j = 0; j < bod->getNumLinks(); ++j)
654 {
655 bod->addLinkForce(j, -m_gravity * bod->getLinkMass(j));
656 }
657 }
658 }
659 }
660
661 void btDeformableMultiBodyDynamicsWorld::beforeSolverCallbacks(btScalar timeStep)
662 {
663 if (0 != m_internalTickCallback)
664 {
665 (*m_internalTickCallback)(this, timeStep);
666 }
667
668 if (0 != m_solverCallback)
669 {
670 (*m_solverCallback)(m_internalTime, this);
671 }
672 }
673
674 void btDeformableMultiBodyDynamicsWorld::afterSolverCallbacks(btScalar timeStep)
675 {
676 if (0 != m_solverCallback)
677 {
678 (*m_solverCallback)(m_internalTime, this);
679 }
680 }
681
682 void btDeformableMultiBodyDynamicsWorld::addForce(btSoftBody* psb, btDeformableLagrangianForce* force)
683 {
684 btAlignedObjectArray<btDeformableLagrangianForce*>& forces = m_deformableBodySolver->m_objective->m_lf;
685 bool added = false;
686 for (int i = 0; i < forces.size(); ++i)
687 {
688 if (forces[i]->getForceType() == force->getForceType())
689 {
690 forces[i]->addSoftBody(psb);
691 added = true;
692 break;
693 }
694 }
695 if (!added)
696 {
697 force->addSoftBody(psb);
698 force->setIndices(m_deformableBodySolver->m_objective->getIndices());
699 forces.push_back(force);
700 }
701 }
702
703 void btDeformableMultiBodyDynamicsWorld::removeForce(btSoftBody* psb, btDeformableLagrangianForce* force)
704 {
705 btAlignedObjectArray<btDeformableLagrangianForce*>& forces = m_deformableBodySolver->m_objective->m_lf;
706 int removed_index = -1;
707 for (int i = 0; i < forces.size(); ++i)
708 {
709 if (forces[i]->getForceType() == force->getForceType())
710 {
711 forces[i]->removeSoftBody(psb);
712 if (forces[i]->m_softBodies.size() == 0)
713 removed_index = i;
714 break;
715 }
716 }
717 if (removed_index >= 0)
718 forces.removeAtIndex(removed_index);
719 }
720
721 void btDeformableMultiBodyDynamicsWorld::removeSoftBodyForce(btSoftBody* psb)
722 {
723 btAlignedObjectArray<btDeformableLagrangianForce*>& forces = m_deformableBodySolver->m_objective->m_lf;
724 for (int i = 0; i < forces.size(); ++i)
725 {
726 forces[i]->removeSoftBody(psb);
727 }
728 }
729
730 void btDeformableMultiBodyDynamicsWorld::removeSoftBody(btSoftBody* body)
731 {
732 removeSoftBodyForce(body);
733 m_softBodies.remove(body);
734 btCollisionWorld::removeCollisionObject(body);
735 // force a reinitialize so that node indices get updated.
736 m_deformableBodySolver->reinitialize(m_softBodies, btScalar(-1));
737 }
738
739 void btDeformableMultiBodyDynamicsWorld::removeCollisionObject(btCollisionObject* collisionObject)
740 {
741 btSoftBody* body = btSoftBody::upcast(collisionObject);
742 if (body)
743 removeSoftBody(body);
744 else
745 btDiscreteDynamicsWorld::removeCollisionObject(collisionObject);
746 }
747
748 int btDeformableMultiBodyDynamicsWorld::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep)
749 {
750 startProfiling(timeStep);
751
752 int numSimulationSubSteps = 0;
753
754 if (maxSubSteps)
755 {
756 //fixed timestep with interpolation
757 m_fixedTimeStep = fixedTimeStep;
758 m_localTime += timeStep;
759 if (m_localTime >= fixedTimeStep)
760 {
761 numSimulationSubSteps = int(m_localTime / fixedTimeStep);
762 m_localTime -= numSimulationSubSteps * fixedTimeStep;
763 }
764 }
765 else
766 {
767 //variable timestep
768 fixedTimeStep = timeStep;
769 m_localTime = m_latencyMotionStateInterpolation ? 0 : timeStep;
770 m_fixedTimeStep = 0;
771 if (btFuzzyZero(timeStep))
772 {
773 numSimulationSubSteps = 0;
774 maxSubSteps = 0;
775 }
776 else
777 {
778 numSimulationSubSteps = 1;
779 maxSubSteps = 1;
780 }
781 }
782
783 //process some debugging flags
784 if (getDebugDrawer())
785 {
786 btIDebugDraw* debugDrawer = getDebugDrawer();
787 gDisableDeactivation = (debugDrawer->getDebugMode() & btIDebugDraw::DBG_NoDeactivation) != 0;
788 }
789 if (numSimulationSubSteps)
790 {
791 //clamp the number of substeps, to prevent simulation grinding spiralling down to a halt
792 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps;
793
794 saveKinematicState(fixedTimeStep * clampedSimulationSteps);
795
796 for (int i = 0; i < clampedSimulationSteps; i++)
797 {
798 internalSingleStepSimulation(fixedTimeStep);
799 synchronizeMotionStates();
800 }
801 }
802 else
803 {
804 synchronizeMotionStates();
805 }
806
807 clearForces();
808
809 #ifndef BT_NO_PROFILE
810 CProfileManager::Increment_Frame_Counter();
811 #endif //BT_NO_PROFILE
812
813 return numSimulationSubSteps;
814 }
DeformableBodyInplaceSolverIslandCallback.h
ACTIVE_TAG
#define ACTIVE_TAG
Definition: btCollisionObject.h:22
DISABLE_DEACTIVATION
#define DISABLE_DEACTIVATION
Definition: btCollisionObject.h:25
WANTS_DEACTIVATION
#define WANTS_DEACTIVATION
Definition: btCollisionObject.h:24
ISLAND_SLEEPING
#define ISLAND_SLEEPING
Definition: btCollisionObject.h:23
btDeformableBodySolver.h
btDeformableMultiBodyDynamicsWorld.h
inverse
btQuaternion inverse(const btQuaternion &q)
Return the inverse of a quaternion.
Definition: btQuaternion.h:909
btQuickprof.h
BT_PROFILE
#define BT_PROFILE(name)
Definition: btQuickprof.h:198
gDisableDeactivation
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btFuzzyZero
bool btFuzzyZero(btScalar x)
Definition: btScalar.h:572
btAssert
#define btAssert(x)
Definition: btScalar.h:153
btSoftBodyInternals.h
OuterProduct
static btMatrix3x3 OuterProduct(const btScalar *v1, const btScalar *v2, const btScalar *v3, const btScalar *u1, const btScalar *u2, const btScalar *u3, int ndof)
Definition: btSoftBodyInternals.h:924
generateUnitOrthogonalVector
static btVector3 generateUnitOrthogonalVector(const btVector3 &u)
Definition: btSoftBodyInternals.h:47
findJacobian
static void findJacobian(const btMultiBodyLinkCollider *multibodyLinkCol, btMultiBodyJacobianData &jacobianData, const btVector3 &contact_point, const btVector3 &dir)
btSoftBody implementation by Nathanael Presson
Definition: btSoftBodyInternals.h:34
Diagonal
static btMatrix3x3 Diagonal(btScalar x)
Definition: btSoftBodyInternals.h:898
btCross
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
Definition: btVector3.h:918
btAlignedObjectArray< btDeformableLagrangianForce * >
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:142
btAlignedObjectArray::resize
void resize(int newsize, const T &fillData=T())
Definition: btAlignedObjectArray.h:203
btAlignedObjectArray::removeAtIndex
void removeAtIndex(int index)
Definition: btAlignedObjectArray.h:472
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:480
btAlignedObjectArray::quickSort
void quickSort(const L &CompareFunc)
Definition: btAlignedObjectArray.h:341
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:257
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
Definition: btBroadphaseInterface.h:50
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
Definition: btCollisionConfiguration.h:27
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:51
btCollisionObject::CO_FEATHERSTONE_LINK
@ CO_FEATHERSTONE_LINK
Definition: btCollisionObject.h:155
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:379
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:374
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:306
btCollisionObject::setActivationState
void setActivationState(int newState) const
Definition: btCollisionObject.cpp:61
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:389
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:289
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:228
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:28
btCollisionWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
Definition: btCollisionWorld.cpp:239
btCollisionWorld::addCollisionObject
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
Definition: btCollisionWorld.cpp:124
btCollisionWorld::getDispatcher
btDispatcher * getDispatcher()
Definition: btCollisionWorld.h:132
btCollisionWorld::getDebugDrawer
virtual btIDebugDraw * getDebugDrawer()
Definition: btCollisionWorld.h:155
btCollisionWorld::performDiscreteCollisionDetection
virtual void performDiscreteCollisionDetection()
Definition: btCollisionWorld.cpp:221
btCollisionWorld::m_debugDrawer
btIDebugDraw * m_debugDrawer
Definition: btCollisionWorld.h:96
btCollisionWorld::getDispatchInfo
btDispatcherInfo & getDispatchInfo()
Definition: btCollisionWorld.h:490
btConstraintSolver::allSolved
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
Definition: btConstraintSolver.h:51
btDeformableBackwardEulerObjective::m_projection
btDeformableContactProjection m_projection
Definition: btDeformableBackwardEulerObjective.h:39
btDeformableBackwardEulerObjective::m_lf
btAlignedObjectArray< btDeformableLagrangianForce * > m_lf
Definition: btDeformableBackwardEulerObjective.h:36
btDeformableBackwardEulerObjective::getIndices
const btAlignedObjectArray< btSoftBody::Node * > * getIndices() const
Definition: btDeformableBackwardEulerObjective.h:123
btDeformableBackwardEulerObjective::m_massPreconditioner
MassPreconditioner * m_massPreconditioner
Definition: btDeformableBackwardEulerObjective.h:43
btDeformableBackwardEulerObjective::m_preconditioner
Preconditioner * m_preconditioner
Definition: btDeformableBackwardEulerObjective.h:38
btDeformableBackwardEulerObjective::m_KKTPreconditioner
KKTPreconditioner * m_KKTPreconditioner
Definition: btDeformableBackwardEulerObjective.h:44
btDeformableBodySolver
Definition: btDeformableBodySolver.h:31
btDeformableBodySolver::solveDeformableConstraints
virtual void solveDeformableConstraints(btScalar solverdt)
Definition: btDeformableBodySolver.cpp:33
btDeformableBodySolver::setConstraints
void setConstraints(const btContactSolverInfo &infoGlobal)
Definition: btDeformableBodySolver.cpp:250
btDeformableBodySolver::m_objective
btDeformableBackwardEulerObjective * m_objective
Definition: btDeformableBodySolver.h:51
btDeformableBodySolver::backupVelocity
void backupVelocity()
Definition: btDeformableBodySolver.cpp:316
btDeformableBodySolver::reinitialize
void reinitialize(const btAlignedObjectArray< btSoftBody * > &softBodies, btScalar dt)
Definition: btDeformableBodySolver.cpp:221
btDeformableBodySolver::setupDeformableSolve
void setupDeformableSolve(bool implicit)
Definition: btDeformableBodySolver.cpp:329
btDeformableBodySolver::setLineSearch
void setLineSearch(bool lineSearch)
Definition: btDeformableBodySolver.cpp:503
btDeformableBodySolver::m_useProjection
bool m_useProjection
Definition: btDeformableBodySolver.h:52
btDeformableBodySolver::predictMotion
virtual void predictMotion(btScalar solverdt)
Predict motion of soft bodies into next timestep.
Definition: btDeformableBodySolver.cpp:387
btDeformableBodySolver::setImplicit
void setImplicit(bool implicit)
Definition: btDeformableBodySolver.cpp:497
btDeformableContactProjection::setLagrangeMultiplier
virtual void setLagrangeMultiplier()
Definition: btDeformableContactProjection.cpp:460
btDeformableContactProjection::m_useStrainLimiting
bool m_useStrainLimiting
Definition: btDeformableContactProjection.h:65
btDeformableContactProjection::setProjection
virtual void setProjection()
Definition: btDeformableContactProjection.cpp:202
btDeformableLagrangianForce
Definition: btDeformableLagrangianForce.h:39
btDeformableLagrangianForce::setIndices
virtual void setIndices(const btAlignedObjectArray< btSoftBody::Node * > *nodes)
Definition: btDeformableLagrangianForce.h:99
btDeformableLagrangianForce::getForceType
virtual btDeformableLagrangianForceType getForceType()=0
btDeformableLagrangianForce::addSoftBody
virtual void addSoftBody(btSoftBody *psb)
Definition: btDeformableLagrangianForce.h:89
btDeformableMultiBodyConstraintSolver
Definition: btDeformableMultiBodyConstraintSolver.h:33
btDeformableMultiBodyDynamicsWorld::m_drawFaceTree
bool m_drawFaceTree
Definition: btDeformableMultiBodyDynamicsWorld.h:45
btDeformableMultiBodyDynamicsWorld::applyRigidBodyGravity
void applyRigidBodyGravity(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:560
btDeformableMultiBodyDynamicsWorld::btDeformableMultiBodyDynamicsWorld
btDeformableMultiBodyDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btDeformableMultiBodyConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration, btDeformableBodySolver *deformableBodySolver=0)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:42
btDeformableMultiBodyDynamicsWorld::removeCollisionObject
void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
Definition: btDeformableMultiBodyDynamicsWorld.cpp:739
btDeformableMultiBodyDynamicsWorld::m_drawFlags
int m_drawFlags
Definition: btDeformableMultiBodyDynamicsWorld.h:43
btDeformableMultiBodyDynamicsWorld::addSoftBody
virtual void addSoftBody(btSoftBody *body, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:501
btDeformableMultiBodyDynamicsWorld::removeSoftBodyForce
void removeSoftBodyForce(btSoftBody *psb)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:721
btDeformableMultiBodyDynamicsWorld::sortConstraints
void sortConstraints()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:425
btDeformableMultiBodyDynamicsWorld::removeSoftBody
void removeSoftBody(btSoftBody *body)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:730
btDeformableMultiBodyDynamicsWorld::reinitialize
void reinitialize(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:521
btDeformableMultiBodyDynamicsWorld::m_drawNodeTree
bool m_drawNodeTree
Definition: btDeformableMultiBodyDynamicsWorld.h:44
btDeformableMultiBodyDynamicsWorld::positionCorrection
void positionCorrection(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:273
btDeformableMultiBodyDynamicsWorld::predictUnconstraintMotion
virtual void predictUnconstraintMotion(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:514
btDeformableMultiBodyDynamicsWorld::afterSolverCallbacks
void afterSolverCallbacks(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:674
btDeformableMultiBodyDynamicsWorld::applyRepulsionForce
void applyRepulsionForce(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:163
btDeformableMultiBodyDynamicsWorld::debugDrawWorld
virtual void debugDrawWorld()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:546
btDeformableMultiBodyDynamicsWorld::solveConstraints
void solveConstraints(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:379
btDeformableMultiBodyDynamicsWorld::addForce
void addForce(btSoftBody *psb, btDeformableLagrangianForce *force)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:682
btDeformableMultiBodyDynamicsWorld::setupConstraints
void setupConstraints()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:407
btDeformableMultiBodyDynamicsWorld::softBodySelfCollision
void softBodySelfCollision()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:260
btDeformableMultiBodyDynamicsWorld::getSoftBodyArray
btSoftBodyArray & getSoftBodyArray()
Definition: btDeformableMultiBodyDynamicsWorld.h:104
btDeformableMultiBodyDynamicsWorld::m_solverCallback
btSolverCallback m_solverCallback
Definition: btDeformableMultiBodyDynamicsWorld.h:56
btDeformableMultiBodyDynamicsWorld::performGeometricCollisions
void performGeometricCollisions(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:176
btDeformableMultiBodyDynamicsWorld::integrateTransforms
virtual void integrateTransforms(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:295
btDeformableMultiBodyDynamicsWorld::m_internalTime
btScalar m_internalTime
Definition: btDeformableMultiBodyDynamicsWorld.h:48
btDeformableMultiBodyDynamicsWorld::removeForce
void removeForce(btSoftBody *psb, btDeformableLagrangianForce *force)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:703
btDeformableMultiBodyDynamicsWorld::m_sbi
btSoftBodyWorldInfo m_sbi
Definition: btDeformableMultiBodyDynamicsWorld.h:47
btDeformableMultiBodyDynamicsWorld::internalSingleStepSimulation
virtual void internalSingleStepSimulation(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:75
btDeformableMultiBodyDynamicsWorld::m_ccdIterations
int m_ccdIterations
Definition: btDeformableMultiBodyDynamicsWorld.h:49
btDeformableMultiBodyDynamicsWorld::updateActivationState
void updateActivationState(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:139
btDeformableMultiBodyDynamicsWorld::~btDeformableMultiBodyDynamicsWorld
virtual ~btDeformableMultiBodyDynamicsWorld()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:70
btDeformableMultiBodyDynamicsWorld::solveContactConstraints
void solveContactConstraints()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:443
btDeformableMultiBodyDynamicsWorld::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: btDeformableMultiBodyDynamicsWorld.cpp:748
btDeformableMultiBodyDynamicsWorld::getDrawFlags
int getDrawFlags() const
Definition: btDeformableMultiBodyDynamicsWorld.h:142
btDeformableMultiBodyDynamicsWorld::m_softBodies
btSoftBodyArray m_softBodies
Definition: btDeformableMultiBodyDynamicsWorld.h:42
btDeformableMultiBodyDynamicsWorld::m_drawClusterTree
bool m_drawClusterTree
Definition: btDeformableMultiBodyDynamicsWorld.h:46
btDeformableMultiBodyDynamicsWorld::m_useProjection
bool m_useProjection
Definition: btDeformableMultiBodyDynamicsWorld.h:52
btDeformableMultiBodyDynamicsWorld::m_solverDeformableBodyIslandCallback
DeformableBodyInplaceSolverIslandCallback * m_solverDeformableBodyIslandCallback
Definition: btDeformableMultiBodyDynamicsWorld.h:53
btDeformableMultiBodyDynamicsWorld::beforeSolverCallbacks
void beforeSolverCallbacks(btScalar timeStep)
Definition: btDeformableMultiBodyDynamicsWorld.cpp:661
btDeformableMultiBodyDynamicsWorld::performDeformableCollisionDetection
void performDeformableCollisionDetection()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:118
btDeformableMultiBodyDynamicsWorld::clearGravity
void clearGravity()
Definition: btDeformableMultiBodyDynamicsWorld.cpp:620
btDeformableMultiBodyDynamicsWorld::m_implicit
bool m_implicit
Definition: btDeformableMultiBodyDynamicsWorld.h:50
btDeformableMultiBodyDynamicsWorld::m_deformableBodySolver
btDeformableBodySolver * m_deformableBodySolver
Solver classes that encapsulate multiple deformable bodies for solving.
Definition: btDeformableMultiBodyDynamicsWorld.h:41
btDeformableMultiBodyDynamicsWorld::m_lineSearch
bool m_lineSearch
Definition: btDeformableMultiBodyDynamicsWorld.h:51
btDiscreteDynamicsWorld::updateActions
void updateActions(btScalar timeStep)
Definition: btDiscreteDynamicsWorld.cpp:584
btDiscreteDynamicsWorld::m_latencyMotionStateInterpolation
bool m_latencyMotionStateInterpolation
Definition: btDiscreteDynamicsWorld.h:67
btDiscreteDynamicsWorld::getCollisionWorld
btCollisionWorld * getCollisionWorld()
Definition: btDiscreteDynamicsWorld.h:135
btDiscreteDynamicsWorld::m_sortedConstraints
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
Definition: btDiscreteDynamicsWorld.h:40
btDiscreteDynamicsWorld::m_localTime
btScalar m_localTime
Definition: btDiscreteDynamicsWorld.h:54
btDiscreteDynamicsWorld::m_gravity
btVector3 m_gravity
Definition: btDiscreteDynamicsWorld.h:51
btDiscreteDynamicsWorld::m_fixedTimeStep
btScalar m_fixedTimeStep
Definition: btDiscreteDynamicsWorld.h:55
btDiscreteDynamicsWorld::synchronizeMotionStates
virtual void synchronizeMotionStates()
Definition: btDiscreteDynamicsWorld.cpp:356
btDiscreteDynamicsWorld::m_islandManager
btSimulationIslandManager * m_islandManager
Definition: btDiscreteDynamicsWorld.h:45
btDiscreteDynamicsWorld::m_constraints
btAlignedObjectArray< btTypedConstraint * > m_constraints
Definition: btDiscreteDynamicsWorld.h:47
btDiscreteDynamicsWorld::m_nonStaticRigidBodies
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
Definition: btDiscreteDynamicsWorld.h:49
btDiscreteDynamicsWorld::getNumConstraints
virtual int getNumConstraints() const
Definition: btDiscreteDynamicsWorld.cpp:1366
btDiscreteDynamicsWorld::removeCollisionObject
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
Definition: btDiscreteDynamicsWorld.cpp:522
btDiscreteDynamicsWorld::m_constraintSolver
btConstraintSolver * m_constraintSolver
Definition: btDiscreteDynamicsWorld.h:43
btDiscreteDynamicsWorld::startProfiling
void startProfiling(btScalar timeStep)
Definition: btDiscreteDynamicsWorld.cpp:1108
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
btDynamicsWorld::m_solverInfo
btContactSolverInfo m_solverInfo
Definition: btDynamicsWorld.h:49
btDynamicsWorld::m_internalTickCallback
btInternalTickCallback m_internalTickCallback
Definition: btDynamicsWorld.h:45
btDynamicsWorld::m_internalPreTickCallback
btInternalTickCallback m_internalPreTickCallback
Definition: btDynamicsWorld.h:46
btDynamicsWorld::getSolverInfo
btContactSolverInfo & getSolverInfo()
Definition: btDynamicsWorld.h:140
btIDebugDraw
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
Definition: btIDebugDraw.h:27
btIDebugDraw::getDebugMode
virtual int getDebugMode() const =0
btIDebugDraw::DBG_NoDeactivation
@ DBG_NoDeactivation
Definition: btIDebugDraw.h:59
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:50
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1049
btMultiBodyConstraintSolver
Definition: btMultiBodyConstraintSolver.h:30
btMultiBodyConstraint
Definition: btMultiBodyConstraint.h:57
btMultiBodyDynamicsWorld
The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet This implementation is s...
Definition: btMultiBodyDynamicsWorld.h:32
btMultiBodyDynamicsWorld::m_multiBodyConstraints
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
Definition: btMultiBodyDynamicsWorld.h:35
btMultiBodyDynamicsWorld::clearForces
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
Definition: btMultiBodyDynamicsWorld.cpp:825
btMultiBodyDynamicsWorld::updateActivationState
virtual void updateActivationState(btScalar timeStep)
Definition: btMultiBodyDynamicsWorld.cpp:125
btMultiBodyDynamicsWorld::forwardKinematics
void forwardKinematics()
Definition: btMultiBodyDynamicsWorld.cpp:215
btMultiBodyDynamicsWorld::m_scratch_m
btAlignedObjectArray< btMatrix3x3 > m_scratch_m
Definition: btMultiBodyDynamicsWorld.h:47
btMultiBodyDynamicsWorld::m_scratch_v
btAlignedObjectArray< btVector3 > m_scratch_v
Definition: btMultiBodyDynamicsWorld.h:46
btMultiBodyDynamicsWorld::predictUnconstraintMotion
virtual void predictUnconstraintMotion(btScalar timeStep)
Definition: btMultiBodyDynamicsWorld.cpp:36
btMultiBodyDynamicsWorld::calculateSimulationIslands
virtual void calculateSimulationIslands()
Definition: btMultiBodyDynamicsWorld.cpp:42
btMultiBodyDynamicsWorld::integrateTransforms
virtual void integrateTransforms(btScalar timeStep)
Definition: btMultiBodyDynamicsWorld.cpp:575
btMultiBodyDynamicsWorld::m_multiBodies
btAlignedObjectArray< btMultiBody * > m_multiBodies
Definition: btMultiBodyDynamicsWorld.h:34
btMultiBodyDynamicsWorld::m_scratch_r
btAlignedObjectArray< btScalar > m_scratch_r
Definition: btMultiBodyDynamicsWorld.h:45
btMultiBodyDynamicsWorld::m_sortedMultiBodyConstraints
btAlignedObjectArray< btMultiBodyConstraint * > m_sortedMultiBodyConstraints
Definition: btMultiBodyDynamicsWorld.h:36
btMultiBodyDynamicsWorld::clearMultiBodyConstraintForces
virtual void clearMultiBodyConstraintForces()
Definition: btMultiBodyDynamicsWorld.cpp:789
btMultiBodyDynamicsWorld::saveKinematicState
virtual void saveKinematicState(btScalar timeStep)
Definition: btMultiBodyDynamicsWorld.cpp:880
btMultiBodyDynamicsWorld::applyGravity
virtual void applyGravity()
apply gravity, call this once per timestep
Definition: btMultiBodyDynamicsWorld.cpp:755
btMultiBodyDynamicsWorld::debugDrawWorld
virtual void debugDrawWorld()
Definition: btMultiBodyDynamicsWorld.cpp:679
btMultiBodyLinkCollider
Definition: btMultiBodyLinkCollider.h:33
btMultiBodyLinkCollider::m_multiBody
btMultiBody * m_multiBody
Definition: btMultiBodyLinkCollider.h:36
btMultiBodyLinkCollider::upcast
static btMultiBodyLinkCollider * upcast(btCollisionObject *colObj)
Definition: btMultiBodyLinkCollider.h:61
btMultiBody
Definition: btMultiBody.h:51
btMultiBody::computeAccelerationsArticulatedBodyAlgorithmMultiDof
void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m, bool isConstraintPass, bool jointFeedbackInWorldSpace, bool jointFeedbackInJointFrame)
Definition: btMultiBody.cpp:728
btMultiBody::getNumLinks
int getNumLinks() const
Definition: btMultiBody.h:166
btMultiBody::getLinkMass
btScalar getLinkMass(int i) const
Definition: btMultiBody.cpp:368
btMultiBody::getNumDofs
int getNumDofs() const
Definition: btMultiBody.h:167
btMultiBody::addLinkForce
void addLinkForce(int i, const btVector3 &f)
Definition: btMultiBody.cpp:624
btMultiBody::getLink
const btMultibodyLink & getLink(int index) const
Definition: btMultiBody.h:114
btMultiBody::processDeltaVeeMultiDof2
void processDeltaVeeMultiDof2()
Definition: btMultiBody.h:455
btMultiBody::isUsingRK4Integration
bool isUsingRK4Integration() const
Definition: btMultiBody.h:643
btMultiBody::internalNeedsJointFeedback
bool internalNeedsJointFeedback() const
Definition: btMultiBody.h:657
btMultiBody::getBaseCollider
const btMultiBodyLinkCollider * getBaseCollider() const
Definition: btMultiBody.h:128
btMultiBody::getBaseMass
btScalar getBaseMass() const
Definition: btMultiBody.h:169
btMultiBody::addBaseForce
void addBaseForce(const btVector3 &f)
Definition: btMultiBody.h:355
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:60
btRigidBody::integrateVelocities
void integrateVelocities(btScalar step)
Definition: btRigidBody.cpp:372
btRigidBody::setTurnVelocity
void setTurnVelocity(const btVector3 &v)
Definition: btRigidBody.h:391
btRigidBody::clearGravity
void clearGravity()
Definition: btRigidBody.cpp:213
btRigidBody::setPushVelocity
void setPushVelocity(const btVector3 &v)
Definition: btRigidBody.h:369
btRigidBody::getPushVelocity
btVector3 getPushVelocity() const
Definition: btRigidBody.h:359
btRigidBody::getTurnVelocity
btVector3 getTurnVelocity() const
Definition: btRigidBody.h:364
btSimulationIslandManager::processIslands
void processIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
Definition: btSimulationIslandManager.cpp:349
btSimulationIslandManager::buildIslands
void buildIslands(btDispatcher *dispatcher, btCollisionWorld *colWorld)
Definition: btSimulationIslandManager.cpp:196
btSoftBody::DeformableNodeRigidAnchor
Definition: btSoftBody.h:385
btSoftBody::DeformableNodeRigidAnchor::m_local
btVector3 m_local
Definition: btSoftBody.h:387
btSoftBody::DeformableNodeRigidContact::m_node
Node * m_node
Definition: btSoftBody.h:381
btSoftBody::DeformableRigidContact::t1
btVector3 t1
Definition: btSoftBody.h:374
btSoftBody::DeformableRigidContact::m_cti
sCti m_cti
Definition: btSoftBody.h:362
btSoftBody::DeformableRigidContact::m_c0
btMatrix3x3 m_c0
Definition: btSoftBody.h:363
btSoftBody::DeformableRigidContact::t2
btVector3 t2
Definition: btSoftBody.h:375
btSoftBody::DeformableRigidContact::jacobianData_t1
btMultiBodyJacobianData jacobianData_t1
Definition: btSoftBody.h:372
btSoftBody::DeformableRigidContact::jacobianData_normal
btMultiBodyJacobianData jacobianData_normal
Definition: btSoftBody.h:371
btSoftBody::DeformableRigidContact::jacobianData_t2
btMultiBodyJacobianData jacobianData_t2
Definition: btSoftBody.h:373
btSoftBody
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition: btSoftBody.h:75
btSoftBody::interpolateRenderMesh
void interpolateRenderMesh()
Definition: btSoftBody.cpp:3797
btSoftBody::defaultCollisionHandler
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
Definition: btSoftBody.cpp:4058
btSoftBody::getWorldInfo
btSoftBodyWorldInfo * getWorldInfo()
Definition: btSoftBody.h:876
btSoftBody::setZeroVelocity
void setZeroVelocity()
Definition: btSoftBody.cpp:4705
btSoftBody::m_worldInfo
btSoftBodyWorldInfo * m_worldInfo
Definition: btSoftBody.h:810
btSoftBody::setSoftBodySolver
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
Definition: btSoftBody.h:1117
btSoftBody::wantsSleeping
bool wantsSleeping()
Definition: btSoftBody.cpp:4713
btSoftBody::m_faceNodeContacts
btAlignedObjectArray< DeformableFaceNodeContact > m_faceNodeContacts
Definition: btSoftBody.h:824
btSoftBody::updateDeactivation
void updateDeactivation(btScalar timeStep)
Definition: btSoftBody.cpp:4689
btSoftBody::m_faces
tFaceArray m_faces
Definition: btSoftBody.h:815
btSoftBody::applyRepulsionForce
void applyRepulsionForce(btScalar timeStep, bool applySpringForce)
Definition: btSoftBody.h:1302
btSoftBody::m_deformableAnchors
btAlignedObjectArray< DeformableNodeRigidAnchor > m_deformableAnchors
Definition: btSoftBody.h:821
btSoftBody::upcast
static const btSoftBody * upcast(const btCollisionObject *colObj)
Definition: btSoftBody.h:1142
btSoftBody::m_nodes
tNodeArray m_nodes
Definition: btSoftBody.h:812
btSortConstraintOnIslandPredicate2
Definition: btMultiBodyInplaceSolverIslandCallback.h:32
btSortMultiBodyConstraintOnIslandPredicate
Definition: btMultiBodyInplaceSolverIslandCallback.h:54
btTransformUtil::integrateTransform
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
Definition: btTransformUtil.h:32
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:108
btTransform::invXform
btVector3 invXform(const btVector3 &inVec) const
Definition: btTransform.h:215
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:76
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
btVector3::getX
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
btVector3::getZ
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btVector3::getY
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
DeformableBodyInplaceSolverIslandCallback
Definition: DeformableBodyInplaceSolverIslandCallback.h:12
DeformableBodyInplaceSolverIslandCallback::processConstraints
virtual void processConstraints(int islandId=-1)
Definition: DeformableBodyInplaceSolverIslandCallback.h:21
MultiBodyInplaceSolverIslandCallback::setup
virtual void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btMultiBodyConstraint **sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw *debugDrawer)
Definition: btMultiBodyInplaceSolverIslandCallback.h:104
btContactSolverInfoData::m_splitImpulseTurnErp
btScalar m_splitImpulseTurnErp
Definition: btContactSolverInfo.h:58
btContactSolverInfoData::m_timeStep
btScalar m_timeStep
Definition: btContactSolverInfo.h:42
btContactSolverInfo
Definition: btContactSolverInfo.h:76
btDispatcherInfo
Definition: btDispatcher.h:31
btDispatcherInfo::m_timeStep
btScalar m_timeStep
Definition: btDispatcher.h:53
btDispatcherInfo::m_stepCount
int m_stepCount
Definition: btDispatcher.h:54
btDispatcherInfo::m_debugDraw
class btIDebugDraw * m_debugDraw
Definition: btDispatcher.h:58
btMultiBodyJacobianData
Definition: btMultiBodyConstraint.h:44
btMultiBodyJacobianData::m_deltaVelocitiesUnitImpulse
btAlignedObjectArray< btScalar > m_deltaVelocitiesUnitImpulse
Definition: btMultiBodyConstraint.h:46
btMultiBodyJacobianData::m_jacobians
btAlignedObjectArray< btScalar > m_jacobians
Definition: btMultiBodyConstraint.h:45
btMultibodyLink::m_collider
class btMultiBodyLinkCollider * m_collider
Definition: btMultiBodyLink.h:132
btSoftBodyHelpers::Draw
static void Draw(btSoftBody *psb, btIDebugDraw *idraw, int drawflags=fDrawFlags::Std)
Definition: btSoftBodyHelpers.cpp:171
btSoftBodyHelpers::DrawFrame
static void DrawFrame(btSoftBody *psb, btIDebugDraw *idraw)
Definition: btSoftBodyHelpers.cpp:666
btSoftBodyWorldInfo::air_density
btScalar air_density
Definition: btSoftBody.h:49
btSoftBodyWorldInfo::m_dispatcher
btDispatcher * m_dispatcher
Definition: btSoftBody.h:55
btSoftBodyWorldInfo::water_density
btScalar water_density
Definition: btSoftBody.h:50
btSoftBodyWorldInfo::m_sparsesdf
btSparseSdf< 3 > m_sparsesdf
Definition: btSoftBody.h:57
btSoftBodyWorldInfo::m_gravity
btVector3 m_gravity
Definition: btSoftBody.h:56
btSoftBodyWorldInfo::water_normal
btVector3 water_normal
Definition: btSoftBody.h:53
btSoftBodyWorldInfo::m_maxDisplacement
btScalar m_maxDisplacement
Definition: btSoftBody.h:52
btSoftBodyWorldInfo::water_offset
btScalar water_offset
Definition: btSoftBody.h:51
btSoftBodyWorldInfo::m_broadphase
btBroadphaseInterface * m_broadphase
Definition: btSoftBody.h:54
btSoftBody::Face
Definition: btSoftBody.h:306
btSoftBody::Face::m_n0
btVector3 m_n0
Definition: btSoftBody.h:312
btSoftBody::Face::m_n1
btVector3 m_n1
Definition: btSoftBody.h:312
btSoftBody::Face::m_vn
btVector3 m_vn
Definition: btSoftBody.h:312
btSoftBody::Face::m_n
Node * m_n[3]
Definition: btSoftBody.h:307
btSoftBody::Node
Definition: btSoftBody.h:268
btSoftBody::Node::m_im
btScalar m_im
Definition: btSoftBody.h:275
btSoftBody::Node::m_x
btVector3 m_x
Definition: btSoftBody.h:269
btSoftBody::Node::m_splitv
btVector3 m_splitv
Definition: btSoftBody.h:281
btSoftBody::Node::m_vn
btVector3 m_vn
Definition: btSoftBody.h:272
btSoftBody::Node::m_v
btVector3 m_v
Definition: btSoftBody.h:271
btSoftBody::Node::m_q
btVector3 m_q
Definition: btSoftBody.h:270
btSoftBody::sCti::m_colObj
const btCollisionObject * m_colObj
Definition: btSoftBody.h:226
btSoftBody::sCti::m_normal
btVector3 m_normal
Definition: btSoftBody.h:227
btSparseSdf::Reset
void Reset()
Definition: btSparseSDF.h:116
btSparseSdf::Evaluate
btScalar Evaluate(const btVector3 &x, const btCollisionShape *shape, btVector3 &normal, btScalar margin)
Definition: btSparseSDF.h:196
btSparseSdf::setDefaultVoxelsz
void setDefaultVoxelsz(btScalar sz)
Definition: btSparseSDF.h:111
btSparseSdf::Initialize
void Initialize(int hashsize=2383, int clampCells=256 *1024)
Definition: btSparseSDF.h:100
fDrawFlags::Std
@ Std
Definition: btSoftBodyHelpers.h:45