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