27 #define HINGE_USE_OBSOLETE_SOLVER false    29 #define HINGE_USE_FRAME_OFFSET true    44                                                                          m_enableAngularMotor(false),
    47                                                                          m_useReferenceFrameA(useReferenceFrameA),
    68                 rbAxisA2 = axisInA.
cross(rbAxisA1);
    69                 rbAxisA1 = rbAxisA2.
cross(axisInA);
    85 #ifndef _BT_USE_CENTER_LIMIT_    90         m_relaxationFactor = 1.0f;
    91         m_limitSoftness = 0.9f;
   137 #ifndef _BT_USE_CENTER_LIMIT_   142         m_relaxationFactor = 1.0f;
   143         m_limitSoftness = 0.9f;
   144         m_solveLimit = 
false;
   168 #ifndef _BT_USE_CENTER_LIMIT_   173         m_relaxationFactor = 1.0f;
   174         m_limitSoftness = 0.9f;
   175         m_solveLimit = 
false;
   201 #ifndef _BT_USE_CENTER_LIMIT_   206         m_relaxationFactor = 1.0f;
   207         m_limitSoftness = 0.9f;
   208         m_solveLimit = 
false;
   226                         btVector3 relPos = pivotBInW - pivotAInW;
   240                         for (
int i=0;i<3;i++)
   326                 return accAngle + result;
   336         return m_accumulatedAngle;
   340         m_accumulatedAngle  = accAngle;
   489                 for(i = 0; i < 3; i++)
   550 #ifdef  _BT_USE_CENTER_LIMIT_   555         limit = (limit_err > 
btScalar(0.0)) ? 1 : 2;
   578                 if(limit && (lostop == histop))
   597                         k = info->
fps * currERP;
   620 #ifdef  _BT_USE_CENTER_LIMIT_   623                         btScalar bounce = m_relaxationFactor;
   628                                 vel -= angVelB.
dot(ax1);
   647                                                 if(newc < info->m_constraintError[srow])
   654 #ifdef  _BT_USE_CENTER_LIMIT_   702 #ifdef  _BT_USE_CENTER_LIMIT_   707         m_solveLimit = 
false;
   708         if (m_lowerLimit <= m_upperLimit)
   750         if (qHinge.
getZ() < 0)
   751                 targetAngle = -targetAngle;
   758 #ifdef  _BT_USE_CENTER_LIMIT_   761         if (m_lowerLimit < m_upperLimit)
   763                 if (targetAngle < m_lowerLimit)
   764                         targetAngle = m_lowerLimit;
   765                 else if (targetAngle > m_upperLimit)
   766                         targetAngle = m_upperLimit;
   771         btScalar dAngle = targetAngle - curAngle;
   809         btVector3 ax1 = ax1A * factA + ax1B * factB;
   832         relA = orthoA + totalDist * factA;
   833         relB = orthoB - totalDist * factB;
   835         p = orthoB * factA + orthoA * factB;
   848         tmpA = relA.
cross(p);
   849         tmpB = relB.
cross(p);
   852         tmpA = relA.
cross(q);
   853         tmpB = relB.
cross(q);
   862         tmpA = relA.
cross(ax1);
   863         tmpB = relB.
cross(ax1);
   890                 rhs = k * q.
dot(ofs);
   892                 rhs = k * ax1.
dot(ofs);
   932         k = info->
fps * normalErp;
   945 #ifdef  _BT_USE_CENTER_LIMIT_   950         limit = (limit_err > 
btScalar(0.0)) ? 1 : 2;
   973                 if(limit && (lostop == histop))
   992                         k = info->
fps * currERP;
  1015 #ifdef  _BT_USE_CENTER_LIMIT_  1018                         btScalar bounce = m_relaxationFactor;
  1023                                 vel -= angVelB.
dot(ax1);
  1042                                                 if(newc < info->m_constraintError[srow])
  1049 #ifdef  _BT_USE_CENTER_LIMIT_  1063         if((axis == -1) || (axis == 5))
  1097         if((axis == -1) || (axis == 5))
 btScalar * m_constraintError
btScalar getCorrection() const
Returns correction value evaluated when test() was invoked. 
btScalar computeAngularImpulseDenominator(const btVector3 &axis) const
#define HINGE_USE_OBSOLETE_SOLVER
void getInfo2Internal(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
const btScalar & getZ() const
Return the z value. 
btScalar getUpperLimit() const
btScalar * m_J2angularAxis
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...
const btVector3 & getAngularVelocity() const
const btRigidBody & getRigidBodyB() const
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Jacobian entry is an abstraction that allows to describe constraints it can be used in combination wi...
btScalar getLowerLimit() const
virtual void getInfo1(btConstraintInfo1 *info)
internal method used by the constraint solver, don't use them directly 
virtual void getInfo1(btConstraintInfo1 *info)
internal method used by the constraint solver, don't use them directly 
void setAccumulatedHingeAngle(btScalar accAngle)
const btTransform & getCenterOfMassTransform() const
btScalar length2() const
Return the length of the vector squared. 
bool m_useSolveConstraintObsolete
btScalar m_accMotorImpulse
void btPlaneSpace1(const T &n, T &p, T &q)
btScalar btSqrt(btScalar y)
bool m_enableAngularMotor
const btScalar & getY() const
Return the y value. 
btScalar * m_J1angularAxis
btScalar getRelaxationFactor() const
Returns limit's relaxation factor. 
btScalar m_motorTargetVelocity
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1. 
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
btVector3 normalized() const
Return a normalized version of this vector. 
btMatrix3x3 transpose() const
Return the transpose of the matrix. 
static btVector3 vHinge(0, 0, btScalar(1))
btQuaternion inverse() const
Return the inverse of this quaternion. 
btVector3 getColumn(int i) const
Get a column of the matrix as a vector. 
const btScalar & getZ() const
Return the z value. 
btScalar getBiasFactor() const
Returns limit's bias factor. 
static btScalar btShortestAngularDistance(btScalar accAngle, btScalar curAngle)
const btVector3 & getInvInertiaDiagLocal() const
btScalar * m_J1linearAxis
void getInfo2NonVirtual(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
btScalar m_accLimitImpulse
btQuaternion shortestArcQuat(const btVector3 &v0, const btVector3 &v1)
#define _BT_USE_CENTER_LIMIT_
btQuaternion & normalize()
Normalize the quaternion Such that x^2 + y^2 + z^2 +w^2 = 1. 
btScalar getInvMass() const
void updateRHS(btScalar timeStep)
void getInfo2InternalUsingFrameOffset(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector. 
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const
btScalar dot(const btVector3 &v) const
Return the dot product. 
btScalar btAtan2(btScalar x, btScalar y)
void fit(btScalar &angle) const
Checks given angle against limit. 
#define HINGE_USE_FRAME_OFFSET
static btScalar btShortestAngleUpdate(btScalar accAngle, btScalar curAngle)
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) 
btScalar m_maxMotorImpulse
void getInfo1NonVirtual(btConstraintInfo1 *info)
The btRigidBody is the main class for rigid body objects. 
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly 
btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
btVector3 can be used to represent 3D points and vectors. 
btScalar getAngle() const
Return the angle [0, 2Pi] of rotation represented by this quaternion. 
btScalar btNormalizeAngle(btScalar angleInRadians)
bool m_useOffsetForConstraintFrame
bool m_useReferenceFrameA
btJacobianEntry m_jacAng[3]
const btVector3 & getCenterOfMassPosition() const
bool getEnableAngularMotor()
btScalar * m_J2linearAxis
btScalar btFmod(btScalar x, btScalar y)
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 
virtual void getInfo2(btConstraintInfo2 *info)
internal method used by the constraint solver, don't use them directly 
btScalar m_appliedImpulse
static btScalar btNormalizeAnglePositive(btScalar angle)
void setFrames(const btTransform &frameA, const btTransform &frameB)
void setMotorTarget(const btQuaternion &qAinB, btScalar dt)
void test(const btScalar angle)
Checks conastaint angle against limit. 
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
btScalar getHingeAngle()
The getHingeAngle gives the hinge angle in range [-PI,PI]. 
#define btAssertConstrParams(_par)
const btRigidBody & getRigidBodyA() const
btScalar getAccumulatedHingeAngle()
void testLimit(const btTransform &transA, const btTransform &transB)
btHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB, const btVector3 &axisInA, const btVector3 &axisInB, bool useReferenceFrameA=false)
const btScalar & getX() const
Return the x value. 
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
virtual btScalar getParam(int num, int axis=-1) const
return the local value of parameter 
btScalar btFabs(btScalar x)