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 btRigidBody::btRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo)
30 {
31 setupRigidBody(constructionInfo);
32 }
33
34 btRigidBody::btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia)
35 {
36 btRigidBodyConstructionInfo cinfo(mass, motionState, collisionShape, localInertia);
37 setupRigidBody(cinfo);
38 }
39
40 void btRigidBody::setupRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo)
41 {
42 m_internalType = CO_RIGID_BODY;
43
44 m_linearVelocity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
45 m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
46 m_angularFactor.setValue(1, 1, 1);
47 m_linearFactor.setValue(1, 1, 1);
48 m_gravity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
49 m_gravity_acceleration.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
50 m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
51 m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
52 setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
53
54 m_linearSleepingThreshold = constructionInfo.m_linearSleepingThreshold;
55 m_angularSleepingThreshold = constructionInfo.m_angularSleepingThreshold;
56 m_optionalMotionState = constructionInfo.m_motionState;
57 m_contactSolverType = 0;
58 m_frictionSolverType = 0;
59 m_additionalDamping = constructionInfo.m_additionalDamping;
60 m_additionalDampingFactor = constructionInfo.m_additionalDampingFactor;
61 m_additionalLinearDampingThresholdSqr = constructionInfo.m_additionalLinearDampingThresholdSqr;
62 m_additionalAngularDampingThresholdSqr = constructionInfo.m_additionalAngularDampingThresholdSqr;
63 m_additionalAngularDampingFactor = constructionInfo.m_additionalAngularDampingFactor;
64
65 if (m_optionalMotionState)
66 {
67 m_optionalMotionState->getWorldTransform(m_worldTransform);
68 }
69 else
70 {
71 m_worldTransform = constructionInfo.m_startWorldTransform;
72 }
73
74 m_interpolationWorldTransform = m_worldTransform;
75 m_interpolationLinearVelocity.setValue(0, 0, 0);
76 m_interpolationAngularVelocity.setValue(0, 0, 0);
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);
86 m_debugBodyId = uniqueId++;
87
88 setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
89 updateInertiaTensor();
90
91 m_rigidbodyFlags = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY;
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 void btRigidBody::predictIntegratedTransform(btScalar timeStep, btTransform& predictedTransform)
101 {
102 btTransformUtil::integrateTransform(m_worldTransform, m_linearVelocity, m_angularVelocity, timeStep, predictedTransform);
103 }
104
105 void btRigidBody::saveKinematicState(btScalar timeStep)
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())
112 getMotionState()->getWorldTransform(m_worldTransform);
113 btVector3 linVel, angVel;
114
115 btTransformUtil::calculateVelocity(m_interpolationWorldTransform, m_worldTransform, timeStep, m_linearVelocity, m_angularVelocity);
116 m_interpolationLinearVelocity = m_linearVelocity;
117 m_interpolationAngularVelocity = m_angularVelocity;
118 m_interpolationWorldTransform = m_worldTransform;
119 //printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ());
120 }
121 }
122
123 void btRigidBody::getAabb(btVector3& aabbMin, btVector3& aabbMax) const
124 {
125 getCollisionShape()->getAabb(m_worldTransform, aabbMin, aabbMax);
126 }
127
128 void btRigidBody::setGravity(const btVector3& acceleration)
129 {
130 if (m_inverseMass != btScalar(0.0))
131 {
132 m_gravity = acceleration * (btScalar(1.0) / m_inverseMass);
133 }
134 m_gravity_acceleration = acceleration;
135 }
136
137 void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping)
138 {
139 m_linearDamping = btClamped(lin_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
140 m_angularDamping = btClamped(ang_damping, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
141 }
142
144 void btRigidBody::applyDamping(btScalar timeStep)
145 {
146 //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
147 //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
148
149 //#define USE_OLD_DAMPING_METHOD 1
150 #ifdef USE_OLD_DAMPING_METHOD
151 m_linearVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_linearDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
152 m_angularVelocity *= GEN_clamped((btScalar(1.) - timeStep * m_angularDamping), (btScalar)btScalar(0.0), (btScalar)btScalar(1.0));
153 #else
154 m_linearVelocity *= btPow(btScalar(1) - m_linearDamping, timeStep);
155 m_angularVelocity *= btPow(btScalar(1) - m_angularDamping, timeStep);
156 #endif
157
158 if (m_additionalDamping)
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
162 if ((m_angularVelocity.length2() < m_additionalAngularDampingThresholdSqr) &&
163 (m_linearVelocity.length2() < m_additionalLinearDampingThresholdSqr))
164 {
165 m_angularVelocity *= m_additionalDampingFactor;
166 m_linearVelocity *= m_additionalDampingFactor;
167 }
168
169 btScalar speed = m_linearVelocity.length();
170 if (speed < m_linearDamping)
171 {
172 btScalar dampVel = btScalar(0.005);
173 if (speed > dampVel)
174 {
175 btVector3 dir = m_linearVelocity.normalized();
176 m_linearVelocity -= dir * dampVel;
177 }
178 else
179 {
180 m_linearVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
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 {
190 btVector3 dir = m_angularVelocity.normalized();
191 m_angularVelocity -= dir * angDampVel;
192 }
193 else
194 {
195 m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
196 }
197 }
198 }
199 }
200
201 void btRigidBody::applyGravity()
202 {
203 if (isStaticOrKinematicObject())
204 return;
205
206 applyCentralForce(m_gravity);
207 }
208
209 void btRigidBody::proceedToTransform(const btTransform& newTrans)
210 {
211 setCenterOfMassTransform(newTrans);
212 }
213
214 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
215 {
216 if (mass == btScalar(0.))
217 {
218 m_collisionFlags |= btCollisionObject::CF_STATIC_OBJECT;
219 m_inverseMass = btScalar(0.);
220 }
221 else
222 {
223 m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT);
224 m_inverseMass = btScalar(1.0) / mass;
225 }
226
227 //Fg = m * a
228 m_gravity = mass * m_gravity_acceleration;
229
230 m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
231 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
232 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
233
234 m_invMass = m_linearFactor * m_inverseMass;
235 }
236
237 void btRigidBody::updateInertiaTensor()
238 {
239 m_invInertiaTensorWorld = m_worldTransform.getBasis().scaled(m_invInertiaLocal) * m_worldTransform.getBasis().transpose();
240 }
241
242 btVector3 btRigidBody::getLocalInertia() const
243 {
244 btVector3 inertiaLocal;
245 const btVector3 inertia = m_invInertiaLocal;
246 inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
247 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
248 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
249 return inertiaLocal;
250 }
251
252 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
253 const btMatrix3x3& I)
254 {
255 const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0);
256 return w2;
257 }
258
259 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
260 const btMatrix3x3& I)
261 {
262 btMatrix3x3 w1x, Iw1x;
263 const btVector3 Iwi = (I * w1);
264 w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
265 Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
266
267 const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt;
268 return dfw1;
269 }
270
271 btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
272 {
273 btVector3 inertiaLocal = getLocalInertia();
274 btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
275 btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
276 btVector3 gf = getAngularVelocity().cross(tmp);
277 btScalar l2 = gf.length2();
278 if (l2 > maxGyroscopicForce * maxGyroscopicForce)
279 {
280 gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce;
281 }
282 return gf;
283 }
284
285 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) const
286 {
287 btVector3 idl = getLocalInertia();
288 btVector3 omega1 = getAngularVelocity();
289 btQuaternion q = getWorldTransform().getRotation();
290
291 // Convert to body coordinates
292 btVector3 omegab = quatRotate(q.inverse(), omega1);
293 btMatrix3x3 Ib;
294 Ib.setValue(idl.x(), 0, 0,
295 0, idl.y(), 0,
296 0, 0, idl.z());
297
298 btVector3 ibo = Ib * omegab;
299
300 // Residual vector
301 btVector3 f = step * omegab.cross(ibo);
302
303 btMatrix3x3 skew0;
304 omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
305 btVector3 om = Ib * omegab;
306 btMatrix3x3 skew1;
307 om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]);
308
309 // Jacobian
310 btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step;
311
312 // btMatrix3x3 Jinv = J.inverse();
313 // btVector3 omega_div = Jinv*f;
314 btVector3 omega_div = J.solve33(f);
315
316 // Single Newton-Raphson update
317 omegab = omegab - omega_div; //Solve33(J, f);
318 // Back to world coordinates
319 btVector3 omega2 = quatRotate(q, omegab);
320 btVector3 gf = omega2 - omega1;
321 return gf;
322 }
323
324 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_World(btScalar step) const
325 {
326 // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
327 // calculate using implicit euler step so it's stable.
328
329 const btVector3 inertiaLocal = getLocalInertia();
330 const btVector3 w0 = getAngularVelocity();
331
332 btMatrix3x3 I;
333
334 I = m_worldTransform.getBasis().scaled(inertiaLocal) *
335 m_worldTransform.getBasis().transpose();
336
337 // use newtons method to find implicit solution for new angular velocity (w')
338 // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
339 // df/dw' = I + 1xIw'*step + w'xI*step
340
341 btVector3 w1 = w0;
342
343 // one step of newton's method
344 {
345 const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
346 const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
347
348 btVector3 dw;
349 dw = dfw.solve33(fw);
350 //const btMatrix3x3 dfw_inv = dfw.inverse();
351 //dw = dfw_inv*fw;
352
353 w1 -= dw;
354 }
355
356 btVector3 gf = (w1 - w0);
357 return gf;
358 }
359
360 void btRigidBody::integrateVelocities(btScalar step)
361 {
362 if (isStaticOrKinematicObject())
363 return;
364
365 m_linearVelocity += m_totalForce * (m_inverseMass * step);
366 m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step;
367
368 #define MAX_ANGVEL SIMD_HALF_PI
369 btScalar angvel = m_angularVelocity.length();
371 if (angvel * step > MAX_ANGVEL)
372 {
373 m_angularVelocity *= (MAX_ANGVEL / step) / angvel;
374 }
375 }
376
377 btQuaternion btRigidBody::getOrientation() const
378 {
379 btQuaternion orn;
380 m_worldTransform.getBasis().getRotation(orn);
381 return orn;
382 }
383
384 void btRigidBody::setCenterOfMassTransform(const btTransform& xform)
385 {
386 if (isKinematicObject())
387 {
388 m_interpolationWorldTransform = m_worldTransform;
389 }
390 else
391 {
392 m_interpolationWorldTransform = xform;
393 }
394 m_interpolationLinearVelocity = getLinearVelocity();
395 m_interpolationAngularVelocity = getAngularVelocity();
396 m_worldTransform = xform;
397 updateInertiaTensor();
398 }
399
400 void btRigidBody::addConstraintRef(btTypedConstraint* c)
401 {
403
404 int index = m_constraintRefs.findLinearSearch(c);
405 //don't add constraints that are already referenced
406 //btAssert(index == m_constraintRefs.size());
407 if (index == m_constraintRefs.size())
408 {
409 m_constraintRefs.push_back(c);
410 btCollisionObject* colObjA = &c->getRigidBodyA();
411 btCollisionObject* colObjB = &c->getRigidBodyB();
412 if (colObjA == this)
413 {
414 colObjA->setIgnoreCollisionCheck(colObjB, true);
415 }
416 else
417 {
418 colObjB->setIgnoreCollisionCheck(colObjA, true);
419 }
420 }
421 }
422
423 void btRigidBody::removeConstraintRef(btTypedConstraint* c)
424 {
425 int index = m_constraintRefs.findLinearSearch(c);
426 //don't remove constraints that are not referenced
427 if (index < m_constraintRefs.size())
428 {
429 m_constraintRefs.remove(c);
430 btCollisionObject* colObjA = &c->getRigidBodyA();
431 btCollisionObject* colObjB = &c->getRigidBodyB();
432 if (colObjA == this)
433 {
434 colObjA->setIgnoreCollisionCheck(colObjB, false);
435 }
436 else
437 {
438 colObjB->setIgnoreCollisionCheck(colObjA, false);
439 }
440 }
441 }
442
443 int btRigidBody::calculateSerializeBufferSize() const
444 {
445 int sz = sizeof(btRigidBodyData);
446 return sz;
447 }
448
450 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
451 {
452 btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer;
453
454 btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
455
456 m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
457 m_linearVelocity.serialize(rbd->m_linearVelocity);
458 m_angularVelocity.serialize(rbd->m_angularVelocity);
459 rbd->m_inverseMass = m_inverseMass;
460 m_angularFactor.serialize(rbd->m_angularFactor);
461 m_linearFactor.serialize(rbd->m_linearFactor);
462 m_gravity.serialize(rbd->m_gravity);
463 m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
464 m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
465 m_totalForce.serialize(rbd->m_totalForce);
466 m_totalTorque.serialize(rbd->m_totalTorque);
467 rbd->m_linearDamping = m_linearDamping;
468 rbd->m_angularDamping = m_angularDamping;
469 rbd->m_additionalDamping = m_additionalDamping;
470 rbd->m_additionalDampingFactor = m_additionalDampingFactor;
471 rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
472 rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
473 rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
474 rbd->m_linearSleepingThreshold = m_linearSleepingThreshold;
475 rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
476
477 // Fill padding with zeros to appease msan.
478 #ifdef BT_USE_DOUBLE_PRECISION
479 memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
480 #endif
481
482 return btRigidBodyDataName;
483 }
484
485 void btRigidBody::serializeSingleObject(class btSerializer* serializer) const
486 {
487 btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1);
488 const char* structType = serialize(chunk->m_oldPtr, serializer);
489 serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this);
490 }
btRigidBody::btRigidBodyConstructionInfo::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:139
btTransformUtil.h
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:264
btRigidBody::getAabb
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition: btRigidBody.cpp:123
btMatrix3x3::serialize
void serialize(struct btMatrix3x3Data &dataOut) const
Definition: btMatrix3x3.h:1378
btChunk
Definition: btSerializer.h:47
btRigidBody::getAngularVelocity
const btVector3 & getAngularVelocity() const
Definition: btRigidBody.h:357
btRigidBody::applyGravity
void applyGravity()
Definition: btRigidBody.cpp:201
btRigidBody::m_totalTorque
btVector3 m_totalTorque
Definition: btRigidBody.h:71
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:80
btRigidBody::btRigidBodyConstructionInfo::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:134
btRigidBody::m_contactSolverType
int m_contactSolverType
Definition: btRigidBody.h:473
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btMatrix3x3::solve33
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition: btMatrix3x3.h:625
btRigidBody::computeGyroscopicForceExplicit
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
Definition: btRigidBody.cpp:271
btRigidBody::predictIntegratedTransform
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
Definition: btRigidBody.cpp:100
btRigidBody::updateInertiaTensor
void updateInertiaTensor()
Definition: btRigidBody.cpp:237
btRigidBody::m_totalForce
btVector3 m_totalForce
Definition: btRigidBody.h:70
btRigidBody::m_angularDamping
btScalar m_angularDamping
Definition: btRigidBody.h:74
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition: btAlignedObjectArray.h:445
evalEulerEqn
btVector3 evalEulerEqn(const btVector3 &w1, const btVector3 &w0, const btVector3 &T, const btScalar dt, const btMatrix3x3 &I)
Definition: btRigidBody.cpp:252
btCollisionObject::m_interpolationWorldTransform
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
Definition: btCollisionObject.h:56
btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition: btVector3.h:251
gDisableDeactivation
bool gDisableDeactivation
Definition: btRigidBody.cpp:26
btTypedConstraint::getRigidBodyA
const btRigidBody & getRigidBodyA() const
Definition: btTypedConstraint.h:214
btRigidBody::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btRigidBody.cpp:443
btRigidBody::m_turnVelocity
btVector3 m_turnVelocity
Definition: btRigidBody.h:101
btSqrt
btScalar btSqrt(btScalar y)
Definition: btScalar.h:446
btTransform::getRotation
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:118
btRigidBody::m_gravity
btVector3 m_gravity
Definition: btRigidBody.h:67
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:26
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition: btCollisionObject.h:198
gDeactivationTime
btScalar gDeactivationTime
Definition: btRigidBody.cpp:25
btRigidBody::btRigidBodyConstructionInfo::m_mass
btScalar m_mass
Definition: btRigidBody.h:111
btRigidBody::btRigidBody
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition: btRigidBody.cpp:29
btRigidBody::setDamping
void setDamping(btScalar lin_damping, btScalar ang_damping)
Definition: btRigidBody.cpp:137
btRigidBody::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition: btRigidBody.h:83
btCollisionObject::CF_STATIC_OBJECT
Definition: btCollisionObject.h:128
btRigidBody::getOrientation
btQuaternion getOrientation() const
Definition: btRigidBody.cpp:377
btRigidBody::m_additionalDamping
bool m_additionalDamping
Definition: btRigidBody.h:76
btTypedConstraint::getRigidBodyB
const btRigidBody & getRigidBodyB() const
Definition: btTypedConstraint.h:218
btRigidBodyData
#define btRigidBodyData
Definition: btRigidBody.h:35
btRigidBody::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:78
btRigidBody::m_rigidbodyFlags
int m_rigidbodyFlags
Definition: btRigidBody.h:91
btCollisionObject::m_spinningFriction
btScalar m_spinningFriction
Definition: btCollisionObject.h:88
btRigidBody::btRigidBodyConstructionInfo::m_localInertia
btVector3 m_localInertia
Definition: btRigidBody.h:119
btRigidBody.h
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:52
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:203
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:127
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:100
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition: btCollisionObject.h:234
btSerializer
Definition: btSerializer.h:65
btRigidBody::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btRigidBody.h:240
quatRotate
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition: btQuaternion.h:926
btVector3::normalized
btVector3 normalized() const
Return a normalized version of this vector.
Definition: btVector3.h:949
btCollisionObject::~btCollisionObject
virtual ~btCollisionObject()
Definition: btCollisionObject.cpp:56
btRigidBody::btRigidBodyConstructionInfo::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition: btRigidBody.h:140
btRigidBody::m_inverseMass
btScalar m_inverseMass
Definition: btRigidBody.h:64
btRigidBody::applyCentralForce
void applyCentralForce(const btVector3 &force)
Definition: btRigidBody.h:271
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:1026
btCollisionObject::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition: btCollisionObject.h:217
btRigidBody::integrateVelocities
void integrateVelocities(btScalar step)
Definition: btRigidBody.cpp:360
btTypedConstraint.h
btRigidBody::m_invInertiaLocal
btVector3 m_invInertiaLocal
Definition: btRigidBody.h:69
btQuaternion::inverse
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:497
btRigidBody::computeGyroscopicImpulseImplicit_World
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
Definition: btRigidBody.cpp:324
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:365
btRigidBody::m_deltaLinearVelocity
btVector3 m_deltaLinearVelocity
Definition: btRigidBody.h:96
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
Definition: btCollisionObject.h:94
btRigidBody::getLinearVelocity
const btVector3 & getLinearVelocity() const
Definition: btRigidBody.h:353
btRigidBody::setupRigidBody
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition: btRigidBody.cpp:40
btVector3::x
const btScalar & x() const
Return the x value.
Definition: btVector3.h:575
btRigidBody::addConstraintRef
void addConstraintRef(btTypedConstraint *c)
Definition: btRigidBody.cpp:400
btVector3::cross
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
Definition: btVector3.h:380
btVector3::getSkewSymmetricMatrix
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
Definition: btVector3.h:648
btCollisionObject::CO_RIGID_BODY
Definition: btCollisionObject.h:144
btRigidBody::m_optionalMotionState
btMotionState * m_optionalMotionState
Definition: btRigidBody.h:86
btRigidBody::btRigidBodyConstructionInfo::m_restitution
btScalar m_restitution
best simulation results using zero restitution.
Definition: btRigidBody.h:131
btMatrix3x3::scaled
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition: btMatrix3x3.h:599
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:48
btRigidBody::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:82
btVector3::y
const btScalar & y() const
Return the y value.
Definition: btVector3.h:577
btVector3::z
const btScalar & z() const
Return the z value.
Definition: btVector3.h:579
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:108
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:195
btVector3::setZero
void setZero()
Definition: btVector3.h:671
btRigidBody::m_angularFactor
btVector3 m_angularFactor
Definition: btRigidBody.h:98
evalEulerEqnDeriv
btMatrix3x3 evalEulerEqnDeriv(const btVector3 &w1, const btVector3 &w0, const btScalar dt, const btMatrix3x3 &I)
Definition: btRigidBody.cpp:259
btRigidBody::btRigidBodyConstructionInfo
The btRigidBodyConstructionInfo structure provides information to create a rigid body.
Definition: btRigidBody.h:109
btRigidBody::m_angularVelocity
btVector3 m_angularVelocity
Definition: btRigidBody.h:63
btRigidBody::proceedToTransform
void proceedToTransform(const btTransform &newTrans)
Definition: btRigidBody.cpp:209
btRigidBodyDataName
#define btRigidBodyDataName
Definition: btRigidBody.h:36
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:76
btRigidBody::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition: btRigidBody.h:77
btMinMax.h
btRigidBody::m_linearDamping
btScalar m_linearDamping
Definition: btRigidBody.h:73
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:142
btRigidBody::m_linearFactor
btVector3 m_linearFactor
Definition: btRigidBody.h:65
btRigidBody::btRigidBodyConstructionInfo::m_startWorldTransform
btTransform m_startWorldTransform
Definition: btRigidBody.h:116
btRigidBody::m_linearVelocity
btVector3 m_linearVelocity
Definition: btRigidBody.h:62
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition: btCollisionObject.h:87
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:80
btPow
btScalar btPow(btScalar x, btScalar y)
Definition: btScalar.h:501
btTransformUtil::integrateTransform
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
Definition: btTransformUtil.h:32
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btRigidBody::m_debugBodyId
int m_debugBodyId
Definition: btRigidBody.h:93
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:28
btMotionState.h
btRigidBody::btRigidBodyConstructionInfo::m_angularDamping
btScalar m_angularDamping
Definition: btRigidBody.h:121
btVector3::serialize
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1317
btRigidBody::setCenterOfMassTransform
void setCenterOfMassTransform(const btTransform &xform)
Definition: btRigidBody.cpp:384
btRigidBody::setMassProps
void setMassProps(btScalar mass, const btVector3 &inertia)
Definition: btRigidBody.cpp:214
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:144
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:487
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:74
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:105
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition: btCollisionObject.h:60
BT_RIGIDBODY_CODE
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:112
btRigidBody::btRigidBodyConstructionInfo::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition: btRigidBody.h:133
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:141
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:86
btRigidBody::btRigidBodyConstructionInfo::m_spinningFriction
btScalar m_spinningFriction
Definition: btRigidBody.h:128
btRigidBody::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition: btRigidBody.h:79
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:46
btRigidBody::getMotionState
btMotionState * getMotionState()
Definition: btRigidBody.h:457
BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
Definition: btRigidBody.h:47
btRigidBody::m_gravity_acceleration
btVector3 m_gravity_acceleration
Definition: btRigidBody.h:68
btRigidBody::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition: btRigidBody.h:80
btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:49
btRigidBody::btRigidBodyConstructionInfo::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btRigidBody.h:118
btRigidBody::m_constraintRefs
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition: btRigidBody.h:89
btCollisionObject::m_interpolationLinearVelocity
btVector3 m_interpolationLinearVelocity
Definition: btCollisionObject.h:59
btRigidBody::m_frictionSolverType
int m_frictionSolverType
Definition: btRigidBody.h:474
btRigidBody::removeConstraintRef
void removeConstraintRef(btTypedConstraint *c)
Definition: btRigidBody.cpp:423
btRigidBody::m_deltaAngularVelocity
btVector3 m_deltaAngularVelocity
Definition: btRigidBody.h:97
btTransformUtil::calculateVelocity
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
Definition: btTransformUtil.h:115
btChunk::m_oldPtr
void * m_oldPtr
Definition: btSerializer.h:52
btClamped
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition: btMinMax.h:33
btRigidBody::btRigidBodyConstructionInfo::m_additionalDamping
bool m_additionalDamping
Definition: btRigidBody.h:138
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:115
btMatrix3x3::getRotation
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition: btMatrix3x3.h:397
btRigidBody::btRigidBodyConstructionInfo::m_linearDamping
btScalar m_linearDamping
Definition: btRigidBody.h:120
btCollisionObject::m_friction
btScalar m_friction
Definition: btCollisionObject.h:85
btRigidBody::btRigidBodyConstructionInfo::m_friction
btScalar m_friction
best simulation results when friction is non-zero
Definition: btRigidBody.h:124
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:285
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:450
btRigidBody::m_invMass
btVector3 m_invMass
Definition: btRigidBody.h:99
btRigidBody::serializeSingleObject
virtual void serializeSingleObject(class btSerializer *serializer) const
Definition: btRigidBody.cpp:485
btRigidBody::getLocalInertia
btVector3 getLocalInertia() const
Definition: btRigidBody.cpp:242
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:294
btVector3::length
btScalar length() const
Return the length of the vector.
Definition: btVector3.h:257
uniqueId
static int uniqueId
Definition: btRigidBody.cpp:27
btSerializer.h
btRigidBody::m_invInertiaTensorWorld
btMatrix3x3 m_invInertiaTensorWorld
Definition: btRigidBody.h:61
btRigidBody::setGravity
void setGravity(const btVector3 &acceleration)
Definition: btRigidBody.cpp:128