Bullet Collision Detection & Physics Library
btGeneric6DofConstraint.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
18 
19 /*
20 2007-09-09
21 btGeneric6DofConstraint Refactored by Francisco Le?n
22 email: projectileman@yahoo.com
23 http://gimpact.sf.net
24 */
25 
26 #ifndef BT_GENERIC_6DOF_CONSTRAINT_H
27 #define BT_GENERIC_6DOF_CONSTRAINT_H
28 
29 #include "LinearMath/btVector3.h"
30 #include "btJacobianEntry.h"
31 #include "btTypedConstraint.h"
32 
33 class btRigidBody;
34 
35 #ifdef BT_USE_DOUBLE_PRECISION
36 #define btGeneric6DofConstraintData2 btGeneric6DofConstraintDoubleData2
37 #define btGeneric6DofConstraintDataName "btGeneric6DofConstraintDoubleData2"
38 #else
39 #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData
40 #define btGeneric6DofConstraintDataName "btGeneric6DofConstraintData"
41 #endif //BT_USE_DOUBLE_PRECISION
42 
45 {
46 public:
61 
63 
71 
73  {
75  m_targetVelocity = 0;
76  m_maxMotorForce = 6.0f;
77  m_maxLimitForce = 300.0f;
78  m_loLimit = 1.0f;
79  m_hiLimit = -1.0f;
80  m_normalCFM = 0.f;
81  m_stopERP = 0.2f;
82  m_stopCFM = 0.f;
83  m_bounce = 0.0f;
84  m_damping = 1.0f;
85  m_limitSoftness = 0.5f;
86  m_currentLimit = 0;
88  m_enableMotor = false;
89  }
90 
92  {
96  m_loLimit = limot.m_loLimit;
97  m_hiLimit = limot.m_hiLimit;
98  m_normalCFM = limot.m_normalCFM;
99  m_stopERP = limot.m_stopERP;
100  m_stopCFM = limot.m_stopCFM;
101  m_bounce = limot.m_bounce;
105  }
106 
108  bool isLimited() const
109  {
110  if (m_loLimit > m_hiLimit) return false;
111  return true;
112  }
113 
115  bool needApplyTorques() const
116  {
117  if (m_currentLimit == 0 && m_enableMotor == false) return false;
118  return true;
119  }
120 
122 
125  int testLimitValue(btScalar test_value);
126 
128  btScalar solveAngularLimits(btScalar timeStep, btVector3& axis, btScalar jacDiagABInv, btRigidBody* body0, btRigidBody* body1);
129 };
130 
132 {
133 public:
145  bool m_enableMotor[3];
151  int m_currentLimit[3];
152 
154  {
155  m_lowerLimit.setValue(0.f, 0.f, 0.f);
156  m_upperLimit.setValue(0.f, 0.f, 0.f);
157  m_accumulatedImpulse.setValue(0.f, 0.f, 0.f);
158  m_normalCFM.setValue(0.f, 0.f, 0.f);
159  m_stopERP.setValue(0.2f, 0.2f, 0.2f);
160  m_stopCFM.setValue(0.f, 0.f, 0.f);
161 
162  m_limitSoftness = 0.7f;
163  m_damping = btScalar(1.0f);
164  m_restitution = btScalar(0.5f);
165  for (int i = 0; i < 3; i++)
166  {
167  m_enableMotor[i] = false;
168  m_targetVelocity[i] = btScalar(0.f);
169  m_maxMotorForce[i] = btScalar(0.f);
170  }
171  }
172 
174  {
175  m_lowerLimit = other.m_lowerLimit;
176  m_upperLimit = other.m_upperLimit;
178 
180  m_damping = other.m_damping;
182  m_normalCFM = other.m_normalCFM;
183  m_stopERP = other.m_stopERP;
184  m_stopCFM = other.m_stopCFM;
185 
186  for (int i = 0; i < 3; i++)
187  {
188  m_enableMotor[i] = other.m_enableMotor[i];
189  m_targetVelocity[i] = other.m_targetVelocity[i];
190  m_maxMotorForce[i] = other.m_maxMotorForce[i];
191  }
192  }
193 
195 
201  inline bool isLimited(int limitIndex) const
202  {
203  return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
204  }
205  inline bool needApplyForce(int limitIndex) const
206  {
207  if (m_currentLimit[limitIndex] == 0 && m_enableMotor[limitIndex] == false) return false;
208  return true;
209  }
210  int testLimitValue(int limitIndex, btScalar test_value);
211 
213  btScalar timeStep,
214  btScalar jacDiagABInv,
215  btRigidBody& body1, const btVector3& pointInA,
216  btRigidBody& body2, const btVector3& pointInB,
217  int limit_index,
218  const btVector3& axis_normal_on_a,
219  const btVector3& anchorPos);
220 };
221 
223 {
227 };
228 #define BT_6DOF_FLAGS_AXIS_SHIFT 3 // bits per axis
229 
231 
268 {
269 protected:
274 
278  btJacobianEntry m_jacLinear[3];
279  btJacobianEntry m_jacAng[3];
280 
286 
289  btRotationalLimitMotor m_angularLimits[3];
291 
292 protected:
299  btVector3 m_calculatedAxis[3];
304 
305  btVector3 m_AnchorPos; // point betwen pivots of bodies A and B to solve linear axes
306 
309 
310  int m_flags;
311 
313 
315  {
316  btAssert(0);
317  (void)other;
318  return *this;
319  }
320 
321  int setAngularLimits(btConstraintInfo2 * info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
322 
323  int setLinearLimits(btConstraintInfo2 * info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
324 
325  void buildLinearJacobian(
326  btJacobianEntry & jacLinear, const btVector3& normalWorld,
327  const btVector3& pivotAInW, const btVector3& pivotBInW);
328 
329  void buildAngularJacobian(btJacobianEntry & jacAngular, const btVector3& jointAxisW);
330 
331  // tests linear limits
332  void calculateLinearInfo();
333 
335  void calculateAngleInfo();
336 
337 public:
339 
342 
343  btGeneric6DofConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
344  btGeneric6DofConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
345 
347 
351  void calculateTransforms(const btTransform& transA, const btTransform& transB);
352 
353  void calculateTransforms();
354 
356 
360  {
361  return m_calculatedTransformA;
362  }
363 
365 
369  {
370  return m_calculatedTransformB;
371  }
372 
374  {
375  return m_frameInA;
376  }
377 
379  {
380  return m_frameInB;
381  }
382 
384  {
385  return m_frameInA;
386  }
387 
389  {
390  return m_frameInB;
391  }
392 
394  virtual void buildJacobian();
395 
396  virtual void getInfo1(btConstraintInfo1 * info);
397 
398  void getInfo1NonVirtual(btConstraintInfo1 * info);
399 
400  virtual void getInfo2(btConstraintInfo2 * info);
401 
402  void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
403 
404  void updateRHS(btScalar timeStep);
405 
407 
410  btVector3 getAxis(int axis_index) const;
411 
413 
416  btScalar getAngle(int axis_index) const;
417 
419 
422  btScalar getRelativePivotPosition(int axis_index) const;
423 
424  void setFrames(const btTransform& frameA, const btTransform& frameB);
425 
427 
431  bool testAngularLimitMotor(int axis_index);
432 
433  void setLinearLowerLimit(const btVector3& linearLower)
434  {
435  m_linearLimits.m_lowerLimit = linearLower;
436  }
437 
438  void getLinearLowerLimit(btVector3 & linearLower) const
439  {
440  linearLower = m_linearLimits.m_lowerLimit;
441  }
442 
443  void setLinearUpperLimit(const btVector3& linearUpper)
444  {
445  m_linearLimits.m_upperLimit = linearUpper;
446  }
447 
448  void getLinearUpperLimit(btVector3 & linearUpper) const
449  {
450  linearUpper = m_linearLimits.m_upperLimit;
451  }
452 
453  void setAngularLowerLimit(const btVector3& angularLower)
454  {
455  for (int i = 0; i < 3; i++)
456  m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
457  }
458 
459  void getAngularLowerLimit(btVector3 & angularLower) const
460  {
461  for (int i = 0; i < 3; i++)
462  angularLower[i] = m_angularLimits[i].m_loLimit;
463  }
464 
465  void setAngularUpperLimit(const btVector3& angularUpper)
466  {
467  for (int i = 0; i < 3; i++)
468  m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
469  }
470 
471  void getAngularUpperLimit(btVector3 & angularUpper) const
472  {
473  for (int i = 0; i < 3; i++)
474  angularUpper[i] = m_angularLimits[i].m_hiLimit;
475  }
476 
479  {
480  return &m_angularLimits[index];
481  }
482 
485  {
486  return &m_linearLimits;
487  }
488 
489  //first 3 are linear, next 3 are angular
490  void setLimit(int axis, btScalar lo, btScalar hi)
491  {
492  if (axis < 3)
493  {
494  m_linearLimits.m_lowerLimit[axis] = lo;
495  m_linearLimits.m_upperLimit[axis] = hi;
496  }
497  else
498  {
499  lo = btNormalizeAngle(lo);
500  hi = btNormalizeAngle(hi);
501  m_angularLimits[axis - 3].m_loLimit = lo;
502  m_angularLimits[axis - 3].m_hiLimit = hi;
503  }
504  }
505 
507 
513  bool isLimited(int limitIndex) const
514  {
515  if (limitIndex < 3)
516  {
517  return m_linearLimits.isLimited(limitIndex);
518  }
519  return m_angularLimits[limitIndex - 3].isLimited();
520  }
521 
522  virtual void calcAnchorPos(void); // overridable
523 
524  int get_limit_motor_info2(btRotationalLimitMotor * limot,
525  const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB,
526  btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false);
527 
528  // access for UseFrameOffset
529  bool getUseFrameOffset() const { return m_useOffsetForConstraintFrame; }
530  void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
531 
532  bool getUseLinearReferenceFrameA() const { return m_useLinearReferenceFrameA; }
533  void setUseLinearReferenceFrameA(bool linearReferenceFrameA) { m_useLinearReferenceFrameA = linearReferenceFrameA; }
534 
537  virtual void setParam(int num, btScalar value, int axis = -1);
539  virtual btScalar getParam(int num, int axis = -1) const;
540 
541  void setAxis(const btVector3& axis1, const btVector3& axis2);
542 
543  virtual int getFlags() const
544  {
545  return m_flags;
546  }
547 
548  virtual int calculateSerializeBufferSize() const;
549 
551  virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
552 };
553 
555 {
557  btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
559 
562 
565 
568 };
569 
571 {
573  btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
575 
578 
581 
584 };
585 
587 {
588  return sizeof(btGeneric6DofConstraintData2);
589 }
590 
592 SIMD_FORCE_INLINE const char* btGeneric6DofConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
593 {
595  btTypedConstraint::serialize(&dof->m_typeConstraintData, serializer);
596 
597  m_frameInA.serialize(dof->m_rbAFrame);
598  m_frameInB.serialize(dof->m_rbBFrame);
599 
600  int i;
601  for (i = 0; i < 3; i++)
602  {
603  dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit;
604  dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit;
605  dof->m_linearLowerLimit.m_floats[i] = m_linearLimits.m_lowerLimit[i];
606  dof->m_linearUpperLimit.m_floats[i] = m_linearLimits.m_upperLimit[i];
607  }
608 
609  dof->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA ? 1 : 0;
610  dof->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame ? 1 : 0;
611 
613 }
614 
615 #endif //BT_GENERIC_6DOF_CONSTRAINT_H
btScalar m_damping
Damping for linear limit.
int m_currentLimit[3]
Current relative offset of constraint frames.
void getAngularUpperLimit(btVector3 &angularUpper) const
btScalar m_timeStep
temporal variables
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btScalar solveLinearAxis(btScalar timeStep, btScalar jacDiagABInv, btRigidBody &body1, const btVector3 &pointInA, btRigidBody &body2, const btVector3 &pointInB, int limit_index, const btVector3 &axis_normal_on_a, const btVector3 &anchorPos)
Jacobian entry is an abstraction that allows to describe constraints it can be used in combination wi...
btScalar m_currentPosition
How much is violated this limit.
bool isLimited(int limitIndex) const
Test limit.
btScalar m_floats[4]
Definition: btVector3.h:111
btScalar m_loLimit
limit_parameters
btRotationalLimitMotor(const btRotationalLimitMotor &limot)
#define btGeneric6DofConstraintData2
btTypedConstraintData m_typeConstraintData
btTranslationalLimitMotor * getTranslationalLimitMotor()
Retrieves the limit informacion.
btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis locatio...
btScalar m_stopERP
Error tolerance factor when joint is at limit.
bool isLimited() const
Is limited.
void setUseLinearReferenceFrameA(bool linearReferenceFrameA)
btScalar m_currentLimitError
temp_variables
btVector3 m_targetVelocity
target motor velocity
btScalar m_normalCFM
Relaxation factor.
#define btAssert(x)
Definition: btScalar.h:133
btScalar m_stopCFM
Constraint force mixing factor when joint is at limit.
#define SIMD_FORCE_INLINE
Definition: btScalar.h:83
void setAngularUpperLimit(const btVector3 &angularUpper)
btVector3 m_upperLimit
the constraint upper limits
void getAngularLowerLimit(btVector3 &angularLower) const
btScalar m_limitSoftness
Linear_Limit_parameters.
const btTransform & getFrameOffsetA() const
const btTransform & getCalculatedTransformA() const
Gets the global transform of the offset for body A.
bool m_useSolveConstraintObsolete
for backwards compatibility during the transition to &#39;getInfo/getInfo2&#39;
const btTransform & getCalculatedTransformB() const
Gets the global transform of the offset for body B.
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
btVector3 m_normalCFM
Bounce parameter for linear limit.
#define btGeneric6DofConstraintDataName
btTranslationalLimitMotor m_linearLimits
Linear_Limit_parameters.
btVector3 m_stopCFM
Constraint force mixing factor when joint is at limit.
btScalar m_targetVelocity
target motor velocity
btTypedConstraintDoubleData m_typeConstraintData
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:59
btVector3 m_lowerLimit
the constraint lower limits
void serialize(struct btTransformData &dataOut) const
Definition: btTransform.h:256
void getLinearUpperLimit(btVector3 &linearUpper) const
bool needApplyForce(int limitIndex) const
virtual int calculateSerializeBufferSize() const
this structure is not used, except for loading pre-2.82 .bullet files
int m_currentLimit
current value of angle
btTranslationalLimitMotor(const btTranslationalLimitMotor &other)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:80
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:84
btTransform m_frameInA
relative_frames
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:761
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:28
btRotationalLimitMotor m_angularLimits[3]
hinge_parameters
bool needApplyTorques() const
Need apply correction.
btScalar m_hiLimit
joint limit
const btTransform & getFrameOffsetB() const
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
int testLimitValue(btScalar test_value)
calculates error
btTransform m_frameInB
the constraint space w.r.t body B
TypedConstraint is the baseclass for Bullet constraints and vehicles.
for serialization
Definition: btTransform.h:244
btRotationalLimitMotor * getRotationalLimitMotor(int index)
Retrieves the angular limit informacion.
btScalar solveAngularLimits(btScalar timeStep, btVector3 &axis, btScalar jacDiagABInv, btRigidBody *body0, btRigidBody *body1)
apply the correction impulses for two bodies
int testLimitValue(int limitIndex, btScalar test_value)
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:405
void setLinearLowerLimit(const btVector3 &linearLower)
btVector3 m_maxMotorForce
max force on motor
btScalar m_maxMotorForce
max force on motor
btScalar m_maxLimitForce
max force on limit
void setLimit(int axis, btScalar lo, btScalar hi)
btVector3 m_currentLinearDiff
How much is violated this limit.
btScalar m_bounce
restitution factor
btVector3 m_stopERP
Error tolerance factor when joint is at limit.
Rotation Limit structure for generic joints.
void getLinearLowerLimit(btVector3 &linearLower) const
void setLinearUpperLimit(const btVector3 &linearUpper)
bool isLimited(int limitIndex) const
Test limit.
void setAngularLowerLimit(const btVector3 &angularLower)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:294
void setUseFrameOffset(bool frameOffsetOnOff)