CameraProperties.h

#pragma once
 
// Standard.
#include <mutex>
#include <optional>
 
// Custom.
#include "math/GLMath.hpp"
#include "misc/Globals.h"
#include "misc/shapes/Frustum.h"
 
namespace ne {
    enum class CameraMode {
        FREE,   
        ORBITAL 
    };
 
    class CameraProperties {
        // Only camera node can control internal data.
        friend class CameraNode;
 
        // Renderer sets render target size and also looks if projection matrix was changed or
        // not to recalculate grid of frustums for light culling.
        friend class Renderer;
 
    public:
        CameraProperties() = default;
 
        struct Data {
            Data() = default;
 
            struct OrbitalModeData {
                OrbitalModeData() = default;
 
                float distanceToTarget = 10.0F; // NOLINT: magic number
 
                float theta = 0.0F; // NOLINT: magic number
 
                float phi = 0.0F; // NOLINT: magic number
            };
 
            struct ViewData {
                ViewData() = default;
 
                glm::mat4x4 viewMatrix = glm::identity<glm::mat4x4>();
 
                bool bViewMatrixNeedsUpdate = true;
 
                glm::vec3 worldLocation = glm::vec3(0.0F, 0.0F, 0.0F);
 
                glm::vec3 worldUpDirection = Globals::WorldDirection::up;
 
                glm::vec3 targetPointWorldLocation = glm::vec3(1.0F, 0.0F, 0.0F);
            };
 
            struct ProjectionData {
                ProjectionData() = default;
 
                glm::mat4x4 projectionMatrix = glm::identity<glm::mat4x4>();
 
                bool bProjectionMatrixNeedsUpdate = true;
 
                bool bLightGridFrustumsNeedUpdate = true;
 
                float nearClipPlaneDistance = 0.3F; // NOLINT: magic number
 
                float farClipPlaneDistance = 500.0F; // NOLINT: good default value
 
                unsigned int iVerticalFov = 90; // NOLINT: magic number
 
                unsigned int iRenderTargetWidth = 800; // NOLINT: default value
 
                unsigned int iRenderTargetHeight = 600; // NOLINT: default value
 
                float nearClipPlaneHeight = 0.0F;
 
                float farClipPlaneHeight = 0.0F;
            };
 
            ViewData viewData;
 
            ProjectionData projectionData;
 
            Frustum frustum;
 
            CameraMode currentCameraMode = CameraMode::FREE;
 
            OrbitalModeData orbitalModeData;
 
            static inline const float minimumClipPlaneDistance = 0.00001F;
        };
 
        void setFov(unsigned int iVerticalFov);
 
        void setNearClipPlaneDistance(float nearClipPlaneDistance);
 
        void setFarClipPlaneDistance(float farClipPlaneDistance);
 
        unsigned int getVerticalFov();
 
        float getNearClipPlaneDistance();
 
        float getFarClipPlaneDistance();
 
        CameraMode getCurrentCameraMode();
 
        Data::OrbitalModeData getOrbitalModeProperties();
 
        glm::vec3 getWorldLocation();
 
        glm::mat4x4 getViewMatrix();
 
        glm::mat4x4 getProjectionMatrix();
 
        inline Frustum* getCameraFrustum() { return &mtxData.second.frustum; }
 
    private:
        void setRenderTargetSize(unsigned int iRenderTargetWidth, unsigned int iRenderTargetHeight);
 
        void makeSureViewMatrixIsUpToDate();
 
        void makeSureProjectionMatrixAndClipPlanesAreUpToDate();
 
        void recalculateFrustum();
 
        std::pair<std::recursive_mutex, Data> mtxData{};
 
        static inline constexpr float floatDelta = 0.00001F;
    };
} // namespace ne