CameraComponent.h

#pragma once
#include "Engine/Component/LogicComponent.h"
#include "SceneComponent.h"
 
#include <glm/glm.hpp>
#include <memory>
 
namespace Engine::Components {
    class Camera : public Logic {
    public:
        static constexpr bool IsUnique = true;  
        static constexpr const char* ComponentName = "Camera"; 

        Camera(Entities::Scene* owningScene,
                       std::shared_ptr<Entities::SceneNode> sceneNode,
                       float fov = 60.0f,
                       float nearPlane = 0.01f,
                       float farPlane = 1000.0f);

        ~Camera() override = default;
 
        void beginPlay() override;
        void tick(double deltaTime) override;
        void endPlay() override;
 
        bool drawImGui() override;

        void setActive(bool active);

        [[nodiscard]] bool isActive() const;

        [[nodiscard]] virtual glm::mat4 getViewMatrix() const;

        [[nodiscard]] virtual glm::mat4 getProjectionMatrix() const;

        [[nodiscard]] virtual glm::mat4 getEyeViewMatrix(size_t eyeIndex) const;

        [[nodiscard]] virtual glm::mat4 getEyeProjectionMatrix(size_t eyeIndex) const;

        [[nodiscard]] glm::mat4 getViewProjectionMatrix() const;

        void setFov(float fov);

        [[nodiscard]] float getFov() const { return fov_; }

        void setAspectRatio(float aspectRatio);

        [[nodiscard]] float getAspectRatio() const { return aspectRatio_; }

        void setNearPlane(float nearPlane);

        [[nodiscard]] float getNearPlane() const { return nearPlane_; }

        void setFarPlane(float farPlane);

        [[nodiscard]] float getFarPlane() const { return farPlane_; }

        [[nodiscard]] glm::vec3 getWorldPosition() const;

        [[nodiscard]] glm::vec3 getForwardVector() const;

        [[nodiscard]] glm::vec3 getRightVector() const;

        [[nodiscard]] glm::vec3 getUpVector() const;

        [[nodiscard]] std::shared_ptr<Entities::SceneNode> getSceneNode() const { return sceneNode_; }
 
    private:
        void updateProjectionMatrix();
 
        std::shared_ptr<Entities::SceneNode> sceneNode_;
        entt::entity cameraEntity_ = entt::null;
 
        float fov_;
        float nearPlane_;
        float farPlane_;
        float aspectRatio_ = 16.0f / 9.0f;
 
        mutable glm::mat4 cachedProjectionMatrix_{1.0f};
        bool projectionDirty_ = true;
    };

    Camera* getActiveCamera();

    bool hasActiveCamera();
}