components.hpp

#ifndef __LIGHT_COMPONENTS_HPP__
#define __LIGHT_COMPONENTS_HPP__ 1
#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>
#include <glm/gtc/matrix_access.hpp>
#include <raftel/mesh.hpp>
#include "raftel/shadow.hpp"
#include <lua.hpp> 
 
 
namespace Raftel {

    struct BasicComponent
    {
        BasicComponent(): name(std::string(" ")) {}
        void SetName(std::string n_) { name = n_; }
 
        std::string name; 
    };

    struct TransformComponent {
        glm::vec3 position; 
        glm::vec3 rotation; 
        glm::vec3 scale;    
        glm::mat4 transform; 

        glm::vec3 GetUpVector() const{
            return glm::normalize(glm::column(transform, 1));
        }

        glm::vec3 GetRightVector() const
        {
            return glm::normalize(glm::column(transform, 0));
        }

        glm::vec3 GetForwardVector() const
        {
            return glm::normalize(glm::column(transform, 2));
        }

        TransformComponent() : position(1.0f), rotation(1.0f), scale(1.0f), transform(1.0f) {}
        TransformComponent(const glm::vec3& pos, const glm::vec3& rot, const glm::vec3& sca)
            : position(pos), rotation(rot), scale(sca), transform(1.0f) {}

        void Update() {
            transform = glm::mat4(1.0f);
            glm::mat4 translationMatrix = glm::translate(transform, position);
            //solucion gymball lock
            auto quat = glm::quat(glm::radians(rotation));
            glm::mat4 rotationMatrix = glm::mat4_cast(quat);
            glm::mat4 scaleMatrix = glm::scale(transform, scale);
            transform = translationMatrix * rotationMatrix * scaleMatrix;
        }
    };

    struct MeshComponent {
        std::weak_ptr<Mesh> mesh; 
    };

    struct RenderComponent {
        bool visible;
        RenderComponent(bool vis) : visible(vis) {}
    };

    class ScriptComponent {
    public:
        ScriptComponent(const std::string& script);
        ~ScriptComponent();
        MOVABLE_BUT_NOT_COPYABLE(ScriptComponent)
 
        
        void ExecuteFunction(const std::string& functionName);
 
        lua_State* luaState; 
        std::string scriptCode; 
        bool enabled = true; 
        bool pause = true; 
    };

    struct LightComponent {
        enum class LightType {
            DIRECTIONAL, 
            POINT,       
            SPOT,        
            AMBIENT      
        } type; 
 
        glm::vec3 color; 
        float intensity; 
        float range; 
        float innerCone; 
        float outerCone; 
        float near; 
        float far; 
        std::unique_ptr<ShadowMap> shadowMap; 

        void CalculateShadowMatrix(const TransformComponent& tr, const class Camera& cam);

        void move(LightComponent& other);
        
        float fov; 
        std::vector<glm::mat4> lightSpaceMatrix; 

        LightComponent(LightType lt, glm::vec3 color_, float intensity_, float range_, float inner_, float outer_, glm::ivec2 screenSize);
        MOVABLE_BUT_NOT_COPYABLE(LightComponent)
 
    };
 
}
 
#endif