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"
31 #include "LinearMath/btMatrix3x3.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"
50 
52 {
53 public:
54 
55 
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 
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  }
135  {
136  return m_baseCollider;
137  }
139  {
140  return m_baseCollider;
141  }
142 
143  //
144  // get parent
145  // input: link num from 0 to num_links-1
146  // output: link num from 0 to num_links-1, OR -1 to mean the base.
147  //
148  int getParent(int link_num) const;
149 
150 
151  //
152  // get number of m_links, masses, moments of inertia
153  //
154 
155  int getNumLinks() const { return m_links.size(); }
156  int getNumDofs() const { return m_dofCount; }
157  int getNumPosVars() const { return m_posVarCnt; }
158  btScalar getBaseMass() const { return m_baseMass; }
159  const btVector3 & getBaseInertia() const { return m_baseInertia; }
160  btScalar getLinkMass(int i) const;
161  const btVector3 & getLinkInertia(int i) const;
162 
163 
164 
165  //
166  // change mass (incomplete: can only change base mass and inertia at present)
167  //
168 
169  void setBaseMass(btScalar mass) { m_baseMass = mass; }
170  void setBaseInertia(const btVector3 &inertia) { m_baseInertia = inertia; }
171 
172 
173  //
174  // get/set pos/vel/rot/omega for the base link
175  //
176 
177  const btVector3 & getBasePos() const { return m_basePos; } // in world frame
178  const btVector3 getBaseVel() const
179  {
180  return btVector3(m_realBuf[3],m_realBuf[4],m_realBuf[5]);
181  } // in world frame
183  {
184  return m_baseQuat;
185  } // rotates world vectors into base frame
186  btVector3 getBaseOmega() const { return btVector3(m_realBuf[0],m_realBuf[1],m_realBuf[2]); } // in world frame
187 
188  void setBasePos(const btVector3 &pos)
189  {
190  m_basePos = pos;
191  }
192 
194  {
195  setBasePos(tr.getOrigin());
196  setWorldToBaseRot(tr.getRotation().inverse());
197 
198  }
199 
201  {
202  btTransform tr;
203  tr.setOrigin(getBasePos());
204  tr.setRotation(getWorldToBaseRot().inverse());
205  return tr;
206  }
207 
208  void setBaseVel(const btVector3 &vel)
209  {
210 
211  m_realBuf[3]=vel[0]; m_realBuf[4]=vel[1]; m_realBuf[5]=vel[2];
212  }
213  void setWorldToBaseRot(const btQuaternion &rot)
214  {
215  m_baseQuat = rot; //m_baseQuat asumed to ba alias!?
216  }
217  void setBaseOmega(const btVector3 &omega)
218  {
219  m_realBuf[0]=omega[0];
220  m_realBuf[1]=omega[1];
221  m_realBuf[2]=omega[2];
222  }
223 
224 
225  //
226  // get/set pos/vel for child m_links (i = 0 to num_links-1)
227  //
228 
229  btScalar getJointPos(int i) const;
230  btScalar getJointVel(int i) const;
231 
232  btScalar * getJointVelMultiDof(int i);
233  btScalar * getJointPosMultiDof(int i);
234 
235  const btScalar * getJointVelMultiDof(int i) const ;
236  const btScalar * getJointPosMultiDof(int i) const ;
237 
238  void setJointPos(int i, btScalar q);
239  void setJointVel(int i, btScalar qdot);
240  void setJointPosMultiDof(int i, btScalar *q);
241  void setJointVelMultiDof(int i, btScalar *qdot);
242 
243 
244 
245  //
246  // direct access to velocities as a vector of 6 + num_links elements.
247  // (omega first, then v, then joint velocities.)
248  //
249  const btScalar * getVelocityVector() const
250  {
251  return &m_realBuf[0];
252  }
253 /* btScalar * getVelocityVector()
254  {
255  return &real_buf[0];
256  }
257  */
258 
259  //
260  // get the frames of reference (positions and orientations) of the child m_links
261  // (i = 0 to num_links-1)
262  //
263 
264  const btVector3 & getRVector(int i) const; // vector from COM(parent(i)) to COM(i), in frame i's coords
265  const btQuaternion & getParentToLocalRot(int i) const; // rotates vectors in frame parent(i) to vectors in frame i.
266 
267 
268  //
269  // transform vectors in local frame of link i to world frame (or vice versa)
270  //
271  btVector3 localPosToWorld(int i, const btVector3 &vec) const;
272  btVector3 localDirToWorld(int i, const btVector3 &vec) const;
273  btVector3 worldPosToLocal(int i, const btVector3 &vec) const;
274  btVector3 worldDirToLocal(int i, const btVector3 &vec) const;
275 
276 
277  //
278  // calculate kinetic energy and angular momentum
279  // useful for debugging.
280  //
281 
282  btScalar getKineticEnergy() const;
283  btVector3 getAngularMomentum() const;
284 
285 
286  //
287  // set external forces and torques. Note all external forces/torques are given in the WORLD frame.
288  //
289 
290  void clearForcesAndTorques();
291  void clearConstraintForces();
292 
293  void clearVelocities();
294 
295  void addBaseForce(const btVector3 &f)
296  {
297  m_baseForce += f;
298  }
299  void addBaseTorque(const btVector3 &t) { m_baseTorque += t; }
300  void addLinkForce(int i, const btVector3 &f);
301  void addLinkTorque(int i, const btVector3 &t);
302 
304  {
305  m_baseConstraintForce += f;
306  }
307  void addBaseConstraintTorque(const btVector3 &t) { m_baseConstraintTorque += t; }
308  void addLinkConstraintForce(int i, const btVector3 &f);
309  void addLinkConstraintTorque(int i, const btVector3 &t);
310 
311 
312 void addJointTorque(int i, btScalar Q);
313  void addJointTorqueMultiDof(int i, int dof, btScalar Q);
314  void addJointTorqueMultiDof(int i, const btScalar *Q);
315 
316  const btVector3 & getBaseForce() const { return m_baseForce; }
317  const btVector3 & getBaseTorque() const { return m_baseTorque; }
318  const btVector3 & getLinkForce(int i) const;
319  const btVector3 & getLinkTorque(int i) const;
320  btScalar getJointTorque(int i) const;
321  btScalar * getJointTorqueMultiDof(int i);
322 
323 
324  //
325  // dynamics routines.
326  //
327 
328  // timestep the velocities (given the external forces/torques set using addBaseForce etc).
329  // also sets up caches for calcAccelerationDeltas.
330  //
331  // Note: the caller must provide three vectors which are used as
332  // temporary scratch space. The idea here is to reduce dynamic
333  // memory allocation: the same scratch vectors can be re-used
334  // again and again for different Multibodies, instead of each
335  // btMultiBody allocating (and then deallocating) their own
336  // individual scratch buffers. This gives a considerable speed
337  // improvement, at least on Windows (where dynamic memory
338  // allocation appears to be fairly slow).
339  //
340 
341 
342  void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt,
346  bool isConstraintPass=false
347  );
348 
354  bool isConstraintPass=false)
355  {
356  computeAccelerationsArticulatedBodyAlgorithmMultiDof(dt,scratch_r,scratch_v,scratch_m,isConstraintPass);
357  }
358 
359  // calcAccelerationDeltasMultiDof
360  // input: force vector (in same format as jacobian, i.e.:
361  // 3 torque values, 3 force values, num_links joint torque values)
362  // output: 3 omegadot values, 3 vdot values, num_links q_double_dot values
363  // (existing contents of output array are replaced)
364  // calcAccelerationDeltasMultiDof must have been called first.
365  void calcAccelerationDeltasMultiDof(const btScalar *force, btScalar *output,
367  btAlignedObjectArray<btVector3> &scratch_v) const;
368 
369 
370  void applyDeltaVeeMultiDof2(const btScalar * delta_vee, btScalar multiplier)
371  {
372  for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
373  {
374  m_deltaV[dof] += delta_vee[dof] * multiplier;
375  }
376  }
378  {
379  applyDeltaVeeMultiDof(&m_deltaV[0],1);
380 
381  for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
382  {
383  m_deltaV[dof] = 0.f;
384  }
385  }
386 
387  void applyDeltaVeeMultiDof(const btScalar * delta_vee, btScalar multiplier)
388  {
389  //for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
390  // printf("%.4f ", delta_vee[dof]*multiplier);
391  //printf("\n");
392 
393  //btScalar sum = 0;
394  //for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
395  //{
396  // sum += delta_vee[dof]*multiplier*delta_vee[dof]*multiplier;
397  //}
398  //btScalar l = btSqrt(sum);
399 
400  //if (l>m_maxAppliedImpulse)
401  //{
402  // multiplier *= m_maxAppliedImpulse/l;
403  //}
404 
405  for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
406  {
407  m_realBuf[dof] += delta_vee[dof] * multiplier;
408  btClamp(m_realBuf[dof],-m_maxCoordinateVelocity,m_maxCoordinateVelocity);
409  }
410  }
411 
412 
413 
414  // timestep the positions (given current velocities).
415  void stepPositionsMultiDof(btScalar dt, btScalar *pq = 0, btScalar *pqd = 0);
416 
417 
418  //
419  // contacts
420  //
421 
422  // This routine fills out a contact constraint jacobian for this body.
423  // the 'normal' supplied must be -n for body1 or +n for body2 of the contact.
424  // 'normal' & 'contact_point' are both given in world coordinates.
425 
427  const btVector3 &contact_point,
428  const btVector3 &normal,
429  btScalar *jac,
432  btAlignedObjectArray<btMatrix3x3> &scratch_m) const { fillConstraintJacobianMultiDof(link, contact_point, btVector3(0, 0, 0), normal, jac, scratch_r, scratch_v, scratch_m); }
433 
434  //a more general version of fillContactJacobianMultiDof which does not assume..
435  //.. that the constraint in question is contact or, to be more precise, constrains linear velocity only
436  void fillConstraintJacobianMultiDof(int link,
437  const btVector3 &contact_point,
438  const btVector3 &normal_ang,
439  const btVector3 &normal_lin,
440  btScalar *jac,
443  btAlignedObjectArray<btMatrix3x3> &scratch_m) const;
444 
445 
446  //
447  // sleeping
448  //
449  void setCanSleep(bool canSleep)
450  {
451  m_canSleep = canSleep;
452  }
453 
454  bool getCanSleep()const
455  {
456  return m_canSleep;
457  }
458 
459  bool isAwake() const { return m_awake; }
460  void wakeUp();
461  void goToSleep();
462  void checkMotionAndSleepIfRequired(btScalar timestep);
463 
464  bool hasFixedBase() const
465  {
466  return m_fixedBase;
467  }
468 
469  int getCompanionId() const
470  {
471  return m_companionId;
472  }
473  void setCompanionId(int id)
474  {
475  //printf("for %p setCompanionId(%d)\n",this, id);
476  m_companionId = id;
477  }
478 
479  void setNumLinks(int numLinks)//careful: when changing the number of m_links, make sure to re-initialize or update existing m_links
480  {
481  m_links.resize(numLinks);
482  }
483 
485  {
486  return m_linearDamping;
487  }
489  {
490  m_linearDamping = damp;
491  }
493  {
494  return m_angularDamping;
495  }
497  {
498  m_angularDamping = damp;
499  }
500 
501  bool getUseGyroTerm() const
502  {
503  return m_useGyroTerm;
504  }
505  void setUseGyroTerm(bool useGyro)
506  {
507  m_useGyroTerm = useGyro;
508  }
510  {
511  return m_maxCoordinateVelocity ;
512  }
514  {
515  m_maxCoordinateVelocity = maxVel;
516  }
517 
519  {
520  return m_maxAppliedImpulse;
521  }
523  {
524  m_maxAppliedImpulse = maxImp;
525  }
526  void setHasSelfCollision(bool hasSelfCollision)
527  {
528  m_hasSelfCollision = hasSelfCollision;
529  }
530  bool hasSelfCollision() const
531  {
532  return m_hasSelfCollision;
533  }
534 
535 
536  void finalizeMultiDof();
537 
538  void useRK4Integration(bool use) { m_useRK4 = use; }
539  bool isUsingRK4Integration() const { return m_useRK4; }
540  void useGlobalVelocities(bool use) { m_useGlobalVelocities = use; }
541  bool isUsingGlobalVelocities() const { return m_useGlobalVelocities; }
542 
543  bool isPosUpdated() const
544  {
545  return __posUpdated;
546  }
547  void setPosUpdated(bool updated)
548  {
549  __posUpdated = updated;
550  }
551 
552  //internalNeedsJointFeedback is for internal use only
554  {
555  return m_internalNeedsJointFeedback;
556  }
557  void forwardKinematics(btAlignedObjectArray<btQuaternion>& scratch_q,btAlignedObjectArray<btVector3>& scratch_m);
558 
559  void updateCollisionObjectWorldTransforms(btAlignedObjectArray<btQuaternion>& scratch_q,btAlignedObjectArray<btVector3>& scratch_m);
560 
561  virtual int calculateSerializeBufferSize() const;
562 
564  virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
565 
566  const char* getBaseName() const
567  {
568  return m_baseName;
569  }
571  void setBaseName(const char* name)
572  {
573  m_baseName = name;
574  }
575 
576 private:
577  btMultiBody(const btMultiBody &); // not implemented
578  void operator=(const btMultiBody &); // not implemented
579 
580  void compTreeLinkVelocities(btVector3 *omega, btVector3 *vel) const;
581 
582  void solveImatrix(const btVector3& rhs_top, const btVector3& rhs_bot, float result[6]) const;
583  void solveImatrix(const btSpatialForceVector &rhs, btSpatialMotionVector &result) const;
584 
586  {
587  int dofOffset = 0, cfgOffset = 0;
588  for(int bidx = 0; bidx < m_links.size(); ++bidx)
589  {
590  m_links[bidx].m_dofOffset = dofOffset; m_links[bidx].m_cfgOffset = cfgOffset;
591  dofOffset += m_links[bidx].m_dofCount; cfgOffset += m_links[bidx].m_posVarCount;
592  }
593  }
594 
595  void mulMatrix(btScalar *pA, btScalar *pB, int rowsA, int colsA, int rowsB, int colsB, btScalar *pC) const;
596 
597 
598 private:
599 
601  const char* m_baseName;//memory needs to be manager by user!
602 
603  btVector3 m_basePos; // position of COM of base (world frame)
604  btQuaternion m_baseQuat; // rotates world points into base frame
605 
606  btScalar m_baseMass; // mass of the base
607  btVector3 m_baseInertia; // inertia of the base (in local frame; diagonal)
608 
609  btVector3 m_baseForce; // external force applied to base. World frame.
610  btVector3 m_baseTorque; // external torque applied to base. World frame.
611 
612  btVector3 m_baseConstraintForce; // external force applied to base. World frame.
613  btVector3 m_baseConstraintTorque; // external torque applied to base. World frame.
614 
615  btAlignedObjectArray<btMultibodyLink> m_links; // array of m_links, excluding the base. index from 0 to num_links-1.
617 
618 
619  //
620  // realBuf:
621  // offset size array
622  // 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]
623  // 6+num_links num_links D
624  //
625  // vectorBuf:
626  // offset size array
627  // 0 num_links h_top
628  // num_links num_links h_bottom
629  //
630  // matrixBuf:
631  // offset size array
632  // 0 num_links+1 rot_from_parent
633  //
638 
639 
644 
646 
647  // Sleep parameters.
648  bool m_awake;
651 
659 
661  int m_dofCount, m_posVarCnt;
662  bool m_useRK4, m_useGlobalVelocities;
663 
666 };
667 
669 {
675 
676 
677  char *m_linkName;
678  char *m_jointName;
680 
681  btVector3DoubleData m_linkInertia; // inertia of the base (in local frame; diagonal)
682  double m_linkMass;
685 
686 
687 
688 
691  double m_jointPos[7];
692  double m_jointVel[6];
693  double m_jointTorque[6];
694 
695 
696 
697 };
698 
700 {
706 
707 
708  char *m_linkName;
709  char *m_jointName;
711 
712  btVector3FloatData m_linkInertia; // inertia of the base (in local frame; diagonal)
714  float m_linkMass;
717 
718 
719 
720  float m_jointPos[7];
721  float m_jointVel[6];
722  float m_jointTorque[6];
724 
725 
726 };
727 
730 {
731  char *m_baseName;
734 
736  btVector3DoubleData m_baseInertia; // inertia of the base (in local frame; diagonal)
737 
739  double m_baseMass;
740 
741  char m_padding[4];
742 
743 };
744 
747 {
748  char *m_baseName;
752  btVector3FloatData m_baseInertia; // inertia of the base (in local frame; diagonal)
753 
754  float m_baseMass;
756 };
757 
758 
759 
760 #endif
void setOrigin(const btVector3 &origin)
Set the translational element.
Definition: btTransform.h:150
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:350
void setCanSleep(bool canSleep)
Definition: btMultiBody.h:449
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btAlignedObjectArray< btMultiBodyLinkCollider * > m_colliders
Definition: btMultiBody.h:616
btAlignedObjectArray< btMatrix3x3 > m_matrixBuf
Definition: btMultiBody.h:637
bool m_useGyroTerm
Definition: btMultiBody.h:655
const btMultibodyLink & getLink(int index) const
Definition: btMultiBody.h:119
btVector3 m_baseForce
Definition: btMultiBody.h:609
bool isUsingGlobalVelocities() const
Definition: btMultiBody.h:541
const btVector3 getBaseVel() const
Definition: btMultiBody.h:178
btMultiBodyLinkCollider * getBaseCollider()
Definition: btMultiBody.h:138
void setNumLinks(int numLinks)
Definition: btMultiBody.h:479
btQuaternion getRotation() const
Return a quaternion representing the rotation.
Definition: btTransform.h:122
btMultiBodyLinkCollider * m_baseCollider
Definition: btMultiBody.h:600
btScalar m_baseMass
Definition: btMultiBody.h:606
bool m_fixedBase
Definition: btMultiBody.h:645
bool isAwake() const
Definition: btMultiBody.h:459
These spatial algebra classes are used for btMultiBody, see BulletDynamics/Featherstone.
int getNumLinks() const
Definition: btMultiBody.h:155
btVector3DoubleData m_jointAxisTop[6]
Definition: btMultiBody.h:673
btScalar m_maxCoordinateVelocity
Definition: btMultiBody.h:657
void addBaseTorque(const btVector3 &t)
Definition: btMultiBody.h:299
virtual int calculateSerializeBufferSize() const
btTransform getBaseWorldTransform() const
Definition: btMultiBody.h:200
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btMultiBody.h:729
btScalar getBaseMass() const
Definition: btMultiBody.h:158
btQuaternionDoubleData m_zeroRotParentToThis
Definition: btMultiBody.h:670
btMatrix3x3 m_cachedInertiaLowerRight
Definition: btMultiBody.h:643
btCollisionObjectFloatData * m_linkCollider
Definition: btMultiBody.h:710
void setBaseCollider(btMultiBodyLinkCollider *collider)
Definition: btMultiBody.h:130
bool internalNeedsJointFeedback() const
Definition: btMultiBody.h:553
void btClamp(T &a, const T &lb, const T &ub)
Definition: btMinMax.h:59
const btVector3 & getBaseTorque() const
Definition: btMultiBody.h:317
bool isPosUpdated() const
Definition: btMultiBody.h:543
btVector3 m_baseConstraintTorque
Definition: btMultiBody.h:613
void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
Definition: btMultiBody.h:387
void setWorldToBaseRot(const btQuaternion &rot)
Definition: btMultiBody.h:213
btQuaternion inverse(const btQuaternion &q)
Return the inverse of a quaternion.
Definition: btQuaternion.h:867
btScalar m_maxAppliedImpulse
Definition: btMultiBody.h:656
const char * getBaseName() const
Definition: btMultiBody.h:566
btAlignedObjectArray< btScalar > m_deltaV
Definition: btMultiBody.h:634
btScalar getMaxAppliedImpulse() const
Definition: btMultiBody.h:518
void setBaseVel(const btVector3 &vel)
Definition: btMultiBody.h:208
btVector3 m_baseTorque
Definition: btMultiBody.h:610
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
int getNumPosVars() const
Definition: btMultiBody.h:157
btMatrix3x3 m_cachedInertiaTopLeft
Definition: btMultiBody.h:640
int m_companionId
Definition: btMultiBody.h:652
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
const btVector3 & getBaseInertia() const
Definition: btMultiBody.h:159
void setHasSelfCollision(bool hasSelfCollision)
Definition: btMultiBody.h:526
void setMaxCoordinateVelocity(btScalar maxVel)
Definition: btMultiBody.h:513
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btTransformFloatData m_baseWorldTransform
Definition: btMultiBody.h:751
void setUseGyroTerm(bool useGyro)
Definition: btMultiBody.h:505
btQuaternion m_baseQuat
Definition: btMultiBody.h:604
btMatrix3x3 m_cachedInertiaLowerLeft
Definition: btMultiBody.h:642
void setCompanionId(int id)
Definition: btMultiBody.h:473
void setBaseOmega(const btVector3 &omega)
Definition: btMultiBody.h:217
bool m_hasSelfCollision
Definition: btMultiBody.h:658
bool hasFixedBase() const
Definition: btMultiBody.h:464
btMultibodyLink & getLink(int index)
Definition: btMultiBody.h:124
#define output
void setRotation(const btQuaternion &q)
Set the rotational element by btQuaternion.
Definition: btTransform.h:165
btScalar getLinearDamping() const
Definition: btMultiBody.h:484
bool hasSelfCollision() const
Definition: btMultiBody.h:530
btQuaternionFloatData m_zeroRotParentToThis
Definition: btMultiBody.h:701
btQuaternion inverse() const
Return the inverse of this quaternion.
Definition: btQuaternion.h:453
btVector3FloatData m_baseInertia
Definition: btMultiBody.h:752
btScalar m_sleepTimer
Definition: btMultiBody.h:650
btVector3 m_basePos
Definition: btMultiBody.h:603
void setAngularDamping(btScalar damp)
Definition: btMultiBody.h:496
btVector3FloatData m_thisPivotToThisComOffset
Definition: btMultiBody.h:703
btVector3DoubleData m_baseInertia
Definition: btMultiBody.h:736
btVector3 m_baseConstraintForce
Definition: btMultiBody.h:612
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:64
bool m_internalNeedsJointFeedback
the m_needsJointFeedback gets updated/computed during the stepVelocitiesMultiDof and it for internal ...
Definition: btMultiBody.h:665
btVector3 m_baseInertia
Definition: btMultiBody.h:607
void setLinearDamping(btScalar damp)
Definition: btMultiBody.h:488
const char * m_baseName
Definition: btMultiBody.h:601
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
void addBaseForce(const btVector3 &f)
Definition: btMultiBody.h:295
btAlignedObjectArray< btScalar > m_realBuf
Definition: btMultiBody.h:635
void updateLinksDofOffsets()
Definition: btMultiBody.h:585
void setMaxAppliedImpulse(btScalar maxImp)
Definition: btMultiBody.h:522
btVector3 getBaseOmega() const
Definition: btMultiBody.h:186
btMultiBodyLinkFloatData * m_links
Definition: btMultiBody.h:749
int getCompanionId() const
Definition: btMultiBody.h:469
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:426
btScalar m_linearDamping
Definition: btMultiBody.h:653
btScalar getAngularDamping() const
Definition: btMultiBody.h:492
for serialization
Definition: btTransform.h:253
btCollisionObjectDoubleData * m_linkCollider
Definition: btMultiBody.h:679
void setBaseInertia(const btVector3 &inertia)
Definition: btMultiBody.h:170
void applyDeltaVeeMultiDof2(const btScalar *delta_vee, btScalar multiplier)
Definition: btMultiBody.h:370
btTransformDoubleData m_baseWorldTransform
Definition: btMultiBody.h:735
bool getCanSleep() const
Definition: btMultiBody.h:454
void setPosUpdated(bool updated)
Definition: btMultiBody.h:547
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
btVector3DoubleData m_parentComToThisComOffset
Definition: btMultiBody.h:671
bool isUsingRK4Integration() const
Definition: btMultiBody.h:539
btAlignedObjectArray< btVector3 > m_vectorBuf
Definition: btMultiBody.h:636
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btMultiBody.h:746
const btMultiBodyLinkCollider * getBaseCollider() const
Definition: btMultiBody.h:134
btVector3FloatData m_parentComToThisComOffset
Definition: btMultiBody.h:702
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
Definition: btQuaternion.h:55
const btQuaternion & getWorldToBaseRot() const
Definition: btMultiBody.h:182
void addBaseConstraintForce(const btVector3 &f)
Definition: btMultiBody.h:303
void setBaseMass(btScalar mass)
Definition: btMultiBody.h:169
btVector3FloatData m_linkInertia
Definition: btMultiBody.h:712
bool __posUpdated
Definition: btMultiBody.h:660
const btVector3 & getBasePos() const
Definition: btMultiBody.h:177
const btVector3 & getBaseForce() const
Definition: btMultiBody.h:316
btAlignedObjectArray< btMultibodyLink > m_links
Definition: btMultiBody.h:615
btVector3DoubleData m_linkInertia
Definition: btMultiBody.h:681
void setBasePos(const btVector3 &pos)
Definition: btMultiBody.h:188
btVector3DoubleData m_thisPivotToThisComOffset
Definition: btMultiBody.h:672
void addBaseConstraintTorque(const btVector3 &t)
Definition: btMultiBody.h:307
void useGlobalVelocities(bool use)
Definition: btMultiBody.h:540
btMultiBodyLinkDoubleData * m_links
Definition: btMultiBody.h:732
btCollisionObjectFloatData * m_baseCollider
Definition: btMultiBody.h:750
btMatrix3x3 m_cachedInertiaTopRight
Definition: btMultiBody.h:641
int getNumDofs() const
Definition: btMultiBody.h:156
void useRK4Integration(bool use)
Definition: btMultiBody.h:538
void setBaseWorldTransform(const btTransform &tr)
Definition: btMultiBody.h:193
const btScalar * getVelocityVector() const
Definition: btMultiBody.h:249
void processDeltaVeeMultiDof2()
Definition: btMultiBody.h:377
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btScalar m_angularDamping
Definition: btMultiBody.h:654
bool getUseGyroTerm() const
Definition: btMultiBody.h:501
btVector3DoubleData m_jointAxisBottom[6]
Definition: btMultiBody.h:674
btScalar getMaxCoordinateVelocity() const
Definition: btMultiBody.h:509
bool m_canSleep
Definition: btMultiBody.h:649
void setBaseName(const char *name)
memory of setBaseName needs to be manager by user
Definition: btMultiBody.h:571
btCollisionObjectDoubleData * m_baseCollider
Definition: btMultiBody.h:733