ecs.hpp

#ifndef __ECS_H__
#define __ECS_H__ 1
 
#pragma once
 
#include <cstddef>
#include <vector>
#include <optional>
#include <memory>
#include <string>
#include "raftel/imguiRenderer.hpp"
#include <raftel/global_macros.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>
#include <raftel/components.hpp>
 
namespace Raftel {
    class Camera;
    class Mesh;
    class ShaderProgram;
    class EntityManager; 
 
    constexpr size_t MAX_ENTITIES = 200;

    class Entity {
    public:
        size_t ID; 

        void addTransformComp(TransformComponent&& trans); 

        std::optional<TransformComponent>& getTransformComp();

        const std::optional<TransformComponent>& getTransformComp() const;

        void addScriptComp(ScriptComponent&& script);

        std::optional<ScriptComponent>& getScriptComp();

        void addRenderComp(RenderComponent&& rend);

        void addMeshComp(const std::shared_ptr<Mesh>& mesh);
        bool hasMeshComp() const;
        bool hasTransformComp() const;
        bool hasRenderComp() const;
        bool hasLightComp() const;
        bool hasScriptComp() const;

        void removeMeshComp();

        void addLightComp(LightComponent&& light);
        std::optional<LightComponent>& getLightComp();
        const std::optional<LightComponent>& getLightComp() const;

        std::optional<MeshComponent> getMeshComp() const;

        Entity(const Entity& other) = default;

        Entity(Entity&& other) noexcept = default;

        Entity& operator=(const Entity& other) = default;

        Entity& operator=(Entity&& other) noexcept = default;
 
        //COPYABLE_AND_MOVABLE(Entity)
    private:
        friend class EntityManager;
        EntityManager* em; 

        Entity(size_t ID, EntityManager* em);

        void setPosition(const glm::vec3& pos);

        glm::vec3 getPosition() const;

        void setRotation(const glm::vec3& rot);

        glm::vec3 getRotation() const;

        void setScale(const glm::vec3& scale);

        glm::vec3 getScale() const;

        void setMesh(const std::shared_ptr<Mesh>& mesh);

        std::optional<MeshComponent> getMesh() const;

        void moveTo(const glm::vec3& target, float speed);
    };

    class EntityManager {
    public:
        EntityManager();

        Entity CreateEntity();

        const std::vector<Entity>& getActiveEntities() const;
        std::vector<Entity>& getActiveEntities();

        void Update(float deltaTime);

        void setPosition(size_t ID, const glm::vec3& pos);

        glm::vec3 getPosition(size_t ID) const;

        void setRotation(size_t ID, const glm::vec3& rot);

        glm::vec3 getRotation(size_t ID) const;

        void setScale(size_t ID, const glm::vec3& scale);

        glm::vec3 getScale(size_t ID) const;

        void setMesh(size_t ID, const std::shared_ptr<Mesh>& mesh);

        std::optional<MeshComponent> getMesh(size_t ID) const;

        void moveTo(size_t ID, const glm::vec3& target, float speed);

        void constantStraightMovement(size_t ID, float speed, bool isHorizontal);

        void addMeshComp(size_t ID, const std::shared_ptr<Mesh>& mesh);

        std::optional<MeshComponent> getMeshComponent(size_t ID);

        bool hasMeshComponent(size_t ID) const;

        void removeMeshComponent(size_t ID);

        void addTransformComp(size_t ID, TransformComponent&& trans);

        void addRenderComp(size_t ID, RenderComponent&& rend);

        void addScriptComp(size_t ID, ScriptComponent&& script);

        void addLightComp(size_t ID, LightComponent&& light);

        std::optional<Raftel::LightComponent>& getLightComponent(size_t ID);

        void removeEntity(size_t id);
        void removeTransformComp(size_t ID);

        void removeLightComp(size_t ID);

        void removeRenderComp(size_t ID);

        void removeScriptComp(size_t ID);

        std::optional<ScriptComponent>& getScriptComponent(size_t ID);

        std::optional<TransformComponent>& getTransformComponent(size_t ID);

        std::optional<RenderComponent>& getRenderComponent(size_t ID);
 
    private:
        friend class RenderSystem;
        friend class Editor;
 
        friend void UpdateRenderSystem(EntityManager& em, Camera& cam, ShaderProgram& shader, glm::ivec2 screen, bool shadow);
        friend void UpdateTransformSystem(EntityManager& em);
        friend void UpdateScriptingSystem(EntityManager& em);
        friend void UpdateLightSystem(EntityManager& em, ShaderProgram& lit_shader, Camera& cam);
 
        friend bool Entity::hasLightComp() const;
 
        std::vector<std::optional<ScriptComponent>> scriptComps;
        std::vector<std::optional<TransformComponent>> transformComps;
        std::vector<std::optional<RenderComponent>> renderComps;
        std::vector<std::optional<MeshComponent>> meshComps;
        std::vector<std::optional<LightComponent>> lightComps;
        std::vector<std::optional<BasicComponent>> basicComps;
 
        std::vector<Entity> activeEntities; 
        size_t lastEntity = 0; 
 
        MOVABLE_BUT_NOT_COPYABLE(EntityManager);
    };
 
 
    int pickEntity(const std::unique_ptr<EntityManager>& ecs, Camera& cam, glm::vec2 mousePos, glm::ivec2 screenSize);

    bool intersectRaySphere(const glm::vec3& rayOrigin, const glm::vec3& rayDir, const glm::vec3& sphereCenter, float sphereRadius, float& distance);
}
 
 
#endif