RendererComputePipeline.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/GPUComputePipeline.hpp"
 
namespace CeresEngine {
 
    enum class RendererComputePipelineFlag {
    };
 
    using RendererComputePipelineFlags = Flags<RendererComputePipelineFlag>;
    CE_FLAGS_OPERATORS(RendererComputePipelineFlag)
 
    
    struct RendererComputePipelineSpecialization {
        RendererShaderSpecialization shaderSpecialization;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(shaderSpecialization); //
        }
    };
 
    class RendererComputePipeline : public RefCounted<RendererComputePipeline> {
    private:
        friend class RendererComputePipelineManager;
 
        RendererComputePipelineManager& mManager;
 
        String mName;
 
        RendererShaderPtr mShader;
 
        GPUPipelineLayoutPtr mPipelineLayout = nullptr;
 
        mutable HashMap<UInt64, GPUComputePipelinePtr> mPipelines;
 
    public:
        explicit RendererComputePipeline(RendererComputePipelineManager& manager, StringView name, const RendererShaderPtr& shader,
            const GPUPipelineLayoutPtr& pipelineLayout = nullptr);
        ~RendererComputePipeline();
 
    public:
        [[nodiscard]] GPUComputePipelinePtr getPipeline(const RendererComputePipelineSpecialization& specialization) const;
 
        [[nodiscard]] GPUComputePipelinePtr getPipeline(RendererShaderSpecialization shaderSpecialization = RendererShaderSpecialization()) const {
            return getPipeline(RendererComputePipelineSpecialization{
                .shaderSpecialization = std::move(shaderSpecialization),
            });
        }
 
    public:
        [[nodiscard]] const String& getName() const noexcept { return mName; }
 
        [[nodiscard]] const GPUPipelineLayoutPtr& getPipelineLayout() const noexcept { return mPipelineLayout; }
 
        [[nodiscard]] const RendererShaderPtr& getShader() const noexcept { return mShader; }
    };
 
    class RendererComputePipelineManager {
    private:
        struct ComputePipelineInfo {
            RendererComputePipeline* rendererComputePipeline;
        };
 
    private:
        friend class RendererComputePipeline;
 
        Renderer& mRenderer;
 
        HashMap<UInt64, ComputePipelineInfo> mComputePipelines;
 
    public:
        explicit RendererComputePipelineManager(Renderer& renderer);
 
    public:
        RendererComputePipelinePtr get(StringView name, const RendererShaderPtr& shader, const GPUPipelineLayoutPtr& pipelineLayout = nullptr);
 
        RendererComputePipelinePtr get(const RendererShaderPtr& shader, const GPUPipelineLayoutPtr& pipelineLayout = nullptr) {
            return get(StringView(), shader, pipelineLayout);
        }
 
    private:
        friend class RendererComputePipeline;
 
        [[nodiscard]] RendererComputePipelinePtr getOrCreate(StringView name, const RendererShaderPtr& shader, const GPUPipelineLayoutPtr& pipelineLayout);
 
        void notifyDestroy(const RendererComputePipeline* computePipeline) noexcept;
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::RendererComputePipelineSpecialization);