Bullet Collision Detection & Physics Library
btRigidBody.h
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 #ifndef BT_RIGIDBODY_H
17 #define BT_RIGIDBODY_H
18 
19 #include "LinearMath/btAlignedObjectArray.h"
20 #include "LinearMath/btTransform.h"
21 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
22 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
23 
24 class btCollisionShape;
25 class btMotionState;
26 class btTypedConstraint;
27 
28 
29 extern btScalar gDeactivationTime;
30 extern bool gDisableDeactivation;
31 
32 #ifdef BT_USE_DOUBLE_PRECISION
33 #define btRigidBodyData btRigidBodyDoubleData
34 #define btRigidBodyDataName "btRigidBodyDoubleData"
35 #else
36 #define btRigidBodyData btRigidBodyFloatData
37 #define btRigidBodyDataName "btRigidBodyFloatData"
38 #endif //BT_USE_DOUBLE_PRECISION
39 
40 
41 enum btRigidBodyFlags
42 {
43  BT_DISABLE_WORLD_GRAVITY = 1,
47  BT_ENABLE_GYROPSCOPIC_FORCE = 2
48 };
49 
50 
59 class btRigidBody : public btCollisionObject
60 {
61 
62  btMatrix3x3 m_invInertiaTensorWorld;
63  btVector3 m_linearVelocity;
64  btVector3 m_angularVelocity;
65  btScalar m_inverseMass;
66  btVector3 m_linearFactor;
67 
68  btVector3 m_gravity;
69  btVector3 m_gravity_acceleration;
70  btVector3 m_invInertiaLocal;
71  btVector3 m_totalForce;
72  btVector3 m_totalTorque;
73 
74  btScalar m_linearDamping;
75  btScalar m_angularDamping;
76 
77  bool m_additionalDamping;
78  btScalar m_additionalDampingFactor;
79  btScalar m_additionalLinearDampingThresholdSqr;
80  btScalar m_additionalAngularDampingThresholdSqr;
81  btScalar m_additionalAngularDampingFactor;
82 
83 
84  btScalar m_linearSleepingThreshold;
85  btScalar m_angularSleepingThreshold;
86 
87  //m_optionalMotionState allows to automatic synchronize the world transform for active objects
88  btMotionState* m_optionalMotionState;
89 
90  //keep track of typed constraints referencing this rigid body
91  btAlignedObjectArray<btTypedConstraint*> m_constraintRefs;
92 
93  int m_rigidbodyFlags;
94 
95  int m_debugBodyId;
96 
97 
98 protected:
99 
100  ATTRIBUTE_ALIGNED16(btVector3 m_deltaLinearVelocity);
101  btVector3 m_deltaAngularVelocity;
102  btVector3 m_angularFactor;
103  btVector3 m_invMass;
104  btVector3 m_pushVelocity;
105  btVector3 m_turnVelocity;
106 
107 
108 public:
109 
110 
116  struct btRigidBodyConstructionInfo
117  {
118  btScalar m_mass;
119 
122  btMotionState* m_motionState;
123  btTransform m_startWorldTransform;
124 
125  btCollisionShape* m_collisionShape;
126  btVector3 m_localInertia;
127  btScalar m_linearDamping;
128  btScalar m_angularDamping;
129 
131  btScalar m_friction;
134  btScalar m_rollingFriction;
136  btScalar m_restitution;
137 
138  btScalar m_linearSleepingThreshold;
139  btScalar m_angularSleepingThreshold;
140 
141  //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
142  //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
143  bool m_additionalDamping;
144  btScalar m_additionalDampingFactor;
145  btScalar m_additionalLinearDampingThresholdSqr;
146  btScalar m_additionalAngularDampingThresholdSqr;
147  btScalar m_additionalAngularDampingFactor;
148 
149  btRigidBodyConstructionInfo( btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0)):
150  m_mass(mass),
151  m_motionState(motionState),
152  m_collisionShape(collisionShape),
153  m_localInertia(localInertia),
154  m_linearDamping(btScalar(0.)),
155  m_angularDamping(btScalar(0.)),
156  m_friction(btScalar(0.5)),
157  m_rollingFriction(btScalar(0)),
158  m_restitution(btScalar(0.)),
159  m_linearSleepingThreshold(btScalar(0.8)),
160  m_angularSleepingThreshold(btScalar(1.f)),
161  m_additionalDamping(false),
162  m_additionalDampingFactor(btScalar(0.005)),
163  m_additionalLinearDampingThresholdSqr(btScalar(0.01)),
164  m_additionalAngularDampingThresholdSqr(btScalar(0.01)),
165  m_additionalAngularDampingFactor(btScalar(0.01))
166  {
167  m_startWorldTransform.setIdentity();
168  }
169  };
170 
172  btRigidBody( const btRigidBodyConstructionInfo& constructionInfo);
173 
176  btRigidBody( btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0));
177 
178 
179  virtual ~btRigidBody()
180  {
181  //No constraints should point to this rigidbody
182  //Remove constraints from the dynamics world before you delete the related rigidbodies.
183  btAssert(m_constraintRefs.size()==0);
184  }
185 
186 protected:
187 
189  void setupRigidBody(const btRigidBodyConstructionInfo& constructionInfo);
190 
191 public:
192 
193  void proceedToTransform(const btTransform& newTrans);
194 
197  static const btRigidBody* upcast(const btCollisionObject* colObj)
198  {
199  if (colObj->getInternalType()&btCollisionObject::CO_RIGID_BODY)
200  return (const btRigidBody*)colObj;
201  return 0;
202  }
203  static btRigidBody* upcast(btCollisionObject* colObj)
204  {
205  if (colObj->getInternalType()&btCollisionObject::CO_RIGID_BODY)
206  return (btRigidBody*)colObj;
207  return 0;
208  }
209 
211  void predictIntegratedTransform(btScalar step, btTransform& predictedTransform) ;
212 
213  void saveKinematicState(btScalar step);
214 
215  void applyGravity();
216 
217  void setGravity(const btVector3& acceleration);
218 
219  const btVector3& getGravity() const
220  {
221  return m_gravity_acceleration;
222  }
223 
224  void setDamping(btScalar lin_damping, btScalar ang_damping);
225 
226  btScalar getLinearDamping() const
227  {
228  return m_linearDamping;
229  }
230 
231  btScalar getAngularDamping() const
232  {
233  return m_angularDamping;
234  }
235 
236  btScalar getLinearSleepingThreshold() const
237  {
238  return m_linearSleepingThreshold;
239  }
240 
241  btScalar getAngularSleepingThreshold() const
242  {
243  return m_angularSleepingThreshold;
244  }
245 
246  void applyDamping(btScalar timeStep);
247 
248  SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const {
249  return m_collisionShape;
250  }
251 
252  SIMD_FORCE_INLINE btCollisionShape* getCollisionShape() {
253  return m_collisionShape;
254  }
255 
256  void setMassProps(btScalar mass, const btVector3& inertia);
257 
258  const btVector3& getLinearFactor() const
259  {
260  return m_linearFactor;
261  }
262  void setLinearFactor(const btVector3& linearFactor)
263  {
264  m_linearFactor = linearFactor;
265  m_invMass = m_linearFactor*m_inverseMass;
266  }
267  btScalar getInvMass() const { return m_inverseMass; }
268  const btMatrix3x3& getInvInertiaTensorWorld() const {
269  return m_invInertiaTensorWorld;
270  }
271 
272  void integrateVelocities(btScalar step);
273 
274  void setCenterOfMassTransform(const btTransform& xform);
275 
276  void applyCentralForce(const btVector3& force)
277  {
278  m_totalForce += force*m_linearFactor;
279  }
280 
281  const btVector3& getTotalForce() const
282  {
283  return m_totalForce;
284  };
285 
286  const btVector3& getTotalTorque() const
287  {
288  return m_totalTorque;
289  };
290 
291  const btVector3& getInvInertiaDiagLocal() const
292  {
293  return m_invInertiaLocal;
294  };
295 
296  void setInvInertiaDiagLocal(const btVector3& diagInvInertia)
297  {
298  m_invInertiaLocal = diagInvInertia;
299  }
300 
301  void setSleepingThresholds(btScalar linear,btScalar angular)
302  {
303  m_linearSleepingThreshold = linear;
304  m_angularSleepingThreshold = angular;
305  }
306 
307  void applyTorque(const btVector3& torque)
308  {
309  m_totalTorque += torque*m_angularFactor;
310  }
311 
312  void applyForce(const btVector3& force, const btVector3& rel_pos)
313  {
314  applyCentralForce(force);
315  applyTorque(rel_pos.cross(force*m_linearFactor));
316  }
317 
318  void applyCentralImpulse(const btVector3& impulse)
319  {
320  m_linearVelocity += impulse *m_linearFactor * m_inverseMass;
321  }
322 
323  void applyTorqueImpulse(const btVector3& torque)
324  {
325  m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
326  }
327 
328  void applyImpulse(const btVector3& impulse, const btVector3& rel_pos)
329  {
330  if (m_inverseMass != btScalar(0.))
331  {
332  applyCentralImpulse(impulse);
333  if (m_angularFactor)
334  {
335  applyTorqueImpulse(rel_pos.cross(impulse*m_linearFactor));
336  }
337  }
338  }
339 
340  void clearForces()
341  {
342  m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
343  m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
344  }
345 
346  void updateInertiaTensor();
347 
348  const btVector3& getCenterOfMassPosition() const {
349  return m_worldTransform.getOrigin();
350  }
351  btQuaternion getOrientation() const;
352 
353  const btTransform& getCenterOfMassTransform() const {
354  return m_worldTransform;
355  }
356  const btVector3& getLinearVelocity() const {
357  return m_linearVelocity;
358  }
359  const btVector3& getAngularVelocity() const {
360  return m_angularVelocity;
361  }
362 
363 
364  inline void setLinearVelocity(const btVector3& lin_vel)
365  {
366  m_updateRevision++;
367  m_linearVelocity = lin_vel;
368  }
369 
370  inline void setAngularVelocity(const btVector3& ang_vel)
371  {
372  m_updateRevision++;
373  m_angularVelocity = ang_vel;
374  }
375 
376  btVector3 getVelocityInLocalPoint(const btVector3& rel_pos) const
377  {
378  //we also calculate lin/ang velocity for kinematic objects
379  return m_linearVelocity + m_angularVelocity.cross(rel_pos);
380 
381  //for kinematic objects, we could also use use:
382  // return (m_worldTransform(rel_pos) - m_interpolationWorldTransform(rel_pos)) / m_kinematicTimeStep;
383  }
384 
385  void translate(const btVector3& v)
386  {
387  m_worldTransform.getOrigin() += v;
388  }
389 
390 
391  void getAabb(btVector3& aabbMin,btVector3& aabbMax) const;
392 
393 
394 
395 
396 
397  SIMD_FORCE_INLINE btScalar computeImpulseDenominator(const btVector3& pos, const btVector3& normal) const
398  {
399  btVector3 r0 = pos - getCenterOfMassPosition();
400 
401  btVector3 c0 = (r0).cross(normal);
402 
403  btVector3 vec = (c0 * getInvInertiaTensorWorld()).cross(r0);
404 
405  return m_inverseMass + normal.dot(vec);
406 
407  }
408 
409  SIMD_FORCE_INLINE btScalar computeAngularImpulseDenominator(const btVector3& axis) const
410  {
411  btVector3 vec = axis * getInvInertiaTensorWorld();
412  return axis.dot(vec);
413  }
414 
415  SIMD_FORCE_INLINE void updateDeactivation(btScalar timeStep)
416  {
417  if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
418  return;
419 
420  if ((getLinearVelocity().length2() < m_linearSleepingThreshold*m_linearSleepingThreshold) &&
421  (getAngularVelocity().length2() < m_angularSleepingThreshold*m_angularSleepingThreshold))
422  {
423  m_deactivationTime += timeStep;
424  } else
425  {
426  m_deactivationTime=btScalar(0.);
427  setActivationState(0);
428  }
429 
430  }
431 
432  SIMD_FORCE_INLINE bool wantsSleeping()
433  {
434 
435  if (getActivationState() == DISABLE_DEACTIVATION)
436  return false;
437 
438  //disable deactivation
439  if (gDisableDeactivation || (gDeactivationTime == btScalar(0.)))
440  return false;
441 
442  if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
443  return true;
444 
445  if (m_deactivationTime> gDeactivationTime)
446  {
447  return true;
448  }
449  return false;
450  }
451 
452 
453 
454  const btBroadphaseProxy* getBroadphaseProxy() const
455  {
456  return m_broadphaseHandle;
457  }
458  btBroadphaseProxy* getBroadphaseProxy()
459  {
460  return m_broadphaseHandle;
461  }
462  void setNewBroadphaseProxy(btBroadphaseProxy* broadphaseProxy)
463  {
464  m_broadphaseHandle = broadphaseProxy;
465  }
466 
467  //btMotionState allows to automatic synchronize the world transform for active objects
468  btMotionState* getMotionState()
469  {
470  return m_optionalMotionState;
471  }
472  const btMotionState* getMotionState() const
473  {
474  return m_optionalMotionState;
475  }
476  void setMotionState(btMotionState* motionState)
477  {
478  m_optionalMotionState = motionState;
479  if (m_optionalMotionState)
480  motionState->getWorldTransform(m_worldTransform);
481  }
482 
483  //for experimental overriding of friction/contact solver func
484  int m_contactSolverType;
485  int m_frictionSolverType;
486 
487  void setAngularFactor(const btVector3& angFac)
488  {
489  m_updateRevision++;
490  m_angularFactor = angFac;
491  }
492 
493  void setAngularFactor(btScalar angFac)
494  {
495  m_updateRevision++;
496  m_angularFactor.setValue(angFac,angFac,angFac);
497  }
498  const btVector3& getAngularFactor() const
499  {
500  return m_angularFactor;
501  }
502 
503  //is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase?
504  bool isInWorld() const
505  {
506  return (getBroadphaseProxy() != 0);
507  }
508 
509  virtual bool checkCollideWithOverride(const btCollisionObject* co) const;
510 
511  void addConstraintRef(btTypedConstraint* c);
512  void removeConstraintRef(btTypedConstraint* c);
513 
514  btTypedConstraint* getConstraintRef(int index)
515  {
516  return m_constraintRefs[index];
517  }
518 
519  int getNumConstraintRefs() const
520  {
521  return m_constraintRefs.size();
522  }
523 
524  void setFlags(int flags)
525  {
526  m_rigidbodyFlags = flags;
527  }
528 
529  int getFlags() const
530  {
531  return m_rigidbodyFlags;
532  }
533 
534  btVector3 computeGyroscopicForce(btScalar maxGyroscopicForce) const;
535 
537 
538  virtual int calculateSerializeBufferSize() const;
539 
541  virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
542 
543  virtual void serializeSingleObject(class btSerializer* serializer) const;
544 
545 };
546 
547 //@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData
549 struct btRigidBodyFloatData
550 {
551  btCollisionObjectFloatData m_collisionObjectData;
552  btMatrix3x3FloatData m_invInertiaTensorWorld;
553  btVector3FloatData m_linearVelocity;
554  btVector3FloatData m_angularVelocity;
555  btVector3FloatData m_angularFactor;
556  btVector3FloatData m_linearFactor;
557  btVector3FloatData m_gravity;
558  btVector3FloatData m_gravity_acceleration;
559  btVector3FloatData m_invInertiaLocal;
560  btVector3FloatData m_totalForce;
561  btVector3FloatData m_totalTorque;
562  float m_inverseMass;
563  float m_linearDamping;
564  float m_angularDamping;
565  float m_additionalDampingFactor;
566  float m_additionalLinearDampingThresholdSqr;
567  float m_additionalAngularDampingThresholdSqr;
568  float m_additionalAngularDampingFactor;
569  float m_linearSleepingThreshold;
570  float m_angularSleepingThreshold;
571  int m_additionalDamping;
572 };
573 
575 struct btRigidBodyDoubleData
576 {
577  btCollisionObjectDoubleData m_collisionObjectData;
578  btMatrix3x3DoubleData m_invInertiaTensorWorld;
579  btVector3DoubleData m_linearVelocity;
580  btVector3DoubleData m_angularVelocity;
581  btVector3DoubleData m_angularFactor;
582  btVector3DoubleData m_linearFactor;
583  btVector3DoubleData m_gravity;
584  btVector3DoubleData m_gravity_acceleration;
585  btVector3DoubleData m_invInertiaLocal;
586  btVector3DoubleData m_totalForce;
587  btVector3DoubleData m_totalTorque;
588  double m_inverseMass;
589  double m_linearDamping;
590  double m_angularDamping;
591  double m_additionalDampingFactor;
592  double m_additionalLinearDampingThresholdSqr;
593  double m_additionalAngularDampingThresholdSqr;
594  double m_additionalAngularDampingFactor;
595  double m_linearSleepingThreshold;
596  double m_angularSleepingThreshold;
597  int m_additionalDamping;
598  char m_padding[4];
599 };
600 
601 
602 
603 #endif //BT_RIGIDBODY_H
604 
Generated on Wed Apr 9 2014 02:38:23 for Bullet Collision Detection & Physics Library by   doxygen 1.8.1.2