RenderTask.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 "CeresEngine/Renderer/Forward.hpp"
#include "CeresEngine/Renderer/Resources/Forward.hpp"
 
#include "RenderGraphSlot.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/RenderAPI/GPUBuffer.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/RenderAPI/GPUCommandBuffer.hpp"
#include "CeresEngine/RenderAPI/GPUImage.hpp"
#include "CeresEngine/RenderAPI/GPURenderPass.hpp"
 
namespace CeresEngine {
 
    struct RenderTaskResourceUsage;
    class RenderTaskCompiler;
 
    struct RenderTaskResourceUsage {
        struct ShaderResourceInfo {
            RenderResource* resource = nullptr;
        };
 
        Vector<ShaderResourceInfo> shaderReads;
 
        Vector<ShaderResourceInfo> shaderWrites;
 
        struct AttachmentResourceInfo {
            ImageRenderResource* resource = nullptr;
 
            GPUAttachmentLoadOp loadOp = GPUAttachmentLoadOp::Clear;
 
            GPUAttachmentStoreOp storeOp = GPUAttachmentStoreOp::Store;
 
            GPUImageLayout initialLayout = GPUImageLayout::DontCare;
 
            GPUImageLayout finalLayout = GPUImageLayout::DontCare;
        };
 
        Vector<AttachmentResourceInfo> colorAttachments;
 
        AttachmentResourceInfo depthAttachment;
 
        AttachmentResourceInfo stencilAttachment;
 
        struct RealizedResourceInfo {
            RenderResource* resource = nullptr;
        };
 
        Vector<RealizedResourceInfo> realizations;
 
        struct UnrealizedResourceInfo {
            RenderResource* resource = nullptr;
        };
 
        Vector<UnrealizedResourceInfo> unrealizations;
 
    public:
        [[nodiscard]] bool uses(const RenderResource& resource) const;
 
        [[nodiscard]] bool reads(const RenderResource& resource) const;
 
        [[nodiscard]] bool writes(const RenderResource& resource) const;
 
        [[nodiscard]] const AttachmentResourceInfo* getAttachmentInfo(UInt32 attachmentIdx) const;
 
        [[nodiscard]] const AttachmentResourceInfo* getAttachmentInfo(const ImageRenderResource& resource) const;
 
        [[nodiscard]] bool realizes(const RenderResource& resource) const;
 
        [[nodiscard]] bool unrealizes(const RenderResource& resource) const;
 
        [[nodiscard]] RenderResource& getResource(const Slot& slot) const;
 
        //        [[nodiscard]] ImageRenderResource& getImage(const Slot& slot) const {
        //            return static_cast<ImageRenderResource&>(getResource(slot));
        //        }
        //
        //        [[nodiscard]] BufferRenderResource& getBuffer(const Slot& slot) const {
        //            return static_cast<BufferRenderResource&>(getResource(slot));
        //        }
    };
 
    struct RenderGraphContext {
        Renderer& renderer;
 
        GPUUniformBufferPool uniformBuffers;
 
        GPUStorageBufferPool storageBuffers;
 
        explicit RenderGraphContext(Renderer& renderer, GPUDevice& device) : renderer(renderer), uniformBuffers(device), storageBuffers(device) {}
    };
 
    enum class RenderTaskStatus {
        ForceRender,
        DontRender,
        RenderIfTargetDirty
    };
 
    class RenderTask : public RefCounted<RenderTask> {
        friend class RenderGraph;
        friend class Slot;
        friend class InputSlot;
        friend class OutputSlot;
 
    private:
        RenderGraph& mRenderGraph;
 
        Vector<InputSlot*> mInputs;
        Vector<OutputSlot*> mOutputs;
 
    protected:
        RenderTaskResourceUsage mResourceUsage;
 
    public:
        explicit RenderTask(RenderGraph& renderGraph) : mRenderGraph(renderGraph) {}
        virtual ~RenderTask();
 
    public:
        RenderTaskResourceUsage& compile();
 
        virtual void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) = 0;
 
        [[nodiscard]] virtual StringView getName() const { return StringView(); }
 
        [[nodiscard]] virtual RenderTaskStatus check() const { return RenderTaskStatus::ForceRender; }
 
    protected:
        virtual void compile(RenderTaskCompiler& compiler) = 0;
 
    public:
        [[nodiscard]] virtual Any getSettings() const { return const_cast<RenderTask*>(this)->getSettings(); }
 
        [[nodiscard]] virtual Any getSettings() { return {}; }
 
        const Vector<InputSlot*>& getInputs() const { return mInputs; }
 
        const Vector<OutputSlot*>& getOutputs() const { return mOutputs; }
 
    protected:
        [[nodiscard]] virtual bool shouldConnect(const Slot& slot, const Slot& targetSlot) const { return true; }
 
        virtual void willConnect(Slot& slot, Slot& targetSlot) {}
 
        virtual void didConnect(Slot& slot, Connection& connection);
 
        [[nodiscard]] virtual bool shouldDisconnect(const Slot& slot, const Connection& connection) const { return true; }
 
        virtual void willDisconnect(Slot& slot, Connection& connection) {}
 
        virtual void didDisconnect(Slot& slot, Connection& connection);
 
    public:
        [[nodiscard]] const RenderTaskResourceUsage& getResourceUsage() const { return mResourceUsage; }
 
    protected:
        ImageRenderResource& create(const GPUImageDescriptor& descriptor);
        BufferRenderResource& create(const GPUBufferDescriptor& descriptor);
    };
 
    class RenderTaskCompiler {
    private:
        RenderTaskResourceUsage& mResourceUsage;
 
    public:
        RenderTaskCompiler(RenderTaskResourceUsage& resourceUsage) : mResourceUsage(resourceUsage) {}
 
    public:
        RenderTaskCompiler& reads(RenderResource& resource);
 
        RenderTaskCompiler& writes(RenderResource& resource);
 
    public:
        RenderTaskCompiler& addColorAttachment(ImageRenderResource& image, GPUAttachmentLoadOp loadOp = GPUAttachmentLoadOp::Load,
            GPUAttachmentStoreOp storeOp = GPUAttachmentStoreOp::Store);
 
        RenderTaskCompiler& setDepthAttachment(ImageRenderResource& image, GPUAttachmentLoadOp loadOp = GPUAttachmentLoadOp::Load,
            GPUAttachmentStoreOp storeOp = GPUAttachmentStoreOp::Store);
 
        RenderTaskCompiler& setStencilAttachment(ImageRenderResource& image, GPUAttachmentLoadOp loadOp = GPUAttachmentLoadOp::Load,
            GPUAttachmentStoreOp storeOp = GPUAttachmentStoreOp::Store);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class GraphicsRenderTask : public RenderTask {
    protected:
        GPURenderPassPtr mRenderPass;
 
        GPURenderTargetPtr mRenderTarget;
 
    public:
        using RenderTask::RenderTask;
 
    public:
        void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) override;
 
    protected:
        virtual void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget) = 0;
 
    protected:
        [[nodiscard]] virtual bool isRenderPassDirty(GPURenderPass& renderPass) const;
 
        [[nodiscard]] virtual GPURenderPassPtr createRenderPass(GPUDevice& device);
 
    protected:
        [[nodiscard]] virtual bool isRenderTargetDirty(GPURenderTarget& renderTarget, GPURenderPass& renderPass) const;
 
        [[nodiscard]] virtual GPURenderTargetPtr createRenderTarget(GPUDevice& device, GPURenderPass& renderPass);
    };
 
    class SimpleGraphicsRenderTask : public GraphicsRenderTask {
    private:
        String mName;
 
        bool mInitialized = false;
 
    protected:
        GPUGraphicsPipelinePtr mPipeline;
 
    public:
        explicit SimpleGraphicsRenderTask(RenderGraph& renderGraph, const String& name) : GraphicsRenderTask(renderGraph), mName(name) {}
 
    public:
        using RenderTask::execute;
 
        void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget) override;
 
        [[nodiscard]] StringView getName() const override { return mName; }
 
    protected:
        virtual void initialize(GPUDevice& device) {}
 
        virtual void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, GPUGraphicsPipeline& pipeline) = 0;
 
    protected:
        [[nodiscard]] virtual bool isGraphicsPipelineDirty(GPUGraphicsPipeline& graphicsPipeline, GPURenderPass& renderPass) const { return false; }
 
        [[nodiscard]] virtual GPUGraphicsPipelinePtr createGraphicsPipeline(GPUDevice& device, GPURenderPass& renderPass) = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class SimpleGraphicsRenderTask2 : public GraphicsRenderTask {
    private:
        String mName;
 
        bool mInitialized = false;
 
    protected:
        RendererShaderPtr mShader;
 
        RendererGraphicsPipelinePtr mPipeline;
 
    public:
        explicit SimpleGraphicsRenderTask2(RenderGraph& renderGraph, const String& name) : GraphicsRenderTask(renderGraph), mName(name) {}
 
    public:
        using RenderTask::execute;
 
        void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget) override;
 
        [[nodiscard]] StringView getName() const override { return mName; }
 
    protected:
        virtual void initialize(GPUDevice& device) {}
 
        virtual void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, RendererGraphicsPipeline& pipeline) = 0;
 
    protected:
        [[nodiscard]] virtual bool isShaderDirty(RendererShader& shader, GPURenderPass& renderPass) const { return false; }
 
        [[nodiscard]] virtual RendererShaderPtr createShader(RendererShaderManager& shaderManager, GPURenderPass& renderPass) = 0;
 
        [[nodiscard]] virtual bool isGraphicsPipelineDirty(RendererGraphicsPipeline& graphicsPipeline, GPURenderPass& renderPass) const { return false; }
 
        [[nodiscard]] virtual RendererGraphicsPipelinePtr createGraphicsPipeline(RendererGraphicsPipelineManager& graphicsPipelineManager,
            RendererShader& shader, GPURenderPass& renderPass) = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class ComputeRenderTask : public RenderTask {
    public:
        using RenderTask::RenderTask;
    };
 
    class SimpleComputeRenderTask : public ComputeRenderTask {
    private:
        String mName;
 
        GPUComputePipelinePtr mPipeline;
 
        bool mInitialized = false;
 
    public:
        explicit SimpleComputeRenderTask(RenderGraph& renderGraph, const String& name) : ComputeRenderTask(renderGraph), mName(name) {}
 
    public:
        void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) override;
 
        [[nodiscard]] StringView getName() const override { return mName; }
 
    protected:
        virtual void initialize(GPUDevice& device) {}
 
        virtual void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPUComputePipeline& pipeline) = 0;
 
    protected:
        [[nodiscard]] virtual bool isComputePipelineDirty(GPUComputePipeline& computePipeline) const { return false; }
 
        [[nodiscard]] virtual GPUComputePipelinePtr createComputePipeline(GPUDevice& device) = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class PresentRenderTask final : public RenderTask {
    public:
        ImageInput image{this, "image"};
 
    public:
        void compile(RenderTaskCompiler& compiler) final;
 
        void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) final;
    };
 
} // namespace CeresEngine