Bullet Collision Detection & Physics Library: btRigidBody.cpp Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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"
17 #include "BulletCollision/CollisionShapes/btConvexShape.h"
18 #include "LinearMath/btMinMax.h"
19 #include "LinearMath/btTransformUtil.h"
20 #include "LinearMath/btMotionState.h"
21 #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
22 #include "LinearMath/btSerializer.h"
23
24 //'temporarily' global variables
25 btScalar gDeactivationTime = btScalar(2.);
26 bool gDisableDeactivation = false;
27 static int uniqueId = 0;
28
29
30 btRigidBody::btRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo)
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
41 void btRigidBody::setupRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo)
42 {
43
44 m_internalType=CO_RIGID_BODY;
45
46 m_linearVelocity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
47 m_angularVelocity.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
48 m_angularFactor.setValue(1,1,1);
49 m_linearFactor.setValue(1,1,1);
50 m_gravity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
51 m_gravity_acceleration.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
52 m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
53 m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
54 setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
55
56 m_linearSleepingThreshold = constructionInfo.m_linearSleepingThreshold;
57 m_angularSleepingThreshold = constructionInfo.m_angularSleepingThreshold;
58 m_optionalMotionState = constructionInfo.m_motionState;
59 m_contactSolverType = 0;
60 m_frictionSolverType = 0;
61 m_additionalDamping = constructionInfo.m_additionalDamping;
62 m_additionalDampingFactor = constructionInfo.m_additionalDampingFactor;
63 m_additionalLinearDampingThresholdSqr = constructionInfo.m_additionalLinearDampingThresholdSqr;
64 m_additionalAngularDampingThresholdSqr = constructionInfo.m_additionalAngularDampingThresholdSqr;
65 m_additionalAngularDampingFactor = constructionInfo.m_additionalAngularDampingFactor;
66
67 if (m_optionalMotionState)
68 {
69 m_optionalMotionState->getWorldTransform(m_worldTransform);
70 } else
71 {
72 m_worldTransform = constructionInfo.m_startWorldTransform;
73 }
74
75 m_interpolationWorldTransform = m_worldTransform;
76 m_interpolationLinearVelocity.setValue(0,0,0);
77 m_interpolationAngularVelocity.setValue(0,0,0);
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 );
85 m_debugBodyId = uniqueId++;
86
87 setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
88 updateInertiaTensor();
89
90 m_rigidbodyFlags = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY;
91
92
93 m_deltaLinearVelocity.setZero();
94 m_deltaAngularVelocity.setZero();
95 m_invMass = m_inverseMass*m_linearFactor;
96 m_pushVelocity.setZero();
97 m_turnVelocity.setZero();
98
99
100
101 }
102
103
104 void btRigidBody::predictIntegratedTransform(btScalar timeStep,btTransform& predictedTransform)
105 {
106 btTransformUtil::integrateTransform(m_worldTransform,m_linearVelocity,m_angularVelocity,timeStep,predictedTransform);
107 }
108
109 void btRigidBody::saveKinematicState(btScalar timeStep)
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())
116 getMotionState()->getWorldTransform(m_worldTransform);
117 btVector3 linVel,angVel;
118
119 btTransformUtil::calculateVelocity(m_interpolationWorldTransform,m_worldTransform,timeStep,m_linearVelocity,m_angularVelocity);
120 m_interpolationLinearVelocity = m_linearVelocity;
121 m_interpolationAngularVelocity = m_angularVelocity;
122 m_interpolationWorldTransform = m_worldTransform;
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
159 void btRigidBody::applyDamping(btScalar timeStep)
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
173 if (m_additionalDamping)
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
177 if ((m_angularVelocity.length2() < m_additionalAngularDampingThresholdSqr) &&
178 (m_linearVelocity.length2() < m_additionalLinearDampingThresholdSqr))
179 {
180 m_angularVelocity *= m_additionalDampingFactor;
181 m_linearVelocity *= m_additionalDampingFactor;
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 {
191 btVector3 dir = m_linearVelocity.normalized();
192 m_linearVelocity -= dir * dampVel;
193 } else
194 {
195 m_linearVelocity.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
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 {
205 btVector3 dir = m_angularVelocity.normalized();
206 m_angularVelocity -= dir * angDampVel;
207 } else
208 {
209 m_angularVelocity.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
210 }
211 }
212 }
213 }
214
215
216 void btRigidBody::applyGravity()
217 {
218 if (isStaticOrKinematicObject())
219 return;
220
221 applyCentralForce(m_gravity);
222
223 }
224
225 void btRigidBody::proceedToTransform(const btTransform& newTrans)
226 {
227 setCenterOfMassTransform( newTrans );
228 }
229
230
231 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
232 {
233 if (mass == btScalar(0.))
234 {
235 m_collisionFlags |= btCollisionObject::CF_STATIC_OBJECT;
236 m_inverseMass = btScalar(0.);
237 } else
238 {
239 m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT);
240 m_inverseMass = btScalar(1.0) / mass;
241 }
242
243 //Fg = m * a
244 m_gravity = mass * m_gravity_acceleration;
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
250 m_invMass = m_linearFactor*m_inverseMass;
251 }
252
253
254 void btRigidBody::updateInertiaTensor()
255 {
256 m_invInertiaTensorWorld = m_worldTransform.getBasis().scaled(m_invInertiaLocal) * m_worldTransform.getBasis().transpose();
257 }
258
259
260
261 btVector3 btRigidBody::getLocalInertia() const
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
292 btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
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
306 void btSetCrossMatrixMinus(btMatrix3x3& res, const btVector3& a)
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
314 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) const
315 {
316 btVector3 idl = getLocalInertia();
317 btVector3 omega1 = getAngularVelocity();
318 btQuaternion q = getWorldTransform().getRotation();
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
355 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_World(btScalar step) const
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) *
366 m_worldTransform.getBasis().transpose();
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
392 void btRigidBody::integrateVelocities(btScalar step)
393 {
394 if (isStaticOrKinematicObject())
395 return;
396
397 m_linearVelocity += m_totalForce * (m_inverseMass * step);
398 m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step;
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
410 btQuaternion btRigidBody::getOrientation() const
411 {
412 btQuaternion orn;
413 m_worldTransform.getBasis().getRotation(orn);
414 return orn;
415 }
416
417
418 void btRigidBody::setCenterOfMassTransform(const btTransform& xform)
419 {
420
421 if (isKinematicObject())
422 {
423 m_interpolationWorldTransform = m_worldTransform;
424 } else
425 {
426 m_interpolationWorldTransform = xform;
427 }
428 m_interpolationLinearVelocity = getLinearVelocity();
429 m_interpolationAngularVelocity = getAngularVelocity();
430 m_worldTransform = xform;
431 updateInertiaTensor();
432 }
433
434
435
436
437
438 void btRigidBody::addConstraintRef(btTypedConstraint* c)
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 {
447 m_constraintRefs.push_back(c);
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
461 void btRigidBody::removeConstraintRef(btTypedConstraint* c)
462 {
463 int index = m_constraintRefs.findLinearSearch(c);
464 //don't remove constraints that are not referenced
465 if(index < m_constraintRefs.size())
466 {
467 m_constraintRefs.remove(c);
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
481 int btRigidBody::calculateSerializeBufferSize() const
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
520 void btRigidBody::serializeSingleObject(class btSerializer* serializer) const
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
btRigidBody::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:251
btRigidBody::btRigidBodyConstructionInfo::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:147
btRigidBody::getAabb
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition: btRigidBody.cpp:127
btTransformUtil.h
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:268
btChunk
Definition: btSerializer.h:51
btRigidBody::applyGravity
void applyGravity()
Definition: btRigidBody.cpp:216
btRigidBody::m_totalTorque
btVector3 m_totalTorque
Definition: btRigidBody.h:75
btMatrix3x3::serialize
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1356
btRigidBody::btRigidBodyConstructionInfo::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:142
btRigidBody::m_contactSolverType
int m_contactSolverType
Definition: btRigidBody.h:487
btTransform::getRotation
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btRigidBody::predictIntegratedTransform
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
Definition: btRigidBody.cpp:104
btRigidBody::updateInertiaTensor
void updateInertiaTensor()
Definition: btRigidBody.cpp:254
btRigidBody::m_totalForce
btVector3 m_totalForce
Definition: btRigidBody.h:74
btRigidBody::m_angularDamping
btScalar m_angularDamping
Definition: btRigidBody.h:78
evalEulerEqn
btVector3 evalEulerEqn(const btVector3 &w1, const btVector3 &w0, const btVector3 &T, const btScalar dt, const btMatrix3x3 &I)
Definition: btRigidBody.cpp:272
btCollisionObject::m_interpolationWorldTransform
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
Definition: btCollisionObject.h:58
btRigidBody::computeGyroscopicImpulseImplicit_World
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
Definition: btRigidBody.cpp:355
gDisableDeactivation
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
btRigidBody::m_turnVelocity
btVector3 m_turnVelocity
Definition: btRigidBody.h:108
btSqrt
btScalar btSqrt(btScalar y)
Definition: btScalar.h:418
btRigidBody::m_gravity
btVector3 m_gravity
Definition: btRigidBody.h:71
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:27
gDeactivationTime
btScalar gDeactivationTime
Definition: btRigidBody.cpp:25
btRigidBody::btRigidBodyConstructionInfo::m_mass
btScalar m_mass
Definition: btRigidBody.h:121
btRigidBody::btRigidBody
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition: btRigidBody.cpp:30
btRigidBody::setDamping
void setDamping(btScalar lin_damping, btScalar ang_damping)
Definition: btRigidBody.cpp:149
btRigidBody::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:88
btCollisionObject::CF_STATIC_OBJECT
Definition: btCollisionObject.h:124
btRigidBody::m_additionalDamping
bool m_additionalDamping
Definition: btRigidBody.h:80
btRigidBodyData
#define btRigidBodyData
Definition: btRigidBody.h:36
btRigidBody::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:82
btRigidBody::m_rigidbodyFlags
int m_rigidbodyFlags
Definition: btRigidBody.h:96
btRigidBody::btRigidBodyConstructionInfo::m_localInertia
btVector3 m_localInertia
Definition: btRigidBody.h:129
btRigidBody.h
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:54
btRigidBody::btRigidBodyConstructionInfo::m_rollingFriction
btScalar m_rollingFriction
the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling f...
Definition: btRigidBody.h:137
btCollisionShape::getAabb
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...
btConvexShape.h
btRigidBody::m_pushVelocity
btVector3 m_pushVelocity
Definition: btRigidBody.h:107
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition: btCollisionObject.h:225
btSerializer
Definition: btSerializer.h:68
btVector3::x
const btScalar & x() const
Return the x value.
Definition: btVector3.h:575
quatRotate
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:884
btSetCrossMatrixMinus
void btSetCrossMatrixMinus(btMatrix3x3 &res, const btVector3 &a)
Definition: btRigidBody.cpp:306
btRigidBody::btRigidBodyConstructionInfo::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:148
btRigidBody::m_inverseMass
btScalar m_inverseMass
Definition: btRigidBody.h:68
btRigidBody::applyCentralForce
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:279
btCollisionObject::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition: btCollisionObject.h:208
btRigidBody::integrateVelocities
void integrateVelocities(btScalar step)
Definition: btRigidBody.cpp:392
btTypedConstraint.h
btRigidBody::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btRigidBody.cpp:481
btRigidBody::m_invInertiaLocal
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:73
btCollisionObject::serialize
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btCollisionObject.cpp:72
btMatrix3x3::getRotation
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:400
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:327
btRigidBody::computeGyroscopicForceExplicit
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
Definition: btRigidBody.cpp:292
btRigidBody::m_deltaLinearVelocity
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:103
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
Definition: btCollisionObject.h:92
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btRigidBody::setupRigidBody
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:41
btMatrix3x3::scaled
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:590
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition: btCollisionObject.h:189
btRigidBody::addConstraintRef
void addConstraintRef(btTypedConstraint *c)
Definition: btRigidBody.cpp:438
btCollisionObject::CO_RIGID_BODY
Definition: btCollisionObject.h:136
btRigidBody::getOrientation
btQuaternion getOrientation() const
Definition: btRigidBody.cpp:410
btRigidBody::getAngularVelocity
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:362
btVector3::cross
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
Definition: btVector3.h:377
btRigidBody::m_optionalMotionState
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:91
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:194
btVector3::serialize
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1340
btRigidBody::btRigidBodyConstructionInfo::m_restitution
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:139
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btRigidBody::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:87
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
btRigidBody::serializeSingleObject
virtual void serializeSingleObject(class btSerializer *serializer) const
Definition: btRigidBody.cpp:520
btMatrix3x3::setValue
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
btVector3::setZero
void setZero()
Definition: btVector3.h:671
btQuaternion::inverse
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:453
btMatrix3x3::solve33
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition: btMatrix3x3.h:616
btVector3::length
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:263
btRigidBody::m_angularFactor
btVector3 m_angularFactor
Definition: btRigidBody.h:105
evalEulerEqnDeriv
btMatrix3x3 evalEulerEqnDeriv(const btVector3 &w1, const btVector3 &w0, const btScalar dt, const btMatrix3x3 &I)
Definition: btRigidBody.cpp:279
btRigidBody::btRigidBodyConstructionInfo
The btRigidBodyConstructionInfo structure provides information to create a rigid body.
Definition: btRigidBody.h:119
btRigidBody::m_angularVelocity
btVector3 m_angularVelocity
Definition: btRigidBody.h:67
btRigidBody::proceedToTransform
void proceedToTransform(const btTransform &newTrans)
Definition: btRigidBody.cpp:225
btRigidBodyDataName
#define btRigidBodyDataName
Definition: btRigidBody.h:37
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:78
btRigidBody::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:81
btMinMax.h
btRigidBody::m_linearDamping
btScalar m_linearDamping
Definition: btRigidBody.h:77
btVector3::y
const btScalar & y() const
Return the y value.
Definition: btVector3.h:577
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:150
btRigidBody::m_linearFactor
btVector3 m_linearFactor
Definition: btRigidBody.h:69
btRigidBody::btRigidBodyConstructionInfo::m_startWorldTransform
btTransform m_startWorldTransform
Definition: btRigidBody.h:126
btRigidBody::m_linearVelocity
btVector3 m_linearVelocity
Definition: btRigidBody.h:66
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition: btCollisionObject.h:88
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
btRigidBody::getLocalInertia
btVector3 getLocalInertia() const
Definition: btRigidBody.cpp:261
btPow
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:471
btTransformUtil::integrateTransform
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
Definition: btTransformUtil.h:43
btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:257
btRigidBody::m_debugBodyId
int m_debugBodyId
Definition: btRigidBody.h:98
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btMotionState.h
btRigidBody::btRigidBodyConstructionInfo::m_angularDamping
btScalar m_angularDamping
Definition: btRigidBody.h:131
btRigidBody::setCenterOfMassTransform
void setCenterOfMassTransform(const btTransform &xform)
Definition: btRigidBody.cpp:418
btRigidBody::setMassProps
void setMassProps(btScalar mass, const btVector3 &inertia)
Definition: btRigidBody.cpp:231
btSerializer::finalizeChunk
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
btRigidBody::applyDamping
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping ...
Definition: btRigidBody.cpp:159
btVector3::normalized
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:952
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:473
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:77
btMotionState
The btMotionState interface class allows the dynamics world to synchronize and interpolate the update...
Definition: btMotionState.h:23
btRigidBody::saveKinematicState
void saveKinematicState(btScalar step)
Definition: btRigidBody.cpp:109
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition: btCollisionObject.h:62
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition: btAlignedObjectArray.h:457
btTypedConstraint::getRigidBodyA
const btRigidBody & getRigidBodyA() const
Definition: btTypedConstraint.h:226
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1001
BT_RIGIDBODY_CODE
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:120
btRigidBody::btRigidBodyConstructionInfo::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:141
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:149
btRigidBody::serialize
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btRigidBody.cpp:488
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:87
btRigidBody::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:83
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
btRigidBody::getMotionState
btMotionState * getMotionState()
Definition: btRigidBody.h:471
btRigidBody::getLinearVelocity
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:359
BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
Definition: btRigidBody.h:49
btRigidBody::m_gravity_acceleration
btVector3 m_gravity_acceleration
Definition: btRigidBody.h:72
btRigidBody::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:84
btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:55
btRigidBody::btRigidBodyConstructionInfo::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btRigidBody.h:128
btRigidBody::computeGyroscopicImpulseImplicit_Body
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
Definition: btRigidBody.cpp:314
btRigidBody::m_constraintRefs
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:94
btCollisionObject::m_interpolationLinearVelocity
btVector3 m_interpolationLinearVelocity
Definition: btCollisionObject.h:61
btRigidBody::m_frictionSolverType
int m_frictionSolverType
Definition: btRigidBody.h:488
btRigidBody::removeConstraintRef
void removeConstraintRef(btTypedConstraint *c)
Definition: btRigidBody.cpp:461
btRigidBody::m_deltaAngularVelocity
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:104
btTransformUtil::calculateVelocity
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
Definition: btTransformUtil.h:112
btChunk::m_oldPtr
void * m_oldPtr
Definition: btSerializer.h:56
btClamped
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:35
btRigidBody::btRigidBodyConstructionInfo::m_additionalDamping
bool m_additionalDamping
Definition: btRigidBody.h:146
btTypedConstraint::getRigidBodyB
const btRigidBody & getRigidBodyB() const
Definition: btTypedConstraint.h:230
btRigidBody::btRigidBodyConstructionInfo::m_motionState
btMotionState * m_motionState
When a motionState is provided, the rigid body will initialize its world transform from the motion st...
Definition: btRigidBody.h:125
btRigidBody::btRigidBodyConstructionInfo::m_linearDamping
btScalar m_linearDamping
Definition: btRigidBody.h:130
btCollisionObject::m_friction
btScalar m_friction
Definition: btCollisionObject.h:86
btRigidBody::btRigidBodyConstructionInfo::m_friction
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:134
btSerializer::allocate
virtual btChunk * allocate(size_t size, int numElements)=0
MAX_ANGVEL
#define MAX_ANGVEL
btRigidBody::m_invMass
btVector3 m_invMass
Definition: btRigidBody.h:106
btVector3::getSkewSymmetricMatrix
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
Definition: btVector3.h:648
btMotionState::getWorldTransform
virtual void getWorldTransform(btTransform &worldTrans) const =0
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
uniqueId
static int uniqueId
Definition: btRigidBody.cpp:27
btSerializer.h
btVector3::z
const btScalar & z() const
Return the z value.
Definition: btVector3.h:579
btRigidBody::m_invInertiaTensorWorld
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:65
btRigidBody::setGravity
void setGravity(const btVector3 &acceleration)
Definition: btRigidBody.cpp:135