Joint.h

// Copyright (c) 2018-2019 Kiwano - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
#include <kiwano-physics/PhysicBody.h>
 
namespace kiwano
{
namespace physics
{
KGE_DECLARE_SMART_PTR(Joint);
KGE_DECLARE_SMART_PTR(DistanceJoint);
KGE_DECLARE_SMART_PTR(FrictionJoint);
KGE_DECLARE_SMART_PTR(GearJoint);
KGE_DECLARE_SMART_PTR(MotorJoint);
KGE_DECLARE_SMART_PTR(MouseJoint);
KGE_DECLARE_SMART_PTR(PrismaticJoint);
KGE_DECLARE_SMART_PTR(PulleyJoint);
KGE_DECLARE_SMART_PTR(RevoluteJoint);
KGE_DECLARE_SMART_PTR(RopeJoint);
KGE_DECLARE_SMART_PTR(WeldJoint);
KGE_DECLARE_SMART_PTR(WheelJoint);
 
class KGE_API Joint : public ObjectBase
{
public:
    enum class Type
    {
        Unknown = 0,  
        Revolute,     
        Prismatic,    
        Distance,     
        Pulley,       
        Mouse,        
        Gear,         
        Wheel,        
        Weld,         
        Friction,     
        Rope,         
        Motor         
    };
 
    struct ParamBase
    {
        PhysicBody* body_a;             
        PhysicBody* body_b;             
        bool        collide_connected;  // 关节连接的物体是否允许碰撞
 
        ParamBase(PhysicBody* body_a, PhysicBody* body_b)
            : body_a(body_a)
            , body_b(body_b)
            , collide_connected(false)
        {
        }
 
        ParamBase(PhysicBodyPtr body_a, PhysicBodyPtr body_b)
            : ParamBase(body_a.Get(), body_b.Get())
        {
        }
    };
 
    Joint();
 
    virtual ~Joint();
 
    virtual bool Init(PhysicWorld* world);
 
    bool Init(PhysicWorld* world, b2JointDef* joint_def);
 
    PhysicBodyPtr GetBodyA() const;
 
    PhysicBodyPtr GetBodyB() const;
 
    PhysicWorld* GetWorld() const;
 
    void Destroy();
 
    b2Joint* GetB2Joint() const;
 
    void SetB2Joint(b2Joint* joint);
 
private:
    b2Joint*     joint_;
    PhysicWorld* world_;
    Type         type_;
};
 
class KGE_API DistanceJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor_a;       
        Point anchor_b;       
        float frequency_hz;   
        float damping_ratio;  
 
        Param()
            : Param(nullptr, nullptr, Point(), Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor_a, const Point& anchor_b)
            : ParamBase(body_a, body_b)
            , anchor_a(anchor_a)
            , anchor_b(anchor_b)
            , frequency_hz(0.0f)
            , damping_ratio(0.0f)
        {
        }
    };
 
    DistanceJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetLength(float length);
 
    float GetLength() const;
 
    void SetFrequency(float hz);
 
    float GetFrequency() const;
 
    void SetDampingRatio(float ratio);
 
    float GetDampingRatio() const;
 
private:
    Param            param_;
    b2DistanceJoint* raw_joint_;
};
 
class KGE_API FrictionJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor;      
        float max_force;   
        float max_torque;  
 
        Param()
            : Param(nullptr, nullptr, Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor, float max_force = 0.f, float max_torque = 0.f)
            : ParamBase(body_a, body_b)
            , anchor(anchor)
            , max_force(max_force)
            , max_torque(max_torque)
        {
        }
    };
 
    FrictionJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetMaxForce(float force);
 
    float GetMaxForce() const;
 
    void SetMaxTorque(float torque);
 
    float GetMaxTorque() const;
 
private:
    Param            param_;
    b2FrictionJoint* raw_joint_;
};
 
class KGE_API GearJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Joint* joint_a;  
        Joint* joint_b;  
        float  ratio;    
 
        Param()
            : Param(nullptr, nullptr)
        {
        }
 
        Param(JointPtr joint_a, JointPtr joint_b, float ratio = 1.f)
            : ParamBase(nullptr, nullptr)
            , joint_a(joint_a.Get())
            , joint_b(joint_b.Get())
            , ratio(ratio)
        {
        }
    };
 
    GearJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetRatio(float ratio);
 
    float GetRatio() const;
 
private:
    Param        param_;
    b2GearJoint* raw_joint_;
};
 
class KGE_API MotorJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        float max_force;          
        float max_torque;         
        float correction_factor;  
 
        Param()
            : Param(nullptr, nullptr)
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, float max_force = 0.f, float max_torque = 0.f)
            : ParamBase(body_a, body_b)
            , max_force(max_force)
            , max_torque(max_torque)
            , correction_factor(0.3f)
        {
        }
    };
 
    MotorJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetMaxForce(float force);
 
    float GetMaxForce() const;
 
    void SetMaxTorque(float torque);
 
    float GetMaxTorque() const;
 
private:
    Param         param_;
    b2MotorJoint* raw_joint_;
};
 
class KGE_API PrismaticJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor;        
        Vec2  axis;          
        bool  enable_limit;  
        float lower_translation;  
        float upper_translation;  
        bool  enable_motor;     
        float max_motor_force;  
        float motor_speed;      
 
        Param()
            : Param(nullptr, nullptr, Point(), Vec2())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor, const Vec2& axis)
            : ParamBase(body_a, body_b)
            , anchor(anchor)
            , axis(axis)
            , enable_limit(false)
            , lower_translation(0.0f)
            , upper_translation(0.0f)
            , enable_motor(false)
            , max_motor_force(0.0f)
            , motor_speed(0.0f)
        {
        }
    };
 
    PrismaticJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    float GetReferenceAngle() const;
 
    float GetJointTranslation() const;
 
    float GetJointSpeed() const;
 
    bool IsLimitEnabled() const;
 
    void EnableLimit(bool flag);
 
    float GetLowerLimit() const;
 
    float GetUpperLimit() const;
 
    void SetLimits(float lower, float upper);
 
    bool IsMotorEnabled() const;
 
    void EnableMotor(bool flag);
 
    void SetMotorSpeed(float speed);
 
    float GetMotorSpeed() const;
 
    void SetMaxMotorForce(float force);
 
    float GetMaxMotorForce() const;
 
private:
    Param             param_;
    b2PrismaticJoint* raw_joint_;
};
 
class KGE_API PulleyJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor_a;         
        Point anchor_b;         
        Point ground_anchor_a;  
        Point ground_anchor_b;  
        float ratio;            
 
        Param()
            : Param(nullptr, nullptr, Point(), Point(), Point(), Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor_a, const Point& anchor_b,
              const Point& ground_anchor_a, const Point& ground_anchor_b, float ratio = 1.0f)
            : ParamBase(body_a, body_b)
            , anchor_a(anchor_a)
            , anchor_b(anchor_b)
            , ground_anchor_a(ground_anchor_a)
            , ground_anchor_b(ground_anchor_b)
            , ratio(ratio)
        {
        }
    };
 
    PulleyJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    Point GetGroundAnchorA() const;
 
    Point GetGroundAnchorB() const;
 
    float GetRatio() const;
 
    float GetLengthA() const;
 
    float GetLengthB() const;
 
    float GetCurrentLengthA() const;
 
    float GetCurrentLengthB() const;
 
private:
    Param          param_;
    b2PulleyJoint* raw_joint_;
};
 
class KGE_API RevoluteJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor;        
        bool  enable_limit;  
        float lower_angle;  
        float upper_angle;  
        bool  enable_motor;      
        float max_motor_torque;  
        float motor_speed;       
 
        Param()
            : Param(nullptr, nullptr, Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor)
            : ParamBase(body_a, body_b)
            , anchor(anchor)
            , enable_limit(false)
            , lower_angle(0.0f)
            , upper_angle(0.0f)
            , enable_motor(false)
            , max_motor_torque(0.0f)
            , motor_speed(0.0f)
        {
        }
    };
 
    RevoluteJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    float GetReferenceAngle() const;
 
    float GetJointAngle() const;
 
    float GetJointSpeed() const;
 
    bool IsLimitEnabled() const;
 
    void EnableLimit(bool flag);
 
    float GetLowerLimit() const;
 
    float GetUpperLimit() const;
 
    void SetLimits(float lower, float upper);
 
    bool IsMotorEnabled() const;
 
    void EnableMotor(bool flag);
 
    void SetMotorSpeed(float speed);
 
    float GetMotorSpeed() const;
 
    void SetMaxMotorTorque(float torque);
 
    float GetMaxMotorTorque() const;
 
private:
    Param            param_;
    b2RevoluteJoint* raw_joint_;
};
 
class KGE_API RopeJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point local_anchor_a;  
        Point local_anchor_b;  
        float max_length;      
 
        Param()
            : Param(nullptr, nullptr, Point(), Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& local_anchor_a, const Point& local_anchor_b)
            : ParamBase(body_a, body_b)
            , local_anchor_a(local_anchor_a)
            , local_anchor_b(local_anchor_b)
            , max_length(0.0f)
        {
        }
    };
 
    RopeJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetMaxLength(float length);
 
    float GetMaxLength() const;
 
private:
    Param        param_;
    b2RopeJoint* raw_joint_;
};
 
class KGE_API WeldJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor;         
        float frequency_hz;   
        float damping_ratio;  
 
        Param()
            : Param(nullptr, nullptr, Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor)
            : ParamBase(body_a, body_b)
            , anchor(anchor)
            , frequency_hz(0.0f)
            , damping_ratio(0.0f)
        {
        }
    };
 
    WeldJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    float GetReferenceAngle() const;
 
    void SetFrequency(float hz);
 
    float GetFrequency() const;
 
    void SetDampingRatio(float ratio);
 
    float GetDampingRatio() const;
 
private:
    Param        param_;
    b2WeldJoint* raw_joint_;
};
 
class KGE_API WheelJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point anchor;            
        Vec2  axis;              
        bool  enable_motor;      
        float max_motor_torque;  
        float motor_speed;       
        float frequency_hz;      
        float damping_ratio;     
 
        Param()
            : Param(nullptr, nullptr, Point(), Vec2())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& anchor, const Vec2& axis)
            : ParamBase(body_a, body_b)
            , anchor(anchor)
            , axis(axis)
            , enable_motor(false)
            , max_motor_torque(0.0f)
            , motor_speed(0.0f)
            , frequency_hz(2.0f)
            , damping_ratio(0.7f)
        {
        }
    };
 
    WheelJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    float GetJointTranslation() const;
 
    float GetJointLinearSpeed() const;
 
    float GetJointAngle() const;
 
    float GetJointAngularSpeed() const;
 
    bool IsMotorEnabled() const;
 
    void EnableMotor(bool flag);
 
    void SetMotorSpeed(float speed);
 
    float GetMotorSpeed() const;
 
    void SetMaxMotorTorque(float torque);
 
    float GetMaxMotorTorque() const;
 
    void SetSpringFrequencyHz(float hz);
 
    float GetSpringFrequencyHz() const;
 
    void SetSpringDampingRatio(float ratio);
 
    float GetSpringDampingRatio() const;
 
private:
    Param         param_;
    b2WheelJoint* raw_joint_;
};
 
class KGE_API MouseJoint : public Joint
{
public:
    struct Param : public Joint::ParamBase
    {
        Point target;         
        float max_force;      
        float frequency_hz;   
        float damping_ratio;  
 
        Param()
            : Param(nullptr, nullptr, Point())
        {
        }
 
        Param(PhysicBodyPtr body_a, PhysicBodyPtr body_b, const Point& target)
            : ParamBase(body_a, body_b)
            , target(target)
            , max_force(0.0f)
            , frequency_hz(5.0f)
            , damping_ratio(0.7f)
        {
        }
    };
 
    MouseJoint(const Param& param);
 
    bool Init(PhysicWorld* world) override;
 
    void SetMaxForce(float force);
 
    float GetMaxForce() const;
 
    void SetFrequency(float hz);
 
    float GetFrequency() const;
 
    void SetDampingRatio(float ratio);
 
    float GetDampingRatio() const;
 
private:
    Param         param_;
    b2MouseJoint* raw_joint_;
};
 
inline b2Joint* Joint::GetB2Joint() const
{
    return joint_;
}
inline PhysicWorld* Joint::GetWorld() const
{
    return world_;
}
 
inline void DistanceJoint::SetFrequency(float hz)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetFrequency(hz);
}
inline float DistanceJoint::GetFrequency() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetFrequency();
}
inline void DistanceJoint::SetDampingRatio(float ratio)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetDampingRatio(ratio);
}
inline float DistanceJoint::GetDampingRatio() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetDampingRatio();
}
 
inline float PrismaticJoint::GetReferenceAngle() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetReferenceAngle());
}
inline bool PrismaticJoint::IsLimitEnabled() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->IsLimitEnabled();
}
inline void PrismaticJoint::EnableLimit(bool flag)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->EnableLimit(flag);
}
inline bool PrismaticJoint::IsMotorEnabled() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->IsMotorEnabled();
}
inline void PrismaticJoint::EnableMotor(bool flag)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->EnableMotor(flag);
}
inline void PrismaticJoint::SetMotorSpeed(float speed)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
}
inline float PrismaticJoint::GetMotorSpeed() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetMotorSpeed());
}
inline void PrismaticJoint::SetMaxMotorForce(float force)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetMaxMotorForce(force);
}
inline float PrismaticJoint::GetMaxMotorForce() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetMaxMotorForce();
}
 
inline float RevoluteJoint::GetReferenceAngle() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetReferenceAngle());
}
inline bool RevoluteJoint::IsLimitEnabled() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->IsLimitEnabled();
}
inline void RevoluteJoint::EnableLimit(bool flag)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->EnableLimit(flag);
}
inline bool RevoluteJoint::IsMotorEnabled() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->IsMotorEnabled();
}
inline void RevoluteJoint::EnableMotor(bool flag)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->EnableMotor(flag);
}
inline void RevoluteJoint::SetMotorSpeed(float speed)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
}
inline float RevoluteJoint::GetMotorSpeed() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetMotorSpeed());
}
 
inline float WeldJoint::GetReferenceAngle() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetReferenceAngle());
}
inline void WeldJoint::SetFrequency(float hz)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetFrequency(hz);
}
inline float WeldJoint::GetFrequency() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetFrequency();
}
inline void WeldJoint::SetDampingRatio(float ratio)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetDampingRatio(ratio);
}
inline float WeldJoint::GetDampingRatio() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetDampingRatio();
}
 
inline float WheelJoint::GetJointAngle() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetJointAngle());
}
inline float WheelJoint::GetJointAngularSpeed() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetJointAngularSpeed());
}
inline bool WheelJoint::IsMotorEnabled() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->IsMotorEnabled();
}
inline void WheelJoint::EnableMotor(bool flag)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->EnableMotor(flag);
}
inline void WheelJoint::SetMotorSpeed(float speed)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
}
inline float WheelJoint::GetMotorSpeed() const
{
    KGE_ASSERT(raw_joint_);
    return math::Radian2Degree(raw_joint_->GetMotorSpeed());
}
inline void WheelJoint::SetSpringFrequencyHz(float hz)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetSpringFrequencyHz(hz);
}
inline float WheelJoint::GetSpringFrequencyHz() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetSpringFrequencyHz();
}
inline void WheelJoint::SetSpringDampingRatio(float ratio)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetSpringDampingRatio(ratio);
}
inline float WheelJoint::GetSpringDampingRatio() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetSpringDampingRatio();
}
 
inline void MouseJoint::SetFrequency(float hz)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetFrequency(hz);
}
inline float MouseJoint::GetFrequency() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetFrequency();
}
inline void MouseJoint::SetDampingRatio(float ratio)
{
    KGE_ASSERT(raw_joint_);
    raw_joint_->SetDampingRatio(ratio);
}
inline float MouseJoint::GetDampingRatio() const
{
    KGE_ASSERT(raw_joint_);
    return raw_joint_->GetDampingRatio();
}
}  // namespace physics
}  // namespace kiwano