Bullet Collision Detection & Physics Library
btRigidBody.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. 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
27static int uniqueId = 0;
28
30{
31 setupRigidBody(constructionInfo);
32}
33
34btRigidBody::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
47 m_linearFactor.setValue(1, 1, 1);
52 setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
53
56 m_optionalMotionState = constructionInfo.m_motionState;
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
123void btRigidBody::getAabb(btVector3& aabbMin, btVector3& aabbMax) const
124{
125 getCollisionShape()->getAabb(m_worldTransform, aabbMin, aabbMax);
126}
127
128void 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
137void 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
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
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{
212 return;
213
215}
216
218{
219 setCenterOfMassTransform(newTrans);
220}
221
223{
224 if (mass == btScalar(0.))
225 {
228 }
229 else
230 {
232 m_inverseMass = btScalar(1.0) / mass;
233 }
234
235 //Fg = m * a
237
238 m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
239 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
240 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
241
243}
244
246{
248}
249
251{
252 btVector3 inertiaLocal;
253 const btVector3 inertia = m_invInertiaLocal;
254 inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
255 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
256 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
257 return inertiaLocal;
258}
259
260inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
261 const btMatrix3x3& I)
262{
263 const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0);
264 return w2;
265}
266
267inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
268 const btMatrix3x3& I)
269{
270 btMatrix3x3 w1x, Iw1x;
271 const btVector3 Iwi = (I * w1);
272 w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
273 Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
274
275 const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt;
276 return dfw1;
277}
278
280{
281 btVector3 inertiaLocal = getLocalInertia();
282 btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
283 btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
285 btScalar l2 = gf.length2();
286 if (l2 > maxGyroscopicForce * maxGyroscopicForce)
287 {
288 gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce;
289 }
290 return gf;
291}
292
294{
296 btVector3 omega1 = getAngularVelocity();
298
299 // Convert to body coordinates
300 btVector3 omegab = quatRotate(q.inverse(), omega1);
301 btMatrix3x3 Ib;
302 Ib.setValue(idl.x(), 0, 0,
303 0, idl.y(), 0,
304 0, 0, idl.z());
305
306 btVector3 ibo = Ib * omegab;
307
308 // Residual vector
309 btVector3 f = step * omegab.cross(ibo);
310
311 btMatrix3x3 skew0;
312 omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
313 btVector3 om = Ib * omegab;
314 btMatrix3x3 skew1;
315 om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]);
316
317 // Jacobian
318 btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step;
319
320 // btMatrix3x3 Jinv = J.inverse();
321 // btVector3 omega_div = Jinv*f;
322 btVector3 omega_div = J.solve33(f);
323
324 // Single Newton-Raphson update
325 omegab = omegab - omega_div; //Solve33(J, f);
326 // Back to world coordinates
327 btVector3 omega2 = quatRotate(q, omegab);
328 btVector3 gf = omega2 - omega1;
329 return gf;
330}
331
333{
334 // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
335 // calculate using implicit euler step so it's stable.
336
337 const btVector3 inertiaLocal = getLocalInertia();
338 const btVector3 w0 = getAngularVelocity();
339
340 btMatrix3x3 I;
341
342 I = m_worldTransform.getBasis().scaled(inertiaLocal) *
344
345 // use newtons method to find implicit solution for new angular velocity (w')
346 // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
347 // df/dw' = I + 1xIw'*step + w'xI*step
348
349 btVector3 w1 = w0;
350
351 // one step of newton's method
352 {
353 const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
354 const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
355
356 btVector3 dw;
357 dw = dfw.solve33(fw);
358 //const btMatrix3x3 dfw_inv = dfw.inverse();
359 //dw = dfw_inv*fw;
360
361 w1 -= dw;
362 }
363
364 btVector3 gf = (w1 - w0);
365 return gf;
366}
367
369{
371 return;
372
375
376#define MAX_ANGVEL SIMD_HALF_PI
379 if (angvel * step > MAX_ANGVEL)
380 {
381 m_angularVelocity *= (MAX_ANGVEL / step) / angvel;
382 }
383}
384
386{
387 btQuaternion orn;
389 return orn;
390}
391
393{
394 if (isKinematicObject())
395 {
397 }
398 else
399 {
401 }
404 m_worldTransform = xform;
406}
407
409{
411
412 int index = m_constraintRefs.findLinearSearch(c);
413 //don't add constraints that are already referenced
414 //btAssert(index == m_constraintRefs.size());
415 if (index == m_constraintRefs.size())
416 {
417 m_constraintRefs.push_back(c);
418 btCollisionObject* colObjA = &c->getRigidBodyA();
419 btCollisionObject* colObjB = &c->getRigidBodyB();
420 if (colObjA == this)
421 {
422 colObjA->setIgnoreCollisionCheck(colObjB, true);
423 }
424 else
425 {
426 colObjB->setIgnoreCollisionCheck(colObjA, true);
427 }
428 }
429}
430
432{
433 int index = m_constraintRefs.findLinearSearch(c);
434 //don't remove constraints that are not referenced
435 if (index < m_constraintRefs.size())
436 {
437 m_constraintRefs.remove(c);
438 btCollisionObject* colObjA = &c->getRigidBodyA();
439 btCollisionObject* colObjB = &c->getRigidBodyB();
440 if (colObjA == this)
441 {
442 colObjA->setIgnoreCollisionCheck(colObjB, false);
443 }
444 else
445 {
446 colObjB->setIgnoreCollisionCheck(colObjA, false);
447 }
448 }
449}
450
452{
453 int sz = sizeof(btRigidBodyData);
454 return sz;
455}
456
458const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
459{
460 btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer;
461
462 btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
463
464 m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
465 m_linearVelocity.serialize(rbd->m_linearVelocity);
466 m_angularVelocity.serialize(rbd->m_angularVelocity);
467 rbd->m_inverseMass = m_inverseMass;
468 m_angularFactor.serialize(rbd->m_angularFactor);
469 m_linearFactor.serialize(rbd->m_linearFactor);
470 m_gravity.serialize(rbd->m_gravity);
471 m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
472 m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
473 m_totalForce.serialize(rbd->m_totalForce);
474 m_totalTorque.serialize(rbd->m_totalTorque);
475 rbd->m_linearDamping = m_linearDamping;
476 rbd->m_angularDamping = m_angularDamping;
477 rbd->m_additionalDamping = m_additionalDamping;
478 rbd->m_additionalDampingFactor = m_additionalDampingFactor;
479 rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
480 rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
481 rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
482 rbd->m_linearSleepingThreshold = m_linearSleepingThreshold;
483 rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
484
485 // Fill padding with zeros to appease msan.
486#ifdef BT_USE_DOUBLE_PRECISION
487 memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
488#endif
489
490 return btRigidBodyDataName;
491}
492
494{
495 btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1);
496 const char* structType = serialize(chunk->m_oldPtr, serializer);
497 serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this);
498}
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:33
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
@ BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
Definition: btRigidBody.h:47
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:521
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btScalar btSqrt(btScalar y)
Definition: btScalar.h:466
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:112
#define btRigidBodyData
void * m_oldPtr
Definition: btSerializer.h:52
btCollisionObject can be used to manage collision detection objects.
bool isStaticOrKinematicObject() const
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTransform & getWorldTransform()
btTransform m_worldTransform
virtual void setCollisionShape(btCollisionShape *collisionShape)
btVector3 m_interpolationLinearVelocity
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
btVector3 m_interpolationAngularVelocity
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody,...
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
bool isKinematicObject() const
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
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.
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition: btMatrix3x3.h:632
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1033
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:404
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:606
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1385
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:202
The btMotionState interface class allows the dynamics world to synchronize and interpolate the update...
Definition: btMotionState.h:24
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
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:80
void applyGravity()
void integrateVelocities(btScalar step)
void addConstraintRef(btTypedConstraint *c)
virtual void serializeSingleObject(class btSerializer *serializer) const
btScalar m_linearDamping
Definition: btRigidBody.h:73
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:61
int m_frictionSolverType
Definition: btRigidBody.h:519
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:69
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:86
btVector3 m_gravity
Definition: btRigidBody.h:67
int m_contactSolverType
Definition: btRigidBody.h:518
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
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:77
virtual int calculateSerializeBufferSize() const
int m_rigidbodyFlags
Definition: btRigidBody.h:91
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:79
void setGravity(const btVector3 &acceleration)
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition: btRigidBody.cpp:29
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:82
btQuaternion getOrientation() const
void proceedToTransform(const btTransform &newTrans)
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:242
btVector3 m_linearFactor
Definition: btRigidBody.h:65
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 m_totalForce
Definition: btRigidBody.h:70
btScalar m_inverseMass
Definition: btRigidBody.h:64
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
btVector3 m_totalTorque
Definition: btRigidBody.h:71
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:402
btMotionState * getMotionState()
Definition: btRigidBody.h:502
btScalar m_angularDamping
Definition: btRigidBody.h:74
void removeConstraintRef(btTypedConstraint *c)
void setMassProps(btScalar mass, const btVector3 &inertia)
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:97
btVector3 m_pushVelocity
Definition: btRigidBody.h:100
bool m_additionalDamping
Definition: btRigidBody.h:76
int m_debugBodyId
Definition: btRigidBody.h:93
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:83
void clearGravity()
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:78
btVector3 m_linearVelocity
Definition: btRigidBody.h:62
void setDamping(btScalar lin_damping, btScalar ang_damping)
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:96
btVector3 m_angularVelocity
Definition: btRigidBody.h:63
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:40
void setCenterOfMassTransform(const btTransform &xform)
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:89
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
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:398
btVector3 m_gravity_acceleration
Definition: btRigidBody.h:68
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)
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:108
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:118
TypedConstraint is the baseclass for Bullet constraints and vehicles.
const btRigidBody & getRigidBodyA() const
const btRigidBody & getRigidBodyB() const
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
const btScalar & z() const
Return the z value.
Definition: btVector3.h:579
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:257
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
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:949
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:251
const btScalar & x() const
Return the x value.
Definition: btVector3.h:575
void setZero()
Definition: btVector3.h:671
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1317
const btScalar & y() const
Return the y value.
Definition: btVector3.h:577
The btRigidBodyConstructionInfo structure provides information to create a rigid body.
Definition: btRigidBody.h:110
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
btMotionState * m_motionState
When a motionState is provided, the rigid body will initialize its world transform from the motion st...
Definition: btRigidBody.h:115
btScalar m_rollingFriction
the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling f...
Definition: btRigidBody.h:127