Bullet Collision Detection & Physics Library: btMultiBody.h Source File

Bullet Collision Detection & Physics Library

btMultiBody.h
Go to the documentation of this file.
1 /*
2 * PURPOSE:
3 * Class representing an articulated rigid body. Stores the body's
4 * current state, allows forces and torques to be set, handles
5 * timestepping and implements Featherstone's algorithm.
6 *
7 * COPYRIGHT:
8 * Copyright (C) Stephen Thompson, <stephen@solarflare.org.uk>, 2011-2013
9 * Portions written By Erwin Coumans: connection to LCP solver, various multibody constraints, replacing Eigen math library by Bullet LinearMath and a dedicated 6x6 matrix inverse (solveImatrix)
10 * Portions written By Jakub Stepien: support for multi-DOF constraints, introduction of spatial algebra and several other improvements
11
12 This software is provided 'as-is', without any express or implied warranty.
13 In no event will the authors be held liable for any damages arising from the use of this software.
14 Permission is granted to anyone to use this software for any purpose,
15 including commercial applications, and to alter it and redistribute it freely,
16 subject to the following restrictions:
17
18 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.
19 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
20 3. This notice may not be removed or altered from any source distribution.
21
22 */
23
24
25 #ifndef BT_MULTIBODY_H
26 #define BT_MULTIBODY_H
27
28 #include "LinearMath/btScalar.h"
29 #include "LinearMath/btVector3.h"
30 #include "LinearMath/btQuaternion.h"
31 #include "LinearMath/btMatrix3x3.h"
32 #include "LinearMath/btAlignedObjectArray.h"
33
34
36 #ifdef BT_USE_DOUBLE_PRECISION
37 #define btMultiBodyData btMultiBodyDoubleData
38 #define btMultiBodyDataName "btMultiBodyDoubleData"
39 #define btMultiBodyLinkData btMultiBodyLinkDoubleData
40 #define btMultiBodyLinkDataName "btMultiBodyLinkDoubleData"
41 #else
42 #define btMultiBodyData btMultiBodyFloatData
43 #define btMultiBodyDataName "btMultiBodyFloatData"
44 #define btMultiBodyLinkData btMultiBodyLinkFloatData
45 #define btMultiBodyLinkDataName "btMultiBodyLinkFloatData"
46 #endif //BT_USE_DOUBLE_PRECISION
47
48 #include "btMultiBodyLink.h"
49 class btMultiBodyLinkCollider;
50
51 ATTRIBUTE_ALIGNED16(class) btMultiBody
52 {
53 public:
54
55
56 BT_DECLARE_ALIGNED_ALLOCATOR();
57
58 //
59 // initialization
60 //
61
62 btMultiBody(int n_links, // NOT including the base
63 btScalar mass, // mass of base
64 const btVector3 &inertia, // inertia of base, in base frame; assumed diagonal
65 bool fixedBase, // whether the base is fixed (true) or can move (false)
66 bool canSleep, bool deprecatedMultiDof=true);
67
68
69 virtual ~btMultiBody();
70
71 //note: fixed link collision with parent is always disabled
72 void setupFixed(int linkIndex,
73 btScalar mass,
74 const btVector3 &inertia,
75 int parent,
76 const btQuaternion &rotParentToThis,
77 const btVector3 &parentComToThisPivotOffset,
78 const btVector3 &thisPivotToThisComOffset, bool deprecatedDisableParentCollision=true);
79
80
81 void setupPrismatic(int i,
82 btScalar mass,
83 const btVector3 &inertia,
84 int parent,
85 const btQuaternion &rotParentToThis,
86 const btVector3 &jointAxis,
87 const btVector3 &parentComToThisPivotOffset,
88 const btVector3 &thisPivotToThisComOffset,
89 bool disableParentCollision);
90
91 void setupRevolute(int linkIndex, // 0 to num_links-1
92 btScalar mass,
93 const btVector3 &inertia,
94 int parentIndex,
95 const btQuaternion &rotParentToThis, // rotate points in parent frame to this frame, when q = 0
96 const btVector3 &jointAxis, // in my frame
97 const btVector3 &parentComToThisPivotOffset, // vector from parent COM to joint axis, in PARENT frame
98 const btVector3 &thisPivotToThisComOffset, // vector from joint axis to my COM, in MY frame
99 bool disableParentCollision=false);
100
101 void setupSpherical(int linkIndex, // 0 to num_links-1
102 btScalar mass,
103 const btVector3 &inertia,
104 int parent,
105 const btQuaternion &rotParentToThis, // rotate points in parent frame to this frame, when q = 0
106 const btVector3 &parentComToThisPivotOffset, // vector from parent COM to joint axis, in PARENT frame
107 const btVector3 &thisPivotToThisComOffset, // vector from joint axis to my COM, in MY frame
108 bool disableParentCollision=false);
109
110 void setupPlanar(int i, // 0 to num_links-1
111 btScalar mass,
112 const btVector3 &inertia,
113 int parent,
114 const btQuaternion &rotParentToThis, // rotate points in parent frame to this frame, when q = 0
115 const btVector3 &rotationAxis,
116 const btVector3 &parentComToThisComOffset, // vector from parent COM to this COM, in PARENT frame
117 bool disableParentCollision=false);
118
119 const btMultibodyLink& getLink(int index) const
120 {
121 return m_links[index];
122 }
123
124 btMultibodyLink& getLink(int index)
125 {
126 return m_links[index];
127 }
128
129
130 void setBaseCollider(btMultiBodyLinkCollider* collider)//collider can be NULL to disable collision for the base
131 {
132 m_baseCollider = collider;
133 }
134 const btMultiBodyLinkCollider* getBaseCollider() const
135 {
136 return m_baseCollider;
137 }
138 btMultiBodyLinkCollider* getBaseCollider()
139 {
140 return m_baseCollider;
141 }
142
143 btMultiBodyLinkCollider* getLinkCollider(int index)
144 {
145 if (index >= 0 && index < getNumLinks())
146 {
147 return getLink(index).m_collider;
148 }
149 return 0;
150 }
151
152 //
153 // get parent
154 // input: link num from 0 to num_links-1
155 // output: link num from 0 to num_links-1, OR -1 to mean the base.
156 //
157 int getParent(int link_num) const;
158
159
160 //
161 // get number of m_links, masses, moments of inertia
162 //
163
164 int getNumLinks() const { return m_links.size(); }
165 int getNumDofs() const { return m_dofCount; }
166 int getNumPosVars() const { return m_posVarCnt; }
167 btScalar getBaseMass() const { return m_baseMass; }
168 const btVector3 & getBaseInertia() const { return m_baseInertia; }
169 btScalar getLinkMass(int i) const;
170 const btVector3 & getLinkInertia(int i) const;
171
172
173
174 //
175 // change mass (incomplete: can only change base mass and inertia at present)
176 //
177
178 void setBaseMass(btScalar mass) { m_baseMass = mass; }
179 void setBaseInertia(const btVector3 &inertia) { m_baseInertia = inertia; }
180
181
182 //
183 // get/set pos/vel/rot/omega for the base link
184 //
185
186 const btVector3 & getBasePos() const { return m_basePos; } // in world frame
187 const btVector3 getBaseVel() const
188 {
189 return btVector3(m_realBuf[3],m_realBuf[4],m_realBuf[5]);
190 } // in world frame
191 const btQuaternion & getWorldToBaseRot() const
192 {
193 return m_baseQuat;
194 } // rotates world vectors into base frame
195 btVector3 getBaseOmega() const { return btVector3(m_realBuf[0],m_realBuf[1],m_realBuf[2]); } // in world frame
196
197 void setBasePos(const btVector3 &pos)
198 {
199 m_basePos = pos;
200 }
201
202 void setBaseWorldTransform(const btTransform& tr)
203 {
204 setBasePos(tr.getOrigin());
205 setWorldToBaseRot(tr.getRotation().inverse());
206
207 }
208
209 btTransform getBaseWorldTransform() const
210 {
211 btTransform tr;
212 tr.setOrigin(getBasePos());
213 tr.setRotation(getWorldToBaseRot().inverse());
214 return tr;
215 }
216
217 void setBaseVel(const btVector3 &vel)
218 {
219
220 m_realBuf[3]=vel[0]; m_realBuf[4]=vel[1]; m_realBuf[5]=vel[2];
221 }
222 void setWorldToBaseRot(const btQuaternion &rot)
223 {
224 m_baseQuat = rot; //m_baseQuat asumed to ba alias!?
225 }
226 void setBaseOmega(const btVector3 &omega)
227 {
228 m_realBuf[0]=omega[0];
229 m_realBuf[1]=omega[1];
230 m_realBuf[2]=omega[2];
231 }
232
233
234 //
235 // get/set pos/vel for child m_links (i = 0 to num_links-1)
236 //
237
238 btScalar getJointPos(int i) const;
239 btScalar getJointVel(int i) const;
240
241 btScalar * getJointVelMultiDof(int i);
242 btScalar * getJointPosMultiDof(int i);
243
244 const btScalar * getJointVelMultiDof(int i) const ;
245 const btScalar * getJointPosMultiDof(int i) const ;
246
247 void setJointPos(int i, btScalar q);
248 void setJointVel(int i, btScalar qdot);
249 void setJointPosMultiDof(int i, btScalar *q);
250 void setJointVelMultiDof(int i, btScalar *qdot);
251
252
253
254 //
255 // direct access to velocities as a vector of 6 + num_links elements.
256 // (omega first, then v, then joint velocities.)
257 //
258 const btScalar * getVelocityVector() const
259 {
260 return &m_realBuf[0];
261 }
262 /* btScalar * getVelocityVector()
263 {
264 return &real_buf[0];
265 }
266 */
267
268 //
269 // get the frames of reference (positions and orientations) of the child m_links
270 // (i = 0 to num_links-1)
271 //
272
273 const btVector3 & getRVector(int i) const; // vector from COM(parent(i)) to COM(i), in frame i's coords
274 const btQuaternion & getParentToLocalRot(int i) const; // rotates vectors in frame parent(i) to vectors in frame i.
275
276
277 //
278 // transform vectors in local frame of link i to world frame (or vice versa)
279 //
280 btVector3 localPosToWorld(int i, const btVector3 &vec) const;
281 btVector3 localDirToWorld(int i, const btVector3 &vec) const;
282 btVector3 worldPosToLocal(int i, const btVector3 &vec) const;
283 btVector3 worldDirToLocal(int i, const btVector3 &vec) const;
284
285 //
286 // transform a frame in local coordinate to a frame in world coordinate
287 //
288 btMatrix3x3 localFrameToWorld(int i, const btMatrix3x3 &mat) const;
289
290 //
291 // calculate kinetic energy and angular momentum
292 // useful for debugging.
293 //
294
295 btScalar getKineticEnergy() const;
296 btVector3 getAngularMomentum() const;
297
298
299 //
300 // set external forces and torques. Note all external forces/torques are given in the WORLD frame.
301 //
302
303 void clearForcesAndTorques();
304 void clearConstraintForces();
305
306 void clearVelocities();
307
308 void addBaseForce(const btVector3 &f)
309 {
310 m_baseForce += f;
311 }
312 void addBaseTorque(const btVector3 &t) { m_baseTorque += t; }
313 void addLinkForce(int i, const btVector3 &f);
314 void addLinkTorque(int i, const btVector3 &t);
315
316 void addBaseConstraintForce(const btVector3 &f)
317 {
318 m_baseConstraintForce += f;
319 }
320 void addBaseConstraintTorque(const btVector3 &t) { m_baseConstraintTorque += t; }
321 void addLinkConstraintForce(int i, const btVector3 &f);
322 void addLinkConstraintTorque(int i, const btVector3 &t);
323
324
325 void addJointTorque(int i, btScalar Q);
326 void addJointTorqueMultiDof(int i, int dof, btScalar Q);
327 void addJointTorqueMultiDof(int i, const btScalar *Q);
328
329 const btVector3 & getBaseForce() const { return m_baseForce; }
330 const btVector3 & getBaseTorque() const { return m_baseTorque; }
331 const btVector3 & getLinkForce(int i) const;
332 const btVector3 & getLinkTorque(int i) const;
333 btScalar getJointTorque(int i) const;
334 btScalar * getJointTorqueMultiDof(int i);
335
336
337 //
338 // dynamics routines.
339 //
340
341 // timestep the velocities (given the external forces/torques set using addBaseForce etc).
342 // also sets up caches for calcAccelerationDeltas.
343 //
344 // Note: the caller must provide three vectors which are used as
345 // temporary scratch space. The idea here is to reduce dynamic
346 // memory allocation: the same scratch vectors can be re-used
347 // again and again for different Multibodies, instead of each
348 // btMultiBody allocating (and then deallocating) their own
349 // individual scratch buffers. This gives a considerable speed
350 // improvement, at least on Windows (where dynamic memory
351 // allocation appears to be fairly slow).
352 //
353
354
355 void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt,
356 btAlignedObjectArray<btScalar> &scratch_r,
357 btAlignedObjectArray<btVector3> &scratch_v,
358 btAlignedObjectArray<btMatrix3x3> &scratch_m,
359 bool isConstraintPass=false
360 );
361
363 void stepVelocitiesMultiDof(btScalar dt,
364 btAlignedObjectArray<btScalar> &scratch_r,
365 btAlignedObjectArray<btVector3> &scratch_v,
366 btAlignedObjectArray<btMatrix3x3> &scratch_m,
367 bool isConstraintPass=false)
368 {
369 computeAccelerationsArticulatedBodyAlgorithmMultiDof(dt,scratch_r,scratch_v,scratch_m,isConstraintPass);
370 }
371
372 // calcAccelerationDeltasMultiDof
373 // input: force vector (in same format as jacobian, i.e.:
374 // 3 torque values, 3 force values, num_links joint torque values)
375 // output: 3 omegadot values, 3 vdot values, num_links q_double_dot values
376 // (existing contents of output array are replaced)
377 // calcAccelerationDeltasMultiDof must have been called first.
378 void calcAccelerationDeltasMultiDof(const btScalar *force, btScalar *output,
379 btAlignedObjectArray<btScalar> &scratch_r,
380 btAlignedObjectArray<btVector3> &scratch_v) const;
381
382
383 void applyDeltaVeeMultiDof2(const btScalar * delta_vee, btScalar multiplier)
384 {
385 for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
386 {
387 m_deltaV[dof] += delta_vee[dof] * multiplier;
388 }
389 }
390 void processDeltaVeeMultiDof2()
391 {
392 applyDeltaVeeMultiDof(&m_deltaV[0],1);
393
394 for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
395 {
396 m_deltaV[dof] = 0.f;
397 }
398 }
399
400 void applyDeltaVeeMultiDof(const btScalar * delta_vee, btScalar multiplier)
401 {
402 //for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
403 // printf("%.4f ", delta_vee[dof]*multiplier);
404 //printf("\n");
405
406 //btScalar sum = 0;
407 //for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
408 //{
409 // sum += delta_vee[dof]*multiplier*delta_vee[dof]*multiplier;
410 //}
411 //btScalar l = btSqrt(sum);
412
413 //if (l>m_maxAppliedImpulse)
414 //{
415 // multiplier *= m_maxAppliedImpulse/l;
416 //}
417
418 for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
419 {
420 m_realBuf[dof] += delta_vee[dof] * multiplier;
421 btClamp(m_realBuf[dof],-m_maxCoordinateVelocity,m_maxCoordinateVelocity);
422 }
423 }
424
425
426
427 // timestep the positions (given current velocities).
428 void stepPositionsMultiDof(btScalar dt, btScalar *pq = 0, btScalar *pqd = 0);
429
430
431 //
432 // contacts
433 //
434
435 // This routine fills out a contact constraint jacobian for this body.
436 // the 'normal' supplied must be -n for body1 or +n for body2 of the contact.
437 // 'normal' & 'contact_point' are both given in world coordinates.
438
439 void fillContactJacobianMultiDof(int link,
440 const btVector3 &contact_point,
441 const btVector3 &normal,
442 btScalar *jac,
443 btAlignedObjectArray<btScalar> &scratch_r,
444 btAlignedObjectArray<btVector3> &scratch_v,
445 btAlignedObjectArray<btMatrix3x3> &scratch_m) const { fillConstraintJacobianMultiDof(link, contact_point, btVector3(0, 0, 0), normal, jac, scratch_r, scratch_v, scratch_m); }
446
447 //a more general version of fillContactJacobianMultiDof which does not assume..
448 //.. that the constraint in question is contact or, to be more precise, constrains linear velocity only
449 void fillConstraintJacobianMultiDof(int link,
450 const btVector3 &contact_point,
451 const btVector3 &normal_ang,
452 const btVector3 &normal_lin,
453 btScalar *jac,
454 btAlignedObjectArray<btScalar> &scratch_r,
455 btAlignedObjectArray<btVector3> &scratch_v,
456 btAlignedObjectArray<btMatrix3x3> &scratch_m) const;
457
458
459 //
460 // sleeping
461 //
462 void setCanSleep(bool canSleep)
463 {
464 m_canSleep = canSleep;
465 }
466
467 bool getCanSleep()const
468 {
469 return m_canSleep;
470 }
471
472 bool isAwake() const { return m_awake; }
473 void wakeUp();
474 void goToSleep();
475 void checkMotionAndSleepIfRequired(btScalar timestep);
476
477 bool hasFixedBase() const
478 {
479 return m_fixedBase;
480 }
481
482 int getCompanionId() const
483 {
484 return m_companionId;
485 }
486 void setCompanionId(int id)
487 {
488 //printf("for %p setCompanionId(%d)\n",this, id);
489 m_companionId = id;
490 }
491
492 void setNumLinks(int numLinks)//careful: when changing the number of m_links, make sure to re-initialize or update existing m_links
493 {
494 m_links.resize(numLinks);
495 }
496
497 btScalar getLinearDamping() const
498 {
499 return m_linearDamping;
500 }
501 void setLinearDamping( btScalar damp)
502 {
503 m_linearDamping = damp;
504 }
505 btScalar getAngularDamping() const
506 {
507 return m_angularDamping;
508 }
509 void setAngularDamping( btScalar damp)
510 {
511 m_angularDamping = damp;
512 }
513
514 bool getUseGyroTerm() const
515 {
516 return m_useGyroTerm;
517 }
518 void setUseGyroTerm(bool useGyro)
519 {
520 m_useGyroTerm = useGyro;
521 }
522 btScalar getMaxCoordinateVelocity() const
523 {
524 return m_maxCoordinateVelocity ;
525 }
526 void setMaxCoordinateVelocity(btScalar maxVel)
527 {
528 m_maxCoordinateVelocity = maxVel;
529 }
530
531 btScalar getMaxAppliedImpulse() const
532 {
533 return m_maxAppliedImpulse;
534 }
535 void setMaxAppliedImpulse(btScalar maxImp)
536 {
537 m_maxAppliedImpulse = maxImp;
538 }
539 void setHasSelfCollision(bool hasSelfCollision)
540 {
541 m_hasSelfCollision = hasSelfCollision;
542 }
543 bool hasSelfCollision() const
544 {
545 return m_hasSelfCollision;
546 }
547
548
549 void finalizeMultiDof();
550
551 void useRK4Integration(bool use) { m_useRK4 = use; }
552 bool isUsingRK4Integration() const { return m_useRK4; }
553 void useGlobalVelocities(bool use) { m_useGlobalVelocities = use; }
554 bool isUsingGlobalVelocities() const { return m_useGlobalVelocities; }
555
556 bool isPosUpdated() const
557 {
558 return __posUpdated;
559 }
560 void setPosUpdated(bool updated)
561 {
562 __posUpdated = updated;
563 }
564
565 //internalNeedsJointFeedback is for internal use only
566 bool internalNeedsJointFeedback() const
567 {
568 return m_internalNeedsJointFeedback;
569 }
570 void forwardKinematics(btAlignedObjectArray<btQuaternion>& scratch_q,btAlignedObjectArray<btVector3>& scratch_m);
571
572 void compTreeLinkVelocities(btVector3 *omega, btVector3 *vel) const;
573
574 void updateCollisionObjectWorldTransforms(btAlignedObjectArray<btQuaternion>& scratch_q,btAlignedObjectArray<btVector3>& scratch_m);
575
576 virtual int calculateSerializeBufferSize() const;
577
579 virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
580
581 const char* getBaseName() const
582 {
583 return m_baseName;
584 }
586 void setBaseName(const char* name)
587 {
588 m_baseName = name;
589 }
590
592 void* getUserPointer() const
593 {
594 return m_userObjectPointer;
595 }
596
597 int getUserIndex() const
598 {
599 return m_userIndex;
600 }
601
602 int getUserIndex2() const
603 {
604 return m_userIndex2;
605 }
607 void setUserPointer(void* userPointer)
608 {
609 m_userObjectPointer = userPointer;
610 }
611
613 void setUserIndex(int index)
614 {
615 m_userIndex = index;
616 }
617
618 void setUserIndex2(int index)
619 {
620 m_userIndex2 = index;
621 }
622
623 private:
624 btMultiBody(const btMultiBody &); // not implemented
625 void operator=(const btMultiBody &); // not implemented
626
627
628 void solveImatrix(const btVector3& rhs_top, const btVector3& rhs_bot, btScalar result[6]) const;
629 void solveImatrix(const btSpatialForceVector &rhs, btSpatialMotionVector &result) const;
630
631 void updateLinksDofOffsets()
632 {
633 int dofOffset = 0, cfgOffset = 0;
634 for(int bidx = 0; bidx < m_links.size(); ++bidx)
635 {
636 m_links[bidx].m_dofOffset = dofOffset; m_links[bidx].m_cfgOffset = cfgOffset;
637 dofOffset += m_links[bidx].m_dofCount; cfgOffset += m_links[bidx].m_posVarCount;
638 }
639 }
640
641 void mulMatrix(btScalar *pA, btScalar *pB, int rowsA, int colsA, int rowsB, int colsB, btScalar *pC) const;
642
643
644 private:
645
646 btMultiBodyLinkCollider* m_baseCollider;//can be NULL
647 const char* m_baseName;//memory needs to be manager by user!
648
649 btVector3 m_basePos; // position of COM of base (world frame)
650 btQuaternion m_baseQuat; // rotates world points into base frame
651
652 btScalar m_baseMass; // mass of the base
653 btVector3 m_baseInertia; // inertia of the base (in local frame; diagonal)
654
655 btVector3 m_baseForce; // external force applied to base. World frame.
656 btVector3 m_baseTorque; // external torque applied to base. World frame.
657
658 btVector3 m_baseConstraintForce; // external force applied to base. World frame.
659 btVector3 m_baseConstraintTorque; // external torque applied to base. World frame.
660
661 btAlignedObjectArray<btMultibodyLink> m_links; // array of m_links, excluding the base. index from 0 to num_links-1.
662
663
664 //
665 // realBuf:
666 // offset size array
667 // 0 6 + num_links v (base_omega; base_vel; joint_vels) MULTIDOF [sysdof x sysdof for D matrices (TOO MUCH!) + pos_delta which is sys-cfg sized]
668 // 6+num_links num_links D
669 //
670 // vectorBuf:
671 // offset size array
672 // 0 num_links h_top
673 // num_links num_links h_bottom
674 //
675 // matrixBuf:
676 // offset size array
677 // 0 num_links+1 rot_from_parent
678 //
679 btAlignedObjectArray<btScalar> m_deltaV;
680 btAlignedObjectArray<btScalar> m_realBuf;
681 btAlignedObjectArray<btVector3> m_vectorBuf;
682 btAlignedObjectArray<btMatrix3x3> m_matrixBuf;
683
684
685 btMatrix3x3 m_cachedInertiaTopLeft;
686 btMatrix3x3 m_cachedInertiaTopRight;
687 btMatrix3x3 m_cachedInertiaLowerLeft;
688 btMatrix3x3 m_cachedInertiaLowerRight;
689 bool m_cachedInertiaValid;
690
691 bool m_fixedBase;
692
693 // Sleep parameters.
694 bool m_awake;
695 bool m_canSleep;
696 btScalar m_sleepTimer;
697
698 void* m_userObjectPointer;
699 int m_userIndex2;
700 int m_userIndex;
701
702 int m_companionId;
703 btScalar m_linearDamping;
704 btScalar m_angularDamping;
705 bool m_useGyroTerm;
706 btScalar m_maxAppliedImpulse;
707 btScalar m_maxCoordinateVelocity;
708 bool m_hasSelfCollision;
709
710 bool __posUpdated;
711 int m_dofCount, m_posVarCnt;
712 bool m_useRK4, m_useGlobalVelocities;
713
715 bool m_internalNeedsJointFeedback;
716 };
717
718 struct btMultiBodyLinkDoubleData
719 {
720 btQuaternionDoubleData m_zeroRotParentToThis;
721 btVector3DoubleData m_parentComToThisComOffset;
722 btVector3DoubleData m_thisPivotToThisComOffset;
723 btVector3DoubleData m_jointAxisTop[6];
724 btVector3DoubleData m_jointAxisBottom[6];
725
726 btVector3DoubleData m_linkInertia; // inertia of the base (in local frame; diagonal)
727 double m_linkMass;
728 int m_parentIndex;
729 int m_jointType;
730
731 int m_dofCount;
732 int m_posVarCount;
733 double m_jointPos[7];
734 double m_jointVel[6];
735 double m_jointTorque[6];
736
737 double m_jointDamping;
738 double m_jointFriction;
739 double m_jointLowerLimit;
740 double m_jointUpperLimit;
741 double m_jointMaxForce;
742 double m_jointMaxVelocity;
743
744 char *m_linkName;
745 char *m_jointName;
746 btCollisionObjectDoubleData *m_linkCollider;
747 char *m_paddingPtr;
748
749 };
750
751 struct btMultiBodyLinkFloatData
752 {
753 btQuaternionFloatData m_zeroRotParentToThis;
754 btVector3FloatData m_parentComToThisComOffset;
755 btVector3FloatData m_thisPivotToThisComOffset;
756 btVector3FloatData m_jointAxisTop[6];
757 btVector3FloatData m_jointAxisBottom[6];
758 btVector3FloatData m_linkInertia; // inertia of the base (in local frame; diagonal)
759 int m_dofCount;
760 float m_linkMass;
761 int m_parentIndex;
762 int m_jointType;
763
764
765
766 float m_jointPos[7];
767 float m_jointVel[6];
768 float m_jointTorque[6];
769 int m_posVarCount;
770 float m_jointDamping;
771 float m_jointFriction;
772 float m_jointLowerLimit;
773 float m_jointUpperLimit;
774 float m_jointMaxForce;
775 float m_jointMaxVelocity;
776
777 char *m_linkName;
778 char *m_jointName;
779 btCollisionObjectFloatData *m_linkCollider;
780 char *m_paddingPtr;
781
782 };
783
785 struct btMultiBodyDoubleData
786 {
787 btTransformDoubleData m_baseWorldTransform;
788 btVector3DoubleData m_baseInertia; // inertia of the base (in local frame; diagonal)
789 double m_baseMass;
790
791 char *m_baseName;
792 btMultiBodyLinkDoubleData *m_links;
793 btCollisionObjectDoubleData *m_baseCollider;
794 char *m_paddingPtr;
795 int m_numLinks;
796 char m_padding[4];
797 };
798
800 struct btMultiBodyFloatData
801 {
802 char *m_baseName;
803 btMultiBodyLinkFloatData *m_links;
804 btCollisionObjectFloatData *m_baseCollider;
805 btTransformFloatData m_baseWorldTransform;
806 btVector3FloatData m_baseInertia; // inertia of the base (in local frame; diagonal)
807
808 float m_baseMass;
809 int m_numLinks;
810 };
811
812
813
814 #endif
btTransform::setOrigin
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:150
btCollisionObject::m_companionId
int m_companionId
Definition: btCollisionObject.h:81
btMultiBody::getLinkCollider
btMultiBodyLinkCollider * getLinkCollider(int index)
Definition: btMultiBody.h:143
btMultiBodyLinkFloatData::m_jointMaxForce
float m_jointMaxForce
Definition: btMultiBody.h:774
btCollisionObject::m_userIndex2
int m_userIndex2
Definition: btCollisionObject.h:104
btMultiBody::stepVelocitiesMultiDof
void stepVelocitiesMultiDof(btScalar dt, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m, bool isConstraintPass=false)
stepVelocitiesMultiDof is deprecated, use computeAccelerationsArticulatedBodyAlgorithmMultiDof instea...
Definition: btMultiBody.h:363
btMultiBodyLinkDoubleData::m_paddingPtr
char * m_paddingPtr
Definition: btMultiBody.h:747
btMultiBodyLinkFloatData::m_jointMaxVelocity
float m_jointMaxVelocity
Definition: btMultiBody.h:775
btMultiBody::setCanSleep
void setCanSleep(bool canSleep)
Definition: btMultiBody.h:462
btCollisionObjectFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionObject.h:637
btMultiBodyLinkFloatData::m_linkName
char * m_linkName
Definition: btMultiBody.h:777
btQuaternionDoubleData
Definition: btQuaternion.h:965
btMultiBodyDoubleData::m_baseName
char * m_baseName
Definition: btMultiBody.h:791
btMultiBody::getBasePos
const btVector3 & getBasePos() const
Definition: btMultiBody.h:186
btMultiBodyLinkDoubleData::m_jointVel
double m_jointVel[6]
Definition: btMultiBody.h:734
btMultiBody::m_awake
bool m_awake
Definition: btMultiBody.h:694
btMultiBody::m_matrixBuf
btAlignedObjectArray< btMatrix3x3 > m_matrixBuf
Definition: btMultiBody.h:682
btMultiBody::m_useGyroTerm
bool m_useGyroTerm
Definition: btMultiBody.h:705
btMultiBody::getNumLinks
int getNumLinks() const
Definition: btMultiBody.h:164
btMultiBodyLinkFloatData::m_paddingPtr
char * m_paddingPtr
Definition: btMultiBody.h:780
btMultiBody::m_baseForce
btVector3 m_baseForce
Definition: btMultiBody.h:655
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
btMultiBodyLinkFloatData::m_jointDamping
float m_jointDamping
Definition: btMultiBody.h:770
btMultiBody::getBaseCollider
btMultiBodyLinkCollider * getBaseCollider()
Definition: btMultiBody.h:138
btMultiBodyLinkDoubleData::m_linkName
char * m_linkName
Definition: btMultiBody.h:744
btMultiBody::internalNeedsJointFeedback
bool internalNeedsJointFeedback() const
Definition: btMultiBody.h:566
btMultiBody::setNumLinks
void setNumLinks(int numLinks)
Definition: btMultiBody.h:492
btMultiBody::getBaseCollider
const btMultiBodyLinkCollider * getBaseCollider() const
Definition: btMultiBody.h:134
btMultiBody::m_baseCollider
btMultiBodyLinkCollider * m_baseCollider
Definition: btMultiBody.h:646
btMultiBody::m_baseMass
btScalar m_baseMass
Definition: btMultiBody.h:652
btMultiBody::getUserIndex
int getUserIndex() const
Definition: btMultiBody.h:597
btMultiBody::getUserIndex2
int getUserIndex2() const
Definition: btMultiBody.h:602
btAlignedObjectArray< btScalar >
btVector3.h
btMultiBody::m_fixedBase
bool m_fixedBase
Definition: btMultiBody.h:691
btSpatialForceVector
These spatial algebra classes are used for btMultiBody, see BulletDynamics/Featherstone.
Definition: btSpatialAlgebra.h:24
btMultiBody::isUsingGlobalVelocities
bool isUsingGlobalVelocities() const
Definition: btMultiBody.h:554
btMultiBodyLink.h
btMultiBodyLinkDoubleData::m_jointAxisTop
btVector3DoubleData m_jointAxisTop[6]
Definition: btMultiBody.h:723
btQuaternionFloatData
Definition: btQuaternion.h:960
btMultiBody::m_maxCoordinateVelocity
btScalar m_maxCoordinateVelocity
Definition: btMultiBody.h:707
btMultiBodyLinkFloatData::m_jointAxisTop
btVector3FloatData m_jointAxisTop[6]
Definition: btMultiBody.h:756
btMultiBody::addBaseTorque
void addBaseTorque(const btVector3 &t)
Definition: btMultiBody.h:312
btMultiBody::getCanSleep
bool getCanSleep() const
Definition: btMultiBody.h:467
btMultiBodyDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btMultiBody.h:785
btMultiBody::getAngularDamping
btScalar getAngularDamping() const
Definition: btMultiBody.h:505
btMultiBody::getUserPointer
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
Definition: btMultiBody.h:592
btMultiBodyLinkDoubleData::m_zeroRotParentToThis
btQuaternionDoubleData m_zeroRotParentToThis
Definition: btMultiBody.h:720
btTransform::getRotation
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
btMultiBodyLinkDoubleData::m_jointUpperLimit
double m_jointUpperLimit
Definition: btMultiBody.h:740
btMultiBody::getWorldToBaseRot
const btQuaternion & getWorldToBaseRot() const
Definition: btMultiBody.h:191
btMultiBody::m_userIndex2
int m_userIndex2
Definition: btMultiBody.h:699
btMultiBody::m_cachedInertiaLowerRight
btMatrix3x3 m_cachedInertiaLowerRight
Definition: btMultiBody.h:688
btMultiBodyLinkDoubleData::m_dofCount
int m_dofCount
Definition: btMultiBody.h:731
btMultiBodyLinkFloatData::m_linkCollider
btCollisionObjectFloatData * m_linkCollider
Definition: btMultiBody.h:779
btMultiBody::isPosUpdated
bool isPosUpdated() const
Definition: btMultiBody.h:556
btMultiBody::setUserIndex
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
Definition: btMultiBody.h:613
btMultiBody::isUsingRK4Integration
bool isUsingRK4Integration() const
Definition: btMultiBody.h:552
btMultiBody::setBaseCollider
void setBaseCollider(btMultiBodyLinkCollider *collider)
Definition: btMultiBody.h:130
btMultiBody::getCompanionId
int getCompanionId() const
Definition: btMultiBody.h:482
btMultiBody::getMaxAppliedImpulse
btScalar getMaxAppliedImpulse() const
Definition: btMultiBody.h:531
btMultiBody::getUseGyroTerm
bool getUseGyroTerm() const
Definition: btMultiBody.h:514
btMultiBodyLinkFloatData::m_jointFriction
float m_jointFriction
Definition: btMultiBody.h:771
btClamp
void btClamp(T &a, const T &lb, const T &ub)
Definition: btMinMax.h:59
btMultibodyLink
Definition: btMultiBodyLink.h:48
btMultiBody
Definition: btMultiBody.h:51
btMatrix3x3.h
btMultiBody::m_baseConstraintTorque
btVector3 m_baseConstraintTorque
Definition: btMultiBody.h:659
btMultiBody::applyDeltaVeeMultiDof
void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
Definition: btMultiBody.h:400
btMultiBody::setWorldToBaseRot
void setWorldToBaseRot(const btQuaternion &rot)
Definition: btMultiBody.h:222
inverse
btQuaternion inverse(const btQuaternion &q)
Return the inverse of a quaternion.
Definition: btQuaternion.h:900
btMultiBody::m_maxAppliedImpulse
btScalar m_maxAppliedImpulse
Definition: btMultiBody.h:706
btMultiBody::m_deltaV
btAlignedObjectArray< btScalar > m_deltaV
Definition: btMultiBody.h:679
btMultiBodyFloatData::m_baseName
char * m_baseName
Definition: btMultiBody.h:802
btMultiBody::getMaxCoordinateVelocity
btScalar getMaxCoordinateVelocity() const
Definition: btMultiBody.h:522
btMultiBody::getBaseOmega
btVector3 getBaseOmega() const
Definition: btMultiBody.h:195
btMultiBodyLinkDoubleData
Definition: btMultiBody.h:718
btMultiBodyLinkDoubleData::m_jointType
int m_jointType
Definition: btMultiBody.h:729
btMultiBodyLinkFloatData::m_jointName
char * m_jointName
Definition: btMultiBody.h:778
btSerializer
Definition: btSerializer.h:68
btMultiBody::setBaseVel
void setBaseVel(const btVector3 &vel)
Definition: btMultiBody.h:217
btMultiBody::m_baseTorque
btVector3 m_baseTorque
Definition: btMultiBody.h:656
btMultiBodyLinkFloatData::m_parentIndex
int m_parentIndex
Definition: btMultiBody.h:761
btMultiBody::getBaseName
const char * getBaseName() const
Definition: btMultiBody.h:581
btQuaternion::inverse
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:482
btMultiBody::m_cachedInertiaTopLeft
btMatrix3x3 m_cachedInertiaTopLeft
Definition: btMultiBody.h:685
btMultiBody::m_companionId
int m_companionId
Definition: btMultiBody.h:702
btCollisionObjectDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionObject.h:602
btMultiBody::m_useRK4
bool m_useRK4
Definition: btMultiBody.h:712
btMultiBodyDoubleData::m_baseMass
double m_baseMass
Definition: btMultiBody.h:789
btMultiBodyLinkDoubleData::m_jointFriction
double m_jointFriction
Definition: btMultiBody.h:738
btMultiBody::setHasSelfCollision
void setHasSelfCollision(bool hasSelfCollision)
Definition: btMultiBody.h:539
btMultiBody::setMaxCoordinateVelocity
void setMaxCoordinateVelocity(btScalar maxVel)
Definition: btMultiBody.h:526
btMultiBody::getBaseInertia
const btVector3 & getBaseInertia() const
Definition: btMultiBody.h:168
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btQuaternion.h
btMultiBodyFloatData::m_baseWorldTransform
btTransformFloatData m_baseWorldTransform
Definition: btMultiBody.h:805
btMultiBody::getBaseWorldTransform
btTransform getBaseWorldTransform() const
Definition: btMultiBody.h:209
btMultiBody::isAwake
bool isAwake() const
Definition: btMultiBody.h:472
btMultiBody::setUseGyroTerm
void setUseGyroTerm(bool useGyro)
Definition: btMultiBody.h:518
btMultiBody::m_baseQuat
btQuaternion m_baseQuat
Definition: btMultiBody.h:650
btMultiBody::m_cachedInertiaLowerLeft
btMatrix3x3 m_cachedInertiaLowerLeft
Definition: btMultiBody.h:687
btMultiBody::getBaseMass
btScalar getBaseMass() const
Definition: btMultiBody.h:167
btMultiBody::setCompanionId
void setCompanionId(int id)
Definition: btMultiBody.h:486
btMultiBodyLinkFloatData::m_linkMass
float m_linkMass
Definition: btMultiBody.h:760
btMultiBody::setBaseOmega
void setBaseOmega(const btVector3 &omega)
Definition: btMultiBody.h:226
btMultiBody::m_hasSelfCollision
bool m_hasSelfCollision
Definition: btMultiBody.h:708
btMultiBody::getLink
btMultibodyLink & getLink(int index)
Definition: btMultiBody.h:124
output
#define output
btMultiBody::getNumDofs
int getNumDofs() const
Definition: btMultiBody.h:165
btMultiBodyLinkFloatData::m_posVarCount
int m_posVarCount
Definition: btMultiBody.h:769
btTransform::setRotation
void setRotation(const btQuaternion &q)
Set the rotational element by btQuaternion.
Definition: btTransform.h:165
btMultiBodyFloatData::m_baseMass
float m_baseMass
Definition: btMultiBody.h:808
btMultiBodyLinkFloatData::m_jointLowerLimit
float m_jointLowerLimit
Definition: btMultiBody.h:772
btMultiBody::m_cachedInertiaValid
bool m_cachedInertiaValid
Definition: btMultiBody.h:689
btMultiBody::hasFixedBase
bool hasFixedBase() const
Definition: btMultiBody.h:477
btMultiBodyLinkFloatData::m_zeroRotParentToThis
btQuaternionFloatData m_zeroRotParentToThis
Definition: btMultiBody.h:753
btMultiBodyFloatData::m_baseInertia
btVector3FloatData m_baseInertia
Definition: btMultiBody.h:806
btMultiBody::m_userObjectPointer
void * m_userObjectPointer
Definition: btMultiBody.h:698
btSpatialMotionVector
Definition: btSpatialAlgebra.h:68
btMultiBody::m_sleepTimer
btScalar m_sleepTimer
Definition: btMultiBody.h:696
btMultiBodyLinkFloatData::m_jointAxisBottom
btVector3FloatData m_jointAxisBottom[6]
Definition: btMultiBody.h:757
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:672
btMultiBodyLinkDoubleData::m_jointDamping
double m_jointDamping
Definition: btMultiBody.h:737
btMultiBody::m_basePos
btVector3 m_basePos
Definition: btMultiBody.h:649
btMultiBody::setAngularDamping
void setAngularDamping(btScalar damp)
Definition: btMultiBody.h:509
btMultiBodyLinkFloatData::m_thisPivotToThisComOffset
btVector3FloatData m_thisPivotToThisComOffset
Definition: btMultiBody.h:755
btMultiBodyDoubleData::m_baseInertia
btVector3DoubleData m_baseInertia
Definition: btMultiBody.h:788
btMultiBody::m_baseConstraintForce
btVector3 m_baseConstraintForce
Definition: btMultiBody.h:658
btMultiBody::getLink
const btMultibodyLink & getLink(int index) const
Definition: btMultiBody.h:119
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:82
btMultiBody::m_internalNeedsJointFeedback
bool m_internalNeedsJointFeedback
the m_needsJointFeedback gets updated/computed during the stepVelocitiesMultiDof and it for internal ...
Definition: btMultiBody.h:715
btMultiBodyLinkDoubleData::m_parentIndex
int m_parentIndex
Definition: btMultiBody.h:728
btMultiBody::getNumPosVars
int getNumPosVars() const
Definition: btMultiBody.h:166
btMultiBody::m_baseInertia
btVector3 m_baseInertia
Definition: btMultiBody.h:653
btMultiBody::setLinearDamping
void setLinearDamping(btScalar damp)
Definition: btMultiBody.h:501
btMultiBody::m_baseName
const char * m_baseName
Definition: btMultiBody.h:647
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btMultiBody::addBaseForce
void addBaseForce(const btVector3 &f)
Definition: btMultiBody.h:308
btMultiBody::m_realBuf
btAlignedObjectArray< btScalar > m_realBuf
Definition: btMultiBody.h:680
btMultiBody::hasSelfCollision
bool hasSelfCollision() const
Definition: btMultiBody.h:543
btMultiBody::m_posVarCnt
int m_posVarCnt
Definition: btMultiBody.h:711
btMultiBodyLinkCollider
Definition: btMultiBodyLinkCollider.h:23
btMultiBodyLinkDoubleData::m_jointLowerLimit
double m_jointLowerLimit
Definition: btMultiBody.h:739
btMultiBody::updateLinksDofOffsets
void updateLinksDofOffsets()
Definition: btMultiBody.h:631
btMultiBody::setMaxAppliedImpulse
void setMaxAppliedImpulse(btScalar maxImp)
Definition: btMultiBody.h:535
btMultiBodyLinkFloatData::m_jointType
int m_jointType
Definition: btMultiBody.h:762
btMultiBodyFloatData::m_links
btMultiBodyLinkFloatData * m_links
Definition: btMultiBody.h:803
btMultiBody::setUserPointer
void setUserPointer(void *userPointer)
users can point to their objects, userPointer is not used by Bullet
Definition: btMultiBody.h:607
btMultiBodyDoubleData::m_padding
char m_padding[4]
Definition: btMultiBody.h:796
btMultiBodyFloatData::m_numLinks
int m_numLinks
Definition: btMultiBody.h:809
btMultiBody::setUserIndex2
void setUserIndex2(int index)
Definition: btMultiBody.h:618
btMultiBody::m_linearDamping
btScalar m_linearDamping
Definition: btMultiBody.h:703
btTransformFloatData
for serialization
Definition: btTransform.h:253
btMultiBodyDoubleData::m_numLinks
int m_numLinks
Definition: btMultiBody.h:795
btMultiBodyLinkDoubleData::m_linkCollider
btCollisionObjectDoubleData * m_linkCollider
Definition: btMultiBody.h:746
btMultiBody::setBaseInertia
void setBaseInertia(const btVector3 &inertia)
Definition: btMultiBody.h:179
btMultiBody::applyDeltaVeeMultiDof2
void applyDeltaVeeMultiDof2(const btScalar *delta_vee, btScalar multiplier)
Definition: btMultiBody.h:383
btMultiBodyDoubleData::m_baseWorldTransform
btTransformDoubleData m_baseWorldTransform
Definition: btMultiBody.h:787
btMultiBody::setPosUpdated
void setPosUpdated(bool updated)
Definition: btMultiBody.h:560
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:403
btMultiBodyLinkFloatData
Definition: btMultiBody.h:751
btMultiBody::m_userIndex
int m_userIndex
Definition: btMultiBody.h:700
btCollisionObject::m_userObjectPointer
void * m_userObjectPointer
users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPoin...
Definition: btCollisionObject.h:102
btMultiBody::getBaseTorque
const btVector3 & getBaseTorque() const
Definition: btMultiBody.h:330
btMultiBodyLinkDoubleData::m_jointTorque
double m_jointTorque[6]
Definition: btMultiBody.h:735
btMultiBodyLinkDoubleData::m_parentComToThisComOffset
btVector3DoubleData m_parentComToThisComOffset
Definition: btMultiBody.h:721
btAlignedObjectArray.h
btMultiBody::m_vectorBuf
btAlignedObjectArray< btVector3 > m_vectorBuf
Definition: btMultiBody.h:681
btMultiBodyDoubleData::m_paddingPtr
char * m_paddingPtr
Definition: btMultiBody.h:794
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
btMultiBodyFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btMultiBody.h:800
btVector3FloatData
Definition: btVector3.h:1312
btMultiBodyLinkFloatData::m_parentComToThisComOffset
btVector3FloatData m_parentComToThisComOffset
Definition: btMultiBody.h:754
btQuaternion
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:55
btMultiBodyLinkDoubleData::m_posVarCount
int m_posVarCount
Definition: btMultiBody.h:732
btMultiBodyLinkFloatData::m_dofCount
int m_dofCount
Definition: btMultiBody.h:759
btMultiBody::addBaseConstraintForce
void addBaseConstraintForce(const btVector3 &f)
Definition: btMultiBody.h:316
btMultiBody::fillContactJacobianMultiDof
void fillContactJacobianMultiDof(int link, const btVector3 &contact_point, const btVector3 &normal, btScalar *jac, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m) const
Definition: btMultiBody.h:439
btMultiBody::setBaseMass
void setBaseMass(btScalar mass)
Definition: btMultiBody.h:178
btMultiBodyLinkDoubleData::m_jointName
char * m_jointName
Definition: btMultiBody.h:745
btMultiBodyLinkFloatData::m_jointUpperLimit
float m_jointUpperLimit
Definition: btMultiBody.h:773
btMultiBodyLinkFloatData::m_linkInertia
btVector3FloatData m_linkInertia
Definition: btMultiBody.h:758
btMultiBody::getBaseForce
const btVector3 & getBaseForce() const
Definition: btMultiBody.h:329
btMultiBody::__posUpdated
bool __posUpdated
Definition: btMultiBody.h:710
btMultiBody::m_links
btAlignedObjectArray< btMultibodyLink > m_links
Definition: btMultiBody.h:661
btMultiBodyLinkDoubleData::m_jointMaxVelocity
double m_jointMaxVelocity
Definition: btMultiBody.h:742
btMultiBodyLinkDoubleData::m_jointPos
double m_jointPos[7]
Definition: btMultiBody.h:733
btMultiBodyLinkDoubleData::m_linkInertia
btVector3DoubleData m_linkInertia
Definition: btMultiBody.h:726
btMultiBody::setBasePos
void setBasePos(const btVector3 &pos)
Definition: btMultiBody.h:197
btMultiBodyLinkDoubleData::m_thisPivotToThisComOffset
btVector3DoubleData m_thisPivotToThisComOffset
Definition: btMultiBody.h:722
btMultiBodyLinkFloatData::m_jointTorque
float m_jointTorque[6]
Definition: btMultiBody.h:768
btMultiBodyLinkFloatData::m_jointVel
float m_jointVel[6]
Definition: btMultiBody.h:767
btMultiBody::addBaseConstraintTorque
void addBaseConstraintTorque(const btVector3 &t)
Definition: btMultiBody.h:320
btMultiBody::useGlobalVelocities
void useGlobalVelocities(bool use)
Definition: btMultiBody.h:553
btMultiBody::getVelocityVector
const btScalar * getVelocityVector() const
Definition: btMultiBody.h:258
btTransformDoubleData
Definition: btTransform.h:259
btMultiBodyDoubleData::m_links
btMultiBodyLinkDoubleData * m_links
Definition: btMultiBody.h:792
btMultiBodyFloatData::m_baseCollider
btCollisionObjectFloatData * m_baseCollider
Definition: btMultiBody.h:804
btMultiBody::m_cachedInertiaTopRight
btMatrix3x3 m_cachedInertiaTopRight
Definition: btMultiBody.h:686
btMultiBody::useRK4Integration
void useRK4Integration(bool use)
Definition: btMultiBody.h:551
btMultiBodyLinkDoubleData::m_linkMass
double m_linkMass
Definition: btMultiBody.h:727
btMultiBody::setBaseWorldTransform
void setBaseWorldTransform(const btTransform &tr)
Definition: btMultiBody.h:202
btMultiBody::processDeltaVeeMultiDof2
void processDeltaVeeMultiDof2()
Definition: btMultiBody.h:390
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
btVector3DoubleData
Definition: btVector3.h:1317
btMultiBody::m_angularDamping
btScalar m_angularDamping
Definition: btMultiBody.h:704
btCollisionObject::m_userIndex
int m_userIndex
Definition: btCollisionObject.h:106
btMultiBodyLinkDoubleData::m_jointAxisBottom
btVector3DoubleData m_jointAxisBottom[6]
Definition: btMultiBody.h:724
btMultiBodyLinkFloatData::m_jointPos
float m_jointPos[7]
Definition: btMultiBody.h:766
btMultiBody::m_canSleep
bool m_canSleep
Definition: btMultiBody.h:695
btMultiBody::getLinearDamping
btScalar getLinearDamping() const
Definition: btMultiBody.h:497
btMultiBody::getBaseVel
const btVector3 getBaseVel() const
Definition: btMultiBody.h:187
btMultiBody::setBaseName
void setBaseName(const char *name)
memory of setBaseName needs to be manager by user
Definition: btMultiBody.h:586
btScalar.h
btMultiBodyDoubleData::m_baseCollider
btCollisionObjectDoubleData * m_baseCollider
Definition: btMultiBody.h:793
btMultiBodyLinkDoubleData::m_jointMaxForce
double m_jointMaxForce
Definition: btMultiBody.h:741