Blender  V3.3
btRigidBody.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
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 
16 #include "btRigidBody.h"
18 #include "LinearMath/btMinMax.h"
23 
24 //'temporarily' global variables
26 bool gDisableDeactivation = false;
27 static int uniqueId = 0;
28 
30 {
31  setupRigidBody(constructionInfo);
32 }
33 
34 btRigidBody::btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia)
35 {
36  btRigidBodyConstructionInfo cinfo(mass, motionState, collisionShape, localInertia);
37  setupRigidBody(cinfo);
38 }
39 
41 {
43 
44  m_linearVelocity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
45  m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
46  m_angularFactor.setValue(1, 1, 1);
47  m_linearFactor.setValue(1, 1, 1);
48  m_gravity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
49  m_gravity_acceleration.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
50  m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
51  m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
52  setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
53 
54  m_linearSleepingThreshold = constructionInfo.m_linearSleepingThreshold;
55  m_angularSleepingThreshold = constructionInfo.m_angularSleepingThreshold;
56  m_optionalMotionState = constructionInfo.m_motionState;
59  m_additionalDamping = constructionInfo.m_additionalDamping;
60  m_additionalDampingFactor = constructionInfo.m_additionalDampingFactor;
61  m_additionalLinearDampingThresholdSqr = constructionInfo.m_additionalLinearDampingThresholdSqr;
62  m_additionalAngularDampingThresholdSqr = constructionInfo.m_additionalAngularDampingThresholdSqr;
63  m_additionalAngularDampingFactor = constructionInfo.m_additionalAngularDampingFactor;
64 
65  if (m_optionalMotionState)
66  {
67  m_optionalMotionState->getWorldTransform(m_worldTransform);
68  }
69  else
70  {
71  m_worldTransform = constructionInfo.m_startWorldTransform;
72  }
73 
75  m_interpolationLinearVelocity.setValue(0, 0, 0);
76  m_interpolationAngularVelocity.setValue(0, 0, 0);
77 
78  //moved to btCollisionObject
79  m_friction = constructionInfo.m_friction;
80  m_rollingFriction = constructionInfo.m_rollingFriction;
81  m_spinningFriction = constructionInfo.m_spinningFriction;
82 
83  m_restitution = constructionInfo.m_restitution;
84 
85  setCollisionShape(constructionInfo.m_collisionShape);
86  m_debugBodyId = uniqueId++;
87 
88  setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
90 
92 
93  m_deltaLinearVelocity.setZero();
94  m_deltaAngularVelocity.setZero();
95  m_invMass = m_inverseMass * m_linearFactor;
96  m_pushVelocity.setZero();
97  m_turnVelocity.setZero();
98 }
99 
101 {
102  btTransformUtil::integrateTransform(m_worldTransform, m_linearVelocity, m_angularVelocity, timeStep, predictedTransform);
103 }
104 
106 {
107  //todo: clamp to some (user definable) safe minimum timestep, to limit maximum angular/linear velocities
108  if (timeStep != btScalar(0.))
109  {
110  //if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform
111  if (getMotionState())
113  btVector3 linVel, angVel;
114 
115  btTransformUtil::calculateVelocity(m_interpolationWorldTransform, m_worldTransform, timeStep, m_linearVelocity, m_angularVelocity);
116  m_interpolationLinearVelocity = m_linearVelocity;
117  m_interpolationAngularVelocity = m_angularVelocity;
119  //printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ());
120  }
121 }
122 
123 void btRigidBody::getAabb(btVector3& aabbMin, btVector3& aabbMax) const
124 {
125  getCollisionShape()->getAabb(m_worldTransform, aabbMin, aabbMax);
126 }
127 
128 void btRigidBody::setGravity(const btVector3& acceleration)
129 {
130  if (m_inverseMass != btScalar(0.0))
131  {
132  m_gravity = acceleration * (btScalar(1.0) / m_inverseMass);
133  }
134  m_gravity_acceleration = acceleration;
135 }
136 
137 void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping)
138 {
139 #ifdef BT_USE_OLD_DAMPING_METHOD
140  m_linearDamping = btMax(lin_damping, btScalar(0.0));
141  m_angularDamping = btMax(ang_damping, btScalar(0.0));
142 #else
143  m_linearDamping = btClamped(lin_damping, btScalar(0.0), btScalar(1.0));
144  m_angularDamping = btClamped(ang_damping, btScalar(0.0), btScalar(1.0));
145 #endif
146 }
147 
150 {
151  //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
152  //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
153 
154 #ifdef BT_USE_OLD_DAMPING_METHOD
155  m_linearVelocity *= btMax((btScalar(1.0) - timeStep * m_linearDamping), btScalar(0.0));
156  m_angularVelocity *= btMax((btScalar(1.0) - timeStep * m_angularDamping), btScalar(0.0));
157 #else
158  m_linearVelocity *= btPow(btScalar(1) - m_linearDamping, timeStep);
159  m_angularVelocity *= btPow(btScalar(1) - m_angularDamping, timeStep);
160 #endif
161 
162  if (m_additionalDamping)
163  {
164  //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
165  //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
166  if ((m_angularVelocity.length2() < m_additionalAngularDampingThresholdSqr) &&
167  (m_linearVelocity.length2() < m_additionalLinearDampingThresholdSqr))
168  {
169  m_angularVelocity *= m_additionalDampingFactor;
170  m_linearVelocity *= m_additionalDampingFactor;
171  }
172 
173  btScalar speed = m_linearVelocity.length();
174  if (speed < m_linearDamping)
175  {
176  btScalar dampVel = btScalar(0.005);
177  if (speed > dampVel)
178  {
179  btVector3 dir = m_linearVelocity.normalized();
180  m_linearVelocity -= dir * dampVel;
181  }
182  else
183  {
184  m_linearVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
185  }
186  }
187 
188  btScalar angSpeed = m_angularVelocity.length();
189  if (angSpeed < m_angularDamping)
190  {
191  btScalar angDampVel = btScalar(0.005);
192  if (angSpeed > angDampVel)
193  {
194  btVector3 dir = m_angularVelocity.normalized();
195  m_angularVelocity -= dir * angDampVel;
196  }
197  else
198  {
199  m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
200  }
201  }
202  }
203 }
204 
206 {
208  return;
209 
210  applyCentralForce(m_gravity);
211 }
212 
214 {
216  return;
217 
218  applyCentralForce(-m_gravity);
219 }
220 
222 {
223  setCenterOfMassTransform(newTrans);
224 }
225 
226 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
227 {
228  if (mass == btScalar(0.))
229  {
231  m_inverseMass = btScalar(0.);
232  }
233  else
234  {
236  m_inverseMass = btScalar(1.0) / mass;
237  }
238 
239  //Fg = m * a
240  m_gravity = mass * m_gravity_acceleration;
241 
242  m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
243  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
244  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
245 
246  m_invMass = m_linearFactor * m_inverseMass;
247 }
248 
250 {
251  m_invInertiaTensorWorld = m_worldTransform.getBasis().scaled(m_invInertiaLocal) * m_worldTransform.getBasis().transpose();
252 }
253 
255 {
256  btVector3 inertiaLocal;
257  const btVector3 inertia = m_invInertiaLocal;
258  inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
259  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
260  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
261  return inertiaLocal;
262 }
263 
264 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
265  const btMatrix3x3& I)
266 {
267  const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0);
268  return w2;
269 }
270 
271 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
272  const btMatrix3x3& I)
273 {
274  btMatrix3x3 w1x, Iw1x;
275  const btVector3 Iwi = (I * w1);
276  w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
277  Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
278 
279  const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt;
280  return dfw1;
281 }
282 
284 {
285  btVector3 inertiaLocal = getLocalInertia();
286  btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
287  btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
288  btVector3 gf = getAngularVelocity().cross(tmp);
289  btScalar l2 = gf.length2();
290  if (l2 > maxGyroscopicForce * maxGyroscopicForce)
291  {
292  gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce;
293  }
294  return gf;
295 }
296 
298 {
299  btVector3 idl = getLocalInertia();
300  btVector3 omega1 = getAngularVelocity();
301  btQuaternion q = getWorldTransform().getRotation();
302 
303  // Convert to body coordinates
304  btVector3 omegab = quatRotate(q.inverse(), omega1);
305  btMatrix3x3 Ib;
306  Ib.setValue(idl.x(), 0, 0,
307  0, idl.y(), 0,
308  0, 0, idl.z());
309 
310  btVector3 ibo = Ib * omegab;
311 
312  // Residual vector
313  btVector3 f = step * omegab.cross(ibo);
314 
315  btMatrix3x3 skew0;
316  omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
317  btVector3 om = Ib * omegab;
318  btMatrix3x3 skew1;
319  om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]);
320 
321  // Jacobian
322  btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step;
323 
324  // btMatrix3x3 Jinv = J.inverse();
325  // btVector3 omega_div = Jinv*f;
326  btVector3 omega_div = J.solve33(f);
327 
328  // Single Newton-Raphson update
329  omegab = omegab - omega_div; //Solve33(J, f);
330  // Back to world coordinates
331  btVector3 omega2 = quatRotate(q, omegab);
332  btVector3 gf = omega2 - omega1;
333  return gf;
334 }
335 
337 {
338  // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
339  // calculate using implicit euler step so it's stable.
340 
341  const btVector3 inertiaLocal = getLocalInertia();
342  const btVector3 w0 = getAngularVelocity();
343 
344  btMatrix3x3 I;
345 
346  I = m_worldTransform.getBasis().scaled(inertiaLocal) *
347  m_worldTransform.getBasis().transpose();
348 
349  // use newtons method to find implicit solution for new angular velocity (w')
350  // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
351  // df/dw' = I + 1xIw'*step + w'xI*step
352 
353  btVector3 w1 = w0;
354 
355  // one step of newton's method
356  {
357  const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
358  const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
359 
360  btVector3 dw;
361  dw = dfw.solve33(fw);
362  //const btMatrix3x3 dfw_inv = dfw.inverse();
363  //dw = dfw_inv*fw;
364 
365  w1 -= dw;
366  }
367 
368  btVector3 gf = (w1 - w0);
369  return gf;
370 }
371 
373 {
375  return;
376 
377  m_linearVelocity += m_totalForce * (m_inverseMass * step);
378  m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step;
379 
380 #define MAX_ANGVEL SIMD_HALF_PI
382  btScalar angvel = m_angularVelocity.length();
383  if (angvel * step > MAX_ANGVEL)
384  {
385  m_angularVelocity *= (MAX_ANGVEL / step) / angvel;
386  }
387  #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
388  clampVelocity(m_angularVelocity);
389  #endif
390 }
391 
393 {
394  btQuaternion orn;
395  m_worldTransform.getBasis().getRotation(orn);
396  return orn;
397 }
398 
400 {
401  if (isKinematicObject())
402  {
404  }
405  else
406  {
408  }
411  m_worldTransform = xform;
413 }
414 
416 {
418 
419  int index = m_constraintRefs.findLinearSearch(c);
420  //don't add constraints that are already referenced
421  //btAssert(index == m_constraintRefs.size());
422  if (index == m_constraintRefs.size())
423  {
424  m_constraintRefs.push_back(c);
425  btCollisionObject* colObjA = &c->getRigidBodyA();
426  btCollisionObject* colObjB = &c->getRigidBodyB();
427  if (colObjA == this)
428  {
429  colObjA->setIgnoreCollisionCheck(colObjB, true);
430  }
431  else
432  {
433  colObjB->setIgnoreCollisionCheck(colObjA, true);
434  }
435  }
436 }
437 
439 {
440  int index = m_constraintRefs.findLinearSearch(c);
441  //don't remove constraints that are not referenced
442  if (index < m_constraintRefs.size())
443  {
444  m_constraintRefs.remove(c);
445  btCollisionObject* colObjA = &c->getRigidBodyA();
446  btCollisionObject* colObjB = &c->getRigidBodyB();
447  if (colObjA == this)
448  {
449  colObjA->setIgnoreCollisionCheck(colObjB, false);
450  }
451  else
452  {
453  colObjB->setIgnoreCollisionCheck(colObjA, false);
454  }
455  }
456 }
457 
459 {
460  int sz = sizeof(btRigidBodyData);
461  return sz;
462 }
463 
465 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
466 {
467  btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer;
468 
469  btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
470 
471  m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
472  m_linearVelocity.serialize(rbd->m_linearVelocity);
473  m_angularVelocity.serialize(rbd->m_angularVelocity);
474  rbd->m_inverseMass = m_inverseMass;
475  m_angularFactor.serialize(rbd->m_angularFactor);
476  m_linearFactor.serialize(rbd->m_linearFactor);
477  m_gravity.serialize(rbd->m_gravity);
478  m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
479  m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
480  m_totalForce.serialize(rbd->m_totalForce);
481  m_totalTorque.serialize(rbd->m_totalTorque);
482  rbd->m_linearDamping = m_linearDamping;
483  rbd->m_angularDamping = m_angularDamping;
484  rbd->m_additionalDamping = m_additionalDamping;
485  rbd->m_additionalDampingFactor = m_additionalDampingFactor;
486  rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
487  rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
488  rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
489  rbd->m_linearSleepingThreshold = m_linearSleepingThreshold;
490  rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
491 
492  // Fill padding with zeros to appease msan.
493 #ifdef BT_USE_DOUBLE_PRECISION
494  memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
495 #endif
496 
497  return btRigidBodyDataName;
498 }
499 
501 {
502  btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1);
503  const char* structType = serialize(chunk->m_oldPtr, serializer);
504  serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this);
505 }
btVector3 m_interpolationAngularVelocity
SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
btCollisionObject
@ CF_STATIC_OBJECT
btTransform m_interpolationWorldTransform
btScalar m_restitution
@ CO_RIGID_BODY
btScalar m_rollingFriction
btScalar m_friction
btScalar m_spinningFriction
virtual ~btCollisionObject()
int m_collisionFlags
SIMD_FORCE_INLINE bool isKinematicObject() const
virtual void setCollisionShape(btCollisionShape *collisionShape)
btVector3 m_interpolationLinearVelocity
btTransform & getWorldTransform()
int m_internalType
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btScalar m_angularDamping
btScalar m_linearDamping
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:50
SIMD_FORCE_INLINE const T & btMax(const T &a, const T &b)
Definition: btMinMax.h:27
SIMD_FORCE_INLINE const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:33
virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
Data buffer MUST be 16 byte aligned.
SIMD_FORCE_INLINE btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:926
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
#define MAX_ANGVEL
btVector3 evalEulerEqn(const btVector3 &w1, const btVector3 &w0, const btVector3 &T, const btScalar dt, const btMatrix3x3 &I)
btScalar gDeactivationTime
Definition: btRigidBody.cpp:25
static int uniqueId
Definition: btRigidBody.cpp:27
btMatrix3x3 evalEulerEqnDeriv(const btVector3 &w1, const btVector3 &w0, const btScalar dt, const btMatrix3x3 &I)
#define btRigidBodyDataName
Definition: btRigidBody.h:36
#define btRigidBodyData
Definition: btRigidBody.h:35
@ BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
Definition: btRigidBody.h:47
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
SIMD_FORCE_INLINE btScalar btSqrt(btScalar y)
Definition: btScalar.h:466
SIMD_FORCE_INLINE btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:521
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:112
btTransform m_worldTransform
Definition: btSolverBody.h:107
btVector3 m_deltaLinearVelocity
Definition: btSolverBody.h:108
btVector3 m_angularVelocity
Definition: btSolverBody.h:116
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btTypedConstraint(btTypedConstraintType type, btRigidBody &rbA)
btVector3
btVector3 can be used to represent 3D points and vectors. It has an un-used w component to suit 16-by...
Definition: btVector3.h:82
int findLinearSearch(const T &key) const
SIMD_FORCE_INLINE int size() const
return the number of elements in the array
void remove(const T &key)
SIMD_FORCE_INLINE void push_back(const T &_Val)
void * m_oldPtr
Definition: btSerializer.h:52
virtual void getWorldTransform(btTransform &worldTrans) const =0
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:50
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:497
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
void applyGravity()
SIMD_FORCE_INLINE const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:242
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:437
void integrateVelocities(btScalar step)
void addConstraintRef(btTypedConstraint *c)
virtual void serializeSingleObject(class btSerializer *serializer) const
btMotionState * getMotionState()
Definition: btRigidBody.h:549
int m_frictionSolverType
Definition: btRigidBody.h:566
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
int m_contactSolverType
Definition: btRigidBody.h:565
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:274
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btVector3 m_turnVelocity
Definition: btRigidBody.h:101
virtual int calculateSerializeBufferSize() const
void setGravity(const btVector3 &acceleration)
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition: btRigidBody.cpp:29
btQuaternion getOrientation() const
void proceedToTransform(const btTransform &newTrans)
void saveKinematicState(btScalar step)
btVector3 getLocalInertia() const
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
btVector3 m_angularFactor
Definition: btRigidBody.h:98
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
void removeConstraintRef(btTypedConstraint *c)
void setMassProps(btScalar mass, const btVector3 &inertia)
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:97
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:433
btVector3 m_pushVelocity
Definition: btRigidBody.h:100
void clearGravity()
void setDamping(btScalar lin_damping, btScalar ang_damping)
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:40
void setCenterOfMassTransform(const btTransform &xform)
void updateInertiaTensor()
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
btVector3 m_invMass
Definition: btRigidBody.h:99
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
#define T
static unsigned c
Definition: RandGen.cpp:83
#define I
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:124
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:131