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/*
19A single step of the deformable body simulation contains the following main components:
20Call internalStepSimulation multiple times, to achieve 240Hz (4 steps of 60Hz).
211. 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.
222. Detect discrete collisions between rigid and deformable bodies at position x_{n+1}^* = x_n + dt * v_{n+1}^*.
23
243a. Solve all constraints, including LCP. Contact, position correction due to numerical drift, friction, and anchors for deformable.
25 TODO: add option for positional drift correction (using vel_target += erp * pos_error/dt
26
273b. 5 Newton steps (multiple step). Conjugent Gradient solves linear system. Deformable Damping: Then velocities of deformable bodies v_{n+1} are solved in
28 M(v_{n+1} - v_{n+1}^*) = damping_force * dt / mass,
29 by a conjugate gradient solver, where the damping force is implicit and depends on v_{n+1}.
30 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.
314. Position is updated via x_{n+1} = x_n + dt * v_{n+1}.
32
33
34The algorithm also closely resembles the one in http://physbam.stanford.edu/~fedkiw/papers/stanford2008-03.pdf
35 */
36
37#include <stdio.h>
42#include "btSoftBodyInternals.h"
44: btMultiBodyDynamicsWorld(dispatcher, pairCache, (btMultiBodyConstraintSolver*)constraintSolver, collisionConfiguration),
45m_deformableBodySolver(deformableBodySolver), m_solverCallback(0)
46{
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
60 m_sbi.water_normal = btVector3(0, 0, 0);
61 m_sbi.m_gravity.setValue(0, -10, 0);
62 m_internalTime = 0.0;
63 m_implicit = false;
64 m_lineSearch = false;
65 m_selfCollision = true;
67}
68
70{
71 BT_PROFILE("internalSingleStepSimulation");
73 {
74 (*m_internalPreTickCallback)(this, timeStep);
75 }
76 reinitialize(timeStep);
77 // add gravity to velocity of rigid and multi bodys
78 applyRigidBodyGravity(timeStep);
79
82
85
87 {
89 }
90
92
93 beforeSolverCallbacks(timeStep);
94
96 solveConstraints(timeStep);
97
98 afterSolverCallbacks(timeStep);
99
100 integrateTransforms(timeStep);
101
104
105 updateActivationState(timeStep);
106 // End solver-wise simulation step
107 // ///////////////////////////////
108}
109
111{
112 for (int i = 0; i < m_softBodies.size(); i++)
113 {
114 btSoftBody* psb = m_softBodies[i];
115 psb->updateDeactivation(timeStep);
116 if (psb->wantsSleeping())
117 {
118 if (psb->getActivationState() == ACTIVE_TAG)
121 {
122 psb->setZeroVelocity();
123 }
124 }
125 else
126 {
129 }
130 }
132}
133
134
136{
138 for (int i = 0; i < m_softBodies.size(); i++)
139 {
140 btSoftBody* psb = m_softBodies[i];
141 if (psb->isActive())
142 {
143 psb->defaultCollisionHandler(psb);
144 }
145 }
146}
147
149{
150 // correct the position of rigid bodies with temporary velocity generated from split impulse
151 btContactSolverInfo infoGlobal;
152 btVector3 zero(0,0,0);
153 for (int i = 0; i < m_nonStaticRigidBodies.size(); ++i)
154 {
156 //correct the position/orientation based on push/turn recovery
157 btTransform newTransform;
158 btVector3 pushVelocity = rb->getPushVelocity();
159 btVector3 turnVelocity = rb->getTurnVelocity();
160 if (pushVelocity[0] != 0.f || pushVelocity[1] != 0 || pushVelocity[2] != 0 || turnVelocity[0] != 0.f || turnVelocity[1] != 0 || turnVelocity[2] != 0)
161 {
162 btTransformUtil::integrateTransform(rb->getWorldTransform(), pushVelocity, turnVelocity * infoGlobal.m_splitImpulseTurnErp, timeStep, newTransform);
163 rb->setWorldTransform(newTransform);
164 rb->setPushVelocity(zero);
165 rb->setTurnVelocity(zero);
166 }
167 }
168}
169
171{
172 BT_PROFILE("integrateTransforms");
173 positionCorrection(timeStep);
175 for (int i = 0; i < m_softBodies.size(); ++i)
176 {
177 btSoftBody* psb = m_softBodies[i];
178 for (int j = 0; j < psb->m_nodes.size(); ++j)
179 {
180 btSoftBody::Node& node = psb->m_nodes[j];
181 btScalar maxDisplacement = psb->getWorldInfo()->m_maxDisplacement;
182 btScalar clampDeltaV = maxDisplacement / timeStep;
183 for (int c = 0; c < 3; c++)
184 {
185 if (node.m_v[c] > clampDeltaV)
186 {
187 node.m_v[c] = clampDeltaV;
188 }
189 if (node.m_v[c] < -clampDeltaV)
190 {
191 node.m_v[c] = -clampDeltaV;
192 }
193 }
194 node.m_x = node.m_x + timeStep * node.m_v;
195 node.m_v -= node.m_vsplit;
196 node.m_vsplit.setZero();
197 node.m_q = node.m_x;
198 node.m_vn = node.m_v;
199 }
200 // enforce anchor constraints
201 for (int j = 0; j < psb->m_deformableAnchors.size();++j)
202 {
206
207 // update multibody anchor info
209 {
211 if (multibodyLinkCol)
212 {
213 btVector3 nrm;
214 const btCollisionShape* shp = multibodyLinkCol->getCollisionShape();
215 const btTransform& wtr = multibodyLinkCol->getWorldTransform();
216 psb->m_worldInfo->m_sparsesdf.Evaluate(
217 wtr.invXform(n->m_x),
218 shp,
219 nrm,
220 0);
221 a.m_cti.m_normal = wtr.getBasis() * nrm;
222 btVector3 normal = a.m_cti.m_normal;
224 btVector3 t2 = btCross(normal, t1);
225 btMultiBodyJacobianData jacobianData_normal, jacobianData_t1, jacobianData_t2;
226 findJacobian(multibodyLinkCol, jacobianData_normal, a.m_node->m_x, normal);
227 findJacobian(multibodyLinkCol, jacobianData_t1, a.m_node->m_x, t1);
228 findJacobian(multibodyLinkCol, jacobianData_t2, a.m_node->m_x, t2);
229
230 btScalar* J_n = &jacobianData_normal.m_jacobians[0];
231 btScalar* J_t1 = &jacobianData_t1.m_jacobians[0];
232 btScalar* J_t2 = &jacobianData_t2.m_jacobians[0];
233
234 btScalar* u_n = &jacobianData_normal.m_deltaVelocitiesUnitImpulse[0];
235 btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
236 btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
237
238 btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
239 t1.getX(), t1.getY(), t1.getZ(),
240 t2.getX(), t2.getY(), t2.getZ()); // world frame to local frame
241 const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
242 btMatrix3x3 local_impulse_matrix = (Diagonal(n->m_im) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
243 a.m_c0 = rot.transpose() * local_impulse_matrix * rot;
244 a.jacobianData_normal = jacobianData_normal;
245 a.jacobianData_t1 = jacobianData_t1;
246 a.jacobianData_t2 = jacobianData_t2;
247 a.t1 = t1;
248 a.t2 = t2;
249 }
250 }
251 }
253 }
254}
255
257{
258 // save v_{n+1}^* velocity after explicit forces
260
261 // set up constraints among multibodies and between multibodies and deformable bodies
263
264 // solve contact constraints
266
267 // set up the directions in which the velocity does not change in the momentum solve
269
270 // for explicit scheme, m_backupVelocity = v_{n+1}^*
271 // for implicit scheme, m_backupVelocity = v_n
272 // Here, set dv = v_{n+1} - v_n for nodes in contact
274
275 // At this point, dv should be golden for nodes in contact
276 // proceed to solve deformable momentum equation
278}
279
281{
282 // set up constraints between multibody and deformable bodies
284
285 // set up constraints among multibodies
286 {
288 // setup the solver callback
289 btMultiBodyConstraint** sortedMultiBodyConstraints = m_sortedMultiBodyConstraints.size() ? &m_sortedMultiBodyConstraints[0] : 0;
290 btTypedConstraint** constraintsPtr = getNumConstraints() ? &m_sortedConstraints[0] : 0;
291 m_solverDeformableBodyIslandCallback->setup(&m_solverInfo, constraintsPtr, m_sortedConstraints.size(), sortedMultiBodyConstraints, m_sortedMultiBodyConstraints.size(), getDebugDrawer());
292
293 // build islands
295 }
296}
297
299{
300 m_sortedConstraints.resize(m_constraints.size());
301 int i;
302 for (i = 0; i < getNumConstraints(); i++)
303 {
305 }
307
309 for (i = 0; i < m_multiBodyConstraints.size(); i++)
310 {
312 }
314}
315
316
318{
319 // process constraints on each island
321
322 // process deferred
325
326 // write joint feedback
327 {
328 for (int i = 0; i < this->m_multiBodies.size(); i++)
329 {
330 btMultiBody* bod = m_multiBodies[i];
331
332 bool isSleeping = false;
333
335 {
336 isSleeping = true;
337 }
338 for (int b = 0; b < bod->getNumLinks(); b++)
339 {
341 isSleeping = true;
342 }
343
344 if (!isSleeping)
345 {
346 //useless? they get resized in stepVelocities once again (AND DIFFERENTLY)
347 m_scratch_r.resize(bod->getNumLinks() + 1); //multidof? ("Y"s use it and it is used to store qdd)
348 m_scratch_v.resize(bod->getNumLinks() + 1);
349 m_scratch_m.resize(bod->getNumLinks() + 1);
350
352 {
353 if (!bod->isUsingRK4Integration())
354 {
356 {
357 bool isConstraintPass = true;
359 getSolverInfo().m_jointFeedbackInWorldSpace,
360 getSolverInfo().m_jointFeedbackInJointFrame);
361 }
362 }
363 }
364 }
365 }
366 }
367
368 for (int i = 0; i < this->m_multiBodies.size(); i++)
369 {
370 btMultiBody* bod = m_multiBodies[i];
372 }
373}
374
375void btDeformableMultiBodyDynamicsWorld::addSoftBody(btSoftBody* body, int collisionFilterGroup, int collisionFilterMask)
376{
378
379 // Set the soft body solver that will deal with this body
380 // to be the world's solver
382
384 collisionFilterGroup,
385 collisionFilterMask);
386}
387
389{
390 BT_PROFILE("predictUnconstraintMotion");
393}
394
396{
397 m_internalTime += timeStep;
402 dispatchInfo.m_timeStep = timeStep;
403 dispatchInfo.m_stepCount = 0;
406}
407
408
410{
411
413
414 for (int i = 0; i < getSoftBodyArray().size(); i++)
415 {
417 {
420 }
421 }
422
423
424}
425
427{
428 // Gravity is applied in stepSimulation and then cleared here and then applied here and then cleared here again
429 // so that 1) gravity is applied to velocity before constraint solve and 2) gravity is applied in each substep
430 // when there are multiple substeps
432 // integrate rigid body gravity
433 for (int i = 0; i < m_nonStaticRigidBodies.size(); ++i)
434 {
436 rb->integrateVelocities(timeStep);
437 }
438
439 // integrate multibody gravity
440 {
443 {
444 for (int i = 0; i < this->m_multiBodies.size(); i++)
445 {
446 btMultiBody* bod = m_multiBodies[i];
447
448 bool isSleeping = false;
449
451 {
452 isSleeping = true;
453 }
454 for (int b = 0; b < bod->getNumLinks(); b++)
455 {
457 isSleeping = true;
458 }
459
460 if (!isSleeping)
461 {
462 m_scratch_r.resize(bod->getNumLinks() + 1);
463 m_scratch_v.resize(bod->getNumLinks() + 1);
464 m_scratch_m.resize(bod->getNumLinks() + 1);
465 bool isConstraintPass = false;
466 {
467 if (!bod->isUsingRK4Integration())
468 {
470 m_scratch_r, m_scratch_v, m_scratch_m,isConstraintPass,
471 getSolverInfo().m_jointFeedbackInWorldSpace,
472 getSolverInfo().m_jointFeedbackInJointFrame);
473 }
474 else
475 {
476 btAssert(" RK4Integration is not supported" );
477 }
478 }
479 }
480 }
481 }
482 }
483 clearGravity();
484}
485
487{
488 BT_PROFILE("btMultiBody clearGravity");
489 // clear rigid body gravity
490 for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
491 {
493 if (body->isActive())
494 {
495 body->clearGravity();
496 }
497 }
498 // clear multibody gravity
499 for (int i = 0; i < this->m_multiBodies.size(); i++)
500 {
501 btMultiBody* bod = m_multiBodies[i];
502
503 bool isSleeping = false;
504
506 {
507 isSleeping = true;
508 }
509 for (int b = 0; b < bod->getNumLinks(); b++)
510 {
512 isSleeping = true;
513 }
514
515 if (!isSleeping)
516 {
517 bod->addBaseForce(-m_gravity * bod->getBaseMass());
518
519 for (int j = 0; j < bod->getNumLinks(); ++j)
520 {
521 bod->addLinkForce(j, -m_gravity * bod->getLinkMass(j));
522 }
523 }
524 }
525}
526
528{
529 if (0 != m_internalTickCallback)
530 {
531 (*m_internalTickCallback)(this, timeStep);
532 }
533
534 if (0 != m_solverCallback)
535 {
536 (*m_solverCallback)(m_internalTime, this);
537 }
538}
539
541{
542 if (0 != m_solverCallback)
543 {
544 (*m_solverCallback)(m_internalTime, this);
545 }
546}
547
549{
551 bool added = false;
552 for (int i = 0; i < forces.size(); ++i)
553 {
554 if (forces[i]->getForceType() == force->getForceType())
555 {
556 forces[i]->addSoftBody(psb);
557 added = true;
558 break;
559 }
560 }
561 if (!added)
562 {
563 force->addSoftBody(psb);
565 forces.push_back(force);
566 }
567}
568
570{
571 m_softBodies.remove(body);
573 // force a reinitialize so that node indices get updated.
575}
576
578{
579 btSoftBody* body = btSoftBody::upcast(collisionObject);
580 if (body)
581 removeSoftBody(body);
582 else
584}
585
586
587int btDeformableMultiBodyDynamicsWorld::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep)
588{
589 startProfiling(timeStep);
590
591 int numSimulationSubSteps = 0;
592
593 if (maxSubSteps)
594 {
595 //fixed timestep with interpolation
596 m_fixedTimeStep = fixedTimeStep;
597 m_localTime += timeStep;
598 if (m_localTime >= fixedTimeStep)
599 {
600 numSimulationSubSteps = int(m_localTime / fixedTimeStep);
601 m_localTime -= numSimulationSubSteps * fixedTimeStep;
602 }
603 }
604 else
605 {
606 //variable timestep
607 fixedTimeStep = timeStep;
609 m_fixedTimeStep = 0;
610 if (btFuzzyZero(timeStep))
611 {
612 numSimulationSubSteps = 0;
613 maxSubSteps = 0;
614 }
615 else
616 {
617 numSimulationSubSteps = 1;
618 maxSubSteps = 1;
619 }
620 }
621
622 //process some debugging flags
623 if (getDebugDrawer())
624 {
625 btIDebugDraw* debugDrawer = getDebugDrawer();
627 }
628 if (numSimulationSubSteps)
629 {
630 //clamp the number of substeps, to prevent simulation grinding spiralling down to a halt
631 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps;
632
633 saveKinematicState(fixedTimeStep * clampedSimulationSteps);
634
635 for (int i = 0; i < clampedSimulationSteps; i++)
636 {
637 internalSingleStepSimulation(fixedTimeStep);
639 }
640 }
641 else
642 {
644 }
645
646 clearForces();
647
648#ifndef BT_NO_PROFILE
649 CProfileManager::Increment_Frame_Counter();
650#endif //BT_NO_PROFILE
651
652 return numSimulationSubSteps;
653}
#define ACTIVE_TAG
#define DISABLE_DEACTIVATION
#define WANTS_DEACTIVATION
#define ISLAND_SLEEPING
btQuaternion inverse(const btQuaternion &q)
Return the inverse of a quaternion.
Definition: btQuaternion.h:909
#define BT_PROFILE(name)
Definition: btQuickprof.h:198
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
bool btFuzzyZero(btScalar x)
Definition: btScalar.h:572
#define btAssert(x)
Definition: btScalar.h:153
static btMatrix3x3 OuterProduct(const btScalar *v1, const btScalar *v2, const btScalar *v3, const btScalar *u1, const btScalar *u2, const btScalar *u3, int ndof)
static btVector3 generateUnitOrthogonalVector(const btVector3 &u)
static void findJacobian(const btMultiBodyLinkCollider *multibodyLinkCol, btMultiBodyJacobianData &jacobianData, const btVector3 &contact_point, const btVector3 &dir)
btSoftBody implementation by Nathanael Presson
static btMatrix3x3 Diagonal(btScalar x)
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
Definition: btVector3.h:918
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
int size() const
return the number of elements in the array
void resize(int newsize, const T &fillData=T())
void remove(const T &key)
void push_back(const T &_Val)
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
btCollisionObject can be used to manage collision detection objects.
btTransform & getWorldTransform()
int getInternalType() const
reserved for Bullet internal usage
void setActivationState(int newState) const
void setWorldTransform(const btTransform &worldTrans)
const btCollisionShape * getCollisionShape() const
int getActivationState() const
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btDispatcher * getDispatcher()
btDispatcherInfo & getDispatchInfo()
virtual btIDebugDraw * getDebugDrawer()
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
virtual void performDiscreteCollisionDetection()
btIDebugDraw * m_debugDrawer
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
btAlignedObjectArray< btDeformableLagrangianForce * > m_lf
const btAlignedObjectArray< btSoftBody::Node * > * getIndices() const
virtual void updateSoftBodies()
Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes.
virtual void solveDeformableConstraints(btScalar solverdt)
btDeformableBackwardEulerObjective * m_objective
void reinitialize(const btAlignedObjectArray< btSoftBody * > &softBodies, btScalar dt)
void setupDeformableSolve(bool implicit)
void setLineSearch(bool lineSearch)
virtual void predictMotion(btScalar solverdt)
Predict motion of soft bodies into next timestep.
virtual void setIndices(const btAlignedObjectArray< btSoftBody::Node * > *nodes)
virtual btDeformableLagrangianForceType getForceType()=0
virtual void addSoftBody(btSoftBody *psb)
btDeformableMultiBodyDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btDeformableMultiBodyConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration, btDeformableBodySolver *deformableBodySolver=0)
void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
virtual void addSoftBody(btSoftBody *body, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
virtual void predictUnconstraintMotion(btScalar timeStep)
void addForce(btSoftBody *psb, btDeformableLagrangianForce *force)
virtual void internalSingleStepSimulation(btScalar timeStep)
virtual int stepSimulation(btScalar timeStep, int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
DeformableBodyInplaceSolverIslandCallback * m_solverDeformableBodyIslandCallback
btDeformableBodySolver * m_deformableBodySolver
Solver classes that encapsulate multiple deformable bodies for solving.
void updateActions(btScalar timeStep)
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
virtual void saveKinematicState(btScalar timeStep)
btSimulationIslandManager * m_islandManager
btAlignedObjectArray< btTypedConstraint * > m_constraints
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
btConstraintSolver * m_constraintSolver
btCollisionWorld * getCollisionWorld()
void startProfiling(btScalar timeStep)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
btContactSolverInfo m_solverInfo
btContactSolverInfo & getSolverInfo()
btInternalTickCallback m_internalTickCallback
btInternalTickCallback m_internalPreTickCallback
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
Definition: btIDebugDraw.h:27
virtual int getDebugMode() const =0
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1033
The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet This implementation is s...
btAlignedObjectArray< btMultiBodyConstraint * > m_multiBodyConstraints
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
virtual void updateActivationState(btScalar timeStep)
btAlignedObjectArray< btMatrix3x3 > m_scratch_m
btAlignedObjectArray< btVector3 > m_scratch_v
virtual void predictUnconstraintMotion(btScalar timeStep)
virtual void integrateTransforms(btScalar timeStep)
btAlignedObjectArray< btMultiBody * > m_multiBodies
btAlignedObjectArray< btScalar > m_scratch_r
btAlignedObjectArray< btMultiBodyConstraint * > m_sortedMultiBodyConstraints
virtual void applyGravity()
apply gravity, call this once per timestep
static btMultiBodyLinkCollider * upcast(btCollisionObject *colObj)
void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m, bool isConstraintPass, bool jointFeedbackInWorldSpace, bool jointFeedbackInJointFrame)
int getNumLinks() const
Definition: btMultiBody.h:166
const btMultibodyLink & getLink(int index) const
Definition: btMultiBody.h:114
btScalar getLinkMass(int i) const
int getNumDofs() const
Definition: btMultiBody.h:167
void addLinkForce(int i, const btVector3 &f)
void processDeltaVeeMultiDof2()
Definition: btMultiBody.h:407
bool isUsingRK4Integration() const
Definition: btMultiBody.h:584
const btMultiBodyLinkCollider * getBaseCollider() const
Definition: btMultiBody.h:128
bool internalNeedsJointFeedback() const
Definition: btMultiBody.h:598
btScalar getBaseMass() const
Definition: btMultiBody.h:169
void addBaseForce(const btVector3 &f)
Definition: btMultiBody.h:327
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:60
void integrateVelocities(btScalar step)
btVector3 getPushVelocity()
Definition: btRigidBody.h:350
void setTurnVelocity(const btVector3 &v)
Definition: btRigidBody.h:365
btVector3 getTurnVelocity()
Definition: btRigidBody.h:355
void clearGravity()
void setPushVelocity(const btVector3 &v)
Definition: btRigidBody.h:360
void processIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
void buildIslands(btDispatcher *dispatcher, btCollisionWorld *colWorld)
btMultiBodyJacobianData jacobianData_t1
Definition: btSoftBody.h:348
btMultiBodyJacobianData jacobianData_normal
Definition: btSoftBody.h:347
btMultiBodyJacobianData jacobianData_t2
Definition: btSoftBody.h:349
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition: btSoftBody.h:73
void interpolateRenderMesh()
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
void setZeroVelocity()
btSoftBodyWorldInfo * m_worldInfo
Definition: btSoftBody.h:775
void setSoftBodySolver(btSoftBodySolver *softBodySolver)
Definition: btSoftBody.h:1067
bool wantsSleeping()
void updateDeactivation(btScalar timeStep)
btAlignedObjectArray< DeformableNodeRigidAnchor > m_deformableAnchors
Definition: btSoftBody.h:786
btSoftBodyWorldInfo * getWorldInfo()
Definition: btSoftBody.h:837
tNodeArray m_nodes
Definition: btSoftBody.h:777
static const btSoftBody * upcast(const btCollisionObject *colObj)
Definition: btSoftBody.h:1092
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
btVector3 invXform(const btVector3 &inVec) const
Definition: btTransform.h:215
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:108
TypedConstraint is the baseclass for Bullet constraints and vehicles.
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
void setZero()
Definition: btVector3.h:671
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
virtual void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btMultiBodyConstraint **sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw *debugDrawer)
btScalar m_timeStep
Definition: btDispatcher.h:53
class btIDebugDraw * m_debugDraw
Definition: btDispatcher.h:58
btAlignedObjectArray< btScalar > m_deltaVelocitiesUnitImpulse
btAlignedObjectArray< btScalar > m_jacobians
static void Draw(btSoftBody *psb, btIDebugDraw *idraw, int drawflags=fDrawFlags::Std)
static void DrawFrame(btSoftBody *psb, btIDebugDraw *idraw)
btScalar air_density
Definition: btSoftBody.h:47
btDispatcher * m_dispatcher
Definition: btSoftBody.h:53
btScalar water_density
Definition: btSoftBody.h:48
btSparseSdf< 3 > m_sparsesdf
Definition: btSoftBody.h:55
btVector3 m_gravity
Definition: btSoftBody.h:54
btVector3 water_normal
Definition: btSoftBody.h:51
btScalar m_maxDisplacement
Definition: btSoftBody.h:50
btScalar water_offset
Definition: btSoftBody.h:49
btBroadphaseInterface * m_broadphase
Definition: btSoftBody.h:52
btVector3 m_x
Definition: btSoftBody.h:257
btVector3 m_vsplit
Definition: btSoftBody.h:260
btVector3 m_vn
Definition: btSoftBody.h:261
btVector3 m_v
Definition: btSoftBody.h:259
btVector3 m_q
Definition: btSoftBody.h:258
const btCollisionObject * m_colObj
Definition: btSoftBody.h:220
btVector3 m_normal
Definition: btSoftBody.h:221