Bullet Collision Detection & Physics Library
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 
29 
31 {
32  setupRigidBody(constructionInfo);
33 }
34 
35 btRigidBody::btRigidBody(btScalar mass, btMotionState *motionState, btCollisionShape *collisionShape, const btVector3 &localInertia)
36 {
37  btRigidBodyConstructionInfo cinfo(mass,motionState,collisionShape,localInertia);
38  setupRigidBody(cinfo);
39 }
40 
42 {
43 
45 
49  m_linearFactor.setValue(1,1,1);
50  m_gravity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
54  setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
55 
58  m_optionalMotionState = constructionInfo.m_motionState;
61  m_additionalDamping = constructionInfo.m_additionalDamping;
66 
68  {
70  } else
71  {
72  m_worldTransform = constructionInfo.m_startWorldTransform;
73  }
74 
78 
79  //moved to btCollisionObject
80  m_friction = constructionInfo.m_friction;
81  m_rollingFriction = constructionInfo.m_rollingFriction;
82  m_spinningFriction = constructionInfo.m_spinningFriction;
83 
84  m_restitution = constructionInfo.m_restitution;
85 
86  setCollisionShape( constructionInfo.m_collisionShape );
88 
89  setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
91 
93 
94 
100 
101 
102 
103 }
104 
105 
107 {
109 }
110 
112 {
113  //todo: clamp to some (user definable) safe minimum timestep, to limit maximum angular/linear velocities
114  if (timeStep != btScalar(0.))
115  {
116  //if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform
117  if (getMotionState())
119  btVector3 linVel,angVel;
120 
125  //printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ());
126  }
127 }
128 
129 void btRigidBody::getAabb(btVector3& aabbMin,btVector3& aabbMax) const
130 {
131  getCollisionShape()->getAabb(m_worldTransform,aabbMin,aabbMax);
132 }
133 
134 
135 
136 
137 void btRigidBody::setGravity(const btVector3& acceleration)
138 {
139  if (m_inverseMass != btScalar(0.0))
140  {
141  m_gravity = acceleration * (btScalar(1.0) / m_inverseMass);
142  }
143  m_gravity_acceleration = acceleration;
144 }
145 
146 
147 
148 
149 
150 
151 void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping)
152 {
153  m_linearDamping = btClamped(lin_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
154  m_angularDamping = btClamped(ang_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
155 }
156 
157 
158 
159 
162 {
163  //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
164  //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
165 
166 //#define USE_OLD_DAMPING_METHOD 1
167 #ifdef USE_OLD_DAMPING_METHOD
168  m_linearVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_linearDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
169  m_angularVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_angularDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
170 #else
171  m_linearVelocity *= btPow(btScalar(1)-m_linearDamping, timeStep);
172  m_angularVelocity *= btPow(btScalar(1)-m_angularDamping, timeStep);
173 #endif
174 
176  {
177  //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
178  //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
181  {
184  }
185 
186 
187  btScalar speed = m_linearVelocity.length();
188  if (speed < m_linearDamping)
189  {
190  btScalar dampVel = btScalar(0.005);
191  if (speed > dampVel)
192  {
194  m_linearVelocity -= dir * dampVel;
195  } else
196  {
198  }
199  }
200 
201  btScalar angSpeed = m_angularVelocity.length();
202  if (angSpeed < m_angularDamping)
203  {
204  btScalar angDampVel = btScalar(0.005);
205  if (angSpeed > angDampVel)
206  {
208  m_angularVelocity -= dir * angDampVel;
209  } else
210  {
212  }
213  }
214  }
215 }
216 
217 
219 {
221  return;
222 
224 
225 }
226 
228 {
229  setCenterOfMassTransform( newTrans );
230 }
231 
232 
233 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
234 {
235  if (mass == btScalar(0.))
236  {
238  m_inverseMass = btScalar(0.);
239  } else
240  {
242  m_inverseMass = btScalar(1.0) / mass;
243  }
244 
245  //Fg = m * a
247 
248  m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x(): btScalar(0.0),
249  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y(): btScalar(0.0),
250  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z(): btScalar(0.0));
251 
253 }
254 
255 
257 {
259 }
260 
261 
262 
264 {
265 
266  btVector3 inertiaLocal;
267  const btVector3 inertia = m_invInertiaLocal;
268  inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
269  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
270  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
271  return inertiaLocal;
272 }
273 
274 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
275  const btMatrix3x3 &I)
276 {
277  const btVector3 w2 = I*w1 + w1.cross(I*w1)*dt - (T*dt + I*w0);
278  return w2;
279 }
280 
281 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
282  const btMatrix3x3 &I)
283 {
284 
285  btMatrix3x3 w1x, Iw1x;
286  const btVector3 Iwi = (I*w1);
287  w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
288  Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
289 
290  const btMatrix3x3 dfw1 = I + (w1x*I - Iw1x)*dt;
291  return dfw1;
292 }
293 
295 {
296  btVector3 inertiaLocal = getLocalInertia();
297  btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
298  btVector3 tmp = inertiaTensorWorld*getAngularVelocity();
299  btVector3 gf = getAngularVelocity().cross(tmp);
300  btScalar l2 = gf.length2();
301  if (l2>maxGyroscopicForce*maxGyroscopicForce)
302  {
303  gf *= btScalar(1.)/btSqrt(l2)*maxGyroscopicForce;
304  }
305  return gf;
306 }
307 
308 
310 {
311  btVector3 idl = getLocalInertia();
312  btVector3 omega1 = getAngularVelocity();
314 
315  // Convert to body coordinates
316  btVector3 omegab = quatRotate(q.inverse(), omega1);
317  btMatrix3x3 Ib;
318  Ib.setValue(idl.x(),0,0,
319  0,idl.y(),0,
320  0,0,idl.z());
321 
322  btVector3 ibo = Ib*omegab;
323 
324  // Residual vector
325  btVector3 f = step * omegab.cross(ibo);
326 
327  btMatrix3x3 skew0;
328  omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
329  btVector3 om = Ib*omegab;
330  btMatrix3x3 skew1;
331  om.getSkewSymmetricMatrix(&skew1[0],&skew1[1],&skew1[2]);
332 
333  // Jacobian
334  btMatrix3x3 J = Ib + (skew0*Ib - skew1)*step;
335 
336 // btMatrix3x3 Jinv = J.inverse();
337 // btVector3 omega_div = Jinv*f;
338  btVector3 omega_div = J.solve33(f);
339 
340  // Single Newton-Raphson update
341  omegab = omegab - omega_div;//Solve33(J, f);
342  // Back to world coordinates
343  btVector3 omega2 = quatRotate(q,omegab);
344  btVector3 gf = omega2-omega1;
345  return gf;
346 }
347 
348 
349 
351 {
352  // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
353  // calculate using implicit euler step so it's stable.
354 
355  const btVector3 inertiaLocal = getLocalInertia();
356  const btVector3 w0 = getAngularVelocity();
357 
358  btMatrix3x3 I;
359 
360  I = m_worldTransform.getBasis().scaled(inertiaLocal) *
362 
363  // use newtons method to find implicit solution for new angular velocity (w')
364  // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
365  // df/dw' = I + 1xIw'*step + w'xI*step
366 
367  btVector3 w1 = w0;
368 
369  // one step of newton's method
370  {
371  const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
372  const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
373 
374  btVector3 dw;
375  dw = dfw.solve33(fw);
376  //const btMatrix3x3 dfw_inv = dfw.inverse();
377  //dw = dfw_inv*fw;
378 
379  w1 -= dw;
380  }
381 
382  btVector3 gf = (w1 - w0);
383  return gf;
384 }
385 
386 
388 {
390  return;
391 
394 
395 #define MAX_ANGVEL SIMD_HALF_PI
396  btScalar angvel = m_angularVelocity.length();
398  if (angvel*step > MAX_ANGVEL)
399  {
400  m_angularVelocity *= (MAX_ANGVEL/step) /angvel;
401  }
402 
403 }
404 
406 {
407  btQuaternion orn;
409  return orn;
410 }
411 
412 
414 {
415 
416  if (isKinematicObject())
417  {
419  } else
420  {
422  }
425  m_worldTransform = xform;
427 }
428 
429 
430 
431 
432 
434 {
436 
437  int index = m_constraintRefs.findLinearSearch(c);
438  //don't add constraints that are already referenced
439  //btAssert(index == m_constraintRefs.size());
440  if (index == m_constraintRefs.size())
441  {
443  btCollisionObject* colObjA = &c->getRigidBodyA();
444  btCollisionObject* colObjB = &c->getRigidBodyB();
445  if (colObjA == this)
446  {
447  colObjA->setIgnoreCollisionCheck(colObjB, true);
448  }
449  else
450  {
451  colObjB->setIgnoreCollisionCheck(colObjA, true);
452  }
453  }
454 }
455 
457 {
458  int index = m_constraintRefs.findLinearSearch(c);
459  //don't remove constraints that are not referenced
460  if(index < m_constraintRefs.size())
461  {
463  btCollisionObject* colObjA = &c->getRigidBodyA();
464  btCollisionObject* colObjB = &c->getRigidBodyB();
465  if (colObjA == this)
466  {
467  colObjA->setIgnoreCollisionCheck(colObjB, false);
468  }
469  else
470  {
471  colObjB->setIgnoreCollisionCheck(colObjA, false);
472  }
473  }
474 }
475 
477 {
478  int sz = sizeof(btRigidBodyData);
479  return sz;
480 }
481 
483 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
484 {
485  btRigidBodyData* rbd = (btRigidBodyData*) dataBuffer;
486 
487  btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
488 
489  m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
490  m_linearVelocity.serialize(rbd->m_linearVelocity);
491  m_angularVelocity.serialize(rbd->m_angularVelocity);
492  rbd->m_inverseMass = m_inverseMass;
493  m_angularFactor.serialize(rbd->m_angularFactor);
494  m_linearFactor.serialize(rbd->m_linearFactor);
495  m_gravity.serialize(rbd->m_gravity);
496  m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
497  m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
498  m_totalForce.serialize(rbd->m_totalForce);
499  m_totalTorque.serialize(rbd->m_totalTorque);
500  rbd->m_linearDamping = m_linearDamping;
501  rbd->m_angularDamping = m_angularDamping;
502  rbd->m_additionalDamping = m_additionalDamping;
503  rbd->m_additionalDampingFactor = m_additionalDampingFactor;
504  rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
505  rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
506  rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
507  rbd->m_linearSleepingThreshold=m_linearSleepingThreshold;
508  rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
509 
510  // Fill padding with zeros to appease msan.
511 #ifdef BT_USE_DOUBLE_PRECISION
512  memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
513 #endif
514 
515  return btRigidBodyDataName;
516 }
517 
518 
519 
521 {
522  btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(),1);
523  const char* structType = serialize(chunk->m_oldPtr, serializer);
524  serializer->finalizeChunk(chunk,structType,BT_RIGIDBODY_CODE,(void*)this);
525 }
526 
527 
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:254
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
void push_back(const T &_Val)
void applyGravity()
btVector3 m_totalTorque
Definition: btRigidBody.h:75
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1388
int m_contactSolverType
Definition: btRigidBody.h:490
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:652
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
void updateInertiaTensor()
btVector3 m_totalForce
Definition: btRigidBody.h:74
btScalar m_angularDamping
Definition: btRigidBody.h:78
btVector3 evalEulerEqn(const btVector3 &w1, const btVector3 &w0, const btVector3 &T, const btScalar dt, const btMatrix3x3 &I)
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
btVector3 m_turnVelocity
Definition: btRigidBody.h:108
btScalar btSqrt(btScalar y)
Definition: btScalar.h:444
btVector3 m_gravity
Definition: btRigidBody.h:71
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
btScalar gDeactivationTime
Definition: btRigidBody.cpp:25
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition: btRigidBody.cpp:30
void setDamping(btScalar lin_damping, btScalar ang_damping)
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:88
bool m_additionalDamping
Definition: btRigidBody.h:80
#define btRigidBodyData
Definition: btRigidBody.h:36
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:82
int m_rigidbodyFlags
Definition: btRigidBody.h:96
btTransform m_worldTransform
btScalar m_rollingFriction
the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling f...
Definition: btRigidBody.h:137
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t...
btVector3 m_pushVelocity
Definition: btRigidBody.h:107
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
const btScalar & x() const
Return the x value.
Definition: btVector3.h:587
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:937
btScalar m_inverseMass
Definition: btRigidBody.h:68
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:282
virtual void setCollisionShape(btCollisionShape *collisionShape)
void integrateVelocities(btScalar step)
virtual int calculateSerializeBufferSize() const
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:73
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:400
btTransform & getWorldTransform()
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:103
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
int size() const
return the number of elements in the array
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:41
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:590
bool isKinematicObject() const
void addConstraintRef(btTypedConstraint *c)
btQuaternion getOrientation() const
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:365
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
Definition: btVector3.h:389
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:91
bool isStaticOrKinematicObject() const
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1352
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:141
btCollisionObject can be used to manage collision detection objects.
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:87
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
virtual void serializeSingleObject(class btSerializer *serializer) const
void setValue(const btScalar &xx, const btScalar &xy, const btScalar &xz, const btScalar &yx, const btScalar &yy, const btScalar &yz, const btScalar &zx, const btScalar &zy, const btScalar &zz)
Set the values of the matrix explicitly (row major)
Definition: btMatrix3x3.h:198
void setZero()
Definition: btVector3.h:683
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:500
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition: btMatrix3x3.h:616
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:263
btVector3 m_angularFactor
Definition: btRigidBody.h:105
btMatrix3x3 evalEulerEqnDeriv(const btVector3 &w1, const btVector3 &w0, const btScalar dt, const btMatrix3x3 &I)
The btRigidBodyConstructionInfo structure provides information to create a rigid body.
Definition: btRigidBody.h:119
btVector3 m_angularVelocity
Definition: btRigidBody.h:67
void proceedToTransform(const btTransform &newTrans)
#define btRigidBodyDataName
Definition: btRigidBody.h:37
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:81
btScalar m_linearDamping
Definition: btRigidBody.h:77
const btScalar & y() const
Return the y value.
Definition: btVector3.h:589
btVector3 m_linearFactor
Definition: btRigidBody.h:69
btVector3 m_linearVelocity
Definition: btRigidBody.h:66
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btVector3 getLocalInertia() const
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:499
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:257
int m_debugBodyId
Definition: btRigidBody.h:98
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
void setCenterOfMassTransform(const btTransform &xform)
void setMassProps(btScalar mass, const btVector3 &inertia)
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping ...
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:966
void remove(const T &key)
TypedConstraint is the baseclass for Bullet constraints and vehicles.
The btMotionState interface class allows the dynamics world to synchronize and interpolate the update...
Definition: btMotionState.h:23
void saveKinematicState(btScalar step)
btVector3 m_interpolationAngularVelocity
int findLinearSearch(const T &key) const
const btRigidBody & getRigidBodyA() const
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1030
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:122
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:83
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
btMotionState * getMotionState()
Definition: btRigidBody.h:474
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:362
btVector3 m_gravity_acceleration
Definition: btRigidBody.h:72
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:84
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:55
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:94
btVector3 m_interpolationLinearVelocity
int m_frictionSolverType
Definition: btRigidBody.h:491
void removeConstraintRef(btTypedConstraint *c)
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:104
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
void * m_oldPtr
Definition: btSerializer.h:56
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:35
const btRigidBody & getRigidBodyB() const
btMotionState * m_motionState
When a motionState is provided, the rigid body will initialize its world transform from the motion st...
Definition: btRigidBody.h:125
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:134
virtual btChunk * allocate(size_t size, int numElements)=0
#define MAX_ANGVEL
btVector3 m_invMass
Definition: btRigidBody.h:106
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
Definition: btVector3.h:660
virtual void getWorldTransform(btTransform &worldTrans) const =0
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
static int uniqueId
Definition: btRigidBody.cpp:27
const btScalar & z() const
Return the z value.
Definition: btVector3.h:591
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:65
void setGravity(const btVector3 &acceleration)