camera.h

#ifndef OE_SCENE_CAMERA_H
#define OE_SCENE_CAMERA_H
 
#include <glm/mat4x4.hpp>
#include "transform.h"
 
#include "camera_projections.h"
 
namespace oe::scene
{
    class AABB;
    class Window;

    class Camera : public Transform
    {
        public:
            template <CameraProjection ProjectionSettings>
            Camera(const ProjectionSettings& projection_settings)
            {
                setProjectionSettings(projection_settings);
            }

            template <CameraProjection ProjectionSettings>
            void setProjectionSettings(const ProjectionSettings& projection_settings)
            {
                _projection = projection_settings.getProjectionMatrix();
                _is_dirty = true;
            }

            void lookAt(const glm::vec3& target);

            bool isInFrustum(const glm::vec3& point) const;

            bool isInFrustum(const glm::vec3& center, const float& radius) const;

            bool isInFrustum(const AABB& box) const;

            const glm::mat4& getView() const;

            const glm::mat4& getProjection() const;
 
            const glm::mat4& getInverseView() const;
            const glm::mat4& getInverseProjection() const;

            const glm::mat4& getTransform() const noexcept;
            const glm::mat4& getInverseTransform() const noexcept;
 
            float getPitch() const noexcept
            {
                return _pitch;
            }
 
            float getYaw() const noexcept
            {
                return _yaw;
            }
 
            float getRoll() const noexcept
            {
                return _roll;
            }
 
            void setPitch(const float pitch);
            void setYaw(const float yaw);
            void setRoll(const float roll);
 
            inline bool isDirty() const
            {
                return Transform::isDirty() || _is_dirty;
            }
 
        private:
            mutable bool _is_dirty = true;

            float _pitch = 0.f;

            float _yaw = 0.f;

            float _roll = 0.f;
 
            mutable glm::mat4 _view{1.0f};
            mutable glm::mat4 _projection{1.0f};
 
            mutable glm::mat4 _inv_view{1.0f};
            mutable glm::mat4 _inv_projection{1.0f};
 
            mutable glm::mat4 _transform{1.0f};
            mutable glm::mat4 _inv_transform{1.0f};
 
            mutable glm::vec4 _frustum_planes[6];
            mutable glm::vec3 _frustum_points[8];
 
            void _recompute_rotation();
            void _recompute_matrices() const;
 
    };
}
 
#endif