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