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 getInvMass() const 
#define HINGE_USE_OBSOLETE_SOLVER
void getInfo2Internal(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
btScalar getAngle() const 
Return the angle of rotation represented by this quaternion. 
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...
btScalar computeAngularImpulseDenominator(const btVector3 &axis) 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...
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)
bool m_useSolveConstraintObsolete
btScalar m_accMotorImpulse
void btPlaneSpace1(const T &n, T &p, T &q)
btScalar btSqrt(btScalar y)
bool m_enableAngularMotor
btScalar * m_J1angularAxis
btVector3 getColumn(int i) const 
Get a column of the matrix as a vector. 
const btRigidBody & getRigidBodyA() const 
btScalar m_motorTargetVelocity
btScalar dot(const btVector3 &v) const 
Return the dot product. 
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1. 
btVector3 quatRotate(const btQuaternion &rotation, const btVector3 &v)
const btScalar & getZ() const 
Return the z value. 
static btVector3 vHinge(0, 0, btScalar(1))
static btScalar btShortestAngularDistance(btScalar accAngle, btScalar curAngle)
btScalar * m_J1linearAxis
void getInfo2NonVirtual(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
btScalar m_accLimitImpulse
btScalar getUpperLimit() const 
btQuaternion shortestArcQuat(const btVector3 &v0, const btVector3 &v1)
#define _BT_USE_CENTER_LIMIT_
const btTransform & getCenterOfMassTransform() const 
btQuaternion & normalize()
Normalize the quaternion Such that x^2 + y^2 + z^2 +w^2 = 1. 
void updateRHS(btScalar timeStep)
void getInfo2InternalUsingFrameOffset(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &angVelA, const btVector3 &angVelB)
btScalar btAtan2(btScalar x, btScalar y)
btScalar getBiasFactor() const 
Returns limit's bias factor. 
const btVector3 & getAngularVelocity() const 
btVector3 cross(const btVector3 &v) const 
Return the cross product between this and another vector. 
const btScalar & getY() const 
Return the y value. 
virtual btScalar getParam(int num, int axis=-1) const 
return the local value of parameter 
const btScalar & getX() const 
Return the x value. 
#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
btScalar getLowerLimit() const 
void getInfo1NonVirtual(btConstraintInfo1 *info)
const btVector3 & getCenterOfMassPosition() const 
btQuaternion inverse() const 
Return the inverse of this quaternion. 
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 length2() const 
Return the length of the vector squared. 
btScalar btNormalizeAngle(btScalar angleInRadians)
bool m_useOffsetForConstraintFrame
bool m_useReferenceFrameA
btJacobianEntry m_jacAng[3]
bool getEnableAngularMotor()
btVector3 normalized() const 
Return a normalized version of this vector. 
btScalar * m_J2linearAxis
btScalar getRelaxationFactor() const 
Returns limit's relaxation factor. 
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 
btMatrix3x3 transpose() const 
Return the transpose of the matrix. 
virtual void getInfo2(btConstraintInfo2 *info)
internal method used by the constraint solver, don't use them directly 
void fit(btScalar &angle) const 
Checks given angle against limit. 
btScalar m_appliedImpulse
static btScalar btNormalizeAnglePositive(btScalar angle)
const btVector3 & getInvInertiaDiagLocal() const 
btScalar getCorrection() const 
Returns correction value evaluated when test() was invoked. 
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]. 
const btRigidBody & getRigidBodyB() const 
#define btAssertConstrParams(_par)
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 & getZ() const 
Return the z value. 
void getSkewSymmetricMatrix(btVector3 *v0, btVector3 *v1, btVector3 *v2) const 
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
btScalar btFabs(btScalar x)