Constraints.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/Entity.h"
#include "ncengine/physics/SpringSettings.h"
 
#include <variant>
 
namespace nc
{
class RigidBody;
 
namespace physics
{
class ConstraintManager;
} // namespace physics
 
enum class ConstraintType : uint8_t
{
    FixedConstraint,
    PointConstraint,
    DistanceConstraint,
    HingeConstraint,
    SliderConstraint,
    SwingTwistConstraint
};
 
struct FixedConstraintInfo
{
    static constexpr auto type = ConstraintType::FixedConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();  
    Vector3 ownerRight = Vector3::Right();    
    Vector3 ownerUp = Vector3::Up();          
    Vector3 targetPosition = Vector3::Zero(); 
    Vector3 targetRight = Vector3::Right();   
    Vector3 targetUp = Vector3::Up();         
};
 
struct PointConstraintInfo
{
    static constexpr auto type = ConstraintType::PointConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();  
    Vector3 targetPosition = Vector3::Zero(); 
};
 
struct DistanceConstraintInfo
{
    static constexpr auto type = ConstraintType::DistanceConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();          
    Vector3 targetPosition = Vector3::Zero();         
    float minLimit = 0.0f;                            
    float maxLimit = 1.0f;                            
    SpringSettings springSettings = SpringSettings{}; 
};
 
struct HingeConstraintInfo
{
    static constexpr auto type = ConstraintType::HingeConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();          
    Vector3 ownerHingeAxis = Vector3::Right();        
    Vector3 ownerNormalAxis = Vector3::Up();          
    Vector3 targetPosition = Vector3::Zero();         
    Vector3 targetHingeAxis = ownerHingeAxis;         
    Vector3 targetNormalAxis = ownerNormalAxis;       
    float minLimit = -std::numbers::pi_v<float>;      
    float maxLimit = std::numbers::pi_v<float>;       
    float maxFrictionTorque = 0.0f;                   
    SpringSettings springSettings = SpringSettings{}; 
};
 
struct SliderConstraintInfo
{
    static constexpr auto type = ConstraintType::SliderConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();          
    Vector3 ownerSliderAxis = Vector3::Right();       
    Vector3 ownerNormalAxis = Vector3::Up();          
    Vector3 targetPosition = Vector3::Zero();         
    Vector3 targetSliderAxis = ownerSliderAxis;       
    Vector3 targetNormalAxis = ownerNormalAxis;       
    float minLimit = -1.0f;                           
    float maxLimit = 1.0f;                            
    float maxFrictionForce = 0.0f;                    
    SpringSettings springSettings = SpringSettings{}; 
};
 
struct SwingTwistConstraintInfo
{
    static constexpr auto type = ConstraintType::SwingTwistConstraint;
 
    Vector3 ownerPosition = Vector3::Zero();      
    Vector3 ownerTwistAxis = Vector3::Right();    
    Vector3 targetPosition = Vector3::Zero();     
    Vector3 targetTwistAxis = Vector3::Right();   
    float swingLimit = std::numbers::pi_v<float>; 
    float twistLimit = std::numbers::pi_v<float>; 
    float maxFrictionTorque = 0.0f;               
};
 
using ConstraintInfo = std::variant<FixedConstraintInfo,
                                    PointConstraintInfo,
                                    DistanceConstraintInfo,
                                    HingeConstraintInfo,
                                    SliderConstraintInfo,
                                    SwingTwistConstraintInfo>;
 
using ConstraintId = uint32_t;
 
class Constraint
{
    public:
        explicit Constraint(const ConstraintInfo& info,
                            Entity otherBody,
                            ConstraintId id)
            : m_info{info},
              m_otherBody{otherBody},
              m_id{id}
        {
        }
 
        auto GetInfo() -> ConstraintInfo& { return m_info; }
        auto GetInfo() const -> const ConstraintInfo& { return m_info; }
 
        auto GetType() const -> ConstraintType;
 
        void NotifyUpdateInfo();
 
        void SetConstraintTarget(RigidBody* otherBody = nullptr);
        auto GetConstraintTarget() const -> Entity { return m_otherBody; }
 
        void Enable(bool enabled);
        auto IsEnabled() const -> bool { return m_enabled; }
 
        auto GetId() const -> ConstraintId { return m_id; }
 
    private:
        friend class physics::ConstraintManager;
        inline static physics::ConstraintManager* s_manager = nullptr;
 
        ConstraintInfo m_info;
        Entity m_otherBody;
        ConstraintId m_id;
        bool m_enabled = true;
};
} // namespace nc