Pipeline.h

#pragma once
 
// Standard.
#include <set>
#include <unordered_set>
 
// Custom.
#include "shader/general/ShaderUser.h"
#include "render/general/pipeline/PipelineCreationSettings.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(const std::string& sVertexShaderName, const std::string& sPixelShaderName);
 
        std::string getVertexShaderName();
 
        std::string getPixelShaderName();
 
        std::string getComputeShaderName();
 
        std::optional<std::set<ShaderMacro>> getCurrentShaderConfiguration(ShaderType shaderType);
 
        bool isUsingPixelBlending() const;
 
        bool isDepthBiasEnabled() const;
 
        bool isUsedForPointLightsShadowMapping() const;
 
        std::pair<std::mutex, std::unordered_set<Material*>>* getMaterialsThatUseThisPipeline();
 
        std::string getPipelineIdentifier() const;
 
        Renderer* getRenderer() const;
 
        std::set<ShaderMacro> getAdditionalVertexShaderMacros() const;
 
        std::set<ShaderMacro> getAdditionalPixelShaderMacros() const;
 
        std::pair<std::mutex, std::optional<ShaderConstantsData>>* getShaderConstants();
 
    protected:
        explicit Pipeline(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            const std::string& sVertexShaderName,
            const std::set<ShaderMacro>& additionalVertexShaderMacros,
            const std::string& sPixelShaderName = "",
            const std::set<ShaderMacro>& additionalPixelShaderMacros = {},
            const std::string& sComputeShaderName = "",
            bool bEnableDepthBias = false,
            bool bIsUsedForPointLightsShadowMapping = false,
            bool bUsePixelBlending = false);
 
        void saveUsedShaderConfiguration(ShaderType shaderType, std::set<ShaderMacro>&& fullConfiguration);
 
        [[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<PipelineCreationSettings> pPipelineCreationSettings);
 
        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;
 
        std::set<ShaderMacro> additionalVertexShaderMacros;
 
        std::set<ShaderMacro> additionalPixelShaderMacros;
 
        std::unordered_map<ShaderType, std::set<ShaderMacro>> usedShaderConfiguration;
 
        PipelineManager* pPipelineManager = nullptr;
 
        Renderer* pRenderer = nullptr;
 
        const std::string sVertexShaderName;
 
        const std::string sPixelShaderName;
 
        const std::string sComputeShaderName;
 
        bool bIsUsingPixelBlending = false;
 
        bool bEnableDepthBias = false;
 
        bool bIsUsedForPointLightsShadowMapping = false;
    };
} // namespace ne