Camera.hpp

#pragma once
 
#include <glm/glm.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>
 
namespace PixelBullet
{
    class Camera
    {
    public:
        explicit Camera(float fov = glm::radians(45.0f), float nearPlane = 0.1f, float farPlane = 1000.0f)
            : m_FOV(fov)
            , m_Near(nearPlane)
            , m_Far(farPlane)
            , m_Position(0.0f)
            , m_RotationEuler(0.0f)
            , m_ViewMatrix(1.0f)
            , m_ProjectionMatrix(1.0f)
        {
        }
 
        virtual ~Camera() = default;
 
        virtual void Start()
        {
        }
        virtual void Update()
        {
        }
 
        void SetPosition(const glm::vec3& pos)
        {
            m_Position = pos;
            RecalculateView();
        }
        void SetRotation(const glm::vec3& rotEuler)
        {
            m_RotationEuler = rotEuler;
            RecalculateView();
        }
 
        void SetPerspective(float fov, float aspect, float nearPlane, float farPlane)
        {
            m_FOV = fov;
            m_Near = nearPlane;
            m_Far = farPlane;
            m_ProjectionMatrix = glm::perspective(fov, aspect, nearPlane, farPlane);
        }
 
        [[nodiscard]] float GetFOV() const
        {
            return m_FOV;
        }
        [[nodiscard]] float GetNearPlane() const
        {
            return m_Near;
        }
        [[nodiscard]] float GetFarPlane() const
        {
            return m_Far;
        }
 
        [[nodiscard]] const glm::vec3& GetPosition() const
        {
            return m_Position;
        }
        [[nodiscard]] const glm::vec3& GetRotationEuler() const
        {
            return m_RotationEuler;
        }
 
        [[nodiscard]] const glm::mat4& GetViewMatrix() const
        {
            return m_ViewMatrix;
        }
        [[nodiscard]] const glm::mat4& GetProjectionMatrix() const
        {
            return m_ProjectionMatrix;
        }
 
        [[nodiscard]] glm::vec3 GetForward() const
        {
            return glm::normalize(glm::rotate(GetRotationQuat(), glm::vec3(0, 0, -1)));
        }
 
        [[nodiscard]] glm::vec3 GetRight() const
        {
            return glm::normalize(glm::rotate(GetRotationQuat(), glm::vec3(1, 0, 0)));
        }
 
        [[nodiscard]] glm::vec3 GetUp() const
        {
            return glm::normalize(glm::rotate(GetRotationQuat(), glm::vec3(0, 1, 0)));
        }
 
    protected:
        [[nodiscard]] glm::quat GetRotationQuat() const
        {
            return { glm::radians(m_RotationEuler) };
        }
 
        void RecalculateView()
        {
            auto rotation = GetRotationQuat();
            auto target = m_Position + glm::rotate(rotation, glm::vec3(0, 0, -1));
            m_ViewMatrix = glm::lookAt(m_Position, target, glm::rotate(rotation, glm::vec3(0, 1, 0)));
        }
 
    protected:
        float m_FOV;  
        float m_Near; 
        float m_Far;  
 
        glm::vec3 m_Position;      
        glm::vec3 m_RotationEuler; 
 
        glm::mat4 m_ViewMatrix;       
        glm::mat4 m_ProjectionMatrix; 
    };
} // namespace PixelBullet