RevoluteJoint.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
 * Modified work Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * 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.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, 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.
 * 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.
 */
 
#ifndef PLAYRHO_DYNAMICS_JOINTS_REVOLUTEJOINT_HPP
#define PLAYRHO_DYNAMICS_JOINTS_REVOLUTEJOINT_HPP
 
#include <PlayRho/Dynamics/Joints/Joint.hpp>
#include <PlayRho/Dynamics/Joints/RevoluteJointConf.hpp>
 
namespace playrho {
namespace d2 {
 
class RevoluteJoint : public Joint
{
public:
    
    RevoluteJoint(const RevoluteJointConf& def);
    
    void Accept(JointVisitor& visitor) const override;
    void Accept(JointVisitor& visitor) override;
 
    Length2 GetAnchorA() const override;
    Length2 GetAnchorB() const override;
 
    Length2 GetLocalAnchorA() const noexcept { return m_localAnchorA; }
 
    Length2 GetLocalAnchorB() const noexcept { return m_localAnchorB; }
 
    Angle GetReferenceAngle() const noexcept { return m_referenceAngle; }
 
    bool IsLimitEnabled() const noexcept;
 
    void EnableLimit(bool flag);
 
    Angle GetLowerLimit() const noexcept;
 
    Angle GetUpperLimit() const noexcept;
 
    void SetLimits(Angle lower, Angle upper);
 
    bool IsMotorEnabled() const noexcept;
 
    void EnableMotor(bool flag);
 
    void SetMotorSpeed(AngularVelocity speed);
 
    AngularVelocity GetMotorSpeed() const noexcept;
 
    void SetMaxMotorTorque(Torque torque);
 
    Torque GetMaxMotorTorque() const noexcept;
 
    Momentum2 GetLinearReaction() const override;
 
    AngularMomentum GetAngularReaction() const override;
 
    AngularMomentum GetMotorImpulse() const noexcept;
    
    LimitState GetLimitState() const noexcept;
 
private:
    
    void InitVelocityConstraints(BodyConstraintsMap& bodies,
                                 const StepConf& step, const ConstraintSolverConf& conf) override;
 
    bool SolveVelocityConstraints(BodyConstraintsMap& bodies, const StepConf& step) override;
    
    bool SolvePositionConstraints(BodyConstraintsMap& bodies,
                                  const ConstraintSolverConf& conf) const override;
 
    // Solver shared
    Length2 m_localAnchorA; 
    Length2 m_localAnchorB; 
 
    Vec3 m_impulse = Vec3{};
    
    AngularMomentum m_motorImpulse = 0;
 
    bool m_enableMotor; 
    Torque m_maxMotorTorque; 
    AngularVelocity m_motorSpeed; 
 
    bool m_enableLimit; 
    Angle m_referenceAngle; 
    Angle m_lowerAngle; 
    Angle m_upperAngle; 
 
    // Solver cached temporary data. Values set by by InitVelocityConstraints.
 
    Length2 m_rA; 
    Length2 m_rB; 
    Mat33 m_mass; 
    RotInertia m_motorMass; 
    LimitState m_limitState = e_inactiveLimit; 
};
 
inline bool RevoluteJoint::IsLimitEnabled() const noexcept
{
    return m_enableLimit;
}
 
inline Angle RevoluteJoint::GetLowerLimit() const noexcept
{
    return m_lowerAngle;
}
 
inline Angle RevoluteJoint::GetUpperLimit() const noexcept
{
    return m_upperAngle;
}
 
inline bool RevoluteJoint::IsMotorEnabled() const noexcept
{
    return m_enableMotor;
}
 
inline AngularVelocity RevoluteJoint::GetMotorSpeed() const noexcept
{
    return m_motorSpeed;
}
 
inline Torque RevoluteJoint::GetMaxMotorTorque() const noexcept
{
    return m_maxMotorTorque;
}
 
inline Joint::LimitState RevoluteJoint::GetLimitState() const noexcept
{
    return m_limitState;
}
 
inline AngularMomentum RevoluteJoint::GetMotorImpulse() const noexcept
{
    return m_motorImpulse;
}
 
// Free functions...
 
Angle GetJointAngle(const RevoluteJoint& joint);
    
AngularVelocity GetAngularVelocity(const RevoluteJoint& joint);
 
inline Torque GetMotorTorque(const RevoluteJoint& joint, Frequency inv_dt) noexcept
{
    return joint.GetMotorImpulse() * inv_dt;
}
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_DYNAMICS_JOINTS_REVOLUTEJOINT_HPP