RigidBody.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/Component.h"
#include "ncengine/ecs/Transform.h"
#include "ncengine/physics/Constraints.h"
#include "ncengine/physics/Vehicle.h"
#include "ncengine/physics/Shape.h"
 
namespace nc
{
namespace physics
{
struct ComponentContext;
} // namespace physics
 
using BodyHandle = void*;
 
struct DegreeOfFreedom
{
    using Type = uint8_t;
 
    static constexpr Type All          = 0b00111111;
    static constexpr Type TranslationX = 0b00000001;
    static constexpr Type TranslationY = 0b00000010;
    static constexpr Type TranslationZ = 0b00000100;
    static constexpr Type Translation  = 0b00000111;
    static constexpr Type RotationX    = 0b00001000;
    static constexpr Type RotationY    = 0b00010000;
    static constexpr Type RotationZ    = 0b00100000;
    static constexpr Type Rotation     = 0b00111000;
};
 
struct RigidBodyFlags
{
    using Type = uint8_t;
 
    static constexpr Type None = 0x0;
 
    static constexpr Type Trigger = 0x1;
 
    static constexpr Type ContinuousDetection = 0x2;
 
    static constexpr Type IgnoreTransformScaling = 0x4;
 
    static constexpr Type DisableSleeping = 0x8;
};
 
enum class BodyType : uint8_t
{
    Dynamic,   
    Kinematic, 
    Static     
};
 
struct RigidBodyInfo
{
    float mass = 1000.0f;                                 
    float friction = 0.4f;                                
    float restitution = 0.0f;                             
    float linearDamping = 0.0f;                           
    float angularDamping = 0.0f;                          
    float gravityMultiplier = 1.0f;                       
    BodyType type = BodyType::Dynamic;                    
    DegreeOfFreedom::Type freedom = DegreeOfFreedom::All; 
    RigidBodyFlags::Type flags = RigidBodyFlags::None;    
};
 
class RigidBody
{
    public:
        RigidBody(Entity self,
                  const Shape& shape = Shape::MakeBox(),
                  const RigidBodyInfo& info = RigidBodyInfo{})
            : m_self{self},
              m_shape{shape},
              m_info{info}
        {
            if (self.IsStatic())
            {
                m_info.type = BodyType::Static;
            }
 
            constexpr auto exclusiveFlags = RigidBodyFlags::Trigger | RigidBodyFlags::ContinuousDetection;
            if ((m_info.flags & exclusiveFlags) == exclusiveFlags)
            {
                m_info.flags &= ~RigidBodyFlags::ContinuousDetection;
            }
 
            VerifyShapeSettings();
        }
 
        RigidBody(RigidBody&& other) noexcept
            : m_self{std::exchange(other.m_self, Entity::Null())},
              m_handle{std::exchange(other.m_handle, nullptr)},
              m_shape{other.m_shape},
              m_info{other.m_info}
        {
        }
 
        RigidBody& operator=(RigidBody&& other) noexcept
        {
            if (this != &other)
            {
                m_self = std::exchange(other.m_self, Entity::Null());
                m_handle = std::exchange(other.m_handle, nullptr);
                m_shape = other.m_shape;
                m_info = other.m_info;
            }
 
            return *this;
        }
 
        RigidBody(RigidBody&) = delete;
        RigidBody& operator=(RigidBody&) = delete;
 
        auto GetEntity() const -> Entity { return m_self; }
        auto GetInfo() const -> const RigidBodyInfo& { return m_info; }
 
        auto GetBodyType() const -> BodyType { return m_info.type; }
        void SetBodyType(BodyType type, bool wake = true);
 
        auto GetDegreesOfFreedom() const -> DegreeOfFreedom::Type { return m_info.freedom; }
        void SetDegreesOfFreedom(DegreeOfFreedom::Type dof);
 
        auto GetShape() const -> const Shape& { return m_shape; }
        void SetShape(const Shape& shape, const Vector3& transformScale, bool wake = true);
 
        auto IsAwake() const -> bool;
        void SetAwakeState(bool wake);
        auto GetFriction() const -> float { return m_info.friction; }
        void SetFriction(float friction);
        auto GetRestitution() const -> float { return m_info.restitution; }
        void SetRestitution(float restitution);
        auto GetGravityMultiplier() const -> float { return m_info.gravityMultiplier; }
        void SetGravityMultiplier(float factor);
 
        auto GetMass() const -> float { return m_info.mass; }
        void SetMass(float mass);
        auto GetLinearDamping() const -> float { return m_info.linearDamping; }
        void SetLinearDamping(float damping);
        auto GetAngularDamping() const -> float { return m_info.angularDamping; }
        void SetAngularDamping(float damping);
 
        auto IsTrigger() const -> bool { return m_info.flags & RigidBodyFlags::Trigger; }
        void SetTrigger(bool value);
        auto UseContinuousDetection() const -> bool { return m_info.flags & RigidBodyFlags::ContinuousDetection; }
        void UseContinuousDetection(bool value);
        auto ScalesWithTransform() const -> bool { return !IgnoreTransformScaling(); }
        auto IgnoreTransformScaling() const -> bool { return m_info.flags & RigidBodyFlags::IgnoreTransformScaling; }
        void IgnoreTransformScaling(bool value);
        auto DisableSleeping() const -> bool { return m_info.flags & RigidBodyFlags::DisableSleeping; }
        void DisableSleeping(bool value);
 
        auto GetLinearVelocity() const -> Vector3;
        void SetLinearVelocity(const Vector3& velocity);
        void AddLinearVelocity(const Vector3& velocity);
        auto GetAngularVelocity() const -> Vector3;
        void SetAngularVelocity(const Vector3& velocity);
        void SetVelocities(const Vector3& linearVelocity, const Vector3& angularVelocity);
        void AddVelocities(const Vector3& linearVelocity, const Vector3& angularVelocity);
 
        void AddForce(const Vector3& force);
        void AddForceAt(const Vector3& force, const Vector3& point);
        void AddTorque(const Vector3& torque);
        void AddImpulse(const Vector3& impulse);
        void AddImpulseAt(const Vector3& impulse, const Vector3& point);
        void AddAngularImpulse(const Vector3& impulse);
 
        auto AddConstraint(const ConstraintInfo& createInfo, const RigidBody& otherBody) -> Constraint&;
 
        auto AddConstraint(const ConstraintInfo& createInfo) -> Constraint&;
 
        void RemoveConstraint(ConstraintId constraintId);
 
        auto GetConstraints()       -> std::span<Constraint>;
        auto GetConstraints() const -> std::span<const Constraint>;
 
        auto AddVehicle(VehicleInfo createInfo) -> Vehicle&;
        void RemoveVehicle();
        auto GetVehicle()       ->       Vehicle*;
        auto GetVehicle() const -> const Vehicle*;
 
        void SetSimulatedBodyPosition(Transform& transform, const Vector3& position, bool wake = true);
 
        void SetSimulatedBodyRotation(Transform& transform, const Quaternion& rotation, bool wake = true);
 
        auto SetSimulatedBodyScale(Transform& transform, const Vector3& scale, bool wake = true) -> Vector3; // End Simulated Body Functions
 
        auto IsInitialized() const noexcept -> bool { return m_handle; }
        auto GetHandle() const -> BodyHandle { return m_handle; }
        void SetHandle(BodyHandle handle) { m_handle = handle; }
        static void SetContext(physics::ComponentContext* ctx) { s_ctx = ctx; }
    private:
        inline static physics::ComponentContext* s_ctx = nullptr;
 
        Entity m_self;
        BodyHandle m_handle = nullptr;
        Shape m_shape;
        RigidBodyInfo m_info;
 
        void VerifyShapeSettings();
};
 
template<>
struct StoragePolicy<RigidBody> : DefaultStoragePolicy
{
    static constexpr bool EnableOnAddCallbacks = true;
    static constexpr bool EnableOnCommitCallbacks = false;
    static constexpr bool EnableOnRemoveCallbacks = true;
};
} // namespace nc