ShadowMapManager.h

#pragma once
 
// Standard.
#include <memory>
#include <variant>
#include <optional>
#include <mutex>
#include <functional>
#include <unordered_map>
#include <array>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resources/shadow/ShadowMapArrayIndexManager.h"
#include "ShadowMapType.hpp"
 
namespace ne {
    class GpuResource;
    class GpuResourceManager;
    class ShadowMapHandle;
 
    class ShadowMapManager {
        // Unique pointers will notify the manager before destruction.
        friend class ShadowMapHandle;
 
        // Renderer will notify us when shadow quality setting is changed.
        friend class Renderer;
 
        // Pipeline manager notifies us about new pipelines or re-created pipelines to re-bind descriptors.
        friend class PipelineManager;
 
    public:
        struct ShadowMapHandleResources {
            std::unique_ptr<GpuResource> pDepthTexture;
 
            std::unique_ptr<GpuResource> pColorTexture;
        };
 
        struct InternalResources {
            std::unordered_map<ShadowMapHandle*, ShadowMapHandleResources> shadowMaps;
 
            std::array<std::unique_ptr<ShadowMapArrayIndexManager>, static_cast<size_t>(ShadowMapType::SIZE)>
                vShadowMapArrayIndexManagers;
        };
 
        ShadowMapManager() = delete;
        ShadowMapManager(const ShadowMapManager&) = delete;
        ShadowMapManager& operator=(const ShadowMapManager&) = delete;
 
        ~ShadowMapManager();
 
        static int getShadowPassDepthBias();
 
        static float getShadowPassDepthSlopeFactor();
 
        static constexpr const char* getDirectionalShadowMapsShaderResourceName() {
            return pDirectionalShadowMapsShaderResourceName;
        }
 
        static constexpr const char* getSpotShadowMapsShaderResourceName() {
            return pSpotShadowMapsShaderResourceName;
        }
 
        static constexpr const char* getPointShadowMapsShaderResourceName() {
            return pPointShadowMapsShaderResourceName;
        }
 
        static constexpr float getVisibleDistanceToNearClipPlaneRatio() {
            return visibleDistanceToNearClipPlaneRatio;
        }
 
        static std::variant<std::unique_ptr<ShadowMapManager>, Error>
        create(GpuResourceManager* pResourceManager);
 
        std::variant<std::unique_ptr<ShadowMapHandle>, Error> createShadowMap(
            const std::string& sResourceName,
            ShadowMapType type,
            const std::function<void(unsigned int)>& onArrayIndexChanged);
 
        inline std::pair<std::recursive_mutex, InternalResources>* getInternalResources() {
            return &mtxInternalResources;
        }
 
        Renderer* getRenderer() const;
 
    private:
        ShadowMapManager(
            GpuResourceManager* pResourceManager,
            std::array<std::unique_ptr<ShadowMapArrayIndexManager>, static_cast<size_t>(ShadowMapType::SIZE)>
                vShadowMapArrayIndexManagers);
 
        [[nodiscard]] std::optional<Error> bindShadowMapsToPipeline(Pipeline* pPipeline);
 
        [[nodiscard]] std::optional<Error> bindShadowMapsToAllPipelines();
 
        void onShadowMapHandleBeingDestroyed(ShadowMapHandle* pHandleToResourceDestroy);
 
        [[nodiscard]] std::optional<Error> recreateShadowMaps();
 
        unsigned int
        correctShadowMapResolutionForType(unsigned int iRenderSettingsShadowMapSize, ShadowMapType type);
 
        ShadowMapArrayIndexManager* getArrayIndexManagerBasedOnShadowMapType(ShadowMapType type);
 
        std::pair<std::recursive_mutex, InternalResources> mtxInternalResources;
 
        GpuResourceManager* pResourceManager = nullptr;
 
        static constexpr float visibleDistanceToNearClipPlaneRatio = 0.004F; // NOLINT
 
        static constexpr auto pDirectionalShadowMapsShaderResourceName = "directionalShadowMaps";
 
        static constexpr auto pSpotShadowMapsShaderResourceName = "spotShadowMaps";
 
        static constexpr auto pPointShadowMapsShaderResourceName = "pointShadowMaps";
    };
}