BasicComponents.hpp

Go to the documentation of this file.

 
#pragma once
#ifndef GLM_ENABLE_EXPERIMENTAL
    #define GLM_ENABLE_EXPERIMENTAL 1
#endif
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <glm/gtx/euler_angles.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <vector>
#include <string>
#include <map>
#include "components/ECS/ECS.hpp"
 
#include "components/Mesh.hpp"
#include "components/ErrorUtils.hpp"
#include "components/ColorTypes.hpp"
#include "components/AssetTypes.hpp"
 
 
#include "components/ErrorUtils.hpp"
 
namespace vex{

struct TransformComponent {
    #ifdef DEBUG
    public:
    glm::vec3 position = {0.0f, 0.0f, 0.0f};
    glm::vec3 rotation = {0.0f, 0.0f, 0.0f};
    glm::vec3 scale = {1.0f, 1.0f, 1.0f};
    glm::quat m_rotationQuat = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
    vex::Entity parent = vex::NULL_ENTITY;
    vex::Registry* m_registry = nullptr;
    glm::mat4 cachedMatrix = glm::mat4(1.0f);
    bool dirty = true;
    #else
    private:
    glm::vec3 position = {0.0f, 0.0f, 0.0f};
    glm::quat m_rotationQuat = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
    glm::vec3 scale = {1.0f, 1.0f, 1.0f};
    vex::Entity parent = vex::NULL_ENTITY;
    bool lastTransformed = true;
    vex::Registry* m_registry = nullptr;
    bool physicsAffected = false;
    glm::mat4 cachedMatrix = glm::mat4(1.0f);
    bool dirty = true;
    public:
    #endif
    TransformComponent(const TransformComponent& other)
        : m_registry(other.m_registry), // Initialize the reference from the other's reference
          position(other.position),
          m_rotationQuat(other.m_rotationQuat), // Copy the quaternion
          scale(other.scale),
          parent(other.parent)
    {}

    TransformComponent& operator=(const TransformComponent& other) {
        if (this != &other) {
            position = other.position;
            m_rotationQuat = other.m_rotationQuat; // Assign the quaternion
            scale = other.scale;
            parent = other.parent;
        }
        return *this;
    }

    TransformComponent(vex::Registry& registry)
        : m_registry(&registry) {}

    TransformComponent(vex::Registry& registry, glm::vec3 pos, vex::Entity p = vex::NULL_ENTITY)
        : m_registry(&registry), position(pos), parent(p) {}

    TransformComponent(vex::Registry& registry, glm::vec3 pos, glm::vec3 rot, vex::Entity p = vex::NULL_ENTITY)
        : m_registry(&registry), position(pos), m_rotationQuat(glm::normalize(glm::quat(glm::radians(rot)))), parent(p) {}

    TransformComponent(vex::Registry& registry, glm::vec3 pos, glm::vec3 rot, glm::vec3 s, vex::Entity p = vex::NULL_ENTITY)
        : m_registry(&registry), position(pos), m_rotationQuat(glm::normalize(glm::quat(glm::radians(rot)))), scale(s), parent(p) {}

    TransformComponent(vex::Registry& registry, vex::Entity p)
        : m_registry(&registry), parent(p) {}

    TransformComponent() = default;
 
    bool isDirty(){
        bool result = false;
 
        if (!isReady()) [[unlikely]] {
            log("TransformComponent is not ready, registry is not valid");
            return false;
        }
 
        if (parent != vex::NULL_ENTITY && m_registry->has<TransformComponent>(parent)) {
            result = m_registry->get<TransformComponent>(parent).isDirty();
        }
        return (dirty || result);
    }
 
    void setRegistry(vex::Registry& reg) {
        dirty = true;
        m_registry = &reg;
    }
 
    bool isReady() const {
        return m_registry != nullptr;
    }
 
    #ifdef DEBUG
    void convertRot(){
        setLocalRotation(rotation);
        //rotation = glm::degrees(glm::eulerAngles(m_rotationQuat));
    }
    #endif

    void setParent(vex::Entity newParent) {
        parent = newParent;
    }

    vex::Entity getParent() const {
        return parent;
    }

    glm::vec3 getLocalPosition() const {
        return position;
    }

    glm::vec3 getLocalRotation() const {
        return glm::degrees(glm::eulerAngles(m_rotationQuat));
    }

    glm::vec3 getLocalScale() const {
        return scale;
    }

    void setLocalPosition(glm::vec3 newPosition) {
        dirty = true;
        position = newPosition;
    }

    void setLocalRotation(glm::vec3 newRotation) {
        dirty = true;
        m_rotationQuat = glm::normalize(glm::quat(glm::radians(newRotation)));
    }

    void setLocalScale(glm::vec3 newScale) {
        dirty = true;
        scale = newScale;
    }
 
        // --- WORLD QUATERNION METHODS FOR PHYSICS SYSTEMS ---

        glm::quat getWorldQuaternion() const {
            if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
                return m_registry->get<TransformComponent>(parent).getWorldQuaternion() * m_rotationQuat;
            }
            return m_rotationQuat;
        }

        void setWorldQuaternion(glm::quat targetWorldQuat) {
                dirty = true;
                if (parent != vex::NULL_ENTITY && m_registry->has<TransformComponent>(parent)) {
                    glm::quat parentWorldQuat = m_registry->get<TransformComponent>(parent).getWorldQuaternion();
                    glm::quat parentInverse = glm::inverse(parentWorldQuat);
                    m_rotationQuat = parentInverse * targetWorldQuat;
                } else {
                    m_rotationQuat = targetWorldQuat;
                }
                m_rotationQuat = glm::normalize(m_rotationQuat);
            }

            void setWorldQuaternionPhys(glm::quat targetWorldQuat) {
                if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
                    glm::quat parentWorldQuat = m_registry->get<TransformComponent>(parent).getWorldQuaternion();
                    glm::quat parentInverse = glm::inverse(parentWorldQuat);
                    m_rotationQuat = parentInverse * targetWorldQuat;
                } else {
                    m_rotationQuat = targetWorldQuat;
                }
                m_rotationQuat = glm::normalize(m_rotationQuat);
                dirty = true;
            }

                glm::quat getLocalQuaternion() const {
                    return m_rotationQuat;
                }

                void setLocalQuaternion(glm::quat newRotation) {
                    dirty = true;
                    m_rotationQuat = glm::normalize(newRotation);
                }

                void addLocalQuaternion(glm::quat deltaRotation) {
                    dirty = true;
                    m_rotationQuat = glm::normalize(m_rotationQuat * deltaRotation);
                }
 
    // --------------------------------------------------
 
    glm::mat4 recalculateMatrix(){
        glm::mat4 local = glm::mat4(1.0f);
        local = glm::translate(local, position);
        local *= glm::mat4_cast(m_rotationQuat);
        local = glm::scale(local, scale);
 
        if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
            cachedMatrix = m_registry->get<TransformComponent>(parent).recalculateMatrix() * local;
        }else{
            cachedMatrix = local;
        }
 
        return cachedMatrix;
    }

    glm::mat4 matrix(bool forceRecalculate = false) {
        if(isDirty() || forceRecalculate){
            dirty = false;
            return recalculateMatrix();
        }
        return cachedMatrix;
    }

    glm::vec3 getWorldPosition() {
        return glm::vec3(matrix()[3]);
    }

    glm::vec3 getWorldRotation() {
        return glm::degrees(glm::eulerAngles(getWorldQuaternion()));
    }

    glm::vec3 getWorldScale() {
    glm::vec3 worldScale = scale;
    vex::Entity current = parent;
    while (current != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(current)) {
        worldScale *= m_registry->get<TransformComponent>(current).scale;
        current = m_registry->get<TransformComponent>(current).parent;
    }
    return worldScale;
}

    void setWorldPosition(glm::vec3 newPosition) {
        dirty = true;
        if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
            glm::mat4 parentWorldMatrix = m_registry->get<TransformComponent>(parent).matrix();
            glm::mat4 inverseParentMatrix = glm::inverse(parentWorldMatrix);
            glm::vec4 newLocalPos4 = inverseParentMatrix * glm::vec4(newPosition, 1.0f);
            position = glm::vec3(newLocalPos4);
        } else {
            position = newPosition;
        }
    }

    void setWorldPositionPhys(glm::vec3 newPosition) {
        if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
            glm::mat4 parentWorldMatrix = m_registry->get<TransformComponent>(parent).matrix();
            glm::mat4 inverseParentMatrix = glm::inverse(parentWorldMatrix);
            glm::vec4 newLocalPos4 = inverseParentMatrix * glm::vec4(newPosition, 1.0f);
            position = glm::vec3(newLocalPos4);
        } else {
            position = newPosition;
        }
        dirty = true;
    }

    void setWorldRotation(glm::vec3 newRotation) {
        glm::quat targetWorldQuat = glm::quat(glm::radians(newRotation));
        setWorldQuaternion(targetWorldQuat);
    }

    void setWorldScale(glm::vec3 newScale) {
        dirty = true;
        if (parent != vex::NULL_ENTITY && m_registry && m_registry->has<TransformComponent>(parent)) {
            glm::vec3 parentWorldScale = m_registry->get<TransformComponent>(parent).getWorldScale();
            scale = newScale / parentWorldScale;
        } else {
            scale = newScale;
        }
    }

    void addLocalPosition(glm::vec3 newPosition) {
        dirty = true;
        position += newPosition;
    }

    void addLocalRotation(glm::vec3 newRotation) {
        dirty = true;
        glm::quat deltaQuat = glm::quat(glm::radians(newRotation));
        m_rotationQuat = m_rotationQuat * deltaQuat;
        m_rotationQuat = glm::normalize(m_rotationQuat);
    }

    void addLocalScale(glm::vec3 newScale) {
        dirty = true;
        scale += newScale;
    }

    void addPitch(float deltaPitch) {
        dirty = true;
        glm::quat deltaQuat = glm::angleAxis(glm::radians(deltaPitch), glm::vec3(1.0f, 0.0f, 0.0f));
        m_rotationQuat = m_rotationQuat * deltaQuat;
        m_rotationQuat = glm::normalize(m_rotationQuat);
    }

    void addYaw(float deltaYaw) {
        dirty = true;
        glm::quat deltaQuat = glm::angleAxis(glm::radians(deltaYaw), glm::vec3(0.0f, 1.0f, 0.0f));
        m_rotationQuat = deltaQuat * m_rotationQuat;
        m_rotationQuat = glm::normalize(m_rotationQuat);
    }

    void addRoll(float deltaRoll) {
        dirty = true;
        glm::quat deltaQuat = glm::angleAxis(glm::radians(deltaRoll), glm::vec3(0.0f, 0.0f, 1.0f));
        m_rotationQuat = m_rotationQuat * deltaQuat;
        m_rotationQuat = glm::normalize(m_rotationQuat);
    }
 
 
    glm::vec3 getForwardVector() {
        return glm::normalize(-glm::vec3(matrix()[2]));
    }

    glm::vec3 getRightVector() {
        return glm::normalize(glm::vec3(matrix()[0]));
    }

    glm::vec3 getUpVector() {
        return glm::normalize(glm::vec3(matrix()[1]));
    }
 
    #if DEBUG
    void enableLastTransformed() {
        dirty = true;
    }
    #endif
 
};
 
#if defined(OPAQUE)
    #undef OPAQUE
#endif
#if defined(TRANSPARENT)
    #undef TRANSPARENT
#endif

enum class RenderType {
    OPAQUE,
    TRANSPARENT,
    MASKED,
    CUSTOM
};

struct MeshComponent {
    // Render Data
    MeshData meshData;
    uint32_t id = UINT32_MAX;
    std::vector<std::string> textureNames;
    RenderType renderType = RenderType::OPAQUE;
    vex::rgba color = glm::vec4(1.f);
 
    std::map<int, texture_asset_path> textureOverrides;
 
    // Simple bounding data
    glm::vec3 localCenter = glm::vec3(0.0f);
    float localRadius = 1.0f;
 
    glm::vec3 worldCenter = glm::vec3(0.0f);
    float worldRadius = 1.0f;

    bool getIsFresh(){
        return fresh;
    }

    void setRendered(){
        fresh = false;
    }

    void forceRefresh(){
        fresh = true;
    }
 
    private:
    bool fresh = true;
};

struct LightComponent {
    vex::rgb color = glm::vec3(1.f);
    float intensity = 1.f;
    float radius = 5.f;
};

struct FogComponent {
    vex::rgb color = glm::vec3(1.f);
    float density = 0.5f;
    float start = 0.0f;
    float end = 100.0f;
};

struct NameComponent {
    std::string name;
};

struct CameraComponent {
    float fov = 45.0f;
    float nearPlane = 0.1f;
    float farPlane = 100.0f;
    uint32_t id = UINT32_MAX; // For editor use
};
}