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

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