Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added a possibility for btHingeConstraint to use frame of rigid body A as a reference frame at construction time.

Browse Source 
It is off by default, so the existing code should work as before
This commit is contained in:
rponom
2009-02-10 02:42:54 +00:00
parent 98436a85c3
commit c94cad8cba
2 changed files with 40 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp
View File

@@ -23,7 +23,7 @@ subject to the following restrictions:
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#define HINGE_USE_OBSOLETE_SOLVER false #define HINGE_USE_OBSOLETE_SOLVER true
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -31,18 +31,21 @@ subject to the following restrictions:
btHingeConstraint::btHingeConstraint() btHingeConstraint::btHingeConstraint()
: btTypedConstraint (HINGE_CONSTRAINT_TYPE), : btTypedConstraint (HINGE_CONSTRAINT_TYPE),
m_enableAngularMotor(false), m_enableAngularMotor(false),
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER) m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
m_useReferenceFrameA(false)
{ {
m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB,
btVector3& axisInA,btVector3& axisInB) btVector3& axisInA,btVector3& axisInB, bool useReferenceFrameA)
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB), :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),
m_angularOnly(false), m_angularOnly(false),
m_enableAngularMotor(false), m_enableAngularMotor(false),
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER) m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
m_useReferenceFrameA(useReferenceFrameA)
{ {
m_rbAFrame.getOrigin() = pivotInA; m_rbAFrame.getOrigin() = pivotInA;
@@ -82,14 +85,15 @@ btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const bt
m_relaxationFactor = 1.0f; m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f; m_limitSoftness = 0.9f;
m_solveLimit = false; m_solveLimit = false;
m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA) btHingeConstraint::btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA, bool useReferenceFrameA)
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), m_angularOnly(false), m_enableAngularMotor(false), :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), m_angularOnly(false), m_enableAngularMotor(false),
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER) m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
m_useReferenceFrameA(useReferenceFrameA)
{ {
// since no frame is given, assume this to be zero angle and just pick rb transform axis // since no frame is given, assume this to be zero angle and just pick rb transform axis
@@ -121,16 +125,18 @@ m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER)
m_relaxationFactor = 1.0f; m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f; m_limitSoftness = 0.9f;
m_solveLimit = false; m_solveLimit = false;
m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB,
const btTransform& rbAFrame, const btTransform& rbBFrame) const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA)
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),m_rbAFrame(rbAFrame),m_rbBFrame(rbBFrame), :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),m_rbAFrame(rbAFrame),m_rbBFrame(rbBFrame),
m_angularOnly(false), m_angularOnly(false),
m_enableAngularMotor(false), m_enableAngularMotor(false),
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER) m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
m_useReferenceFrameA(useReferenceFrameA)
{ {
//start with free //start with free
m_lowerLimit = btScalar(1e30); m_lowerLimit = btScalar(1e30);
@@ -139,15 +145,17 @@ m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER)
m_relaxationFactor = 1.0f; m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f; m_limitSoftness = 0.9f;
m_solveLimit = false; m_solveLimit = false;
m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame) btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame, bool useReferenceFrameA)
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA),m_rbAFrame(rbAFrame),m_rbBFrame(rbAFrame), :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA),m_rbAFrame(rbAFrame),m_rbBFrame(rbAFrame),
m_angularOnly(false), m_angularOnly(false),
m_enableAngularMotor(false), m_enableAngularMotor(false),
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER) m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
m_useReferenceFrameA(useReferenceFrameA)
{ {
///not providing rigidbody B means implicitly using worldspace for body B ///not providing rigidbody B means implicitly using worldspace for body B
@@ -160,6 +168,7 @@ m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER)
m_relaxationFactor = 1.0f; m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f; m_limitSoftness = 0.9f;
m_solveLimit = false; m_solveLimit = false;
m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -365,7 +374,7 @@ void btHingeConstraint::getInfo2 (btConstraintInfo2* info)
int limit = 0; int limit = 0;
if(getSolveLimit()) if(getSolveLimit())
{ {
limit_err = m_correction; limit_err = m_correction * m_referenceSign;
limit = (limit_err > btScalar(0.0)) ? 1 : 2; limit = (limit_err > btScalar(0.0)) ? 1 : 2;
} }
// if the hinge has joint limits or motor, add in the extra row // if the hinge has joint limits or motor, add in the extra row
@@ -397,7 +406,7 @@ void btHingeConstraint::getInfo2 (btConstraintInfo2* info)
{ {
info->cfm[srow] = btScalar(0.0); info->cfm[srow] = btScalar(0.0);
btScalar mot_fact = getMotorFactor(m_hingeAngle, lostop, histop, m_motorTargetVelocity, info->fps * info->erp); btScalar mot_fact = getMotorFactor(m_hingeAngle, lostop, histop, m_motorTargetVelocity, info->fps * info->erp);
info->m_constraintError[srow] += mot_fact * m_motorTargetVelocity; info->m_constraintError[srow] += mot_fact * m_motorTargetVelocity * m_referenceSign;
info->m_lowerLimit[srow] = - m_maxMotorImpulse; info->m_lowerLimit[srow] = - m_maxMotorImpulse;
info->m_upperLimit[srow] = m_maxMotorImpulse; info->m_upperLimit[srow] = m_maxMotorImpulse;
} }
@@ -621,8 +630,8 @@ btScalar btHingeConstraint::getHingeAngle()
const btVector3 refAxis0 = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(0); const btVector3 refAxis0 = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(0);
const btVector3 refAxis1 = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(1); const btVector3 refAxis1 = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(1);
const btVector3 swingAxis = getRigidBodyB().getCenterOfMassTransform().getBasis() * m_rbBFrame.getBasis().getColumn(1); const btVector3 swingAxis = getRigidBodyB().getCenterOfMassTransform().getBasis() * m_rbBFrame.getBasis().getColumn(1);
btScalar angle = btAtan2Fast(swingAxis.dot(refAxis0), swingAxis.dot(refAxis1));
return btAtan2Fast( swingAxis.dot(refAxis0), swingAxis.dot(refAxis1) ); return m_referenceSign * angle;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

14
src/BulletDynamics/ConstraintSolver/btHingeConstraint.h
View File

@@ -54,22 +54,24 @@ public:
btScalar m_accLimitImpulse; btScalar m_accLimitImpulse;
btScalar m_hingeAngle; btScalar m_hingeAngle;
btScalar m_referenceSign;
bool m_angularOnly; bool m_angularOnly;
bool m_enableAngularMotor; bool m_enableAngularMotor;
bool m_solveLimit; bool m_solveLimit;
bool m_useSolveConstraintObsolete; bool m_useSolveConstraintObsolete;
bool m_useReferenceFrameA;
public: public:
btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btVector3& axisInA,btVector3& axisInB); btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btVector3& axisInA,btVector3& axisInB, bool useReferenceFrameA = false);
btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA); btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA, bool useReferenceFrameA = false);
btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame); btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false);
btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame); btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA = false);
btHingeConstraint(); btHingeConstraint();
@@ -96,12 +98,12 @@ public:
{ {
return m_rbA; return m_rbA;
} }
btRigidBody& getRigidBodyB() btRigidBody& getRigidBodyB()
{ {
return m_rbB; return m_rbB;
} }
void setAngularOnly(bool angularOnly) void setAngularOnly(bool angularOnly)
{ {
m_angularOnly = angularOnly; m_angularOnly = angularOnly;