| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   40 #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H 
   41 #define BT_GENERIC_6DOF_CONSTRAINT2_H 
   49 #ifdef BT_USE_DOUBLE_PRECISION 
   50 #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintDoubleData2 
   51 #define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintDoubleData2" 
   53 #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData 
   54 #define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintData" 
   55 #endif  //BT_USE_DOUBLE_PRECISION 
  204                 for (
int i = 0; i < 3; i++)
 
  236                 for (
int i = 0; i < 3; i++)
 
  269 #define BT_6DOF_FLAGS_AXIS_SHIFT2 4  // bits per axis 
  306         void calculateLinearInfo();
 
  307         void calculateAngleInfo();
 
  308         void testAngularLimitMotor(
int axis_index);
 
  313                                                           btConstraintInfo2* info, 
int row, 
btVector3& ax1, 
int rotational, 
int rotAllowed = 
false);
 
  322         virtual void getInfo1(btConstraintInfo1 * info);
 
  323         virtual void getInfo2(btConstraintInfo2 * info);
 
  324         virtual int calculateSerializeBufferSize() 
const;
 
  325         virtual const char* serialize(
void* dataBuffer, 
btSerializer* serializer) 
const;
 
  332         void calculateTransforms();
 
  363                 for (
int i = 0; i < 3; i++)
 
  369                 for (
int i = 0; i < 3; i++)
 
  375                 for (
int i = 0; i < 3; i++)
 
  376                         angularLower[i] = m_angularLimits[i].m_loLimit;
 
  381                 for (
int i = 0; i < 3; i++)
 
  382                         angularLower[i] = -m_angularLimits[i].m_hiLimit;
 
  387                 for (
int i = 0; i < 3; i++)
 
  393                 for (
int i = 0; i < 3; i++)
 
  399                 for (
int i = 0; i < 3; i++)
 
  400                         angularUpper[i] = m_angularLimits[i].m_hiLimit;
 
  405                 for (
int i = 0; i < 3; i++)
 
  406                         angularUpper[i] = -m_angularLimits[i].m_loLimit;
 
  422                         m_angularLimits[axis - 3].
m_loLimit = lo;
 
  423                         m_angularLimits[axis - 3].
m_hiLimit = hi;
 
  438                         m_angularLimits[axis - 3].
m_hiLimit = -lo;
 
  439                         m_angularLimits[axis - 3].
m_loLimit = -hi;
 
  447                         return m_linearLimits.
isLimited(limitIndex);
 
  449                 return m_angularLimits[limitIndex - 3].
isLimited();
 
  457         void setBounce(
int index, 
btScalar bounce);
 
  459         void enableMotor(
int index, 
bool onOff);
 
  460         void setServo(
int index, 
bool onOff);  
 
  461         void setTargetVelocity(
int index, 
btScalar velocity);
 
  462         void setServoTarget(
int index, 
btScalar target);
 
  463         void setMaxMotorForce(
int index, 
btScalar force);
 
  465         void enableSpring(
int index, 
bool onOff);
 
  466         void setStiffness(
int index, 
btScalar stiffness, 
bool limitIfNeeded = 
true);  
 
  467         void setDamping(
int index, 
btScalar damping, 
bool limitIfNeeded = 
true);      
 
  468         void setEquilibriumPoint();                                                   
 
  469         void setEquilibriumPoint(
int index);                                          
 
  470         void setEquilibriumPoint(
int index, 
btScalar val);
 
  474         virtual void setParam(
int num, 
btScalar value, 
int axis = -1);
 
  475         virtual btScalar getParam(
int num, 
int axis = -1) 
const;
 
  596         for (i = 0; i < 3; i++)
 
  612         dof->m_angularLowerLimit.m_floats[3] = 0;
 
  613         dof->m_angularUpperLimit.m_floats[3] = 0;
 
  614         dof->m_angularBounce.m_floats[3] = 0;
 
  615         dof->m_angularStopERP.m_floats[3] = 0;
 
  616         dof->m_angularStopCFM.m_floats[3] = 0;
 
  617         dof->m_angularMotorERP.m_floats[3] = 0;
 
  618         dof->m_angularMotorCFM.m_floats[3] = 0;
 
  619         dof->m_angularTargetVelocity.m_floats[3] = 0;
 
  620         dof->m_angularMaxMotorForce.m_floats[3] = 0;
 
  621         dof->m_angularServoTarget.m_floats[3] = 0;
 
  622         dof->m_angularSpringStiffness.m_floats[3] = 0;
 
  623         dof->m_angularSpringDamping.m_floats[3] = 0;
 
  624         dof->m_angularEquilibriumPoint.m_floats[3] = 0;
 
  625         for (i = 0; i < 4; i++)
 
  647         for (i = 0; i < 4; i++)
 
  658         dof->m_padding1[0] = 0;
 
  659         dof->m_padding1[1] = 0;
 
  660         dof->m_padding1[2] = 0;
 
  661         dof->m_padding1[3] = 0;
 
  666 #endif  //BT_GENERIC_6DOF_CONSTRAINT_H 
  
char m_angularSpringDampingLimited[4]
bool m_springStiffnessLimited[3]
TypedConstraint is the baseclass for Bullet constraints and vehicles.
char m_linearEnableSpring[4]
void serialize(struct btVector3Data &dataOut) const
The btRigidBody is the main class for rigid body objects.
bool isLimited(int limitIndex)
btVector3FloatData m_linearLowerLimit
void setLinearUpperLimit(const btVector3 &linearUpper)
btVector3DoubleData m_linearTargetVelocity
btTransformFloatData m_rbBFrame
btScalar getRelativePivotPosition(int axis_index) const
btVector3FloatData m_angularSpringDamping
btTransform & getFrameOffsetB()
btVector3DoubleData m_angularMaxMotorForce
btVector3 m_currentLimitError
const btTransform & getFrameOffsetA() const
void getAngularUpperLimitReversed(btVector3 &angularUpper)
btVector3 m_targetVelocity
char m_linearEnableMotor[4]
btScalar m_equilibriumPoint
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
btVector3FloatData m_linearBounce
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void setAngularLowerLimitReversed(const btVector3 &angularLower)
btTransformDoubleData m_rbBFrame
Jacobian entry is an abstraction that allows to describe constraints it can be used in combination wi...
btVector3FloatData m_angularLowerLimit
btVector3 m_currentLimitErrorHi
void setRotationOrder(RotateOrder order)
btScalar m_currentPosition
void getAngularLowerLimitReversed(btVector3 &angularLower)
btVector3FloatData m_angularUpperLimit
btVector3FloatData m_angularServoTarget
btScalar m_currentLimitErrorHi
char m_linearSpringDampingLimited[4]
char m_angularEnableSpring[4]
RotateOrder getRotationOrder()
btVector3FloatData m_linearMaxMotorForce
const btTransform & getCalculatedTransformA() const
btVector3FloatData m_angularBounce
bool isLimited(int limitIndex)
btScalar btGetMatrixElem(const btMatrix3x3 &mat, int index)
btVector3FloatData m_linearSpringStiffness
btVector3FloatData m_linearMotorCFM
btVector3 getAxis(int axis_index) const
btTranslationalLimitMotor2(const btTranslationalLimitMotor2 &other)
void testLimitValue(int limitIndex, btScalar test_value)
btTranslationalLimitMotor2()
btVector3DoubleData m_linearStopERP
char m_linearServoMotor[4]
btScalar m_targetVelocity
btVector3 m_calculatedLinearDiff
btVector3FloatData m_linearTargetVelocity
btVector3DoubleData m_linearEquilibriumPoint
btVector3FloatData m_angularMaxMotorForce
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
btScalar m_currentLimitError
btVector3DoubleData m_linearSpringStiffness
btVector3DoubleData m_linearBounce
btVector3DoubleData m_angularSpringDamping
btTranslationalLimitMotor2 m_linearLimits
char m_angularEnableMotor[4]
char m_linearServoMotor[4]
btVector3DoubleData m_angularStopERP
const btTransform & getCalculatedTransformB() const
void setAngularLowerLimit(const btVector3 &angularLower)
btVector3FloatData m_linearUpperLimit
btVector3 m_currentLinearDiff
btScalar btNormalizeAngle(btScalar angleInRadians)
bool m_springStiffnessLimited
btTransform m_calculatedTransformB
void setLimitReversed(int axis, btScalar lo, btScalar hi)
char m_linearEnableSpring[4]
btVector3FloatData m_angularMotorCFM
char m_angularServoMotor[4]
bool m_springDampingLimited
btVector3FloatData m_linearServoTarget
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
btVector3 m_springDamping
char m_linearSpringStiffnessLimited[4]
#define btGeneric6DofSpring2ConstraintData2
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
const btTransform & getFrameOffsetB() const
btTransformFloatData m_rbAFrame
char m_angularSpringDampingLimited[4]
char m_linearSpringStiffnessLimited[4]
btVector3FloatData m_linearMotorERP
#define BT_DECLARE_ALIGNED_ALLOCATOR()
char m_angularEnableSpring[4]
char m_angularEnableMotor[4]
btVector3DoubleData m_linearStopCFM
btVector3 can be used to represent 3D points and vectors.
RotateOrder m_rotateOrder
char m_linearEnableMotor[4]
void setLimit(int axis, btScalar lo, btScalar hi)
btVector3DoubleData m_angularServoTarget
btVector3FloatData m_angularStopCFM
btVector3DoubleData m_linearLowerLimit
char m_angularSpringStiffnessLimited[4]
btVector3DoubleData m_angularSpringStiffness
btScalar getAngle(int axis_index) const
btVector3DoubleData m_angularBounce
btVector3DoubleData m_angularStopCFM
btVector3DoubleData m_linearUpperLimit
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
#define ATTRIBUTE_ALIGNED16(a)
btVector3DoubleData m_angularUpperLimit
btVector3DoubleData m_angularEquilibriumPoint
btTransformDoubleData m_rbAFrame
btVector3 m_maxMotorForce
btVector3DoubleData m_linearSpringDamping
virtual int calculateSerializeBufferSize() const
btVector3FloatData m_linearStopCFM
void testLimitValue(btScalar test_value)
btVector3FloatData m_linearSpringDamping
btVector3FloatData m_linearStopERP
#define SIMD_FORCE_INLINE
void setLinearLowerLimit(const btVector3 &linearLower)
btRotationalLimitMotor2()
btRotationalLimitMotor2(const btRotationalLimitMotor2 &limot)
void setAngularUpperLimitReversed(const btVector3 &angularUpper)
btVector3DoubleData m_angularMotorCFM
btVector3DoubleData m_angularTargetVelocity
btVector3FloatData m_angularStopERP
this structure is not used, except for loading pre-2.82 .bullet files
bool m_springDampingLimited[3]
btVector3DoubleData m_linearMotorCFM
btVector3DoubleData m_angularLowerLimit
btGeneric6DofSpring2Constraint & operator=(btGeneric6DofSpring2Constraint &)
btVector3FloatData m_angularEquilibriumPoint
btVector3DoubleData m_linearServoTarget
char m_angularSpringStiffnessLimited[4]
btVector3FloatData m_angularTargetVelocity
bool matrixToEulerXYZ(const btMatrix3x3 &mat, btVector3 &xyz)
MatrixToEulerXYZ from http://www.geometrictools.com/LibFoundation/Mathematics/Wm4Matrix3....
void getAngularUpperLimit(btVector3 &angularUpper)
void getLinearLowerLimit(btVector3 &linearLower)
char m_linearSpringDampingLimited[4]
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTransform & getFrameOffsetA()
void getAngularLowerLimit(btVector3 &angularLower)
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btVector3 m_equilibriumPoint
btVector3FloatData m_angularMotorERP
btVector3DoubleData m_linearMotorERP
btVector3 m_springStiffness
btRotationalLimitMotor2 m_angularLimits[3]
void setAngularUpperLimit(const btVector3 &angularUpper)
#define btGeneric6DofSpring2ConstraintDataName
btVector3DoubleData m_linearMaxMotorForce
char m_angularServoMotor[4]
btTypedConstraintDoubleData m_typeConstraintData
btVector3FloatData m_angularSpringStiffness
btScalar m_springStiffness
void getLinearUpperLimit(btVector3 &linearUpper)
btVector3FloatData m_linearEquilibriumPoint
btTypedConstraintData m_typeConstraintData
btVector3DoubleData m_angularMotorERP
btVector3 m_calculatedAxisAngleDiff
btTransform m_calculatedTransformA