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/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#include "btRigidBody.h"
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
29btRigidBody::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#ifdef BT_USE_OLD_DAMPING_METHOD
140 m_linearDamping = btMax(lin_damping, btScalar(0.0));
141 m_angularDamping = btMax(ang_damping, btScalar(0.0));
142#else
143 m_linearDamping = btClamped(lin_damping, btScalar(0.0), btScalar(1.0));
144 m_angularDamping = btClamped(ang_damping, btScalar(0.0), btScalar(1.0));
145#endif
146}
147
149 void btRigidBody::applyDamping(btScalar timeStep)
150{
151 //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74
152 //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway
153
154#ifdef BT_USE_OLD_DAMPING_METHOD
155 m_linearVelocity *= btMax((btScalar(1.0) - timeStep * m_linearDamping), btScalar(0.0));
156 m_angularVelocity *= btMax((btScalar(1.0) - timeStep * m_angularDamping), btScalar(0.0));
157#else
158 m_linearVelocity *= btPow(btScalar(1) - m_linearDamping, timeStep);
159 m_angularVelocity *= btPow(btScalar(1) - m_angularDamping, timeStep);
160#endif
161
162 if (m_additionalDamping)
163 {
164 //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
165 //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
166 if ((m_angularVelocity.length2() < m_additionalAngularDampingThresholdSqr) &&
167 (m_linearVelocity.length2() < m_additionalLinearDampingThresholdSqr))
168 {
169 m_angularVelocity *= m_additionalDampingFactor;
170 m_linearVelocity *= m_additionalDampingFactor;
171 }
172
173 btScalar speed = m_linearVelocity.length();
174 if (speed < m_linearDamping)
175 {
176 btScalar dampVel = btScalar(0.005);
177 if (speed > dampVel)
178 {
179 btVector3 dir = m_linearVelocity.normalized();
180 m_linearVelocity -= dir * dampVel;
181 }
182 else
183 {
184 m_linearVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
185 }
186 }
187
188 btScalar angSpeed = m_angularVelocity.length();
189 if (angSpeed < m_angularDamping)
190 {
191 btScalar angDampVel = btScalar(0.005);
192 if (angSpeed > angDampVel)
193 {
194 btVector3 dir = m_angularVelocity.normalized();
195 m_angularVelocity -= dir * angDampVel;
196 }
197 else
198 {
199 m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
200 }
201 }
202 }
203}
204
205 void btRigidBody::applyGravity()
206{
207 if (isStaticOrKinematicObject())
208 return;
209
210 applyCentralForce(m_gravity);
211}
212
213 void btRigidBody::clearGravity()
214{
215 if (isStaticOrKinematicObject())
216 return;
217
218 applyCentralForce(-m_gravity);
219}
220
221 void btRigidBody::proceedToTransform(const btTransform& newTrans)
222{
223 setCenterOfMassTransform(newTrans);
224}
225
226 void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
227{
228 if (mass == btScalar(0.))
229 {
230 m_collisionFlags |= btCollisionObject::CF_STATIC_OBJECT;
231 m_inverseMass = btScalar(0.);
232 }
233 else
234 {
235 m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT);
236 m_inverseMass = btScalar(1.0) / mass;
237 }
238
239 //Fg = m * a
240 m_gravity = mass * m_gravity_acceleration;
241
242 m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
243 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
244 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
245
246 m_invMass = m_linearFactor * m_inverseMass;
247}
248
249 void btRigidBody::updateInertiaTensor()
250{
251 m_invInertiaTensorWorld = m_worldTransform.getBasis().scaled(m_invInertiaLocal) * m_worldTransform.getBasis().transpose();
252}
253
254 btVector3 btRigidBody::getLocalInertia() const
255{
256 btVector3 inertiaLocal;
257 const btVector3 inertia = m_invInertiaLocal;
258 inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
259 inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
260 inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
261 return inertiaLocal;
262}
263
264 inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt,
265 const btMatrix3x3& I)
266{
267 const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0);
268 return w2;
269}
270
271 inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt,
272 const btMatrix3x3& I)
273{
274 btMatrix3x3 w1x, Iw1x;
275 const btVector3 Iwi = (I * w1);
276 w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]);
277 Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]);
278
279 const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt;
280 return dfw1;
281}
282
283 btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
284{
285 btVector3 inertiaLocal = getLocalInertia();
286 btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose();
287 btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
288 btVector3 gf = getAngularVelocity().cross(tmp);
289 btScalar l2 = gf.length2();
290 if (l2 > maxGyroscopicForce * maxGyroscopicForce)
291 {
292 gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce;
293 }
294 return gf;
295}
296
297 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) const
298{
299 btVector3 idl = getLocalInertia();
300 btVector3 omega1 = getAngularVelocity();
301 btQuaternion q = getWorldTransform().getRotation();
302
303 // Convert to body coordinates
304 btVector3 omegab = quatRotate(q.inverse(), omega1);
305 btMatrix3x3 Ib;
306 Ib.setValue(idl.x(), 0, 0,
307 0, idl.y(), 0,
308 0, 0, idl.z());
309
310 btVector3 ibo = Ib * omegab;
311
312 // Residual vector
313 btVector3 f = step * omegab.cross(ibo);
314
315 btMatrix3x3 skew0;
316 omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]);
317 btVector3 om = Ib * omegab;
318 btMatrix3x3 skew1;
319 om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]);
320
321 // Jacobian
322 btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step;
323
324 // btMatrix3x3 Jinv = J.inverse();
325 // btVector3 omega_div = Jinv*f;
326 btVector3 omega_div = J.solve33(f);
327
328 // Single Newton-Raphson update
329 omegab = omegab - omega_div; //Solve33(J, f);
330 // Back to world coordinates
331 btVector3 omega2 = quatRotate(q, omegab);
332 btVector3 gf = omega2 - omega1;
333 return gf;
334}
335
336 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_World(btScalar step) const
337{
338 // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior.
339 // calculate using implicit euler step so it's stable.
340
341 const btVector3 inertiaLocal = getLocalInertia();
342 const btVector3 w0 = getAngularVelocity();
343
344 btMatrix3x3 I;
345
346 I = m_worldTransform.getBasis().scaled(inertiaLocal) *
347 m_worldTransform.getBasis().transpose();
348
349 // use newtons method to find implicit solution for new angular velocity (w')
350 // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0
351 // df/dw' = I + 1xIw'*step + w'xI*step
352
353 btVector3 w1 = w0;
354
355 // one step of newton's method
356 {
357 const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I);
358 const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I);
359
360 btVector3 dw;
361 dw = dfw.solve33(fw);
362 //const btMatrix3x3 dfw_inv = dfw.inverse();
363 //dw = dfw_inv*fw;
364
365 w1 -= dw;
366 }
367
368 btVector3 gf = (w1 - w0);
369 return gf;
370}
371
372 void btRigidBody::integrateVelocities(btScalar step)
373{
374 if (isStaticOrKinematicObject())
375 return;
376
377 m_linearVelocity += m_totalForce * (m_inverseMass * step);
378 m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step;
379
380#define MAX_ANGVEL SIMD_HALF_PI
382 btScalar angvel = m_angularVelocity.length();
383 if (angvel * step > MAX_ANGVEL)
384 {
385 m_angularVelocity *= (MAX_ANGVEL / step) / angvel;
386 }
387 #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
388 clampVelocity(m_angularVelocity);
389 #endif
390}
391
392 btQuaternion btRigidBody::getOrientation() const
393{
394 btQuaternion orn;
395 m_worldTransform.getBasis().getRotation(orn);
396 return orn;
397}
398
399 void btRigidBody::setCenterOfMassTransform(const btTransform& xform)
400{
401 if (isKinematicObject())
402 {
403 m_interpolationWorldTransform = m_worldTransform;
404 }
405 else
406 {
407 m_interpolationWorldTransform = xform;
408 }
409 m_interpolationLinearVelocity = getLinearVelocity();
410 m_interpolationAngularVelocity = getAngularVelocity();
411 m_worldTransform = xform;
412 updateInertiaTensor();
413}
414
415 void btRigidBody::addConstraintRef(btTypedConstraint* c)
416{
418
419 int index = m_constraintRefs.findLinearSearch(c);
420 //don't add constraints that are already referenced
421 //btAssert(index == m_constraintRefs.size());
422 if (index == m_constraintRefs.size())
423 {
424 m_constraintRefs.push_back(c);
425 btCollisionObject* colObjA = &c->getRigidBodyA();
426 btCollisionObject* colObjB = &c->getRigidBodyB();
427 if (colObjA == this)
428 {
429 colObjA->setIgnoreCollisionCheck(colObjB, true);
430 }
431 else
432 {
433 colObjB->setIgnoreCollisionCheck(colObjA, true);
434 }
435 }
436}
437
438 void btRigidBody::removeConstraintRef(btTypedConstraint* c)
439{
440 int index = m_constraintRefs.findLinearSearch(c);
441 //don't remove constraints that are not referenced
442 if (index < m_constraintRefs.size())
443 {
444 m_constraintRefs.remove(c);
445 btCollisionObject* colObjA = &c->getRigidBodyA();
446 btCollisionObject* colObjB = &c->getRigidBodyB();
447 if (colObjA == this)
448 {
449 colObjA->setIgnoreCollisionCheck(colObjB, false);
450 }
451 else
452 {
453 colObjB->setIgnoreCollisionCheck(colObjA, false);
454 }
455 }
456}
457
458 int btRigidBody::calculateSerializeBufferSize() const
459{
460 int sz = sizeof(btRigidBodyData);
461 return sz;
462}
463
465 const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const
466{
467 btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer;
468
469 btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer);
470
471 m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld);
472 m_linearVelocity.serialize(rbd->m_linearVelocity);
473 m_angularVelocity.serialize(rbd->m_angularVelocity);
474 rbd->m_inverseMass = m_inverseMass;
475 m_angularFactor.serialize(rbd->m_angularFactor);
476 m_linearFactor.serialize(rbd->m_linearFactor);
477 m_gravity.serialize(rbd->m_gravity);
478 m_gravity_acceleration.serialize(rbd->m_gravity_acceleration);
479 m_invInertiaLocal.serialize(rbd->m_invInertiaLocal);
480 m_totalForce.serialize(rbd->m_totalForce);
481 m_totalTorque.serialize(rbd->m_totalTorque);
482 rbd->m_linearDamping = m_linearDamping;
483 rbd->m_angularDamping = m_angularDamping;
484 rbd->m_additionalDamping = m_additionalDamping;
485 rbd->m_additionalDampingFactor = m_additionalDampingFactor;
486 rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr;
487 rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr;
488 rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor;
489 rbd->m_linearSleepingThreshold = m_linearSleepingThreshold;
490 rbd->m_angularSleepingThreshold = m_angularSleepingThreshold;
491
492 // Fill padding with zeros to appease msan.
493#ifdef BT_USE_DOUBLE_PRECISION
494 memset(rbd->m_padding, 0, sizeof(rbd->m_padding));
495#endif
496
497 return btRigidBodyDataName;
498}
499
500 void btRigidBody::serializeSingleObject(class btSerializer* serializer) const
501{
502 btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1);
503 const char* structType = serialize(chunk->m_oldPtr, serializer);
504 serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this);
505}
btConvexShape.h
btMinMax.h
btClamped
const T & btClamped(const T &a, const T &lb, const T &ub)
Definition btMinMax.h:33
btMax
const T & btMax(const T &a, const T &b)
Definition btMinMax.h:27
btMotionState.h
quatRotate
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
Definition btQuaternion.h:926
gDisableDeactivation
bool gDisableDeactivation
Definition btRigidBody.cpp:26
MAX_ANGVEL
#define MAX_ANGVEL
evalEulerEqn
btVector3 evalEulerEqn(const btVector3 &w1, const btVector3 &w0, const btVector3 &T, const btScalar dt, const btMatrix3x3 &I)
Definition btRigidBody.cpp:264
gDeactivationTime
btScalar gDeactivationTime
Definition btRigidBody.cpp:25
uniqueId
static int uniqueId
Definition btRigidBody.cpp:27
evalEulerEqnDeriv
btMatrix3x3 evalEulerEqnDeriv(const btVector3 &w1, const btVector3 &w0, const btScalar dt, const btMatrix3x3 &I)
Definition btRigidBody.cpp:271
btRigidBody.h
btRigidBodyDataName
#define btRigidBodyDataName
Definition btRigidBody.h:36
btRigidBodyData
#define btRigidBodyData
Definition btRigidBody.h:35
BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
@ BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
Definition btRigidBody.h:47
btPow
btScalar btPow(btScalar x, btScalar y)
Definition btScalar.h:521
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition btScalar.h:314
btSqrt
btScalar btSqrt(btScalar y)
Definition btScalar.h:466
btSerializer.h
BT_RIGIDBODY_CODE
#define BT_RIGIDBODY_CODE
Definition btSerializer.h:112
btTransformUtil.h
btTypedConstraint.h
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition btAlignedObjectArray.h:142
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition btAlignedObjectArray.h:438
btAlignedObjectArray::remove
void remove(const T &key)
Definition btAlignedObjectArray.h:480
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition btAlignedObjectArray.h:257
btChunk
Definition btSerializer.h:48
btChunk::m_oldPtr
void * m_oldPtr
Definition btSerializer.h:52
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition btCollisionObject.h:51
btCollisionObject::CF_STATIC_OBJECT
@ CF_STATIC_OBJECT
Definition btCollisionObject.h:132
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition btCollisionObject.h:207
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:81
btCollisionObject::CO_RIGID_BODY
@ CO_RIGID_BODY
Definition btCollisionObject.h:148
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition btCollisionObject.h:379
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition btCollisionObject.h:53
btCollisionObject::m_friction
btScalar m_friction
Definition btCollisionObject.h:86
btCollisionObject::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition btCollisionObject.h:221
btCollisionObject::m_interpolationLinearVelocity
btVector3 m_interpolationLinearVelocity
Definition btCollisionObject.h:60
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition btCollisionObject.h:238
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition btCollisionObject.h:61
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody,...
Definition btCollisionObject.h:95
btCollisionObject::m_interpolationWorldTransform
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
Definition btCollisionObject.h:57
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition btCollisionObject.h:202
btCollisionObject::~btCollisionObject
virtual ~btCollisionObject()
Definition btCollisionObject.cpp:57
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition btCollisionObject.h:77
btCollisionObject::m_spinningFriction
btScalar m_spinningFriction
Definition btCollisionObject.h:89
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition btCollisionObject.h:88
btCollisionObject::m_restitution
btScalar m_restitution
Definition btCollisionObject.h:87
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition btCollisionShape.h:28
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.
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition btMatrix3x3.h:50
btMatrix3x3::solve33
btVector3 solve33(const btVector3 &b) const
Solve A * x = b, where b is a column vector.
Definition btMatrix3x3.h:648
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition btMatrix3x3.h:1049
btMatrix3x3::getRotation
void getRotation(btQuaternion &q) const
Get the matrix represented as a quaternion.
Definition btMatrix3x3.h:420
btMatrix3x3::scaled
btMatrix3x3 scaled(const btVector3 &s) const
Create a scaled copy of the matrix.
Definition btMatrix3x3.h:622
btMatrix3x3::serialize
void serialize(struct btMatrix3x3Data &dataOut) const
Definition btMatrix3x3.h:1401
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:204
btMotionState
The btMotionState interface class allows the dynamics world to synchronize and interpolate the update...
Definition btMotionState.h:24
btMotionState::getWorldTransform
virtual void getWorldTransform(btTransform &worldTrans) const =0
btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition btQuaternion.h:50
btQuaternion::inverse
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition btQuaternion.h:497
btRigidBody::getAabb
void getAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
Definition btRigidBody.cpp:123
btRigidBody::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition btRigidBody.h:80
btRigidBody::applyGravity
void applyGravity()
Definition btRigidBody.cpp:205
btRigidBody::integrateVelocities
void integrateVelocities(btScalar step)
Definition btRigidBody.cpp:372
btRigidBody::addConstraintRef
void addConstraintRef(btTypedConstraint *c)
Definition btRigidBody.cpp:415
btRigidBody::serializeSingleObject
virtual void serializeSingleObject(class btSerializer *serializer) const
Definition btRigidBody.cpp:500
btRigidBody::m_linearDamping
btScalar m_linearDamping
Definition btRigidBody.h:73
btRigidBody::m_invInertiaTensorWorld
btMatrix3x3 m_invInertiaTensorWorld
Definition btRigidBody.h:61
btRigidBody::m_frictionSolverType
int m_frictionSolverType
Definition btRigidBody.h:566
btRigidBody::m_invInertiaLocal
btVector3 m_invInertiaLocal
Definition btRigidBody.h:69
btRigidBody::applyDamping
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
Definition btRigidBody.cpp:149
btRigidBody::m_optionalMotionState
btMotionState * m_optionalMotionState
Definition btRigidBody.h:86
btRigidBody::m_gravity
btVector3 m_gravity
Definition btRigidBody.h:67
btRigidBody::m_contactSolverType
int m_contactSolverType
Definition btRigidBody.h:565
btRigidBody::applyCentralForce
void applyCentralForce(const btVector3 &force)
Definition btRigidBody.h:274
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:465
btRigidBody::m_turnVelocity
btVector3 m_turnVelocity
Definition btRigidBody.h:101
btRigidBody::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition btRigidBody.h:77
btRigidBody::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition btRigidBody.cpp:458
btRigidBody::m_rigidbodyFlags
int m_rigidbodyFlags
Definition btRigidBody.h:91
btRigidBody::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition btRigidBody.h:79
btRigidBody::setGravity
void setGravity(const btVector3 &acceleration)
Definition btRigidBody.cpp:128
btRigidBody::btRigidBody
btRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
btRigidBody constructor using construction info
Definition btRigidBody.cpp:29
btRigidBody::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition btRigidBody.h:82
btRigidBody::getOrientation
btQuaternion getOrientation() const
Definition btRigidBody.cpp:392
btRigidBody::proceedToTransform
void proceedToTransform(const btTransform &newTrans)
Definition btRigidBody.cpp:221
btRigidBody::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition btRigidBody.h:242
btRigidBody::m_linearFactor
btVector3 m_linearFactor
Definition btRigidBody.h:65
btRigidBody::saveKinematicState
void saveKinematicState(btScalar step)
Definition btRigidBody.cpp:105
btRigidBody::getLocalInertia
btVector3 getLocalInertia() const
Definition btRigidBody.cpp:254
btRigidBody::computeGyroscopicImpulseImplicit_World
btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const
perform implicit force computation in world space
Definition btRigidBody.cpp:336
btRigidBody::m_angularFactor
btVector3 m_angularFactor
Definition btRigidBody.h:98
btRigidBody::m_totalForce
btVector3 m_totalForce
Definition btRigidBody.h:70
btRigidBody::m_inverseMass
btScalar m_inverseMass
Definition btRigidBody.h:64
btRigidBody::computeGyroscopicImpulseImplicit_Body
btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const
perform implicit force computation in body space (inertial frame)
Definition btRigidBody.cpp:297
btRigidBody::m_totalTorque
btVector3 m_totalTorque
Definition btRigidBody.h:71
btRigidBody::getAngularVelocity
const btVector3 & getAngularVelocity() const
Definition btRigidBody.h:437
btRigidBody::getMotionState
btMotionState * getMotionState()
Definition btRigidBody.h:549
btRigidBody::m_angularDamping
btScalar m_angularDamping
Definition btRigidBody.h:74
btRigidBody::removeConstraintRef
void removeConstraintRef(btTypedConstraint *c)
Definition btRigidBody.cpp:438
btRigidBody::setMassProps
void setMassProps(btScalar mass, const btVector3 &inertia)
Definition btRigidBody.cpp:226
btRigidBody::m_deltaAngularVelocity
btVector3 m_deltaAngularVelocity
Definition btRigidBody.h:97
btRigidBody::m_pushVelocity
btVector3 m_pushVelocity
Definition btRigidBody.h:100
btRigidBody::m_additionalDamping
bool m_additionalDamping
Definition btRigidBody.h:76
btRigidBody::m_debugBodyId
int m_debugBodyId
Definition btRigidBody.h:93
btRigidBody::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition btRigidBody.h:83
btRigidBody::clearGravity
void clearGravity()
Definition btRigidBody.cpp:213
btRigidBody::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition btRigidBody.h:78
btRigidBody::m_linearVelocity
btVector3 m_linearVelocity
Definition btRigidBody.h:62
btRigidBody::setDamping
void setDamping(btScalar lin_damping, btScalar ang_damping)
Definition btRigidBody.cpp:137
btRigidBody::m_deltaLinearVelocity
btVector3 m_deltaLinearVelocity
Definition btRigidBody.h:96
btRigidBody::m_angularVelocity
btVector3 m_angularVelocity
Definition btRigidBody.h:63
btRigidBody::setupRigidBody
void setupRigidBody(const btRigidBodyConstructionInfo &constructionInfo)
setupRigidBody is only used internally by the constructor
Definition btRigidBody.cpp:40
btRigidBody::setCenterOfMassTransform
void setCenterOfMassTransform(const btTransform &xform)
Definition btRigidBody.cpp:399
btRigidBody::m_constraintRefs
btAlignedObjectArray< btTypedConstraint * > m_constraintRefs
Definition btRigidBody.h:89
btRigidBody::updateInertiaTensor
void updateInertiaTensor()
Definition btRigidBody.cpp:249
btRigidBody::predictIntegratedTransform
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
Definition btRigidBody.cpp:100
btRigidBody::computeGyroscopicForceExplicit
btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
explicit version is best avoided, it gains energy
Definition btRigidBody.cpp:283
btRigidBody::m_invMass
btVector3 m_invMass
Definition btRigidBody.h:99
btRigidBody::getLinearVelocity
const btVector3 & getLinearVelocity() const
Definition btRigidBody.h:433
btRigidBody::m_gravity_acceleration
btVector3 m_gravity_acceleration
Definition btRigidBody.h:68
btSerializer
Definition btSerializer.h:66
btSerializer::allocate
virtual btChunk * allocate(size_t size, int numElements)=0
btSerializer::finalizeChunk
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
btTransformUtil::integrateTransform
static void integrateTransform(const btTransform &curTrans, const btVector3 &linvel, const btVector3 &angvel, btScalar timeStep, btTransform &predictedTransform)
Definition btTransformUtil.h:32
btTransformUtil::calculateVelocity
static void calculateVelocity(const btTransform &transform0, const btTransform &transform1, btScalar timeStep, btVector3 &linVel, btVector3 &angVel)
Definition btTransformUtil.h:115
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition btTransform.h:30
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition btTransform.h:109
btTransform::getRotation
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition btTransform.h:119
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition btTypedConstraint.h:76
btTypedConstraint::getRigidBodyA
const btRigidBody & getRigidBodyA() const
Definition btTypedConstraint.h:214
btTypedConstraint::getRigidBodyB
const btRigidBody & getRigidBodyB() const
Definition btTypedConstraint.h:218
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition btVector3.h:82
btVector3::z
const btScalar & z() const
Return the z value.
Definition btVector3.h:579
btVector3::length
btScalar length() const
Return the length of the vector.
Definition btVector3.h:257
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
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition btVector3.h:640
btVector3::normalized
btVector3 normalized() const
Return a normalized version of this vector.
Definition btVector3.h:949
btVector3::length2
btScalar length2() const
Return the length of the vector squared.
Definition btVector3.h:251
btVector3::x
const btScalar & x() const
Return the x value.
Definition btVector3.h:575
btVector3::setZero
void setZero()
Definition btVector3.h:671
btVector3::serialize
void serialize(struct btVector3Data &dataOut) const
Definition btVector3.h:1317
btVector3::y
const btScalar & y() const
Return the y value.
Definition btVector3.h:577
btRigidBody::btRigidBodyConstructionInfo
The btRigidBodyConstructionInfo structure provides information to create a rigid body.
Definition btRigidBody.h:110
btRigidBody::btRigidBodyConstructionInfo::m_friction
btScalar m_friction
best simulation results when friction is non-zero
Definition btRigidBody.h:124
btRigidBody::btRigidBodyConstructionInfo::m_additionalDamping
bool m_additionalDamping
Definition btRigidBody.h:138
btRigidBody::btRigidBodyConstructionInfo::m_linearSleepingThreshold
btScalar m_linearSleepingThreshold
Definition btRigidBody.h:133
btRigidBody::btRigidBodyConstructionInfo::m_spinningFriction
btScalar m_spinningFriction
Definition btRigidBody.h:128
btRigidBody::btRigidBodyConstructionInfo::m_restitution
btScalar m_restitution
best simulation results using zero restitution.
Definition btRigidBody.h:131
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
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingFactor
btScalar m_additionalAngularDampingFactor
Definition btRigidBody.h:142
btRigidBody::btRigidBodyConstructionInfo::m_additionalLinearDampingThresholdSqr
btScalar m_additionalLinearDampingThresholdSqr
Definition btRigidBody.h:140
btRigidBody::btRigidBodyConstructionInfo::m_angularDamping
btScalar m_angularDamping
Definition btRigidBody.h:121
btRigidBody::btRigidBodyConstructionInfo::m_linearDamping
btScalar m_linearDamping
Definition btRigidBody.h:120
btRigidBody::btRigidBodyConstructionInfo::m_localInertia
btVector3 m_localInertia
Definition btRigidBody.h:119
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
btRigidBody::btRigidBodyConstructionInfo::m_additionalDampingFactor
btScalar m_additionalDampingFactor
Definition btRigidBody.h:139
btRigidBody::btRigidBodyConstructionInfo::m_angularSleepingThreshold
btScalar m_angularSleepingThreshold
Definition btRigidBody.h:134
btRigidBody::btRigidBodyConstructionInfo::m_collisionShape
btCollisionShape * m_collisionShape
Definition btRigidBody.h:118
btRigidBody::btRigidBodyConstructionInfo::m_startWorldTransform
btTransform m_startWorldTransform
Definition btRigidBody.h:116
btRigidBody::btRigidBodyConstructionInfo::m_mass
btScalar m_mass
Definition btRigidBody.h:111
btRigidBody::btRigidBodyConstructionInfo::m_additionalAngularDampingThresholdSqr
btScalar m_additionalAngularDampingThresholdSqr
Definition btRigidBody.h:141