PipelineManager.h

#pragma once
 
// Standard.
#include <array>
#include <mutex>
#include <unordered_map>
#include <memory>
#include <atomic>
#include <unordered_set>
 
// Custom.
#include "render/general/pipeline/Pipeline.h"
#include "shader/general/ShaderMacro.h"
#include "render/general/pipeline/PipelineSharedPtr.h"
#include "shader/ComputeShaderInterface.h"
#include "render/general/pipeline/PipelineType.hpp"
#include "render/general/pipeline/PipelineCreationSettings.h"
 
namespace ne {
    class Renderer;
    class Material;
    class MeshNode;
    class ComputeShaderInterface;
 
    class DelayedPipelineResourcesCreation {
    public:
        DelayedPipelineResourcesCreation() = delete;
 
        DelayedPipelineResourcesCreation(const DelayedPipelineResourcesCreation&) = delete;
        DelayedPipelineResourcesCreation& operator=(const DelayedPipelineResourcesCreation&) = delete;
 
        DelayedPipelineResourcesCreation(DelayedPipelineResourcesCreation&& other) noexcept = delete;
        DelayedPipelineResourcesCreation&
        operator=(DelayedPipelineResourcesCreation&& other) noexcept = delete;
 
        DelayedPipelineResourcesCreation(PipelineManager* pPipelineManager) {
            this->pPipelineManager = pPipelineManager;
            initialize();
        }
 
        ~DelayedPipelineResourcesCreation() { destroy(); }
 
    private:
        void initialize();
 
        void destroy();
 
        PipelineManager* pPipelineManager = nullptr;
    };
 
    struct QueuedForExecutionComputeShaders {
        std::array<
            std::array<
                std::unordered_map<Pipeline*, std::unordered_set<ComputeShaderInterface*>>,
                static_cast<size_t>(ComputeExecutionGroup::SIZE)>,
            static_cast<size_t>(ComputeExecutionStage::SIZE)>
            vGraphicsQueueStagesGroups;
    };
 
    class PipelineManager {
        // Pipeline notifies the manager when a material stops referencing it.
        friend class Pipeline;
 
        // Releases/restores internal Pipeline's resources.
        friend class DelayedPipelineResourcesCreation;
 
        // Compute interfaces request compute pipelines and queue for execution.
        friend class ComputeShaderInterface;
 
    public:
        struct ShaderPipelines {
            std::unordered_map<std::set<ShaderMacro>, std::shared_ptr<Pipeline>, ShaderMacroSetHash>
                shaderPipelines;
        };
 
        struct GraphicsPipelineRegistry {
            std::array<
                std::unordered_map<std::string, ShaderPipelines>,
                static_cast<size_t>(PipelineType::SIZE)>
                vPipelineTypes;
        };
 
        PipelineManager(Renderer* pRenderer);
 
        virtual ~PipelineManager();
 
        PipelineManager() = delete;
        PipelineManager(const PipelineManager&) = delete;
        PipelineManager& operator=(const PipelineManager&) = delete;
 
        [[nodiscard]] DelayedPipelineResourcesCreation
        clearGraphicsPipelinesInternalResourcesAndDelayRestoring();
 
        std::variant<PipelineSharedPtr, Error> getGraphicsPipelineForMaterial(
            std::unique_ptr<PipelineCreationSettings> pPipelineCreationSettings, Material* pMaterial);
 
        inline std::pair<std::recursive_mutex*, QueuedForExecutionComputeShaders*>
        getComputeShadersForGraphicsQueueExecution() {
            return computePipelines.getComputeShadersForGraphicsQueueExecution();
        }
 
        inline std::pair<std::recursive_mutex, GraphicsPipelineRegistry>* getGraphicsPipelines() {
            return &mtxGraphicsPipelines;
        }
 
        size_t getCurrentGraphicsPipelineCount();
 
        size_t getCurrentComputePipelineCount();
 
        Renderer* getRenderer() const;
 
    private:
        struct ComputePipelines {
            struct Resources {
                std::unordered_map<std::string, std::shared_ptr<Pipeline>> pipelines;
 
                QueuedForExecutionComputeShaders queuedComputeShaders;
            };
 
            ComputePipelines() = default;
 
            ComputePipelines(const ComputePipelines&) = delete;
            ComputePipelines& operator=(const ComputePipelines&) = delete;
 
            std::variant<PipelineSharedPtr, Error> getComputePipelineForShader(
                PipelineManager* pPipelineManager, ComputeShaderInterface* pComputeShaderInterface);
 
            [[nodiscard]] std::optional<Error> onPipelineNoLongerUsedByComputeShaderInterface(
                const std::string& sComputeShaderName, ComputeShaderInterface* pComputeShaderInterface);
 
            [[nodiscard]] std::optional<Error>
            queueShaderExecutionOnGraphicsQueue(ComputeShaderInterface* pComputeShaderInterface);
 
            size_t getComputePipelineCount();
 
            inline std::pair<std::recursive_mutex*, QueuedForExecutionComputeShaders*>
            getComputeShadersForGraphicsQueueExecution() {
                return std::make_pair(&mtxResources.first, &mtxResources.second.queuedComputeShaders);
            }
 
        private:
            [[nodiscard]] static std::optional<Error> queueComputeShaderInterfaceForExecution(
                std::unordered_map<Pipeline*, std::unordered_set<ComputeShaderInterface*>>& pipelineShaders,
                ComputeShaderInterface* pComputeShaderInterface);
 
            std::pair<std::recursive_mutex, Resources> mtxResources;
        };
 
        [[nodiscard]] std::optional<Error> releaseInternalGraphicsPipelinesResources();
 
        [[nodiscard]] std::optional<Error> restoreInternalGraphicsPipelinesResources();
 
        std::variant<PipelineSharedPtr, Error> createGraphicsPipelineForMaterial(
            std::unordered_map<std::string, ShaderPipelines>& pipelines,
            const std::string& sShaderNames,
            const std::set<ShaderMacro>& macrosToUse,
            std::unique_ptr<PipelineCreationSettings> pPipelineCreationSettings,
            Material* pMaterial);
 
        void onPipelineNoLongerUsedByMaterial(const std::string& sPipelineIdentifier);
 
        void onPipelineNoLongerUsedByComputeShaderInterface(
            const std::string& sComputeShaderName, ComputeShaderInterface* pComputeShaderInterface);
 
        std::variant<PipelineSharedPtr, Error> findOrCreatePipeline(
            std::unordered_map<std::string, ShaderPipelines>& pipelines,
            const std::string& sKeyToLookFor,
            const std::set<ShaderMacro>& macrosToLookFor,
            std::unique_ptr<PipelineCreationSettings> pPipelineCreationSettings,
            Material* pMaterial);
 
        std::pair<std::recursive_mutex, GraphicsPipelineRegistry> mtxGraphicsPipelines;
 
        ComputePipelines computePipelines;
 
        Renderer* pRenderer = nullptr;
    };
} // namespace ne