Body.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Mesh/Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Any.hpp"
 
#include "CeresEngine/Entity/Action.hpp"
#include "CeresEngine/Entity/Component.hpp"
#include "CeresEngine/Math/Math.hpp"
#include "CeresEngine/Resource/ResourceHandle.hpp"
#include "CeresEngine/Scene/Motion.hpp"
#include "CeresEngine/Scene/SceneObject.hpp"
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() RigidBodyComponent final : public Component<RigidBodyComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
        CE_SCRIPT_EXPORT()
        double mass = 0.0;
 
        CE_SCRIPT_EXPORT()
        Vector3 localInertia;
 
        CE_SCRIPT_EXPORT()
        double linearDamping;
 
        CE_SCRIPT_EXPORT()
        double angularDamping;
 
        CE_SCRIPT_EXPORT()
        double friction;
 
        CE_SCRIPT_EXPORT()
        double rollingFriction;
 
        CE_SCRIPT_EXPORT()
        double spinningFriction;
 
        CE_SCRIPT_EXPORT()
        double restitution;
 
        CE_SCRIPT_EXPORT()
        bool fixed = false;
 
        HMesh mesh = nullptr;
 
        Any engineContext;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(mass);
            CE_REFL_DATA(localInertia);
            CE_REFL_DATA(linearDamping);
            CE_REFL_DATA(angularDamping);
            CE_REFL_DATA(friction);
            CE_REFL_DATA(rollingFriction);
            CE_REFL_DATA(spinningFriction);
            CE_REFL_DATA(restitution);
            CE_REFL_DATA(fixed);
            CE_REFL_DATA(mesh);
        }
    };
 
    struct RigidBodyComponent::Accessor : public Component<RigidBodyComponent>::Accessor {
        using Component<RigidBodyComponent>::Accessor::Accessor;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getMass() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setMass(double mass) noexcept;
 
        [[nodiscard]] Vector3 getLocalInertia() const;
 
        void setLocalInertia(Vector3 localInertia);
 
        [[nodiscard]] double getLinearDamping() const;
 
        void setLinearDamping(double linearDamping);
 
        [[nodiscard]] double getAngularDamping() const;
 
        void setAngularDamping(double angularDamping);
 
        [[nodiscard]] double getFriction() const;
 
        void setFriction(double friction);
 
        [[nodiscard]] double getRollingFriction() const;
 
        void setRollingFriction(double rollingFriction);
 
        [[nodiscard]] double getSpinningFriction() const;
 
        void setSpinningFriction(double spinningFriction);
 
        [[nodiscard]] double getRestitution() const;
 
        void setRestitution(double restitution);
 
        [[nodiscard]] bool isFixed() const;
 
        void setFixed(bool fixed);
 
        [[nodiscard]] const HMesh& getMesh() const;
 
        void setMesh(HMesh mesh);
 
        CE_SCRIPT_EXPORT()
        void applyForce(Vector3 force, Vector3 relativePosition = Vector3(0.0)) const;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA_GETSET(mass, getMass, setMass);
            CE_REFL_DATA_GETSET(localInertia, getLocalInertia, setLocalInertia);
            CE_REFL_DATA_GETSET(linearDamping, getLinearDamping, setLinearDamping);
            CE_REFL_DATA_GETSET(angularDamping, getAngularDamping, setAngularDamping);
            CE_REFL_DATA_GETSET(friction, getFriction, setFriction);
            CE_REFL_DATA_GETSET(rollingFriction, getRollingFriction, setRollingFriction);
            CE_REFL_DATA_GETSET(spinningFriction, getSpinningFriction, setSpinningFriction);
            CE_REFL_DATA_GETSET(restitution, getRestitution, setRestitution);
            CE_REFL_DATA_GETSET(fixed, isFixed, setFixed);
            CE_REFL_DATA_GETSET(mesh, getMesh, setMesh);
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct CE_SCRIPT_EXPORT() SoftBodyComponent final : public Component<SoftBodyComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            //            CE_REFL_DATA(mass);
        }
    };
 
    struct SoftBodyComponent::Accessor : public Component<SoftBodyComponent>::Accessor {
        using Component<SoftBodyComponent>::Accessor::Accessor;
 
        CE_SCRIPT_EXPORT()
        void applyForce(Vector3 force, Vector3 relativePosition = Vector3(0.0)) const;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            //            CE_REFL_DATA_GETSET(mass, getMass, setMass);
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct ApplyForce final : public EntityAction<ApplyForce> {
        Vector3 force;
 
        Vector3 relativePosition = Vector3(0.0);
 
        explicit ApplyForce(Vector3 force, Vector3 relativePosition = Vector3(0.0));
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class CE_SCRIPT_EXPORT() StaticBody final : public EntityObject<RigidBodyComponent, TransformComponent> {
    public:
        using EntityObject::EntityObject;
    };
 
    class CE_SCRIPT_EXPORT() RigidBody final : public EntityObject<RigidBodyComponent, Motion, TransformComponent> {
    public:
        using EntityObject::EntityObject;
    };
 
    class CE_SCRIPT_EXPORT() SoftBody final : public EntityObject<SoftBodyComponent, Motion, TransformComponent> {
    public:
        using EntityObject::EntityObject;
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::RigidBodyComponent);
 
CE_REFLECT_HASH(CeresEngine::SoftBodyComponent);
 
CE_EXTERN_COMPONENT(CeresEngine::RigidBodyComponent);
 
CE_EXTERN_COMPONENT(CeresEngine::SoftBodyComponent);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::RigidBody);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::SoftBody);