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 
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 
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));
52  setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
53 
56  m_optionalMotionState = constructionInfo.m_motionState;
59  m_additionalDamping = constructionInfo.m_additionalDamping;
64 
66  {
68  }
69  else
70  {
71  m_worldTransform = constructionInfo.m_startWorldTransform;
72  }
73 
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);
87 
88  setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
90 
92 
98 }
99 
101 {
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 
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  m_linearDamping = btClamped(lin_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
140  m_angularDamping = btClamped(ang_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
141 }
142 
145 {
146  //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
147  //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
148 
149 //#define USE_OLD_DAMPING_METHOD 1
150 #ifdef USE_OLD_DAMPING_METHOD
151  m_linearVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_linearDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
152  m_angularVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_angularDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
153 #else
154  m_linearVelocity *= btPow(btScalar(1) - m_linearDamping, timeStep);
156 #endif
157 
159  {
160  //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
161  //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
164  {
167  }
168 
169  btScalar speed = m_linearVelocity.length();
170  if (speed < m_linearDamping)
171  {
172  btScalar dampVel = btScalar(0.005);
173  if (speed > dampVel)
174  {
176  m_linearVelocity -= dir * dampVel;
177  }
178  else
179  {
181  }
182  }
183 
184  btScalar angSpeed = m_angularVelocity.length();
185  if (angSpeed < m_angularDamping)
186  {
187  btScalar angDampVel = btScalar(0.005);
188  if (angSpeed > angDampVel)
189  {
191  m_angularVelocity -= dir * angDampVel;
192  }
193  else
194  {
196  }
197  }
198  }
199 }
200 
202 {
204  return;
205 
207 }
208 
210 {
211  setCenterOfMassTransform(newTrans);
212 }
213 
214 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
215 {
216  if (mass == btScalar(0.))
217  {
219  m_inverseMass = btScalar(0.);
220  }
221  else
222  {
224  m_inverseMass = btScalar(1.0) / mass;
225  }
226 
227  //Fg = m * a
229 
230  m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
231  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
232  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
233 
235 }
236 
238 {
240 }
241 
243 {
244  btVector3 inertiaLocal;
245  const btVector3 inertia = m_invInertiaLocal;
246  inertiaLocal.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  return inertiaLocal;
250 }
251 
252 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
253  const btMatrix3x3& I)
254 {
255  const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0);
256  return w2;
257 }
258 
259 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
260  const btMatrix3x3& I)
261 {
262  btMatrix3x3 w1x, Iw1x;
263  const btVector3 Iwi = (I * w1);
264  w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
265  Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
266 
267  const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt;
268  return dfw1;
269 }
270 
272 {
273  btVector3 inertiaLocal = getLocalInertia();
274  btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
275  btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
276  btVector3 gf = getAngularVelocity().cross(tmp);
277  btScalar l2 = gf.length2();
278  if (l2 > maxGyroscopicForce * maxGyroscopicForce)
279  {
280  gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce;
281  }
282  return gf;
283 }
284 
286 {
287  btVector3 idl = getLocalInertia();
288  btVector3 omega1 = getAngularVelocity();
290 
291  // Convert to body coordinates
292  btVector3 omegab = quatRotate(q.inverse(), omega1);
293  btMatrix3x3 Ib;
294  Ib.setValue(idl.x(), 0, 0,
295  0, idl.y(), 0,
296  0, 0, idl.z());
297 
298  btVector3 ibo = Ib * omegab;
299 
300  // Residual vector
301  btVector3 f = step * omegab.cross(ibo);
302 
303  btMatrix3x3 skew0;
304  omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
305  btVector3 om = Ib * omegab;
306  btMatrix3x3 skew1;
307  om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]);
308 
309  // Jacobian
310  btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step;
311 
312  // btMatrix3x3 Jinv = J.inverse();
313  // btVector3 omega_div = Jinv*f;
314  btVector3 omega_div = J.solve33(f);
315 
316  // Single Newton-Raphson update
317  omegab = omegab - omega_div; //Solve33(J, f);
318  // Back to world coordinates
319  btVector3 omega2 = quatRotate(q, omegab);
320  btVector3 gf = omega2 - omega1;
321  return gf;
322 }
323 
325 {
326  // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
327  // calculate using implicit euler step so it's stable.
328 
329  const btVector3 inertiaLocal = getLocalInertia();
330  const btVector3 w0 = getAngularVelocity();
331 
332  btMatrix3x3 I;
333 
334  I = m_worldTransform.getBasis().scaled(inertiaLocal) *
336 
337  // use newtons method to find implicit solution for new angular velocity (w')
338  // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
339  // df/dw' = I + 1xIw'*step + w'xI*step
340 
341  btVector3 w1 = w0;
342 
343  // one step of newton's method
344  {
345  const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
346  const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
347 
348  btVector3 dw;
349  dw = dfw.solve33(fw);
350  //const btMatrix3x3 dfw_inv = dfw.inverse();
351  //dw = dfw_inv*fw;
352 
353  w1 -= dw;
354  }
355 
356  btVector3 gf = (w1 - w0);
357  return gf;
358 }
359 
361 {
363  return;
364 
367 
368 #define MAX_ANGVEL SIMD_HALF_PI
369  btScalar angvel = m_angularVelocity.length();
371  if (angvel * step > MAX_ANGVEL)
372  {
373  m_angularVelocity *= (MAX_ANGVEL / step) / angvel;
374  }
375 }
376 
378 {
379  btQuaternion orn;
381  return orn;
382 }
383 
385 {
386  if (isKinematicObject())
387  {
389  }
390  else
391  {
393  }
396  m_worldTransform = xform;
398 }
399 
401 {
403 
404  int index = m_constraintRefs.findLinearSearch(c);
405  //don't add constraints that are already referenced
406  //btAssert(index == m_constraintRefs.size());
407  if (index == m_constraintRefs.size())
408  {
410  btCollisionObject* colObjA = &c->getRigidBodyA();
411  btCollisionObject* colObjB = &c->getRigidBodyB();
412  if (colObjA == this)
413  {
414  colObjA->setIgnoreCollisionCheck(colObjB, true);
415  }
416  else
417  {
418  colObjB->setIgnoreCollisionCheck(colObjA, true);
419  }
420  }
421 }
422 
424 {
425  int index = m_constraintRefs.findLinearSearch(c);
426  //don't remove constraints that are not referenced
427  if (index < m_constraintRefs.size())
428  {
430  btCollisionObject* colObjA = &c->getRigidBodyA();
431  btCollisionObject* colObjB = &c->getRigidBodyB();
432  if (colObjA == this)
433  {
434  colObjA->setIgnoreCollisionCheck(colObjB, false);
435  }
436  else
437  {
438  colObjB->setIgnoreCollisionCheck(colObjA, false);
439  }
440  }
441 }
442 
444 {
445  int sz = sizeof(btRigidBodyData);
446  return sz;
447 }
448 
450 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
451 {
452  btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer;
453 
454  btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
455 
456  m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
457  m_linearVelocity.serialize(rbd->m_linearVelocity);
458  m_angularVelocity.serialize(rbd->m_angularVelocity);
459  rbd->m_inverseMass = m_inverseMass;
460  m_angularFactor.serialize(rbd->m_angularFactor);
461  m_linearFactor.serialize(rbd->m_linearFactor);
462  m_gravity.serialize(rbd->m_gravity);
463  m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
464  m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
465  m_totalForce.serialize(rbd->m_totalForce);
466  m_totalTorque.serialize(rbd->m_totalTorque);
467  rbd->m_linearDamping = m_linearDamping;
468  rbd->m_angularDamping = m_angularDamping;
469  rbd->m_additionalDamping = m_additionalDamping;
470  rbd->m_additionalDampingFactor = m_additionalDampingFactor;
471  rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
472  rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
473  rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
474  rbd->m_linearSleepingThreshold = m_linearSleepingThreshold;
475  rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
476 
477  // Fill padding with zeros to appease msan.
478 #ifdef BT_USE_DOUBLE_PRECISION
479  memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
480 #endif
481 
482  return btRigidBodyDataName;
483 }
484 
486 {
487  btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1);
488  const char* structType = serialize(chunk->m_oldPtr, serializer);
489  serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this);
490 }
void push_back(const T &_Val)
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1378
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:357
void applyGravity()
btVector3 m_totalTorque
Definition: btRigidBody.h:71
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:473
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:625
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:70
btScalar m_angularDamping
Definition: btRigidBody.h:74
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:251
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
const btRigidBody & getRigidBodyA() const
virtual int calculateSerializeBufferSize() const
btVector3 m_turnVelocity
Definition: btRigidBody.h:101
btScalar btSqrt(btScalar y)
Definition: btScalar.h:446
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:118
btVector3 m_gravity
Definition: btRigidBody.h:67
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:29
void setDamping(btScalar lin_damping, btScalar ang_damping)
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:83
btQuaternion getOrientation() const
bool m_additionalDamping
Definition: btRigidBody.h:76
const btRigidBody & getRigidBodyB() const
#define btRigidBodyData
Definition: btRigidBody.h:35
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:78
int m_rigidbodyFlags
Definition: btRigidBody.h:91
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:127
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:100
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:240
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:926
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:949
btScalar m_inverseMass
Definition: btRigidBody.h:64
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:271
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1026
virtual void setCollisionShape(btCollisionShape *collisionShape)
void integrateVelocities(btScalar step)
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:69
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:497
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
btTransform & getWorldTransform()
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:96
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:353
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:40
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:380
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
Definition: btVector3.h:648
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:86
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:131
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:599
btCollisionObject can be used to manage collision detection objects.
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:82
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:108
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:195
void setZero()
Definition: btVector3.h:671
btVector3 m_angularFactor
Definition: btRigidBody.h:98
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:109
btVector3 m_angularVelocity
Definition: btRigidBody.h:63
void proceedToTransform(const btTransform &newTrans)
#define btRigidBodyDataName
Definition: btRigidBody.h:36
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:77
btScalar m_linearDamping
Definition: btRigidBody.h:73
btVector3 m_linearFactor
Definition: btRigidBody.h:65
btVector3 m_linearVelocity
Definition: btRigidBody.h:62
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:80
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:501
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:93
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:28
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1317
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:112
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:79
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:46
btMotionState * getMotionState()
Definition: btRigidBody.h:457
btVector3 m_gravity_acceleration
Definition: btRigidBody.h:68
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:80
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:49
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:89
btVector3 m_interpolationLinearVelocity
int m_frictionSolverType
Definition: btRigidBody.h:474
void removeConstraintRef(btTypedConstraint *c)
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:97
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
void * m_oldPtr
Definition: btSerializer.h:52
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:33
btMotionState * m_motionState
When a motionState is provided, the rigid body will initialize its world transform from the motion st...
Definition: btRigidBody.h:115
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:397
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:124
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:99
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:294
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:257
static int uniqueId
Definition: btRigidBody.cpp:27
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:61
void setGravity(const btVector3 &acceleration)