Pipeline.h

#pragma once
 
// Standard.
#include <set>
#include <unordered_set>
 
// Custom.
#include "shader/general/ShaderUser.h"
#include "render/general/pipeline/PipelineConfiguration.h"
#include "render/general/pipeline/PipelineShaderConstantsManager.hpp"
 
namespace ne {
    class Renderer;
    class PipelineManager;
    class Material;
    class ComputeShaderInterface;
    class Pipeline;
 
    class Pipeline : public ShaderUser {
        // Only Pipeline manager should be able to create Pipeline.
        friend class PipelineManager;
 
        // Will notify when material is no longer referencing a Pipeline.
        friend class PipelineSharedPtr;
 
    public:
        Pipeline() = delete;
        Pipeline(const Pipeline&) = delete;
        Pipeline& operator=(const Pipeline&) = delete;
 
        virtual ~Pipeline() override = default;
 
        struct ShaderConstantsData {
            void findOffsetAndCopySpecialValueToConstant(
                Pipeline* pPipeline, const char* pConstantName, unsigned int iValueToCopy);
 
            std::unique_ptr<PipelineShaderConstantsManager> pConstantsManager;
 
            std::unordered_map<std::string, size_t> uintConstantsOffsets;
        };
 
        static std::string combineShaderNames(
            std::string_view sVertexShaderName,
            std::string_view sPixelShaderName,
            std::string_view sComputeShaderName = "");
 
        std::variant<size_t, Error> getUintConstantOffset(const std::string& sConstantName);
 
        std::pair<std::mutex, std::unordered_set<Material*>>* getMaterialsThatUseThisPipeline();
 
        std::string getPipelineIdentifier() const;
 
        Renderer* getRenderer() const;
 
        const PipelineConfiguration* getConfiguration() const;
 
        std::pair<std::mutex, std::optional<ShaderConstantsData>>* getShaderConstants();
 
    protected:
        explicit Pipeline(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        [[nodiscard]] virtual std::optional<Error> releaseInternalResources() = 0;
 
        [[nodiscard]] virtual std::optional<Error> restoreInternalResources() = 0;
 
        void setShaderConstants(const std::unordered_map<std::string, size_t>& uintConstantsOffsets);
 
    private:
        static std::variant<std::shared_ptr<Pipeline>, Error> createGraphicsPipeline(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        static std::variant<std::shared_ptr<Pipeline>, Error> createComputePipeline(
            Renderer* pRenderer, PipelineManager* pPipelineManager, const std::string& sComputeShaderName);
 
        void onMaterialUsingPipeline(Material* pMaterial);
 
        void onMaterialNoLongerUsingPipeline(Material* pMaterial);
 
        void onComputeShaderUsingPipeline(ComputeShaderInterface* pComputeShaderInterface);
 
        void onComputeShaderNoLongerUsingPipeline(ComputeShaderInterface* pComputeShaderInterface);
 
        std::pair<std::mutex, std::unordered_set<Material*>> mtxMaterialsThatUseThisPipeline;
 
        std::pair<std::mutex, std::unordered_set<ComputeShaderInterface*>>
            mtxComputeShadersThatUseThisPipeline;
 
        std::pair<std::mutex, std::optional<ShaderConstantsData>> mtxShaderConstantsData;
 
        const std::unique_ptr<PipelineConfiguration> pPipelineConfiguration;
 
        PipelineManager* const pPipelineManager = nullptr;
 
        Renderer* const pRenderer = nullptr;
    };
} // namespace ne