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

Bullet Collision Detection & Physics Library

btRigidBody.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans 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