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_restitution = constructionInfo.m_restitution;
83 
84  setCollisionShape( constructionInfo.m_collisionShape );
86 
87  setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
89 
91 
92 
98 
99 
100 
101 }
102 
103 
105 {
107 }
108 
110 {
111  //todo: clamp to some (user definable) safe minimum timestep, to limit maximum angular/linear velocities
112  if (timeStep != btScalar(0.))
113  {
114  //if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform
115  if (getMotionState())
117  btVector3 linVel,angVel;
118 
123  //printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ());
124  }
125 }
126 
127 void btRigidBody::getAabb(btVector3& aabbMin,btVector3& aabbMax) const
128 {
129  getCollisionShape()->getAabb(m_worldTransform,aabbMin,aabbMax);
130 }
131 
132 
133 
134 
135 void btRigidBody::setGravity(const btVector3& acceleration)
136 {
137  if (m_inverseMass != btScalar(0.0))
138  {
139  m_gravity = acceleration * (btScalar(1.0) / m_inverseMass);
140  }
141  m_gravity_acceleration = acceleration;
142 }
143 
144 
145 
146 
147 
148 
149 void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping)
150 {
151  m_linearDamping = btClamped(lin_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
152  m_angularDamping = btClamped(ang_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
153 }
154 
155 
156 
157 
160 {
161  //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
162  //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
163 
164 //#define USE_OLD_DAMPING_METHOD 1
165 #ifdef USE_OLD_DAMPING_METHOD
166  m_linearVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_linearDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
167  m_angularVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_angularDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
168 #else
169  m_linearVelocity *= btPow(btScalar(1)-m_linearDamping, timeStep);
170  m_angularVelocity *= btPow(btScalar(1)-m_angularDamping, timeStep);
171 #endif
172 
174  {
175  //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
176  //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
179  {
182  }
183 
184 
185  btScalar speed = m_linearVelocity.length();
186  if (speed < m_linearDamping)
187  {
188  btScalar dampVel = btScalar(0.005);
189  if (speed > dampVel)
190  {
192  m_linearVelocity -= dir * dampVel;
193  } else
194  {
196  }
197  }
198 
199  btScalar angSpeed = m_angularVelocity.length();
200  if (angSpeed < m_angularDamping)
201  {
202  btScalar angDampVel = btScalar(0.005);
203  if (angSpeed > angDampVel)
204  {
206  m_angularVelocity -= dir * angDampVel;
207  } else
208  {
210  }
211  }
212  }
213 }
214 
215 
217 {
219  return;
220 
222 
223 }
224 
226 {
227  setCenterOfMassTransform( newTrans );
228 }
229 
230 
231 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
232 {
233  if (mass == btScalar(0.))
234  {
236  m_inverseMass = btScalar(0.);
237  } else
238  {
240  m_inverseMass = btScalar(1.0) / mass;
241  }
242 
243  //Fg = m * a
245 
246  m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x(): btScalar(0.0),
247  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y(): btScalar(0.0),
248  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z(): btScalar(0.0));
249 
251 }
252 
253 
255 {
257 }
258 
259 
260 
262 {
263 
264  btVector3 inertiaLocal;
265  const btVector3 inertia = m_invInertiaLocal;
266  inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
267  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
268  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
269  return inertiaLocal;
270 }
271 
272 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
273  const btMatrix3x3 &I)
274 {
275  const btVector3 w2 = I*w1 + w1.cross(I*w1)*dt - (T*dt + I*w0);
276  return w2;
277 }
278 
279 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
280  const btMatrix3x3 &I)
281 {
282 
283  btMatrix3x3 w1x, Iw1x;
284  const btVector3 Iwi = (I*w1);
285  w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
286  Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
287 
288  const btMatrix3x3 dfw1 = I + (w1x*I - Iw1x)*dt;
289  return dfw1;
290 }
291 
293 {
294  btVector3 inertiaLocal = getLocalInertia();
295  btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
296  btVector3 tmp = inertiaTensorWorld*getAngularVelocity();
297  btVector3 gf = getAngularVelocity().cross(tmp);
298  btScalar l2 = gf.length2();
299  if (l2>maxGyroscopicForce*maxGyroscopicForce)
300  {
301  gf *= btScalar(1.)/btSqrt(l2)*maxGyroscopicForce;
302  }
303  return gf;
304 }
305 
307 {
308  const btScalar a_0 = a[0], a_1 = a[1], a_2 = a[2];
309  res.setValue(0, +a_2, -a_1,
310  -a_2, 0, +a_0,
311  +a_1, -a_0, 0);
312 }
313 
315 {
316  btVector3 idl = getLocalInertia();
317  btVector3 omega1 = getAngularVelocity();
319 
320  // Convert to body coordinates
321  btVector3 omegab = quatRotate(q.inverse(), omega1);
322  btMatrix3x3 Ib;
323  Ib.setValue(idl.x(),0,0,
324  0,idl.y(),0,
325  0,0,idl.z());
326 
327  btVector3 ibo = Ib*omegab;
328 
329  // Residual vector
330  btVector3 f = step * omegab.cross(ibo);
331 
332  btMatrix3x3 skew0;
333  omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
334  btVector3 om = Ib*omegab;
335  btMatrix3x3 skew1;
336  om.getSkewSymmetricMatrix(&skew1[0],&skew1[1],&skew1[2]);
337 
338  // Jacobian
339  btMatrix3x3 J = Ib + (skew0*Ib - skew1)*step;
340 
341 // btMatrix3x3 Jinv = J.inverse();
342 // btVector3 omega_div = Jinv*f;
343  btVector3 omega_div = J.solve33(f);
344 
345  // Single Newton-Raphson update
346  omegab = omegab - omega_div;//Solve33(J, f);
347  // Back to world coordinates
348  btVector3 omega2 = quatRotate(q,omegab);
349  btVector3 gf = omega2-omega1;
350  return gf;
351 }
352 
353 
354 
356 {
357  // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
358  // calculate using implicit euler step so it's stable.
359 
360  const btVector3 inertiaLocal = getLocalInertia();
361  const btVector3 w0 = getAngularVelocity();
362 
363  btMatrix3x3 I;
364 
365  I = m_worldTransform.getBasis().scaled(inertiaLocal) *
367 
368  // use newtons method to find implicit solution for new angular velocity (w')
369  // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
370  // df/dw' = I + 1xIw'*step + w'xI*step
371 
372  btVector3 w1 = w0;
373 
374  // one step of newton's method
375  {
376  const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
377  const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
378 
379  btVector3 dw;
380  dw = dfw.solve33(fw);
381  //const btMatrix3x3 dfw_inv = dfw.inverse();
382  //dw = dfw_inv*fw;
383 
384  w1 -= dw;
385  }
386 
387  btVector3 gf = (w1 - w0);
388  return gf;
389 }
390 
391 
393 {
395  return;
396 
399 
400 #define MAX_ANGVEL SIMD_HALF_PI
401  btScalar angvel = m_angularVelocity.length();
403  if (angvel*step > MAX_ANGVEL)
404  {
405  m_angularVelocity *= (MAX_ANGVEL/step) /angvel;
406  }
407 
408 }
409 
411 {
412  btQuaternion orn;
414  return orn;
415 }
416 
417 
419 {
420 
421  if (isKinematicObject())
422  {
424  } else
425  {
427  }
430  m_worldTransform = xform;
432 }
433 
434 
435 
436 
437 
439 {
441 
442  int index = m_constraintRefs.findLinearSearch(c);
443  //don't add constraints that are already referenced
444  //btAssert(index == m_constraintRefs.size());
445  if (index == m_constraintRefs.size())
446  {
448  btCollisionObject* colObjA = &c->getRigidBodyA();
449  btCollisionObject* colObjB = &c->getRigidBodyB();
450  if (colObjA == this)
451  {
452  colObjA->setIgnoreCollisionCheck(colObjB, true);
453  }
454  else
455  {
456  colObjB->setIgnoreCollisionCheck(colObjA, true);
457  }
458  }
459 }
460 
462 {
463  int index = m_constraintRefs.findLinearSearch(c);
464  //don't remove constraints that are not referenced
465  if(index < m_constraintRefs.size())
466  {
468  btCollisionObject* colObjA = &c->getRigidBodyA();
469  btCollisionObject* colObjB = &c->getRigidBodyB();
470  if (colObjA == this)
471  {
472  colObjA->setIgnoreCollisionCheck(colObjB, false);
473  }
474  else
475  {
476  colObjB->setIgnoreCollisionCheck(colObjA, false);
477  }
478  }
479 }
480 
482 {
483  int sz = sizeof(btRigidBodyData);
484  return sz;
485 }
486 
488 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
489 {
490  btRigidBodyData* rbd = (btRigidBodyData*) dataBuffer;
491 
492  btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
493 
494  m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
495  m_linearVelocity.serialize(rbd->m_linearVelocity);
496  m_angularVelocity.serialize(rbd->m_angularVelocity);
497  rbd->m_inverseMass = m_inverseMass;
498  m_angularFactor.serialize(rbd->m_angularFactor);
499  m_linearFactor.serialize(rbd->m_linearFactor);
500  m_gravity.serialize(rbd->m_gravity);
501  m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
502  m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
503  m_totalForce.serialize(rbd->m_totalForce);
504  m_totalTorque.serialize(rbd->m_totalTorque);
505  rbd->m_linearDamping = m_linearDamping;
506  rbd->m_angularDamping = m_angularDamping;
507  rbd->m_additionalDamping = m_additionalDamping;
508  rbd->m_additionalDampingFactor = m_additionalDampingFactor;
509  rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
510  rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
511  rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
512  rbd->m_linearSleepingThreshold=m_linearSleepingThreshold;
513  rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
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 
void push_back(const T &_Val)
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1356
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:362
void applyGravity()
btVector3 m_totalTorque
Definition: btRigidBody.h:75
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
int m_contactSolverType
Definition: btRigidBody.h:487
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition: btMatrix3x3.h:616
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
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
int findLinearSearch(const T &key) const
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 (...
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:257
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
const btRigidBody & getRigidBodyA() const
virtual int calculateSerializeBufferSize() const
btVector3 m_turnVelocity
Definition: btRigidBody.h:108
btScalar btSqrt(btScalar y)
Definition: btScalar.h:418
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
btVector3 m_gravity
Definition: btRigidBody.h:71
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
bool isKinematicObject() const
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
btQuaternion getOrientation() const
bool m_additionalDamping
Definition: btRigidBody.h:80
const btRigidBody & getRigidBodyB() const
#define btRigidBodyData
Definition: btRigidBody.h:36
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:82
int m_rigidbodyFlags
Definition: btRigidBody.h:96
btTransform m_worldTransform
bool isStaticOrKinematicObject() const
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 btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:251
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:866
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:952
void btSetCrossMatrixMinus(btMatrix3x3 &res, const btVector3 &a)
btScalar m_inverseMass
Definition: btRigidBody.h:68
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:279
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1001
virtual void setCollisionShape(btCollisionShape *collisionShape)
void integrateVelocities(btScalar step)
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:73
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:446
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
btTransform & getWorldTransform()
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:103
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:359
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:41
const btScalar & x() const
Return the x value.
Definition: btVector3.h:575
void addConstraintRef(btTypedConstraint *c)
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
Definition: btVector3.h:377
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
Definition: btVector3.h:648
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:91
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:139
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:590
btCollisionObject can be used to manage collision detection objects.
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:87
const btScalar & y() const
Return the y value.
Definition: btVector3.h:577
const btScalar & z() const
Return the z value.
Definition: btVector3.h:579
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
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:671
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
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
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:471
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
int size() const
return the number of elements in the array
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 serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1340
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 ...
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
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:118
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:471
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:48
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:94
btVector3 m_interpolationLinearVelocity
int m_frictionSolverType
Definition: btRigidBody.h:488
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
btMotionState * m_motionState
When a motionState is provided, the rigid body will initialize its world transform from the motion st...
Definition: btRigidBody.h:125
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:400
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:134
virtual btChunk * allocate(size_t size, int numElements)=0
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
#define MAX_ANGVEL
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btVector3 m_invMass
Definition: btRigidBody.h:106
virtual void serializeSingleObject(class btSerializer *serializer) const
btVector3 getLocalInertia() const
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:278
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:263
static int uniqueId
Definition: btRigidBody.cpp:27
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:65
void setGravity(const btVector3 &acceleration)