RenderGraphTask.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 "RenderGraphBuffer.hpp"
#include "RenderGraphImage.hpp"
#include "RenderGraphResource.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Graph/GraphNode.hpp"
 
namespace CeresEngine::RenderGraph2 {
 
    class RenderGraph;
    class RenderGraphBuilder;
 
    class RenderGraphImage;
 
    struct RenderGraphTaskCompiledInformation;
    class RenderGraphTaskCompiler;
 
    class RenderGraphTask : public GraphNode {
    protected:
        bool mEnabled = true;
 
    public:
        using GraphNode::GraphNode;
        //      explicit RenderGraphTask(RenderGraph& graph);
 
    public:
        RenderGraphTaskCompiledInformation compile();
        virtual void compile(RenderGraphTaskCompiler& compiler) = 0;
    };
 
    class RenderGraphGraphicsTask : public RenderGraphTask {};
 
    class RenderGraphComputeTask : public RenderGraphTask {};
 
    class RenderGraphAsyncComputeTask : public RenderGraphComputeTask {};
 
    class RenderGraphClearTask final : public RenderGraphTask {
    public:
        GraphSocket& input = addInputSocket<RenderGraphImage>("input");
        GraphSocket& output = addOutputSocket<RenderGraphImage>("output");
 
    public:
        using RenderGraphTask::RenderGraphTask;
 
    public:
        void compile(RenderGraphTaskCompiler& compiler) final;
        void execute();
    };
 
    class RenderGraphPresentTask final : public RenderGraphTask {
    public:
        GraphSocket& input = addInputSocket<RenderGraphImage>("input");
 
    public:
        using RenderGraphTask::RenderGraphTask;
 
    public:
        void compile(RenderGraphTaskCompiler& compiler) final;
        void execute();
    };
 
    using RenderGraphResourceOrSocket = Variant<GraphSocket*, RenderGraphImage*>;
 
    struct RenderGraphTaskCompiledInformation {
        struct Attachment {
            GraphSocket* socket = nullptr;
            RenderGraphImage* image = nullptr;
            Optional<RenderGraphImageDescriptor> descriptor;
        };
 
        Vector<Attachment> colorAttachments;
        Attachment depthAttachment;
        Attachment stencilAttachment;
 
        struct ResourceAccess {
            GraphSocket* socket = nullptr;
            RenderGraphResource* resource = nullptr;
            Variant<RenderGraphBufferDescriptor, RenderGraphImageDescriptor> descriptor;
        };
 
        Vector<ResourceAccess> reads;
        Vector<ResourceAccess> writes;
    };
 
    class RenderGraphTaskCompiler {
    private:
        RenderGraphTaskCompiledInformation mDescriptor;
 
    public: // Color attachments
        void addColorAttachment(GraphSocket& socket) {
            mDescriptor.colorAttachments.emplace_back(RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
            });
        }
        void addColorAttachment(GraphSocket& socket, const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.colorAttachments.emplace_back(RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
                .descriptor = descriptor,
            });
        }
 
        void addColorAttachment(const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.colorAttachments.emplace_back(RenderGraphTaskCompiledInformation::Attachment{
                .descriptor = descriptor,
            });
        }
        void addColorAttachment(RenderGraphImage& image) {
            mDescriptor.colorAttachments.emplace_back(RenderGraphTaskCompiledInformation::Attachment{
                .image = &image,
            });
        }
 
    public: // Depth attachment
        void setDepthAttachment(GraphSocket& socket) {
            mDescriptor.depthAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
            };
        }
 
        void setDepthAttachment(GraphSocket& socket, const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.depthAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
                .descriptor = descriptor,
            };
        }
 
        void setDepthAttachment(const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.depthAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .descriptor = descriptor,
            };
        }
 
        void setDepthAttachment(RenderGraphImage& image) {
            mDescriptor.depthAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .image = &image,
            };
        }
 
    public: // Stencil attachment
        void setStencilAttachment(GraphSocket& socket) {
            mDescriptor.stencilAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
            };
        }
 
        void setStencilAttachment(GraphSocket& socket, const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.stencilAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .socket = &socket,
                .descriptor = descriptor,
            };
        }
 
        void setStencilAttachment(const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.stencilAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .descriptor = descriptor,
            };
        }
 
        void setStencilAttachment(RenderGraphImage& image) {
            mDescriptor.stencilAttachment = RenderGraphTaskCompiledInformation::Attachment{
                .image = &image,
            };
        }
 
    public: // Generic read-writes
        void read(GraphSocket& socket) {
            mDescriptor.reads.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .socket = &socket,
            });
        }
 
        void read(RenderGraphResource& resource) {
            mDescriptor.reads.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .resource = &resource,
            });
        }
 
        void write(GraphSocket& socket) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .socket = &socket,
            });
        }
 
        void write(GraphSocket& socket, const RenderGraphBufferDescriptor& descriptor) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .socket = &socket,
                .descriptor = descriptor,
            });
        }
 
        void write(GraphSocket& socket, const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .socket = &socket,
                .descriptor = descriptor,
            });
        }
 
        void write(RenderGraphResource& resource) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .resource = &resource,
            });
        }
 
        void write(const RenderGraphBufferDescriptor& descriptor) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .descriptor = descriptor,
            });
        }
 
        void write(const RenderGraphImageDescriptor& descriptor) {
            mDescriptor.writes.emplace_back(RenderGraphTaskCompiledInformation::ResourceAccess{
                .descriptor = descriptor,
            });
        }
 
        void readAndWrite(GraphSocket& socket) {
            read(socket);
            write(socket);
        }
 
        void readAndWrite(RenderGraphResource& resource) {
            read(resource);
            write(resource);
        }
    };
 
} // namespace CeresEngine::RenderGraph2