Add some accessor methods to btHingeConstraint and btSliderConstraint, to allow conversion.
Thanks to Roman Ponomarev.
This commit is contained in:
erwin.coumans
@@ -403,3 +403,4 @@ btScalar btHingeConstraint::getHingeAngle()
|
|||||||
|
|
||||||
return btAtan2Fast( swingAxis.dot(refAxis0), swingAxis.dot(refAxis1) );
|
return btAtan2Fast( swingAxis.dot(refAxis0), swingAxis.dot(refAxis1) );
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -135,7 +135,24 @@ public:
|
|||||||
{
|
{
|
||||||
return m_limitSign;
|
return m_limitSign;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
inline bool getAngularOnly()
|
||||||
|
{
|
||||||
|
return m_angularOnly;
|
||||||
|
}
|
||||||
|
inline bool getEnableAngularMotor()
|
||||||
|
{
|
||||||
|
return m_enableAngularMotor;
|
||||||
|
}
|
||||||
|
inline btScalar getMotorTargetVelosity()
|
||||||
|
{
|
||||||
|
return m_motorTargetVelocity;
|
||||||
|
}
|
||||||
|
inline btScalar getMaxMotorImpulse()
|
||||||
|
{
|
||||||
|
return m_maxMotorImpulse;
|
||||||
|
}
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif //HINGECONSTRAINT_H
|
#endif //HINGECONSTRAINT_H
|
||||||
|
|||||||
@@ -1,397 +1,414 @@
|
|||||||
/*
|
/*
|
||||||
Bullet Continuous Collision Detection and Physics Library
|
Bullet Continuous Collision Detection and Physics Library
|
||||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||||
|
|
||||||
This software is provided 'as-is', without any express or implied warranty.
|
This software is provided 'as-is', without any express or implied warranty.
|
||||||
In no event will the authors be held liable for any damages arising from the use of this software.
|
In no event will the authors be held liable for any damages arising from the use of this software.
|
||||||
Permission is granted to anyone to use this software for any purpose,
|
Permission is granted to anyone to use this software for any purpose,
|
||||||
including commercial applications, and to alter it and redistribute it freely,
|
including commercial applications, and to alter it and redistribute it freely,
|
||||||
subject to the following restrictions:
|
subject to the following restrictions:
|
||||||
|
|
||||||
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
||||||
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
||||||
3. This notice may not be removed or altered from any source distribution.
|
3. This notice may not be removed or altered from any source distribution.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Added by Roman Ponomarev (rponom@gmail.com)
|
Added by Roman Ponomarev (rponom@gmail.com)
|
||||||
April 04, 2008
|
April 04, 2008
|
||||||
*/
|
*/
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
#include "btSliderConstraint.h"
|
#include "btSliderConstraint.h"
|
||||||
#include "BulletDynamics/Dynamics/btRigidBody.h"
|
#include "BulletDynamics/Dynamics/btRigidBody.h"
|
||||||
#include "LinearMath/btTransformUtil.h"
|
#include "LinearMath/btTransformUtil.h"
|
||||||
#include <new>
|
#include <new>
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::initParams()
|
void btSliderConstraint::initParams()
|
||||||
{
|
{
|
||||||
m_lowerLinLimit = btScalar(1.0);
|
m_lowerLinLimit = btScalar(1.0);
|
||||||
m_upperLinLimit = btScalar(-1.0);
|
m_upperLinLimit = btScalar(-1.0);
|
||||||
m_lowerAngLimit = btScalar(0.);
|
m_lowerAngLimit = btScalar(0.);
|
||||||
m_upperAngLimit = btScalar(0.);
|
m_upperAngLimit = btScalar(0.);
|
||||||
m_softnessDirLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessDirLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionDirLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionDirLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingDirLin = btScalar(0.);
|
m_dampingDirLin = btScalar(0.);
|
||||||
m_softnessDirAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessDirAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionDirAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionDirAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingDirAng = btScalar(0.);
|
m_dampingDirAng = btScalar(0.);
|
||||||
m_softnessOrthoLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessOrthoLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionOrthoLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionOrthoLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingOrthoLin = SLIDER_CONSTRAINT_DEF_DAMPING;
|
m_dampingOrthoLin = SLIDER_CONSTRAINT_DEF_DAMPING;
|
||||||
m_softnessOrthoAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessOrthoAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionOrthoAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionOrthoAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingOrthoAng = SLIDER_CONSTRAINT_DEF_DAMPING;
|
m_dampingOrthoAng = SLIDER_CONSTRAINT_DEF_DAMPING;
|
||||||
m_softnessLimLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessLimLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionLimLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionLimLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingLimLin = SLIDER_CONSTRAINT_DEF_DAMPING;
|
m_dampingLimLin = SLIDER_CONSTRAINT_DEF_DAMPING;
|
||||||
m_softnessLimAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
m_softnessLimAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
|
||||||
m_restitutionLimAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
m_restitutionLimAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
|
||||||
m_dampingLimAng = SLIDER_CONSTRAINT_DEF_DAMPING;
|
m_dampingLimAng = SLIDER_CONSTRAINT_DEF_DAMPING;
|
||||||
|
|
||||||
m_poweredLinMotor = false;
|
m_poweredLinMotor = false;
|
||||||
m_targetLinMotorVelocity = btScalar(0.);
|
m_targetLinMotorVelocity = btScalar(0.);
|
||||||
m_maxLinMotorForce = btScalar(0.);
|
m_maxLinMotorForce = btScalar(0.);
|
||||||
m_accumulatedLinMotorImpulse = btScalar(0.0);
|
m_accumulatedLinMotorImpulse = btScalar(0.0);
|
||||||
|
|
||||||
m_poweredAngMotor = false;
|
m_poweredAngMotor = false;
|
||||||
m_targetAngMotorVelocity = btScalar(0.);
|
m_targetAngMotorVelocity = btScalar(0.);
|
||||||
m_maxAngMotorForce = btScalar(0.);
|
m_maxAngMotorForce = btScalar(0.);
|
||||||
m_accumulatedAngMotorImpulse = btScalar(0.0);
|
m_accumulatedAngMotorImpulse = btScalar(0.0);
|
||||||
|
|
||||||
} // btSliderConstraint::initParams()
|
} // btSliderConstraint::initParams()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
btSliderConstraint::btSliderConstraint()
|
btSliderConstraint::btSliderConstraint()
|
||||||
:btTypedConstraint(SLIDER_CONSTRAINT_TYPE),
|
:btTypedConstraint(SLIDER_CONSTRAINT_TYPE),
|
||||||
m_useLinearReferenceFrameA(true)
|
m_useLinearReferenceFrameA(true)
|
||||||
{
|
{
|
||||||
initParams();
|
initParams();
|
||||||
} // btSliderConstraint::btSliderConstraint()
|
} // btSliderConstraint::btSliderConstraint()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
btSliderConstraint::btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA)
|
btSliderConstraint::btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA)
|
||||||
: btTypedConstraint(SLIDER_CONSTRAINT_TYPE, rbA, rbB)
|
: btTypedConstraint(SLIDER_CONSTRAINT_TYPE, rbA, rbB)
|
||||||
, m_frameInA(frameInA)
|
, m_frameInA(frameInA)
|
||||||
, m_frameInB(frameInB),
|
, m_frameInB(frameInB),
|
||||||
m_useLinearReferenceFrameA(useLinearReferenceFrameA)
|
m_useLinearReferenceFrameA(useLinearReferenceFrameA)
|
||||||
{
|
{
|
||||||
initParams();
|
initParams();
|
||||||
} // btSliderConstraint::btSliderConstraint()
|
} // btSliderConstraint::btSliderConstraint()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::buildJacobian()
|
void btSliderConstraint::buildJacobian()
|
||||||
{
|
{
|
||||||
if(m_useLinearReferenceFrameA)
|
if(m_useLinearReferenceFrameA)
|
||||||
{
|
{
|
||||||
buildJacobianInt(m_rbA, m_rbB, m_frameInA, m_frameInB);
|
buildJacobianInt(m_rbA, m_rbB, m_frameInA, m_frameInB);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
buildJacobianInt(m_rbB, m_rbA, m_frameInB, m_frameInA);
|
buildJacobianInt(m_rbB, m_rbA, m_frameInB, m_frameInA);
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::buildJacobian()
|
} // btSliderConstraint::buildJacobian()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB)
|
void btSliderConstraint::buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB)
|
||||||
{
|
{
|
||||||
//calculate transforms
|
//calculate transforms
|
||||||
m_calculatedTransformA = rbA.getCenterOfMassTransform() * frameInA;
|
m_calculatedTransformA = rbA.getCenterOfMassTransform() * frameInA;
|
||||||
m_calculatedTransformB = rbB.getCenterOfMassTransform() * frameInB;
|
m_calculatedTransformB = rbB.getCenterOfMassTransform() * frameInB;
|
||||||
m_realPivotAInW = m_calculatedTransformA.getOrigin();
|
m_realPivotAInW = m_calculatedTransformA.getOrigin();
|
||||||
m_realPivotBInW = m_calculatedTransformB.getOrigin();
|
m_realPivotBInW = m_calculatedTransformB.getOrigin();
|
||||||
m_sliderAxis = m_calculatedTransformA.getBasis().getColumn(0); // along X
|
m_sliderAxis = m_calculatedTransformA.getBasis().getColumn(0); // along X
|
||||||
m_delta = m_realPivotBInW - m_realPivotAInW;
|
m_delta = m_realPivotBInW - m_realPivotAInW;
|
||||||
m_projPivotInW = m_realPivotAInW + m_sliderAxis.dot(m_delta) * m_sliderAxis;
|
m_projPivotInW = m_realPivotAInW + m_sliderAxis.dot(m_delta) * m_sliderAxis;
|
||||||
m_relPosA = m_projPivotInW - rbA.getCenterOfMassPosition();
|
m_relPosA = m_projPivotInW - rbA.getCenterOfMassPosition();
|
||||||
m_relPosB = m_realPivotBInW - rbB.getCenterOfMassPosition();
|
m_relPosB = m_realPivotBInW - rbB.getCenterOfMassPosition();
|
||||||
btVector3 normalWorld;
|
btVector3 normalWorld;
|
||||||
int i;
|
int i;
|
||||||
//linear part
|
//linear part
|
||||||
for(i = 0; i < 3; i++)
|
for(i = 0; i < 3; i++)
|
||||||
{
|
{
|
||||||
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
||||||
new (&m_jacLin[i]) btJacobianEntry(
|
new (&m_jacLin[i]) btJacobianEntry(
|
||||||
rbA.getCenterOfMassTransform().getBasis().transpose(),
|
rbA.getCenterOfMassTransform().getBasis().transpose(),
|
||||||
rbB.getCenterOfMassTransform().getBasis().transpose(),
|
rbB.getCenterOfMassTransform().getBasis().transpose(),
|
||||||
m_relPosA,
|
m_relPosA,
|
||||||
m_relPosB,
|
m_relPosB,
|
||||||
normalWorld,
|
normalWorld,
|
||||||
rbA.getInvInertiaDiagLocal(),
|
rbA.getInvInertiaDiagLocal(),
|
||||||
rbA.getInvMass(),
|
rbA.getInvMass(),
|
||||||
rbB.getInvInertiaDiagLocal(),
|
rbB.getInvInertiaDiagLocal(),
|
||||||
rbB.getInvMass()
|
rbB.getInvMass()
|
||||||
);
|
);
|
||||||
m_jacLinDiagABInv[i] = btScalar(1.) / m_jacLin[i].getDiagonal();
|
m_jacLinDiagABInv[i] = btScalar(1.) / m_jacLin[i].getDiagonal();
|
||||||
m_depth[i] = m_delta.dot(normalWorld);
|
m_depth[i] = m_delta.dot(normalWorld);
|
||||||
}
|
}
|
||||||
testLinLimits();
|
testLinLimits();
|
||||||
// angular part
|
// angular part
|
||||||
for(i = 0; i < 3; i++)
|
for(i = 0; i < 3; i++)
|
||||||
{
|
{
|
||||||
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
||||||
new (&m_jacAng[i]) btJacobianEntry(
|
new (&m_jacAng[i]) btJacobianEntry(
|
||||||
normalWorld,
|
normalWorld,
|
||||||
rbA.getCenterOfMassTransform().getBasis().transpose(),
|
rbA.getCenterOfMassTransform().getBasis().transpose(),
|
||||||
rbB.getCenterOfMassTransform().getBasis().transpose(),
|
rbB.getCenterOfMassTransform().getBasis().transpose(),
|
||||||
rbA.getInvInertiaDiagLocal(),
|
rbA.getInvInertiaDiagLocal(),
|
||||||
rbB.getInvInertiaDiagLocal()
|
rbB.getInvInertiaDiagLocal()
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
testAngLimits();
|
testAngLimits();
|
||||||
btVector3 axisA = m_calculatedTransformA.getBasis().getColumn(0);
|
btVector3 axisA = m_calculatedTransformA.getBasis().getColumn(0);
|
||||||
m_kAngle = btScalar(1.0 )/ (rbA.computeAngularImpulseDenominator(axisA) + rbB.computeAngularImpulseDenominator(axisA));
|
m_kAngle = btScalar(1.0 )/ (rbA.computeAngularImpulseDenominator(axisA) + rbB.computeAngularImpulseDenominator(axisA));
|
||||||
// clear accumulator for motors
|
// clear accumulator for motors
|
||||||
m_accumulatedLinMotorImpulse = btScalar(0.0);
|
m_accumulatedLinMotorImpulse = btScalar(0.0);
|
||||||
m_accumulatedAngMotorImpulse = btScalar(0.0);
|
m_accumulatedAngMotorImpulse = btScalar(0.0);
|
||||||
} // btSliderConstraint::buildJacobianInt()
|
} // btSliderConstraint::buildJacobianInt()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::solveConstraint(btScalar timeStep)
|
void btSliderConstraint::solveConstraint(btScalar timeStep)
|
||||||
{
|
{
|
||||||
m_timeStep = timeStep;
|
m_timeStep = timeStep;
|
||||||
if(m_useLinearReferenceFrameA)
|
if(m_useLinearReferenceFrameA)
|
||||||
{
|
{
|
||||||
solveConstraintInt(m_rbA, m_rbB);
|
solveConstraintInt(m_rbA, m_rbB);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
solveConstraintInt(m_rbB, m_rbA);
|
solveConstraintInt(m_rbB, m_rbA);
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::solveConstraint()
|
} // btSliderConstraint::solveConstraint()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::solveConstraintInt(btRigidBody& rbA, btRigidBody& rbB)
|
void btSliderConstraint::solveConstraintInt(btRigidBody& rbA, btRigidBody& rbB)
|
||||||
{
|
{
|
||||||
int i;
|
int i;
|
||||||
// linear
|
// linear
|
||||||
btVector3 velA = rbA.getVelocityInLocalPoint(m_relPosA);
|
btVector3 velA = rbA.getVelocityInLocalPoint(m_relPosA);
|
||||||
btVector3 velB = rbB.getVelocityInLocalPoint(m_relPosB);
|
btVector3 velB = rbB.getVelocityInLocalPoint(m_relPosB);
|
||||||
btVector3 vel = velA - velB;
|
btVector3 vel = velA - velB;
|
||||||
for(i = 0; i < 3; i++)
|
for(i = 0; i < 3; i++)
|
||||||
{
|
{
|
||||||
const btVector3& normal = m_jacLin[i].m_linearJointAxis;
|
const btVector3& normal = m_jacLin[i].m_linearJointAxis;
|
||||||
btScalar rel_vel = normal.dot(vel);
|
btScalar rel_vel = normal.dot(vel);
|
||||||
// calculate positional error
|
// calculate positional error
|
||||||
btScalar depth = m_depth[i];
|
btScalar depth = m_depth[i];
|
||||||
// get parameters
|
// get parameters
|
||||||
btScalar softness = (i) ? m_softnessOrthoLin : (m_solveLinLim ? m_softnessLimLin : m_softnessDirLin);
|
btScalar softness = (i) ? m_softnessOrthoLin : (m_solveLinLim ? m_softnessLimLin : m_softnessDirLin);
|
||||||
btScalar restitution = (i) ? m_restitutionOrthoLin : (m_solveLinLim ? m_restitutionLimLin : m_restitutionDirLin);
|
btScalar restitution = (i) ? m_restitutionOrthoLin : (m_solveLinLim ? m_restitutionLimLin : m_restitutionDirLin);
|
||||||
btScalar damping = (i) ? m_dampingOrthoLin : (m_solveLinLim ? m_dampingLimLin : m_dampingDirLin);
|
btScalar damping = (i) ? m_dampingOrthoLin : (m_solveLinLim ? m_dampingLimLin : m_dampingDirLin);
|
||||||
// calcutate and apply impulse
|
// calcutate and apply impulse
|
||||||
btScalar normalImpulse = softness * (restitution * depth / m_timeStep - damping * rel_vel) * m_jacLinDiagABInv[i];
|
btScalar normalImpulse = softness * (restitution * depth / m_timeStep - damping * rel_vel) * m_jacLinDiagABInv[i];
|
||||||
btVector3 impulse_vector = normal * normalImpulse;
|
btVector3 impulse_vector = normal * normalImpulse;
|
||||||
rbA.applyImpulse( impulse_vector, m_relPosA);
|
rbA.applyImpulse( impulse_vector, m_relPosA);
|
||||||
rbB.applyImpulse(-impulse_vector, m_relPosB);
|
rbB.applyImpulse(-impulse_vector, m_relPosB);
|
||||||
if(m_poweredLinMotor && (!i))
|
if(m_poweredLinMotor && (!i))
|
||||||
{ // apply linear motor
|
{ // apply linear motor
|
||||||
if(m_accumulatedLinMotorImpulse < m_maxLinMotorForce)
|
if(m_accumulatedLinMotorImpulse < m_maxLinMotorForce)
|
||||||
{
|
{
|
||||||
btScalar desiredMotorVel = m_targetLinMotorVelocity;
|
btScalar desiredMotorVel = m_targetLinMotorVelocity;
|
||||||
btScalar motor_relvel = desiredMotorVel + rel_vel;
|
btScalar motor_relvel = desiredMotorVel + rel_vel;
|
||||||
normalImpulse = -motor_relvel * m_jacLinDiagABInv[i];
|
normalImpulse = -motor_relvel * m_jacLinDiagABInv[i];
|
||||||
// clamp accumulated impulse
|
// clamp accumulated impulse
|
||||||
btScalar new_acc = m_accumulatedLinMotorImpulse + btFabs(normalImpulse);
|
btScalar new_acc = m_accumulatedLinMotorImpulse + btFabs(normalImpulse);
|
||||||
if(new_acc > m_maxLinMotorForce)
|
if(new_acc > m_maxLinMotorForce)
|
||||||
{
|
{
|
||||||
new_acc = m_maxLinMotorForce;
|
new_acc = m_maxLinMotorForce;
|
||||||
}
|
}
|
||||||
btScalar del = new_acc - m_accumulatedLinMotorImpulse;
|
btScalar del = new_acc - m_accumulatedLinMotorImpulse;
|
||||||
if(normalImpulse < btScalar(0.0))
|
if(normalImpulse < btScalar(0.0))
|
||||||
{
|
{
|
||||||
normalImpulse = -del;
|
normalImpulse = -del;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
normalImpulse = del;
|
normalImpulse = del;
|
||||||
}
|
}
|
||||||
m_accumulatedLinMotorImpulse = new_acc;
|
m_accumulatedLinMotorImpulse = new_acc;
|
||||||
// apply clamped impulse
|
// apply clamped impulse
|
||||||
impulse_vector = normal * normalImpulse;
|
impulse_vector = normal * normalImpulse;
|
||||||
rbA.applyImpulse( impulse_vector, m_relPosA);
|
rbA.applyImpulse( impulse_vector, m_relPosA);
|
||||||
rbB.applyImpulse(-impulse_vector, m_relPosB);
|
rbB.applyImpulse(-impulse_vector, m_relPosB);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// angular
|
// angular
|
||||||
// get axes in world space
|
// get axes in world space
|
||||||
btVector3 axisA = m_calculatedTransformA.getBasis().getColumn(0);
|
btVector3 axisA = m_calculatedTransformA.getBasis().getColumn(0);
|
||||||
btVector3 axisB = m_calculatedTransformB.getBasis().getColumn(0);
|
btVector3 axisB = m_calculatedTransformB.getBasis().getColumn(0);
|
||||||
|
|
||||||
const btVector3& angVelA = rbA.getAngularVelocity();
|
const btVector3& angVelA = rbA.getAngularVelocity();
|
||||||
const btVector3& angVelB = rbB.getAngularVelocity();
|
const btVector3& angVelB = rbB.getAngularVelocity();
|
||||||
|
|
||||||
btVector3 angVelAroundAxisA = axisA * axisA.dot(angVelA);
|
btVector3 angVelAroundAxisA = axisA * axisA.dot(angVelA);
|
||||||
btVector3 angVelAroundAxisB = axisB * axisB.dot(angVelB);
|
btVector3 angVelAroundAxisB = axisB * axisB.dot(angVelB);
|
||||||
|
|
||||||
btVector3 angAorthog = angVelA - angVelAroundAxisA;
|
btVector3 angAorthog = angVelA - angVelAroundAxisA;
|
||||||
btVector3 angBorthog = angVelB - angVelAroundAxisB;
|
btVector3 angBorthog = angVelB - angVelAroundAxisB;
|
||||||
btVector3 velrelOrthog = angAorthog-angBorthog;
|
btVector3 velrelOrthog = angAorthog-angBorthog;
|
||||||
//solve orthogonal angular velocity correction
|
//solve orthogonal angular velocity correction
|
||||||
btScalar len = velrelOrthog.length();
|
btScalar len = velrelOrthog.length();
|
||||||
if (len > btScalar(0.00001))
|
if (len > btScalar(0.00001))
|
||||||
{
|
{
|
||||||
btVector3 normal = velrelOrthog.normalized();
|
btVector3 normal = velrelOrthog.normalized();
|
||||||
btScalar denom = rbA.computeAngularImpulseDenominator(normal) + rbB.computeAngularImpulseDenominator(normal);
|
btScalar denom = rbA.computeAngularImpulseDenominator(normal) + rbB.computeAngularImpulseDenominator(normal);
|
||||||
velrelOrthog *= (btScalar(1.)/denom) * m_dampingOrthoAng * m_softnessOrthoAng;
|
velrelOrthog *= (btScalar(1.)/denom) * m_dampingOrthoAng * m_softnessOrthoAng;
|
||||||
}
|
}
|
||||||
//solve angular positional correction
|
//solve angular positional correction
|
||||||
btVector3 angularError = axisA.cross(axisB) *(btScalar(1.)/m_timeStep);
|
btVector3 angularError = axisA.cross(axisB) *(btScalar(1.)/m_timeStep);
|
||||||
btScalar len2 = angularError.length();
|
btScalar len2 = angularError.length();
|
||||||
if (len2>btScalar(0.00001))
|
if (len2>btScalar(0.00001))
|
||||||
{
|
{
|
||||||
btVector3 normal2 = angularError.normalized();
|
btVector3 normal2 = angularError.normalized();
|
||||||
btScalar denom2 = rbA.computeAngularImpulseDenominator(normal2) + rbB.computeAngularImpulseDenominator(normal2);
|
btScalar denom2 = rbA.computeAngularImpulseDenominator(normal2) + rbB.computeAngularImpulseDenominator(normal2);
|
||||||
angularError *= (btScalar(1.)/denom2) * m_restitutionOrthoAng * m_softnessOrthoAng;
|
angularError *= (btScalar(1.)/denom2) * m_restitutionOrthoAng * m_softnessOrthoAng;
|
||||||
}
|
}
|
||||||
// apply impulse
|
// apply impulse
|
||||||
rbA.applyTorqueImpulse(-velrelOrthog+angularError);
|
rbA.applyTorqueImpulse(-velrelOrthog+angularError);
|
||||||
rbB.applyTorqueImpulse(velrelOrthog-angularError);
|
rbB.applyTorqueImpulse(velrelOrthog-angularError);
|
||||||
btScalar impulseMag;
|
btScalar impulseMag;
|
||||||
//solve angular limits
|
//solve angular limits
|
||||||
if(m_solveAngLim)
|
if(m_solveAngLim)
|
||||||
{
|
{
|
||||||
impulseMag = (angVelB - angVelA).dot(axisA) * m_dampingLimAng + m_angDepth * m_restitutionLimAng / m_timeStep;
|
impulseMag = (angVelB - angVelA).dot(axisA) * m_dampingLimAng + m_angDepth * m_restitutionLimAng / m_timeStep;
|
||||||
impulseMag *= m_kAngle * m_softnessLimAng;
|
impulseMag *= m_kAngle * m_softnessLimAng;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
impulseMag = (angVelB - angVelA).dot(axisA) * m_dampingDirAng + m_angDepth * m_restitutionDirAng / m_timeStep;
|
impulseMag = (angVelB - angVelA).dot(axisA) * m_dampingDirAng + m_angDepth * m_restitutionDirAng / m_timeStep;
|
||||||
impulseMag *= m_kAngle * m_softnessDirAng;
|
impulseMag *= m_kAngle * m_softnessDirAng;
|
||||||
}
|
}
|
||||||
btVector3 impulse = axisA * impulseMag;
|
btVector3 impulse = axisA * impulseMag;
|
||||||
rbA.applyTorqueImpulse(impulse);
|
rbA.applyTorqueImpulse(impulse);
|
||||||
rbB.applyTorqueImpulse(-impulse);
|
rbB.applyTorqueImpulse(-impulse);
|
||||||
//apply angular motor
|
//apply angular motor
|
||||||
if(m_poweredAngMotor)
|
if(m_poweredAngMotor)
|
||||||
{
|
{
|
||||||
if(m_accumulatedAngMotorImpulse < m_maxAngMotorForce)
|
if(m_accumulatedAngMotorImpulse < m_maxAngMotorForce)
|
||||||
{
|
{
|
||||||
btVector3 velrel = angVelAroundAxisA - angVelAroundAxisB;
|
btVector3 velrel = angVelAroundAxisA - angVelAroundAxisB;
|
||||||
btScalar projRelVel = velrel.dot(axisA);
|
btScalar projRelVel = velrel.dot(axisA);
|
||||||
|
|
||||||
btScalar desiredMotorVel = m_targetAngMotorVelocity;
|
btScalar desiredMotorVel = m_targetAngMotorVelocity;
|
||||||
btScalar motor_relvel = desiredMotorVel - projRelVel;
|
btScalar motor_relvel = desiredMotorVel - projRelVel;
|
||||||
|
|
||||||
btScalar angImpulse = m_kAngle * motor_relvel;
|
btScalar angImpulse = m_kAngle * motor_relvel;
|
||||||
// clamp accumulated impulse
|
// clamp accumulated impulse
|
||||||
btScalar new_acc = m_accumulatedAngMotorImpulse + btFabs(angImpulse);
|
btScalar new_acc = m_accumulatedAngMotorImpulse + btFabs(angImpulse);
|
||||||
if(new_acc > m_maxAngMotorForce)
|
if(new_acc > m_maxAngMotorForce)
|
||||||
{
|
{
|
||||||
new_acc = m_maxAngMotorForce;
|
new_acc = m_maxAngMotorForce;
|
||||||
}
|
}
|
||||||
btScalar del = new_acc - m_accumulatedAngMotorImpulse;
|
btScalar del = new_acc - m_accumulatedAngMotorImpulse;
|
||||||
if(angImpulse < btScalar(0.0))
|
if(angImpulse < btScalar(0.0))
|
||||||
{
|
{
|
||||||
angImpulse = -del;
|
angImpulse = -del;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
angImpulse = del;
|
angImpulse = del;
|
||||||
}
|
}
|
||||||
m_accumulatedAngMotorImpulse = new_acc;
|
m_accumulatedAngMotorImpulse = new_acc;
|
||||||
// apply clamped impulse
|
// apply clamped impulse
|
||||||
btVector3 motorImp = angImpulse * axisA;
|
btVector3 motorImp = angImpulse * axisA;
|
||||||
m_rbA.applyTorqueImpulse(motorImp);
|
m_rbA.applyTorqueImpulse(motorImp);
|
||||||
m_rbB.applyTorqueImpulse(-motorImp);
|
m_rbB.applyTorqueImpulse(-motorImp);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::solveConstraint()
|
} // btSliderConstraint::solveConstraint()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::calculateTransforms(void){
|
void btSliderConstraint::calculateTransforms(void){
|
||||||
if(m_useLinearReferenceFrameA)
|
if(m_useLinearReferenceFrameA)
|
||||||
{
|
{
|
||||||
m_calculatedTransformA = m_rbA.getCenterOfMassTransform() * m_frameInA;
|
m_calculatedTransformA = m_rbA.getCenterOfMassTransform() * m_frameInA;
|
||||||
m_calculatedTransformB = m_rbB.getCenterOfMassTransform() * m_frameInB;
|
m_calculatedTransformB = m_rbB.getCenterOfMassTransform() * m_frameInB;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
m_calculatedTransformA = m_rbB.getCenterOfMassTransform() * m_frameInB;
|
m_calculatedTransformA = m_rbB.getCenterOfMassTransform() * m_frameInB;
|
||||||
m_calculatedTransformB = m_rbA.getCenterOfMassTransform() * m_frameInA;
|
m_calculatedTransformB = m_rbA.getCenterOfMassTransform() * m_frameInA;
|
||||||
}
|
}
|
||||||
m_realPivotAInW = m_calculatedTransformA.getOrigin();
|
m_realPivotAInW = m_calculatedTransformA.getOrigin();
|
||||||
m_realPivotBInW = m_calculatedTransformB.getOrigin();
|
m_realPivotBInW = m_calculatedTransformB.getOrigin();
|
||||||
m_sliderAxis = m_calculatedTransformA.getBasis().getColumn(0); // along X
|
m_sliderAxis = m_calculatedTransformA.getBasis().getColumn(0); // along X
|
||||||
m_delta = m_realPivotBInW - m_realPivotAInW;
|
m_delta = m_realPivotBInW - m_realPivotAInW;
|
||||||
m_projPivotInW = m_realPivotAInW + m_sliderAxis.dot(m_delta) * m_sliderAxis;
|
m_projPivotInW = m_realPivotAInW + m_sliderAxis.dot(m_delta) * m_sliderAxis;
|
||||||
btVector3 normalWorld;
|
btVector3 normalWorld;
|
||||||
int i;
|
int i;
|
||||||
//linear part
|
//linear part
|
||||||
for(i = 0; i < 3; i++)
|
for(i = 0; i < 3; i++)
|
||||||
{
|
{
|
||||||
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
normalWorld = m_calculatedTransformA.getBasis().getColumn(i);
|
||||||
m_depth[i] = m_delta.dot(normalWorld);
|
m_depth[i] = m_delta.dot(normalWorld);
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::calculateTransforms()
|
} // btSliderConstraint::calculateTransforms()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
void btSliderConstraint::testLinLimits(void)
|
void btSliderConstraint::testLinLimits(void)
|
||||||
{
|
{
|
||||||
m_solveLinLim = false;
|
m_solveLinLim = false;
|
||||||
if(m_lowerLinLimit <= m_upperLinLimit)
|
if(m_lowerLinLimit <= m_upperLinLimit)
|
||||||
{
|
{
|
||||||
if(m_depth[0] > m_upperLinLimit)
|
if(m_depth[0] > m_upperLinLimit)
|
||||||
{
|
{
|
||||||
m_depth[0] -= m_upperLinLimit;
|
m_depth[0] -= m_upperLinLimit;
|
||||||
m_solveLinLim = true;
|
m_solveLinLim = true;
|
||||||
}
|
}
|
||||||
else if(m_depth[0] < m_lowerLinLimit)
|
else if(m_depth[0] < m_lowerLinLimit)
|
||||||
{
|
{
|
||||||
m_depth[0] -= m_lowerLinLimit;
|
m_depth[0] -= m_lowerLinLimit;
|
||||||
m_solveLinLim = true;
|
m_solveLinLim = true;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
m_depth[0] = btScalar(0.);
|
m_depth[0] = btScalar(0.);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
m_depth[0] = btScalar(0.);
|
m_depth[0] = btScalar(0.);
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::testLinLimits()
|
} // btSliderConstraint::testLinLimits()
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
void btSliderConstraint::testAngLimits(void)
|
void btSliderConstraint::testAngLimits(void)
|
||||||
{
|
{
|
||||||
m_angDepth = btScalar(0.);
|
m_angDepth = btScalar(0.);
|
||||||
m_solveAngLim = false;
|
m_solveAngLim = false;
|
||||||
if(m_lowerAngLimit <= m_upperAngLimit)
|
if(m_lowerAngLimit <= m_upperAngLimit)
|
||||||
{
|
{
|
||||||
const btVector3 axisA0 = m_calculatedTransformA.getBasis().getColumn(1);
|
const btVector3 axisA0 = m_calculatedTransformA.getBasis().getColumn(1);
|
||||||
const btVector3 axisA1 = m_calculatedTransformA.getBasis().getColumn(2);
|
const btVector3 axisA1 = m_calculatedTransformA.getBasis().getColumn(2);
|
||||||
const btVector3 axisB0 = m_calculatedTransformB.getBasis().getColumn(1);
|
const btVector3 axisB0 = m_calculatedTransformB.getBasis().getColumn(1);
|
||||||
btScalar rot = btAtan2Fast(axisB0.dot(axisA1), axisB0.dot(axisA0));
|
btScalar rot = btAtan2Fast(axisB0.dot(axisA1), axisB0.dot(axisA0));
|
||||||
if(rot < m_lowerAngLimit)
|
if(rot < m_lowerAngLimit)
|
||||||
{
|
{
|
||||||
m_angDepth = rot - m_lowerAngLimit;
|
m_angDepth = rot - m_lowerAngLimit;
|
||||||
m_solveAngLim = true;
|
m_solveAngLim = true;
|
||||||
}
|
}
|
||||||
else if(rot > m_upperAngLimit)
|
else if(rot > m_upperAngLimit)
|
||||||
{
|
{
|
||||||
m_angDepth = rot - m_upperAngLimit;
|
m_angDepth = rot - m_upperAngLimit;
|
||||||
m_solveAngLim = true;
|
m_solveAngLim = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} // btSliderConstraint::testAngLimits()
|
} // btSliderConstraint::testAngLimits()
|
||||||
|
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
btVector3 btSliderConstraint::getAncorInA(void)
|
||||||
|
{
|
||||||
|
btVector3 ancorInA;
|
||||||
|
ancorInA = m_realPivotAInW + (m_lowerLinLimit + m_upperLinLimit) * btScalar(0.5) * m_sliderAxis;
|
||||||
|
ancorInA = m_rbA.getCenterOfMassTransform().inverse() * ancorInA;
|
||||||
|
return ancorInA;
|
||||||
|
} // btSliderConstraint::getAncorInA()
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
|
btVector3 btSliderConstraint::getAncorInB(void)
|
||||||
|
{
|
||||||
|
btVector3 ancorInB;
|
||||||
|
ancorInB = m_frameInB.getOrigin();
|
||||||
|
return ancorInB;
|
||||||
|
} // btSliderConstraint::getAncorInB();
|
||||||
|
|||||||
@@ -1,212 +1,215 @@
|
|||||||
/*
|
/*
|
||||||
Bullet Continuous Collision Detection and Physics Library
|
Bullet Continuous Collision Detection and Physics Library
|
||||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||||
|
|
||||||
This software is provided 'as-is', without any express or implied warranty.
|
This software is provided 'as-is', without any express or implied warranty.
|
||||||
In no event will the authors be held liable for any damages arising from the use of this software.
|
In no event will the authors be held liable for any damages arising from the use of this software.
|
||||||
Permission is granted to anyone to use this software for any purpose,
|
Permission is granted to anyone to use this software for any purpose,
|
||||||
including commercial applications, and to alter it and redistribute it freely,
|
including commercial applications, and to alter it and redistribute it freely,
|
||||||
subject to the following restrictions:
|
subject to the following restrictions:
|
||||||
|
|
||||||
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
||||||
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
||||||
3. This notice may not be removed or altered from any source distribution.
|
3. This notice may not be removed or altered from any source distribution.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Added by Roman Ponomarev (rponom@gmail.com)
|
Added by Roman Ponomarev (rponom@gmail.com)
|
||||||
April 04, 2008
|
April 04, 2008
|
||||||
|
|
||||||
TODO:
|
TODO:
|
||||||
- add clamping od accumulated impulse to improve stability
|
- add clamping od accumulated impulse to improve stability
|
||||||
- add conversion for ODE constraint solver
|
- add conversion for ODE constraint solver
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifndef SLIDER_CONSTRAINT_H
|
#ifndef SLIDER_CONSTRAINT_H
|
||||||
#define SLIDER_CONSTRAINT_H
|
#define SLIDER_CONSTRAINT_H
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
#include "LinearMath/btVector3.h"
|
#include "LinearMath/btVector3.h"
|
||||||
#include "btJacobianEntry.h"
|
#include "btJacobianEntry.h"
|
||||||
#include "btTypedConstraint.h"
|
#include "btTypedConstraint.h"
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
class btRigidBody;
|
class btRigidBody;
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
|
#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
|
||||||
#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
|
#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
|
||||||
#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))
|
#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))
|
||||||
|
|
||||||
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
class btSliderConstraint : public btTypedConstraint
|
class btSliderConstraint : public btTypedConstraint
|
||||||
{
|
{
|
||||||
protected:
|
protected:
|
||||||
btTransform m_frameInA;
|
btTransform m_frameInA;
|
||||||
btTransform m_frameInB;
|
btTransform m_frameInB;
|
||||||
// use frameA fo define limits, if true
|
// use frameA fo define limits, if true
|
||||||
bool m_useLinearReferenceFrameA;
|
bool m_useLinearReferenceFrameA;
|
||||||
// linear limits
|
// linear limits
|
||||||
btScalar m_lowerLinLimit;
|
btScalar m_lowerLinLimit;
|
||||||
btScalar m_upperLinLimit;
|
btScalar m_upperLinLimit;
|
||||||
// angular limits
|
// angular limits
|
||||||
btScalar m_lowerAngLimit;
|
btScalar m_lowerAngLimit;
|
||||||
btScalar m_upperAngLimit;
|
btScalar m_upperAngLimit;
|
||||||
// softness, restitution and damping for different cases
|
// softness, restitution and damping for different cases
|
||||||
// DirLin - moving inside linear limits
|
// DirLin - moving inside linear limits
|
||||||
// LimLin - hitting linear limit
|
// LimLin - hitting linear limit
|
||||||
// DirAng - moving inside angular limits
|
// DirAng - moving inside angular limits
|
||||||
// LimAng - hitting angular limit
|
// LimAng - hitting angular limit
|
||||||
// OrthoLin, OrthoAng - against constraint axis
|
// OrthoLin, OrthoAng - against constraint axis
|
||||||
btScalar m_softnessDirLin;
|
btScalar m_softnessDirLin;
|
||||||
btScalar m_restitutionDirLin;
|
btScalar m_restitutionDirLin;
|
||||||
btScalar m_dampingDirLin;
|
btScalar m_dampingDirLin;
|
||||||
btScalar m_softnessDirAng;
|
btScalar m_softnessDirAng;
|
||||||
btScalar m_restitutionDirAng;
|
btScalar m_restitutionDirAng;
|
||||||
btScalar m_dampingDirAng;
|
btScalar m_dampingDirAng;
|
||||||
btScalar m_softnessLimLin;
|
btScalar m_softnessLimLin;
|
||||||
btScalar m_restitutionLimLin;
|
btScalar m_restitutionLimLin;
|
||||||
btScalar m_dampingLimLin;
|
btScalar m_dampingLimLin;
|
||||||
btScalar m_softnessLimAng;
|
btScalar m_softnessLimAng;
|
||||||
btScalar m_restitutionLimAng;
|
btScalar m_restitutionLimAng;
|
||||||
btScalar m_dampingLimAng;
|
btScalar m_dampingLimAng;
|
||||||
btScalar m_softnessOrthoLin;
|
btScalar m_softnessOrthoLin;
|
||||||
btScalar m_restitutionOrthoLin;
|
btScalar m_restitutionOrthoLin;
|
||||||
btScalar m_dampingOrthoLin;
|
btScalar m_dampingOrthoLin;
|
||||||
btScalar m_softnessOrthoAng;
|
btScalar m_softnessOrthoAng;
|
||||||
btScalar m_restitutionOrthoAng;
|
btScalar m_restitutionOrthoAng;
|
||||||
btScalar m_dampingOrthoAng;
|
btScalar m_dampingOrthoAng;
|
||||||
|
|
||||||
// for interlal use
|
// for interlal use
|
||||||
bool m_solveLinLim;
|
bool m_solveLinLim;
|
||||||
bool m_solveAngLim;
|
bool m_solveAngLim;
|
||||||
|
|
||||||
btJacobianEntry m_jacLin[3];
|
btJacobianEntry m_jacLin[3];
|
||||||
btScalar m_jacLinDiagABInv[3];
|
btScalar m_jacLinDiagABInv[3];
|
||||||
|
|
||||||
btJacobianEntry m_jacAng[3];
|
btJacobianEntry m_jacAng[3];
|
||||||
|
|
||||||
btScalar m_timeStep;
|
btScalar m_timeStep;
|
||||||
btTransform m_calculatedTransformA;
|
btTransform m_calculatedTransformA;
|
||||||
btTransform m_calculatedTransformB;
|
btTransform m_calculatedTransformB;
|
||||||
|
|
||||||
btVector3 m_sliderAxis;
|
btVector3 m_sliderAxis;
|
||||||
btVector3 m_realPivotAInW;
|
btVector3 m_realPivotAInW;
|
||||||
btVector3 m_realPivotBInW;
|
btVector3 m_realPivotBInW;
|
||||||
btVector3 m_projPivotInW;
|
btVector3 m_projPivotInW;
|
||||||
btVector3 m_delta;
|
btVector3 m_delta;
|
||||||
btVector3 m_depth;
|
btVector3 m_depth;
|
||||||
btVector3 m_relPosA;
|
btVector3 m_relPosA;
|
||||||
btVector3 m_relPosB;
|
btVector3 m_relPosB;
|
||||||
|
|
||||||
btScalar m_angDepth;
|
btScalar m_angDepth;
|
||||||
btScalar m_kAngle;
|
btScalar m_kAngle;
|
||||||
|
|
||||||
bool m_poweredLinMotor;
|
bool m_poweredLinMotor;
|
||||||
btScalar m_targetLinMotorVelocity;
|
btScalar m_targetLinMotorVelocity;
|
||||||
btScalar m_maxLinMotorForce;
|
btScalar m_maxLinMotorForce;
|
||||||
btScalar m_accumulatedLinMotorImpulse;
|
btScalar m_accumulatedLinMotorImpulse;
|
||||||
|
|
||||||
bool m_poweredAngMotor;
|
bool m_poweredAngMotor;
|
||||||
btScalar m_targetAngMotorVelocity;
|
btScalar m_targetAngMotorVelocity;
|
||||||
btScalar m_maxAngMotorForce;
|
btScalar m_maxAngMotorForce;
|
||||||
btScalar m_accumulatedAngMotorImpulse;
|
btScalar m_accumulatedAngMotorImpulse;
|
||||||
|
|
||||||
//------------------------
|
//------------------------
|
||||||
void initParams();
|
void initParams();
|
||||||
public:
|
public:
|
||||||
// constructors
|
// constructors
|
||||||
btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
|
btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
|
||||||
btSliderConstraint();
|
btSliderConstraint();
|
||||||
// overrides
|
// overrides
|
||||||
virtual void buildJacobian();
|
virtual void buildJacobian();
|
||||||
virtual void solveConstraint(btScalar timeStep);
|
virtual void solveConstraint(btScalar timeStep);
|
||||||
// access
|
// access
|
||||||
const btRigidBody& getRigidBodyA() const { return m_rbA; }
|
const btRigidBody& getRigidBodyA() const { return m_rbA; }
|
||||||
const btRigidBody& getRigidBodyB() const { return m_rbB; }
|
const btRigidBody& getRigidBodyB() const { return m_rbB; }
|
||||||
const btTransform & getCalculatedTransformA() const { return m_calculatedTransformA; }
|
const btTransform & getCalculatedTransformA() const { return m_calculatedTransformA; }
|
||||||
const btTransform & getCalculatedTransformB() const { return m_calculatedTransformB; }
|
const btTransform & getCalculatedTransformB() const { return m_calculatedTransformB; }
|
||||||
const btTransform & getFrameOffsetA() const { return m_frameInA; }
|
const btTransform & getFrameOffsetA() const { return m_frameInA; }
|
||||||
const btTransform & getFrameOffsetB() const { return m_frameInB; }
|
const btTransform & getFrameOffsetB() const { return m_frameInB; }
|
||||||
btTransform & getFrameOffsetA() { return m_frameInA; }
|
btTransform & getFrameOffsetA() { return m_frameInA; }
|
||||||
btTransform & getFrameOffsetB() { return m_frameInB; }
|
btTransform & getFrameOffsetB() { return m_frameInB; }
|
||||||
btScalar getLowerLinLimit() { return m_lowerLinLimit; }
|
btScalar getLowerLinLimit() { return m_lowerLinLimit; }
|
||||||
void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; }
|
void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; }
|
||||||
btScalar getUpperLinLimit() { return m_upperLinLimit; }
|
btScalar getUpperLinLimit() { return m_upperLinLimit; }
|
||||||
void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; }
|
void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; }
|
||||||
btScalar getLowerAngLimit() { return m_lowerAngLimit; }
|
btScalar getLowerAngLimit() { return m_lowerAngLimit; }
|
||||||
void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = lowerLimit; }
|
void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = lowerLimit; }
|
||||||
btScalar getUpperAngLimit() { return m_upperAngLimit; }
|
btScalar getUpperAngLimit() { return m_upperAngLimit; }
|
||||||
void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = upperLimit; }
|
void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = upperLimit; }
|
||||||
bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFrameA; }
|
bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFrameA; }
|
||||||
btScalar getSoftnessDirLin() { return m_softnessDirLin; }
|
btScalar getSoftnessDirLin() { return m_softnessDirLin; }
|
||||||
btScalar getRestitutionDirLin() { return m_restitutionDirLin; }
|
btScalar getRestitutionDirLin() { return m_restitutionDirLin; }
|
||||||
btScalar getDampingDirLin() { return m_dampingDirLin ; }
|
btScalar getDampingDirLin() { return m_dampingDirLin ; }
|
||||||
btScalar getSoftnessDirAng() { return m_softnessDirAng; }
|
btScalar getSoftnessDirAng() { return m_softnessDirAng; }
|
||||||
btScalar getRestitutionDirAng() { return m_restitutionDirAng; }
|
btScalar getRestitutionDirAng() { return m_restitutionDirAng; }
|
||||||
btScalar getDampingDirAng() { return m_dampingDirAng; }
|
btScalar getDampingDirAng() { return m_dampingDirAng; }
|
||||||
btScalar getSoftnessLimLin() { return m_softnessLimLin; }
|
btScalar getSoftnessLimLin() { return m_softnessLimLin; }
|
||||||
btScalar getRestitutionLimLin() { return m_restitutionLimLin; }
|
btScalar getRestitutionLimLin() { return m_restitutionLimLin; }
|
||||||
btScalar getDampingLimLin() { return m_dampingLimLin; }
|
btScalar getDampingLimLin() { return m_dampingLimLin; }
|
||||||
btScalar getSoftnessLimAng() { return m_softnessLimAng; }
|
btScalar getSoftnessLimAng() { return m_softnessLimAng; }
|
||||||
btScalar getRestitutionLimAng() { return m_restitutionLimAng; }
|
btScalar getRestitutionLimAng() { return m_restitutionLimAng; }
|
||||||
btScalar getDampingLimAng() { return m_dampingLimAng; }
|
btScalar getDampingLimAng() { return m_dampingLimAng; }
|
||||||
btScalar getSoftnessOrthoLin() { return m_softnessOrthoLin; }
|
btScalar getSoftnessOrthoLin() { return m_softnessOrthoLin; }
|
||||||
btScalar getRestitutionOrthoLin() { return m_restitutionOrthoLin; }
|
btScalar getRestitutionOrthoLin() { return m_restitutionOrthoLin; }
|
||||||
btScalar getDampingOrthoLin() { return m_dampingOrthoLin; }
|
btScalar getDampingOrthoLin() { return m_dampingOrthoLin; }
|
||||||
btScalar getSoftnessOrthoAng() { return m_softnessOrthoAng; }
|
btScalar getSoftnessOrthoAng() { return m_softnessOrthoAng; }
|
||||||
btScalar getRestitutionOrthoAng() { return m_restitutionOrthoAng; }
|
btScalar getRestitutionOrthoAng() { return m_restitutionOrthoAng; }
|
||||||
btScalar getDampingOrthoAng() { return m_dampingOrthoAng; }
|
btScalar getDampingOrthoAng() { return m_dampingOrthoAng; }
|
||||||
void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; }
|
void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; }
|
||||||
void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; }
|
void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; }
|
||||||
void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; }
|
void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; }
|
||||||
void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; }
|
void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; }
|
||||||
void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; }
|
void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; }
|
||||||
void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; }
|
void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; }
|
||||||
void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; }
|
void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; }
|
||||||
void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; }
|
void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; }
|
||||||
void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; }
|
void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; }
|
||||||
void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; }
|
void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; }
|
||||||
void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; }
|
void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; }
|
||||||
void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; }
|
void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; }
|
||||||
void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; }
|
void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; }
|
||||||
void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; }
|
void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; }
|
||||||
void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; }
|
void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; }
|
||||||
void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; }
|
void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; }
|
||||||
void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; }
|
void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; }
|
||||||
void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; }
|
void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; }
|
||||||
void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; }
|
void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; }
|
||||||
bool getPoweredLinMotor() { return m_poweredLinMotor; }
|
bool getPoweredLinMotor() { return m_poweredLinMotor; }
|
||||||
void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; }
|
void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; }
|
||||||
btScalar getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; }
|
btScalar getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; }
|
||||||
void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; }
|
void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; }
|
||||||
btScalar getMaxLinMotorForce() { return m_maxLinMotorForce; }
|
btScalar getMaxLinMotorForce() { return m_maxLinMotorForce; }
|
||||||
void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; }
|
void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; }
|
||||||
bool getPoweredAngMotor() { return m_poweredAngMotor; }
|
bool getPoweredAngMotor() { return m_poweredAngMotor; }
|
||||||
void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; }
|
void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; }
|
||||||
btScalar getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; }
|
btScalar getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; }
|
||||||
void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
|
void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
|
||||||
btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
|
btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
|
||||||
|
|
||||||
// access for ODE solver
|
// access for ODE solver
|
||||||
bool getSolveLinLimit() { return m_solveLinLim; }
|
bool getSolveLinLimit() { return m_solveLinLim; }
|
||||||
btScalar getLinDepth() { return m_depth[0]; }
|
btScalar getLinDepth() { return m_depth[0]; }
|
||||||
bool getSolveAngLimit() { return m_solveAngLim; }
|
bool getSolveAngLimit() { return m_solveAngLim; }
|
||||||
btScalar getAngDepth() { return m_angDepth; }
|
btScalar getAngDepth() { return m_angDepth; }
|
||||||
// internal
|
// internal
|
||||||
void buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB);
|
void buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB);
|
||||||
void solveConstraintInt(btRigidBody& rbA, btRigidBody& rbB);
|
void solveConstraintInt(btRigidBody& rbA, btRigidBody& rbB);
|
||||||
// shared code used by ODE solver
|
// shared code used by ODE solver
|
||||||
void calculateTransforms(void);
|
void calculateTransforms(void);
|
||||||
void testLinLimits(void);
|
void testLinLimits(void);
|
||||||
void testAngLimits(void);
|
void testAngLimits(void);
|
||||||
};
|
// access for PE Solver
|
||||||
|
btVector3 getAncorInA(void);
|
||||||
//-----------------------------------------------------------------------------
|
btVector3 getAncorInB(void);
|
||||||
|
};
|
||||||
#endif //SLIDER_CONSTRAINT_H
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
|
#endif //SLIDER_CONSTRAINT_H
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user