Back to index

supertuxkart  0.5+dfsg1
Public Member Functions | Protected Attributes | Private Attributes
btHingeConstraint Class Reference

hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space axis defines the orientation of the hinge axis More...

#include <btHingeConstraint.h>

Inheritance diagram for btHingeConstraint:
Inheritance graph
[legend]
Collaboration diagram for btHingeConstraint:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 btHingeConstraint (btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB, btVector3 &axisInA, btVector3 &axisInB)
 btHingeConstraint (btRigidBody &rbA, const btVector3 &pivotInA, btVector3 &axisInA)
 btHingeConstraint (btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
 btHingeConstraint (btRigidBody &rbA, const btTransform &rbAFrame)
 btHingeConstraint ()
virtual void buildJacobian ()
virtual void solveConstraint (btScalar timeStep)
void updateRHS (btScalar timeStep)
const btRigidBodygetRigidBodyA () const
const btRigidBodygetRigidBodyB () const
void setAngularOnly (bool angularOnly)
void enableAngularMotor (bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
void setLimit (btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
btScalar getLowerLimit () const
btScalar getUpperLimit () const
btScalar getHingeAngle ()
const btTransformgetAFrame ()
const btTransformgetBFrame ()
int getSolveLimit ()
btScalar getLimitSign ()
btRigidBodygetRigidBodyA ()
btRigidBodygetRigidBodyB ()
int getUserConstraintType () const
void setUserConstraintType (int userConstraintType)
void setUserConstraintId (int uid)
int getUserConstraintId () const
int getUid () const
btScalar getAppliedImpulse () const
btTypedConstraintType getConstraintType () const

Protected Attributes

btRigidBodym_rbA
btRigidBodym_rbB
btScalar m_appliedImpulse

Private Attributes

btJacobianEntry m_jac [3]
btJacobianEntry m_jacAng [3]
btTransform m_rbAFrame
btTransform m_rbBFrame
btScalar m_motorTargetVelocity
btScalar m_maxMotorImpulse
btScalar m_limitSoftness
btScalar m_biasFactor
btScalar m_relaxationFactor
btScalar m_lowerLimit
btScalar m_upperLimit
btScalar m_kHinge
btScalar m_limitSign
btScalar m_correction
btScalar m_accLimitImpulse
bool m_angularOnly
bool m_enableAngularMotor
bool m_solveLimit

Detailed Description

hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space axis defines the orientation of the hinge axis

Definition at line 29 of file btHingeConstraint.h.


Constructor & Destructor Documentation

btHingeConstraint::btHingeConstraint ( btRigidBody rbA,
btRigidBody rbB,
const btVector3 pivotInA,
const btVector3 pivotInB,
btVector3 axisInA,
btVector3 axisInB 
)

Definition at line 30 of file btHingeConstraint.cpp.

                                                                :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),
                                                                m_angularOnly(false),
                                                                m_enableAngularMotor(false)
{
       m_rbAFrame.getOrigin() = pivotInA;
       
       // since no frame is given, assume this to be zero angle and just pick rb transform axis
       btVector3 rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(0);

       btVector3 rbAxisA2;
       btScalar projection = axisInA.dot(rbAxisA1);
       if (projection >= 1.0f - SIMD_EPSILON) {
              rbAxisA1 = -rbA.getCenterOfMassTransform().getBasis().getColumn(2);
              rbAxisA2 = rbA.getCenterOfMassTransform().getBasis().getColumn(1);
       } else if (projection <= -1.0f + SIMD_EPSILON) {
              rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(2);
              rbAxisA2 = rbA.getCenterOfMassTransform().getBasis().getColumn(1);      
       } else {
              rbAxisA2 = axisInA.cross(rbAxisA1);
              rbAxisA1 = rbAxisA2.cross(axisInA);
       }

       m_rbAFrame.getBasis().setValue( rbAxisA1.getX(),rbAxisA2.getX(),axisInA.getX(),
                                                               rbAxisA1.getY(),rbAxisA2.getY(),axisInA.getY(),
                                                               rbAxisA1.getZ(),rbAxisA2.getZ(),axisInA.getZ() );

       btQuaternion rotationArc = shortestArcQuat(axisInA,axisInB);
       btVector3 rbAxisB1 =  quatRotate(rotationArc,rbAxisA1);
       btVector3 rbAxisB2 =  axisInB.cross(rbAxisB1);   
       
       m_rbBFrame.getOrigin() = pivotInB;
       m_rbBFrame.getBasis().setValue( rbAxisB1.getX(),rbAxisB2.getX(),-axisInB.getX(),
                                                               rbAxisB1.getY(),rbAxisB2.getY(),-axisInB.getY(),
                                                               rbAxisB1.getZ(),rbAxisB2.getZ(),-axisInB.getZ() );
       
       //start with free
       m_lowerLimit = btScalar(1e30);
       m_upperLimit = btScalar(-1e30);
       m_biasFactor = 0.3f;
       m_relaxationFactor = 1.0f;
       m_limitSoftness = 0.9f;
       m_solveLimit = false;

}

Here is the call graph for this function:

btHingeConstraint::btHingeConstraint ( btRigidBody rbA,
const btVector3 pivotInA,
btVector3 axisInA 
)

Definition at line 78 of file btHingeConstraint.cpp.

:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), m_angularOnly(false), m_enableAngularMotor(false)
{

       // since no frame is given, assume this to be zero angle and just pick rb transform axis
       // fixed axis in worldspace
       btVector3 rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(0);
       btScalar projection = rbAxisA1.dot(axisInA);
       if (projection > SIMD_EPSILON)
              rbAxisA1 = rbAxisA1*projection - axisInA;
       else
              rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(1);

       btVector3 rbAxisA2 = axisInA.cross(rbAxisA1);

       m_rbAFrame.getOrigin() = pivotInA;
       m_rbAFrame.getBasis().setValue( rbAxisA1.getX(),rbAxisA2.getX(),axisInA.getX(),
                                                               rbAxisA1.getY(),rbAxisA2.getY(),axisInA.getY(),
                                                               rbAxisA1.getZ(),rbAxisA2.getZ(),axisInA.getZ() );


       btVector3 axisInB = rbA.getCenterOfMassTransform().getBasis() * -axisInA;

       btQuaternion rotationArc = shortestArcQuat(axisInA,axisInB);
       btVector3 rbAxisB1 =  quatRotate(rotationArc,rbAxisA1);
       btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);


       m_rbBFrame.getOrigin() = rbA.getCenterOfMassTransform()(pivotInA);
       m_rbBFrame.getBasis().setValue( rbAxisB1.getX(),rbAxisB2.getX(),axisInB.getX(),
                                                               rbAxisB1.getY(),rbAxisB2.getY(),axisInB.getY(),
                                                               rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
       
       //start with free
       m_lowerLimit = btScalar(1e30);
       m_upperLimit = btScalar(-1e30);
       m_biasFactor = 0.3f;
       m_relaxationFactor = 1.0f;
       m_limitSoftness = 0.9f;
       m_solveLimit = false;
}

Here is the call graph for this function:

btHingeConstraint::btHingeConstraint ( btRigidBody rbA,
btRigidBody rbB,
const btTransform rbAFrame,
const btTransform rbBFrame 
)

Definition at line 120 of file btHingeConstraint.cpp.

:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),m_rbAFrame(rbAFrame),m_rbBFrame(rbBFrame),
m_angularOnly(false),
m_enableAngularMotor(false)
{
       // flip axis
       m_rbBFrame.getBasis()[0][2] *= btScalar(-1.);
       m_rbBFrame.getBasis()[1][2] *= btScalar(-1.);
       m_rbBFrame.getBasis()[2][2] *= btScalar(-1.);

       //start with free
       m_lowerLimit = btScalar(1e30);
       m_upperLimit = btScalar(-1e30);
       m_biasFactor = 0.3f;
       m_relaxationFactor = 1.0f;
       m_limitSoftness = 0.9f;
       m_solveLimit = false;
}                    

Here is the call graph for this function:

not providing rigidbody B means implicitly using worldspace for body B

Definition at line 142 of file btHingeConstraint.cpp.

Here is the call graph for this function:


Member Function Documentation

Implements btTypedConstraint.

Definition at line 165 of file btHingeConstraint.cpp.

{
       m_appliedImpulse = btScalar(0.);

       if (!m_angularOnly)
       {
              btVector3 pivotAInW = m_rbA.getCenterOfMassTransform()*m_rbAFrame.getOrigin();
              btVector3 pivotBInW = m_rbB.getCenterOfMassTransform()*m_rbBFrame.getOrigin();
              btVector3 relPos = pivotBInW - pivotAInW;

              btVector3 normal[3];
              if (relPos.length2() > SIMD_EPSILON)
              {
                     normal[0] = relPos.normalized();
              }
              else
              {
                     normal[0].setValue(btScalar(1.0),0,0);
              }

              btPlaneSpace1(normal[0], normal[1], normal[2]);

              for (int i=0;i<3;i++)
              {
                     new (&m_jac[i]) btJacobianEntry(
                            m_rbA.getCenterOfMassTransform().getBasis().transpose(),
                            m_rbB.getCenterOfMassTransform().getBasis().transpose(),
                            pivotAInW - m_rbA.getCenterOfMassPosition(),
                            pivotBInW - m_rbB.getCenterOfMassPosition(),
                            normal[i],
                            m_rbA.getInvInertiaDiagLocal(),
                            m_rbA.getInvMass(),
                            m_rbB.getInvInertiaDiagLocal(),
                            m_rbB.getInvMass());
              }
       }

       //calculate two perpendicular jointAxis, orthogonal to hingeAxis
       //these two jointAxis require equal angular velocities for both bodies

       //this is unused for now, it's a todo
       btVector3 jointAxis0local;
       btVector3 jointAxis1local;
       
       btPlaneSpace1(m_rbAFrame.getBasis().getColumn(2),jointAxis0local,jointAxis1local);

       getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(2);
       btVector3 jointAxis0 = getRigidBodyA().getCenterOfMassTransform().getBasis() * jointAxis0local;
       btVector3 jointAxis1 = getRigidBodyA().getCenterOfMassTransform().getBasis() * jointAxis1local;
       btVector3 hingeAxisWorld = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(2);
              
       new (&m_jacAng[0])   btJacobianEntry(jointAxis0,
              m_rbA.getCenterOfMassTransform().getBasis().transpose(),
              m_rbB.getCenterOfMassTransform().getBasis().transpose(),
              m_rbA.getInvInertiaDiagLocal(),
              m_rbB.getInvInertiaDiagLocal());

       new (&m_jacAng[1])   btJacobianEntry(jointAxis1,
              m_rbA.getCenterOfMassTransform().getBasis().transpose(),
              m_rbB.getCenterOfMassTransform().getBasis().transpose(),
              m_rbA.getInvInertiaDiagLocal(),
              m_rbB.getInvInertiaDiagLocal());

       new (&m_jacAng[2])   btJacobianEntry(hingeAxisWorld,
              m_rbA.getCenterOfMassTransform().getBasis().transpose(),
              m_rbB.getCenterOfMassTransform().getBasis().transpose(),
              m_rbA.getInvInertiaDiagLocal(),
              m_rbB.getInvInertiaDiagLocal());


       // Compute limit information
       btScalar hingeAngle = getHingeAngle();  

       //set bias, sign, clear accumulator
       m_correction = btScalar(0.);
       m_limitSign = btScalar(0.);
       m_solveLimit = false;
       m_accLimitImpulse = btScalar(0.);

       if (m_lowerLimit < m_upperLimit)
       {
              if (hingeAngle <= m_lowerLimit*m_limitSoftness)
              {
                     m_correction = (m_lowerLimit - hingeAngle);
                     m_limitSign = 1.0f;
                     m_solveLimit = true;
              } 
              else if (hingeAngle >= m_upperLimit*m_limitSoftness)
              {
                     m_correction = m_upperLimit - hingeAngle;
                     m_limitSign = -1.0f;
                     m_solveLimit = true;
              }
       }

       //Compute K = J*W*J' for hinge axis
       btVector3 axisA =  getRigidBodyA().getCenterOfMassTransform().getBasis() *  m_rbAFrame.getBasis().getColumn(2);
       m_kHinge =   1.0f / (getRigidBodyA().computeAngularImpulseDenominator(axisA) +
                                  getRigidBodyB().computeAngularImpulseDenominator(axisA));

}

Here is the call graph for this function:

void btHingeConstraint::enableAngularMotor ( bool  enableMotor,
btScalar  targetVelocity,
btScalar  maxMotorImpulse 
) [inline]

Definition at line 94 of file btHingeConstraint.h.

       {
              m_enableAngularMotor  = enableMotor;
              m_motorTargetVelocity = targetVelocity;
              m_maxMotorImpulse = maxMotorImpulse;
       }

Definition at line 126 of file btHingeConstraint.h.

{ return m_rbAFrame; };     
btScalar btTypedConstraint::getAppliedImpulse ( ) const [inline, inherited]

Definition at line 108 of file btTypedConstraint.h.

       {
              return m_appliedImpulse;
       }

Definition at line 127 of file btHingeConstraint.h.

{ return m_rbBFrame; };

Definition at line 113 of file btTypedConstraint.h.

       {
              return m_constraintType;
       }

Here is the caller graph for this function:

Definition at line 398 of file btHingeConstraint.cpp.

{
       const btVector3 refAxis0  = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(0);
       const btVector3 refAxis1  = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(1);
       const btVector3 swingAxis = getRigidBodyB().getCenterOfMassTransform().getBasis() * m_rbBFrame.getBasis().getColumn(1);

       return btAtan2Fast( swingAxis.dot(refAxis0), swingAxis.dot(refAxis1)  );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 134 of file btHingeConstraint.h.

       {
              return m_limitSign;
       }

Definition at line 112 of file btHingeConstraint.h.

       {
              return m_lowerLimit;
       }

Definition at line 74 of file btTypedConstraint.h.

       {
              return m_rbA;
       }
const btRigidBody& btHingeConstraint::getRigidBodyA ( ) const [inline]

Reimplemented from btTypedConstraint.

Definition at line 80 of file btHingeConstraint.h.

       {
              return m_rbA;
       }

Here is the caller graph for this function:

Definition at line 78 of file btTypedConstraint.h.

       {
              return m_rbB;
       }
const btRigidBody& btHingeConstraint::getRigidBodyB ( ) const [inline]

Reimplemented from btTypedConstraint.

Definition at line 84 of file btHingeConstraint.h.

       {
              return m_rbB;
       }

Here is the caller graph for this function:

Definition at line 129 of file btHingeConstraint.h.

       {
              return m_solveLimit;
       }
int btTypedConstraint::getUid ( ) const [inline, inherited]

Definition at line 103 of file btTypedConstraint.h.

       {
              return m_userConstraintId;   
       } 

Definition at line 117 of file btHingeConstraint.h.

       {
              return m_upperLimit;
       }
int btTypedConstraint::getUserConstraintId ( ) const [inline, inherited]

Definition at line 98 of file btTypedConstraint.h.

       {
              return m_userConstraintId;
       }
int btTypedConstraint::getUserConstraintType ( ) const [inline, inherited]

Definition at line 83 of file btTypedConstraint.h.

       {
              return m_userConstraintType ;
       }
void btHingeConstraint::setAngularOnly ( bool  angularOnly) [inline]

Definition at line 89 of file btHingeConstraint.h.

       {
              m_angularOnly = angularOnly;
       }
void btHingeConstraint::setLimit ( btScalar  low,
btScalar  high,
btScalar  _softness = 0.9f,
btScalar  _biasFactor = 0.3f,
btScalar  _relaxationFactor = 1.0f 
) [inline]

Definition at line 101 of file btHingeConstraint.h.

       {
              m_lowerLimit = low;
              m_upperLimit = high;

              m_limitSoftness =  _softness;
              m_biasFactor = _biasFactor;
              m_relaxationFactor = _relaxationFactor;

       }
void btTypedConstraint::setUserConstraintId ( int  uid) [inline, inherited]

Definition at line 93 of file btTypedConstraint.h.

       {
              m_userConstraintId = uid;
       }
void btTypedConstraint::setUserConstraintType ( int  userConstraintType) [inline, inherited]

Definition at line 88 of file btTypedConstraint.h.

       {
              m_userConstraintType = userConstraintType;
       };
void btHingeConstraint::solveConstraint ( btScalar  timeStep) [virtual]

solve angular part

Implements btTypedConstraint.

Definition at line 267 of file btHingeConstraint.cpp.

{

       btVector3 pivotAInW = m_rbA.getCenterOfMassTransform()*m_rbAFrame.getOrigin();
       btVector3 pivotBInW = m_rbB.getCenterOfMassTransform()*m_rbBFrame.getOrigin();

       btScalar tau = btScalar(0.3);

       //linear part
       if (!m_angularOnly)
       {
              btVector3 rel_pos1 = pivotAInW - m_rbA.getCenterOfMassPosition(); 
              btVector3 rel_pos2 = pivotBInW - m_rbB.getCenterOfMassPosition();

              btVector3 vel1 = m_rbA.getVelocityInLocalPoint(rel_pos1);
              btVector3 vel2 = m_rbB.getVelocityInLocalPoint(rel_pos2);
              btVector3 vel = vel1 - vel2;

              for (int i=0;i<3;i++)
              {             
                     const btVector3& normal = m_jac[i].m_linearJointAxis;
                     btScalar jacDiagABInv = btScalar(1.) / m_jac[i].getDiagonal();

                     btScalar rel_vel;
                     rel_vel = normal.dot(vel);
                     //positional error (zeroth order error)
                     btScalar depth = -(pivotAInW - pivotBInW).dot(normal); //this is the error projected on the normal
                     btScalar impulse = depth*tau/timeStep  * jacDiagABInv -  rel_vel * jacDiagABInv;
                     m_appliedImpulse += impulse;
                     btVector3 impulse_vector = normal * impulse;
                     m_rbA.applyImpulse(impulse_vector, pivotAInW - m_rbA.getCenterOfMassPosition());
                     m_rbB.applyImpulse(-impulse_vector, pivotBInW - m_rbB.getCenterOfMassPosition());
              }
       }

       
       {

              // get axes in world space
              btVector3 axisA =  getRigidBodyA().getCenterOfMassTransform().getBasis() *  m_rbAFrame.getBasis().getColumn(2);
              btVector3 axisB =  getRigidBodyB().getCenterOfMassTransform().getBasis() *  m_rbBFrame.getBasis().getColumn(2);

              const btVector3& angVelA = getRigidBodyA().getAngularVelocity();
              const btVector3& angVelB = getRigidBodyB().getAngularVelocity();

              btVector3 angVelAroundHingeAxisA = axisA * axisA.dot(angVelA);
              btVector3 angVelAroundHingeAxisB = axisB * axisB.dot(angVelB);

              btVector3 angAorthog = angVelA - angVelAroundHingeAxisA;
              btVector3 angBorthog = angVelB - angVelAroundHingeAxisB;
              btVector3 velrelOrthog = angAorthog-angBorthog;
              {
                     //solve orthogonal angular velocity correction
                     btScalar relaxation = btScalar(1.);
                     btScalar len = velrelOrthog.length();
                     if (len > btScalar(0.00001))
                     {
                            btVector3 normal = velrelOrthog.normalized();
                            btScalar denom = getRigidBodyA().computeAngularImpulseDenominator(normal) +
                                   getRigidBodyB().computeAngularImpulseDenominator(normal);
                            // scale for mass and relaxation
                            //todo:  expose this 0.9 factor to developer
                            velrelOrthog *= (btScalar(1.)/denom) * m_relaxationFactor;
                     }

                     //solve angular positional correction
                     btVector3 angularError = -axisA.cross(axisB) *(btScalar(1.)/timeStep);
                     btScalar len2 = angularError.length();
                     if (len2>btScalar(0.00001))
                     {
                            btVector3 normal2 = angularError.normalized();
                            btScalar denom2 = getRigidBodyA().computeAngularImpulseDenominator(normal2) +
                                          getRigidBodyB().computeAngularImpulseDenominator(normal2);
                            angularError *= (btScalar(1.)/denom2) * relaxation;
                     }

                     m_rbA.applyTorqueImpulse(-velrelOrthog+angularError);
                     m_rbB.applyTorqueImpulse(velrelOrthog-angularError);

                     // solve limit
                     if (m_solveLimit)
                     {
                            btScalar amplitude = ( (angVelB - angVelA).dot( axisA )*m_relaxationFactor + m_correction* (btScalar(1.)/timeStep)*m_biasFactor  ) * m_limitSign;

                            btScalar impulseMag = amplitude * m_kHinge;

                            // Clamp the accumulated impulse
                            btScalar temp = m_accLimitImpulse;
                            m_accLimitImpulse = btMax(m_accLimitImpulse + impulseMag, btScalar(0) );
                            impulseMag = m_accLimitImpulse - temp;


                            btVector3 impulse = axisA * impulseMag * m_limitSign;
                            m_rbA.applyTorqueImpulse(impulse);
                            m_rbB.applyTorqueImpulse(-impulse);
                     }
              }

              //apply motor
              if (m_enableAngularMotor) 
              {
                     //todo: add limits too
                     btVector3 angularLimit(0,0,0);

                     btVector3 velrel = angVelAroundHingeAxisA - angVelAroundHingeAxisB;
                     btScalar projRelVel = velrel.dot(axisA);

                     btScalar desiredMotorVel = m_motorTargetVelocity;
                     btScalar motor_relvel = desiredMotorVel - projRelVel;

                     btScalar unclippedMotorImpulse = m_kHinge * motor_relvel;;
                     //todo: should clip against accumulated impulse
                     btScalar clippedMotorImpulse = unclippedMotorImpulse > m_maxMotorImpulse ? m_maxMotorImpulse : unclippedMotorImpulse;
                     clippedMotorImpulse = clippedMotorImpulse < -m_maxMotorImpulse ? -m_maxMotorImpulse : clippedMotorImpulse;
                     btVector3 motorImp = clippedMotorImpulse * axisA;

                     m_rbA.applyTorqueImpulse(motorImp+angularLimit);
                     m_rbB.applyTorqueImpulse(-motorImp-angularLimit);
                     
              }
       }

}

Here is the call graph for this function:

Definition at line 392 of file btHingeConstraint.cpp.

{
       (void)timeStep;

}

Member Data Documentation

Definition at line 55 of file btHingeConstraint.h.

Definition at line 57 of file btHingeConstraint.h.

Definition at line 50 of file btTypedConstraint.h.

Definition at line 44 of file btHingeConstraint.h.

Definition at line 53 of file btHingeConstraint.h.

Definition at line 58 of file btHingeConstraint.h.

Definition at line 34 of file btHingeConstraint.h.

Definition at line 35 of file btHingeConstraint.h.

Definition at line 50 of file btHingeConstraint.h.

Definition at line 52 of file btHingeConstraint.h.

Definition at line 43 of file btHingeConstraint.h.

Definition at line 47 of file btHingeConstraint.h.

Definition at line 41 of file btHingeConstraint.h.

Definition at line 40 of file btHingeConstraint.h.

btRigidBody& btTypedConstraint::m_rbA [protected, inherited]

Definition at line 48 of file btTypedConstraint.h.

Definition at line 37 of file btHingeConstraint.h.

btRigidBody& btTypedConstraint::m_rbB [protected, inherited]

Definition at line 49 of file btTypedConstraint.h.

Definition at line 38 of file btHingeConstraint.h.

Definition at line 45 of file btHingeConstraint.h.

Definition at line 59 of file btHingeConstraint.h.

Definition at line 48 of file btHingeConstraint.h.


The documentation for this class was generated from the following files: