Joint.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2007 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_JOINT_HPP
#define PLAYRHO_DYNAMICS_JOINTS_JOINT_HPP
 
#include <PlayRho/Common/Math.hpp>
 
#include <unordered_map>
#include <vector>
#include <utility>
#include <stdexcept>
 
namespace playrho {
class StepConf;
struct ConstraintSolverConf;
 
namespace d2 {
 
class Body;
struct Velocity;
class BodyConstraint;
class JointVisitor;
struct JointConf;
 
 
using BodyConstraintPtr = BodyConstraint*;
 
using BodyConstraintPair = std::pair<const Body*, BodyConstraintPtr>;
 
// #define USE_VECTOR_MAP
 
using BodyConstraintsMap =
#ifdef USE_VECTOR_MAP
    std::vector<std::pair<const Body*, BodyConstraintPtr>>;
#else
    std::unordered_map<const Body*, BodyConstraint*>;
#endif
 
class Joint
{
public:
    
    enum LimitState
    {
        e_inactiveLimit,
 
        e_atLowerLimit,
        
        e_atUpperLimit,
        
        e_equalLimits
    };
 
    static bool IsOkay(const JointConf& def) noexcept;
 
    virtual ~Joint() noexcept = default;
 
    Body* GetBodyA() const noexcept;
 
    Body* GetBodyB() const noexcept;
 
    virtual Length2 GetAnchorA() const = 0;
 
    virtual Length2 GetAnchorB() const = 0;
 
    virtual Momentum2 GetLinearReaction() const = 0;
 
    virtual AngularMomentum GetAngularReaction() const = 0;
    
    virtual void Accept(JointVisitor& visitor) const = 0;
    
    virtual void Accept(JointVisitor& visitor) = 0;
 
    void* GetUserData() const noexcept;
 
    void SetUserData(void* data) noexcept;
 
    bool GetCollideConnected() const noexcept;
 
    virtual bool ShiftOrigin(const Length2) { return false;  }
 
protected:
    
    explicit Joint(const JointConf& def);
 
private:
    friend class JointAtty;
 
    using FlagsType = std::uint8_t;
 
    enum Flag: FlagsType
    {
        // Used when crawling contact graph when forming islands.
        e_islandFlag = 0x01u,
 
        e_collideConnectedFlag = 0x02u
    };
 
    static FlagsType GetFlags(const JointConf& def) noexcept;
 
    template <class OUT_TYPE, class IN_TYPE>
    static OUT_TYPE* Create(IN_TYPE def)
    {
        if (OUT_TYPE::IsOkay(def))
        {
            return new OUT_TYPE(def);
        }
        throw InvalidArgument("definition not okay");
    }
    
    static Joint* Create(const JointConf& def);
 
    static void Destroy(const Joint* joint) noexcept;
 
    virtual void InitVelocityConstraints(BodyConstraintsMap& bodies,
                                         const playrho::StepConf& step,
                                         const ConstraintSolverConf& conf) = 0;
 
    virtual bool SolveVelocityConstraints(BodyConstraintsMap& bodies,
                                          const playrho::StepConf& step) = 0;
 
    virtual bool SolvePositionConstraints(BodyConstraintsMap& bodies,
                                          const ConstraintSolverConf& conf) const = 0;
 
    bool IsIslanded() const noexcept;
    
    void SetIslanded() noexcept;
    
    void UnsetIslanded() noexcept;
 
    Body* const m_bodyA; 
    Body* const m_bodyB; 
    void* m_userData; 
    FlagsType m_flags = 0u; 
};
 
inline Body* Joint::GetBodyA() const noexcept
{
    return m_bodyA;
}
 
inline Body* Joint::GetBodyB() const noexcept
{
    return m_bodyB;
}
 
inline void* Joint::GetUserData() const noexcept
{
    return m_userData;
}
 
inline void Joint::SetUserData(void* data) noexcept
{
    m_userData = data;
}
 
inline bool Joint::GetCollideConnected() const noexcept
{
    return (m_flags & e_collideConnectedFlag) != 0u;
}
 
inline bool Joint::IsIslanded() const noexcept
{
    return (m_flags & e_islandFlag) != 0u;
}
 
inline void Joint::SetIslanded() noexcept
{
    m_flags |= e_islandFlag;
}
 
inline void Joint::UnsetIslanded() noexcept
{
    m_flags &= ~e_islandFlag;
}
 
// Free functions...
 
bool IsEnabled(const Joint& j) noexcept;
 
void SetAwake(Joint& j) noexcept;
 
JointCounter GetWorldIndex(const Joint* joint);
 
#ifdef PLAYRHO_PROVIDE_VECTOR_AT
BodyConstraintPtr& At(std::vector<BodyConstraintPair>& container, const Body* key);
#endif
 
BodyConstraintPtr& At(std::unordered_map<const Body*, BodyConstraint*>& container,
                      const Body* key);
 
const char* ToString(Joint::LimitState val) noexcept;
 
template <class T>
inline void IncMotorSpeed(T& j, AngularVelocity delta)
{
    j.SetMotorSpeed(j.GetMotorSpeed() + delta);
}
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_DYNAMICS_JOINTS_JOINT_HPP