RenderGraph.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/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    using RenderGraphAllocator = DefaultAllocator;
 
    template<typename T> using RenderGraphVector = Vector<T>;
 
    class RenderGraph {
    private:
        struct Step;
        friend class RenderResource;
 
        RenderGraphAllocator mAllocator;
 
        RenderGraphVector<RenderResourcePtr> mResources;
        RenderGraphVector<RenderTaskPtr> mTasks;
        RenderGraphVector<Step> mTimeline;
 
    public:
        RenderGraph();
 
        RenderGraph(const RenderGraph&) = delete;
        RenderGraph& operator=(const RenderGraph&) = delete;
 
        ~RenderGraph();
 
    public:
        template<typename T, typename... Args> T& addTask(Args&&... args) {
            T* const ptr = new T(*this, std::forward<Args>(args)...);
            mTasks.emplace_back(ptr);
            return *ptr;
        }
 
        ImageRenderResource& createResource(const GPUImageDescriptor& descriptor);
 
        ImageRenderResource& createResource(GPUImage& image);
 
        BufferRenderResource& createResource(const GPUBufferDescriptor& descriptor);
 
        BufferRenderResource& createResource(GPUBuffer& buffer);
 
        template<typename T, typename... Args> T& createResource(Args&&... args) {
            T* const ptr = new T(*this, std::forward<Args>(args)...);
            mResources.emplace_back(ptr);
            return *ptr;
        }
 
    private: // Internal API
        template<typename T, typename... Args> T* allocate(Args&&... args) {
            StdAllocator<T, RenderGraphAllocator> allocator(mAllocator);
            return new(allocator.allocate()) T(std::forward<Args>(args)...);
        }
 
        template<typename T> void deallocate(T* ptr) {
            StdAllocator<T, RenderGraphAllocator> allocator(mAllocator);
            allocator.deallocate(ptr);
        }
 
    public:
        void compile();
        void compile2();
 
        void execute(Renderer& renderer, GPUDevice& device);
 
        void reset();
    };
 
    struct RenderGraph::Step {
        RenderTask* task;
 
        explicit Step(RenderTask* task) : task(task) {}
    };
 
} // namespace CeresEngine