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