51         , m_frameInA(frameInA)
    52         , m_frameInB(frameInB)
    53         , m_rotateOrder(rotOrder)       
   456         for(i = 0; i < 3; i++)
   485         int row = 
setAngularLimits(info, 0,transA,transB,linVelA,linVelB,angVelA,angVelB);
   486         setLinearLimits(info, row, transA,transB,linVelA,linVelB,angVelA,angVelB);
   494         for (
int i=0;i<3 ;i++ )
   524                         int indx1 = (i + 1) % 3;
   525                         int indx2 = (i + 2) % 3;
   527                         #define D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION 1.0e-3   536                         if( indx1Violated && indx2Violated )
   540                         row += 
get_limit_motor_info2(&limot, transA,transB,linVelA,linVelB,angVelA,angVelB, info, row, axis, 0, rotAllowed);
   551         int row = row_offset;
   554         int cIdx[] = {0, 1, 2};
   557                 case RO_XYZ : cIdx[0] = 0; cIdx[1] = 1; cIdx[2] = 2; 
break;
   558                 case RO_XZY : cIdx[0] = 0; cIdx[1] = 2; cIdx[2] = 1; 
break;
   559                 case RO_YXZ : cIdx[0] = 1; cIdx[1] = 0; cIdx[2] = 2; 
break;
   560                 case RO_YZX : cIdx[0] = 1; cIdx[1] = 2; cIdx[2] = 0; 
break;
   561                 case RO_ZXY : cIdx[0] = 2; cIdx[1] = 0; cIdx[2] = 1; 
break;
   562                 case RO_ZYX : cIdx[0] = 2; cIdx[1] = 1; cIdx[2] = 0; 
break;
   566         for (
int ii = 0; ii < 3 ; ii++ )
   589                         row += 
get_limit_motor_info2(&
m_angularLimits[i],transA,transB,linVelA,linVelB,angVelA,angVelB, info,row,axis,1);
   610         for(
int i = 0; i < 3; i++)
   626         J2[srow+0] = -ax1[0];
   627         J2[srow+1] = -ax1[1];
   628         J2[srow+2] = -ax1[2];
   637                 tmpA = relA.
cross(ax1);
   638                 tmpB = relB.
cross(ax1);
   657         int srow = row * info->
rowskip;
   661                 btScalar vel = rotational ? angVelA.
dot(ax1) - angVelB.
dot(ax1) : linVelA.
dot(ax1) - linVelB.
dot(ax1);
   663                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   673                                 if (bounceerror < info->m_constraintError[srow]) info->
m_constraintError[srow] = bounceerror;
   682                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   687                                 if (bounceerror < info->m_constraintError[srow]) info->
m_constraintError[srow] = bounceerror;
   703                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   714                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   732                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   756                 info->
m_constraintError[srow] = mot_fact * targetvelocity * (rotational ? -1 : 1);
   767                 calculateJacobi(limot,transA,transB,info,srow,ax1,rotational,rotAllowed);
   780                 btScalar vel = rotational ? angVelA.
dot(ax1) - angVelB.
dot(ax1) : linVelA.
dot(ax1) - linVelB.
dot(ax1);
   786                 btScalar angularfreq = sqrt(ks / m);
   800                 btScalar fd = -kd * (vel) * (rotational ? -1 : 1) * dt;
   818                 info->
cfm[srow] = cfm;
   831         if((axis >= 0) && (axis < 3))
   855         else if((axis >=3) && (axis < 6))
   889         if((axis >= 0) && (axis < 3))
   913         else if((axis >=3) && (axis < 6))
   955                                       xAxis[1], yAxis[1], zAxis[1],
   956                                       xAxis[2], yAxis[2], zAxis[2]);
   967         btAssert((index >= 0) && (index < 6));
   976         btAssert((index >= 0) && (index < 6));
   985         btAssert((index >= 0) && (index < 6));
   994         btAssert((index >= 0) && (index < 6));
  1003         btAssert((index >= 0) && (index < 6));
  1012         btAssert((index >= 0) && (index < 6));
  1021         btAssert((index >= 0) && (index < 6));
  1030         btAssert((index >= 0) && (index < 6));
  1042         btAssert((index >= 0) && (index < 6));
  1056         for( i = 0; i < 3; i++)
  1058         for(i = 0; i < 3; i++)
  1064         btAssert((index >= 0) && (index < 6));
  1074         btAssert((index >= 0) && (index < 6));
  1087         if(m_loLimit > m_hiLimit) {
  1089                 m_currentLimitError = 
btScalar(0.f);
  1091         else if(m_loLimit == m_hiLimit) {
  1092                 m_currentLimitError = test_value - m_loLimit;
  1095                 m_currentLimitError = test_value - m_loLimit;
  1096                 m_currentLimitErrorHi = test_value - m_hiLimit;
  1105         btScalar loLimit = m_lowerLimit[limitIndex];
  1106         btScalar hiLimit = m_upperLimit[limitIndex];
  1107         if(loLimit > hiLimit) {
  1108                 m_currentLimitError[limitIndex] = 0;
  1109                 m_currentLimit[limitIndex] = 0;
  1111         else if(loLimit == hiLimit) {
  1112                 m_currentLimitError[limitIndex] = test_value - loLimit;
  1113                 m_currentLimit[limitIndex] = 3;
  1115                 m_currentLimitError[limitIndex] = test_value - loLimit;
  1116                 m_currentLimitErrorHi[limitIndex] = test_value - hiLimit;
  1117                 m_currentLimit[limitIndex] = 4;
 btMatrix3x3 inverse() const 
Return the inverse of the matrix. 
btScalar * m_constraintError
btScalar getInvMass() const 
static bool matrixToEulerXYZ(const btMatrix3x3 &mat, btVector3 &xyz)
void setTargetVelocity(int index, btScalar velocity)
btScalar * m_J2angularAxis
static bool matrixToEulerZXY(const btMatrix3x3 &mat, btVector3 &xyz)
btVector3 m_maxMotorForce
#define D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION
btVector3 m_springStiffness
void setMaxMotorForce(int index, btScalar force)
#define BT_6DOF_FLAGS_AXIS_SHIFT2
void testLimitValue(int limitIndex, btScalar test_value)
static bool matrixToEulerYXZ(const btMatrix3x3 &mat, btVector3 &xyz)
int get_limit_motor_info2(btRotationalLimitMotor2 *limot, const btTransform &transA, const btTransform &transB, const btVector3 &linVelA, const btVector3 &linVelB, const btVector3 &angVelA, const btVector3 &angVelB, btConstraintInfo2 *info, int row, btVector3 &ax1, int rotational, int rotAllowed=false)
void setServo(int index, bool onOff)
bool m_springStiffnessLimited[3]
bool m_springStiffnessLimited
btVector3 m_springDamping
static btScalar btGetMatrixElem(const btMatrix3x3 &mat, int index)
void setAxis(const btVector3 &axis1, const btVector3 &axis2)
virtual btScalar getParam(int num, int axis=-1) const 
return the local value of parameter 
void calculateLinearInfo()
int setLinearLimits(btConstraintInfo2 *info, int row, const btTransform &transA, const btTransform &transB, const btVector3 &linVelA, const btVector3 &linVelB, const btVector3 &angVelA, const btVector3 &angVelB)
btVector3 getAxis(int axis_index) const 
btScalar * m_J1angularAxis
bool m_springDampingLimited[3]
btVector3 getColumn(int i) const 
Get a column of the matrix as a vector. 
static bool matrixToEulerZYX(const btMatrix3x3 &mat, btVector3 &xyz)
btTranslationalLimitMotor2 m_linearLimits
btScalar dot(const btVector3 &v) const 
Return the dot product. 
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1. 
void calculateTransforms()
btVector3 m_currentLinearDiff
btVector3 m_calculatedLinearDiff
btScalar m_currentLimitError
btScalar * m_J1linearAxis
bool m_springDampingLimited
const btTransform & getCenterOfMassTransform() const 
btScalar btAtan2(btScalar x, btScalar y)
const btVector3 & getAngularVelocity() const 
btVector3 cross(const btVector3 &v) const 
Return the cross product between this and another vector. 
btVector3 m_currentLimitErrorHi
void setValue(const btScalar &xx, const btScalar &xy, const btScalar &xz, const btScalar &yx, const btScalar &yy, const btScalar &yz, const btScalar &zx, const btScalar &zy, const btScalar &zz)
Set the values of the matrix explicitly (row major) 
btTransform m_calculatedTransformB
btScalar m_currentLimitErrorHi
The btRigidBody is the main class for rigid body objects. 
btTransform m_calculatedTransformA
void setEquilibriumPoint()
btVector3 m_equilibriumPoint
btScalar m_targetVelocity
btGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, RotateOrder rotOrder=RO_XYZ)
2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev Added support for generic constrain...
virtual void setParam(int num, btScalar value, int axis=-1)
override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0...
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly 
btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
btVector3 m_currentLimitError
btVector3 can be used to represent 3D points and vectors. 
static bool matrixToEulerXZY(const btMatrix3x3 &mat, btVector3 &xyz)
static btRigidBody & getFixedBody()
RotateOrder m_rotateOrder
void calculateJacobi(btRotationalLimitMotor2 *limot, const btTransform &transA, const btTransform &transB, btConstraintInfo2 *info, int srow, btVector3 &ax1, int rotational, int rotAllowed)
btVector3 m_calculatedAxis[3]
btVector3 normalized() const 
Return a normalized version of this vector. 
btScalar * m_J2linearAxis
TypedConstraint is the baseclass for Bullet constraints and vehicles. 
btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact)
internal method used by the constraint solver, don't use them directly 
const btRigidBody & getRigidBodyA() const 
void setStiffness(int index, btScalar stiffness, bool limitIfNeeded=true)
btVector3 m_targetVelocity
btScalar m_equilibriumPoint
btRotationalLimitMotor2 m_angularLimits[3]
static bool matrixToEulerYZX(const btMatrix3x3 &mat, btVector3 &xyz)
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
void testLimitValue(btScalar test_value)
btScalar m_currentPosition
void enableSpring(int index, bool onOff)
const btVector3 & getLinearVelocity() const 
btScalar btAsin(btScalar x)
void setFrames(const btTransform &frameA, const btTransform &frameB)
virtual void getInfo1(btConstraintInfo1 *info)
internal method used by the constraint solver, don't use them directly 
#define btAssertConstrParams(_par)
btScalar m_springStiffness
void setDamping(int index, btScalar damping, bool limitIfNeeded=true)
void calculateAngleInfo()
btVector3 m_calculatedAxisAngleDiff
void testAngularLimitMotor(int axis_index)
const btRigidBody & getRigidBodyB() const 
void setServoTarget(int index, btScalar target)
virtual void getInfo2(btConstraintInfo2 *info)
internal method used by the constraint solver, don't use them directly 
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
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)
void enableMotor(int index, bool onOff)
void setBounce(int index, btScalar bounce)