RendererGraphicsPipeline.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "RendererShader.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
 
#include "CeresEngine/RenderAPI/GPUGraphicsPipeline.hpp"
 
namespace CeresEngine {
 
    enum class RendererGraphicsPipelineFlag {
    };
 
    using RendererGraphicsPipelineFlags = Flags<RendererGraphicsPipelineFlag>;
    CE_FLAGS_OPERATORS(RendererGraphicsPipelineFlag)
 
    
    struct RendererGraphicsPipelineSpecialization {
        SmallVector<VertexDeclaration, 1> vertexDeclarations;
 
        PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles;
 
        RendererShaderSpecialization shaderSpecialization;
 
        GPUGraphicsPipelineState state;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(vertexDeclarations);
            CE_REFL_DATA(primitiveTopology);
            CE_REFL_DATA(shaderSpecialization);
            CE_REFL_DATA(state);
        }
    };
 
    class RendererGraphicsPipeline : public RefCounted<RendererGraphicsPipeline> {
    private:
        friend class RendererGraphicsPipelineManager;
 
        RendererGraphicsPipelineManager& mManager;
 
        String mName;
 
        RendererShaderPtr mShader;
 
        GPURenderPassPtr mRenderPass = nullptr;
 
        GPUPipelineLayoutPtr mPipelineLayout = nullptr;
 
        mutable HashMap<UInt64, GPUGraphicsPipelinePtr> mPipelines;
 
    public:
        explicit RendererGraphicsPipeline(RendererGraphicsPipelineManager& manager, StringView name,
            const RendererShaderPtr& shader, const GPURenderPassPtr& renderPass, const GPUPipelineLayoutPtr& pipelineLayout = nullptr);
        ~RendererGraphicsPipeline();
 
    public:
        [[nodiscard]] GPUGraphicsPipelinePtr getPipeline(const RendererGraphicsPipelineSpecialization& specialization) const;
 
        [[nodiscard]] GPUGraphicsPipelinePtr getPipeline(
            const GPUGraphicsPipelineState& state,
            const PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles, RendererShaderSpecialization shaderSpecialization = {}) const {
            return getPipeline(RendererGraphicsPipelineSpecialization{
                .primitiveTopology = primitiveTopology,
                .shaderSpecialization = std::move(shaderSpecialization),
                .state = state,
            });
        }
 
        [[nodiscard]] GPUGraphicsPipelinePtr getPipeline(
            VertexDeclaration vertexDeclaration, const GPUGraphicsPipelineState& state,
            const PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles, RendererShaderSpecialization shaderSpecialization = {}) const {
            return getPipeline(RendererGraphicsPipelineSpecialization{
                .vertexDeclarations = {std::move(vertexDeclaration)},
                .primitiveTopology = primitiveTopology,
                .shaderSpecialization = std::move(shaderSpecialization),
                .state = state,
            });
        }
 
        [[nodiscard]] GPUGraphicsPipelinePtr getPipeline(
            const RendererMesh& mesh, const GPUGraphicsPipelineState& state,
            PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles, RendererShaderSpecialization shaderSpecialization = {}) const;
 
        [[nodiscard]] GPUGraphicsPipelinePtr getPipeline(const RendererMeshPtr& mesh, const GPUGraphicsPipelineState& state,
            const PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles, RendererShaderSpecialization shaderSpecialization = {}) const {
            return getPipeline(*mesh, state, primitiveTopology, std::move(shaderSpecialization));
        }
 
    public:
        [[nodiscard]] const String& getName() const noexcept { return mName; }
 
        [[nodiscard]] const GPURenderPassPtr& getRenderPass() const noexcept { return mRenderPass; }
 
        [[nodiscard]] const GPUPipelineLayoutPtr& getPipelineLayout() const noexcept { return mPipelineLayout; }
 
        [[nodiscard]] const RendererShaderPtr& getShader() const noexcept { return mShader; }
    };
 
    class RendererGraphicsPipelineManager {
    private:
        struct GraphicsPipelineInfo {
            RendererGraphicsPipeline* rendererGraphicsPipeline;
        };
 
    private:
        friend class RendererGraphicsPipeline;
 
        Renderer& mRenderer;
 
        HashMap<UInt64, GraphicsPipelineInfo> mGraphicsPipelines;
 
    public:
        explicit RendererGraphicsPipelineManager(Renderer& renderer);
 
    public:
        RendererGraphicsPipelinePtr get(StringView name, const RendererShaderPtr& shader,
            const GPURenderPassPtr& renderPass, const GPUPipelineLayoutPtr& pipelineLayout = nullptr);
 
        RendererGraphicsPipelinePtr get(const RendererShaderPtr& shader, const GPURenderPassPtr& renderPass,
            const GPUPipelineLayoutPtr& pipelineLayout = nullptr) {
            return get(StringView(), shader, renderPass, pipelineLayout);
        }
 
    private:
        friend class RendererGraphicsPipeline;
 
        [[nodiscard]] RendererGraphicsPipelinePtr getOrCreate(StringView name, const RendererShaderPtr& shader,
            const GPURenderPassPtr& renderPass, const GPUPipelineLayoutPtr& pipelineLayout);
 
        void notifyDestroy(const RendererGraphicsPipeline* graphicsPipeline) noexcept;
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::RendererGraphicsPipelineSpecialization);