Renderer.hpp

Go to the documentation of this file.

#pragma once
#include <Async/ThreadPool.hpp>
#include <Core/StackAllocator.hpp>
#include <RHICore/Application.hpp>
 
#include "RenderPass.hpp"
#include "RenderResource.hpp"
namespace Foundation::RenderCore
{
    struct RendererDesc
    {
        bool enableAsyncCompute{true};
        bool enablePresent{true};
        uint32_t numRenderThreads{std::max(1u, std::thread::hardware_concurrency() - 1)};
    };
    /* -- Constants -- */
    // Maximum number of render passes per frame
    // NOTE: The limit here is mostly arbitrary - and is only used
    //       for the default priority heuristic when determining pass order.
    constexpr size_t kMaxRenderPasses = 1024;
    // Maximum number of command lists per frame
    constexpr size_t kMaxCommandListsPerThread = kMaxRenderPasses;
    // Maximum size of the per-frame transient arena (16MB)
    constexpr size_t kExecuteArenaSize = 16 * (1 << 20);
    // Stub name for bind_point names that's not found in shaders. This has no
    // effect - as bindings not found will simply not participate
    // in the PSO building process.
    const String kBindpointIgnored = "<ignored>"; // no constexpr in Debug?? thanks MSVC 
    const RHIPipelineStage kComputeStagesMask = RHIPipelineStageBits::FragmentShader |
        RHIPipelineStageBits::VertexShader | RHIPipelineStageBits::MeshShader | RHIPipelineStageBits::RayTracingShader |
        RHIPipelineStageBits::AllGraphics;
    const RHIResourceAccessBits kAllShaderWrites = RHIResourceAccessBits::ShaderWrite |
        RHIResourceAccessBits::RenderTargetWrite | RHIResourceAccessBits::DepthStencilWrite |
        RHIResourceAccessBits::TransferWrite | RHIResourceAccessBits::HostWrite;
    const RHIResourceAccessBits kAllShaderReads = RHIResourceAccessBits::ShaderRead |
        RHIResourceAccessBits::RenderTargetRead | RHIResourceAccessBits::UniformRead |
        RHIResourceAccessBits::TransferRead | RHIResourceAccessBits::HostRead;
    class Renderer
    {
        struct RendererSetup
        {
            Vector<Vector<Pair<PassHandle, ResourceHandle>>> graph;
            Vector<PassHandle> indegree;
            Vector<TrackedPass> trackedPasses;
            Vector<TrackedResource> trackedResources;
            // Backbuffer producer
            PassHandle lastBackbufferProducer{kInvalidHandle};
            // [resource, view desc]
            Vector<Pair<ResourceHandle, RHITextureViewDesc>> trackedViews;
            Vector<RHIDeviceSampler::SamplerDesc> trackedSamplers;
            // [resource, ord range]
            Map<ResourceHandle, Pair<PassHandle, PassHandle>> activeResources;
            // Passes ordered by pass.ord
            Vector<PassHandle> execution;
            Map<RHIDescriptorType, uint32_t> bindingCounts;
            PassHandle epilogue{kInvalidHandle};
            // Execution grouped by queue type
            struct ExecutionGroups
            {
                const int groupIndex{}; // Index in executionGroups
                int graphicsGroupIndex{-1}; // Index of all unique graphics groups before this one
                int computeGroupIndex{-1}; // Index of all unique compute groups before this one
                const RHIDeviceQueueType queue{};
                Vector<PassHandle> passes;
                // Resources used in this group
                Vector<ResourceHandle> resources;
                bool isLastGraphics = false;
                bool isLastCompute = false;
                RHIPipelineStage allStages{}; // All stages used in this group
 
                ExecutionGroups(int groupIndex, RHIDeviceQueueType queue, Allocator* allocator) :
                    groupIndex(groupIndex), queue(queue), passes(allocator), resources(allocator)
                {
                }
            };
            Vector<ExecutionGroups> executionGroups;
            bool executionAnyCompute{false}, executionAnyGraphics{false};
            int executionNumGraphicsGroups{0}, executionNumComputeGroups{0};
            void add_edge(const PassHandle u, const PassHandle v, const ResourceHandle hdl)
            {
                while (u >= graph.size())
                    graph.emplace_back(graph.get_allocator());
                graph[u].emplace_back(v, hdl);
                while (v >= indegree.size())
                    indegree.push_back(0);
                indegree[v]++;
            }
            explicit RendererSetup(Allocator* allocator) :
                graph(allocator), indegree(allocator), trackedPasses(allocator), trackedResources(allocator), trackedViews(allocator),
                trackedSamplers(allocator), activeResources(allocator), execution(allocator), bindingCounts(allocator),
                executionGroups(allocator)
            {
            }
        };
    public:
        enum class State
        {
            Undefined,
            Setup,
            PostSetup,
            Execute
        };
 
    private:
        State mState;
        Allocator* mAllocator{nullptr};
 
        const RendererDesc mDesc{};
 
        uint64_t mFrameSwapped{0}; // Frame rendered in the current Swapchain
 
        uint32_t mFrameSwaps{1}; // Max frames in flight
        uint32_t mCurrentSync{0};
        uint32_t mCurrentSwap{0};
 
        UniquePtr<ExecuteResources> mResources;
        RHIDeviceScopedObjectHandle<RHIDeviceDescriptorPool> mDescPool;
        Async::Mutex mDescPoolMutex;
 
        struct FrameSyncObjects
        {
            // Index of this swap
            const size_t swapIndex;
            RHIDeviceScopedObjectHandle<RHIDeviceSemaphore> render{}, present{};
            RHIDeviceScopedObjectHandle<RHIDeviceFence> graphicsFence{}, computeFence{};
            // RTV for the backbuffer
            RHITextureScopedHandle<RHITextureView> rtv{};
            // Tracked backbuffer handle
            ResourceHandle backbuffer{kInvalidHandle};
            FrameSyncObjects(size_t swapIndex) : swapIndex(swapIndex) {};
        };
        Vector<FrameSyncObjects> mSwaps;
        // Semaphore for async compute
        RHIDeviceScopedObjectHandle<RHIDeviceSemaphore> mGraphicsTimeline{}, mComputeTimeline{};
        RHIApplicationObjectHandle<RHIDevice> mDevice{};
        RHIDeviceObjectHandle<RHISwapchain> mSwapchain{};
        RHIDeviceQueue *mGraphicsQueue{}, *mComputeQueue{};
 
        UniquePtr<RendererSetup> mSetup;
        // Setup
        [[nodiscard]] ResourceHandle CreateTextureView(PassHandle pass, ResourceHandle handle,
                                                       RHITextureViewDesc const& desc) const;
        // PostSetup
        void CullPasses(PassHandle epilogue) const;
        void BuildPipelineState(PassHandle pass);
        void FinalizeResources();
        void FinalizePSOs();
        // Temporary memory arena for execution
        ScopedArena mExecuteArena;
        // Temporary allocator for execution
        // This is reset every frame, and only guaranteed to be valid during Execute state.
        StackAllocator mExecuteAlloc;
        // Temporary storage for submits calls
        // This is reset every frame, and only guaranteed to be valid during Execute state.
        Vector<RHIDeviceQueue::SubmitDesc> *mExecuteGraphicsSubmits{}, *mExecuteComputeSubmits{};
        // Thread pool for concurrent command list recording
        Async::ThreadPool mExecuteThreadPool;
        struct ExecutePerThreadCommandLists
        {
            RHIDeviceScopedObjectHandle<RHICommandPool> graphicsPool{}, computePool{};
            Vector<RHICommandPoolScopedHandle<RHICommandList>> graphicsCmds, computeCmds;
            // Resets every frame
            size_t graphicsCtr{}, computeCtr{};
            ExecutePerThreadCommandLists(RHIDevice* device, size_t maxPerThread, Allocator* alloc);
            void Reset();
            RHICommandList* AllocateGraphics(int thread_id);
            RHICommandList* AllocateCompute(int thread_id);
        };
        // [current sync][thread id]
        Vector<Vector<UniquePtr<ExecutePerThreadCommandLists>>> mExecutePerSwapCmds;
        RHICommandList* ExecuteAllocateCommandList(RHIDeviceQueueType queue, int thread_id);
        [[nodiscard]] uint32_t ExecuteGetQueueIndex(RHIDeviceQueueType queue) const
        {
            switch (queue)
            {
            case RHIDeviceQueueType::Undefined:
                return kCommandQueueTransferIgnored;
            case RHIDeviceQueueType::Graphics:
                return mGraphicsQueue->GetQueueIndex();
            case RHIDeviceQueueType::Compute:
                return mComputeQueue->GetQueueIndex();
            default:
                throw std::runtime_error("Unhandled queue type");
            }
        };
        using ExecuteBarrierList = Vector<Pair<Variant<RHIBuffer*, RHITexture*>, RHICommandList::TransitionDesc>>;
        using ExecuteBarrierPCmdOrPBarrierList = Variant<RHICommandList*, ExecuteBarrierList*>;
        void ExecuteBarrierSubresourceState(PassHandle pass, RHITexture* res, TrackedResource::SubresourceState& sta,
                                            RHIResourceAccess access, RHIPipelineStage stage, RHITextureLayout layout,
                                            ExecuteBarrierPCmdOrPBarrierList cmd) const;
        void ExecuteBarrierSubresource(PassHandle pass, TrackedResource& res, RHITextureSubresourceRange const& range,
                                       RHIResourceAccess access, RHIPipelineStage stage, RHITextureLayout layout,
                                       ExecuteBarrierPCmdOrPBarrierList cmd);
        void ExecuteBarrierBuffer(PassHandle pass, TrackedResource& res, RHIResourceAccess access,
                                  RHIPipelineStage stage, ExecuteBarrierPCmdOrPBarrierList cmd);
        void ExecuteBarriers(TrackedPass& pass, ExecuteBarrierPCmdOrPBarrierList cmd);
        void ExecuteAcquireQueueResources(RHIDeviceQueueType currentQueue, size_t groupIndex, RHICommandList* cmd);
        void ExecuteReleaseQueueResources(RHIDeviceQueueType currentQueue, size_t groupIndex, RHICommandList* cmd);
        void SetFrameSyncObjects();
        void DeclareBufferAccess(PassHandle pass, ResourceHandle handle, RHIPipelineStage stage,
                                 RHIResourceAccess access = RHIResourceAccessBits::ShaderRead) const;
        void DeclareTextureAccess(PassHandle pass, ResourceHandle handle, RHIPipelineStage stage,
                                  RHITextureSubresourceRange range = {},
                                  RHIResourceAccess access = RHIResourceAccessBits::ShaderRead,
                                  RHITextureLayout layout = RHITextureLayout::ShaderReadOnly) const;
        RHIDeviceIdleGuard mWaitIdle; // Ensure device is idle on destruction
    public:
        Renderer(RendererDesc const& desc, RHIApplicationObjectHandle<RHIDevice> device,
                 RHIDeviceObjectHandle<RHISwapchain> swapchain, Allocator* allocator);
 
#pragma region Render Graph Setup
        void BeginSetup();
        template <typename T, typename... Args>
            requires std::is_base_of_v<RenderPass, T>
        T* CreatePassImpl(StringView name, RHIDeviceQueueType queue, size_t priority, Args&&... args)
        {
            CHECK(mState == State::Setup);
            CHECK_MSG(queue == RHIDeviceQueueType::Graphics || queue == RHIDeviceQueueType::Compute,
                      "Invalid queue type. Only Graphics and Compute queues are supported.");
            PassHandle handle = mSetup->trackedPasses.size();
            CHECK_MSG(handle < kMaxRenderPasses, "Exceeded maximum number of render passes ({})", kMaxRenderPasses);
            if (!mDesc.enableAsyncCompute)
                queue = RHIDeviceQueueType::Graphics; // Force graphics queue if async compute is disabled
            mSetup->trackedPasses.emplace_back(
                mAllocator, handle, name, queue,
                ConstructUniqueBase<RenderPass, T>(mAllocator, std::forward<Args>(args)...), priority);
            mSetup->epilogue = handle;
            return static_cast<T*>(mSetup->trackedPasses.back().pass.get());
        }
        template <typename FSetup, typename FRecord, typename FSkip = FSkipDefault>
        LambdaPass<FSetup, FRecord, FSkip>* CreatePass(StringView name, RHIDeviceQueueType queue, size_t priority,
                                                       FSetup&& setup, FRecord&& record, FSkip&& skip = {})
        {
            return CreatePassImpl<LambdaPass<FSetup, FRecord, FSkip>>(
                name, queue, priority, std::forward<FSetup>(setup), std::forward<FRecord>(record),
                std::forward<FSkip>(skip));
        }
        template <typename T>
        [[nodiscard]] ResourceHandle CreateResource(StringView name, T const& desc)
        {
            CHECK(mState == State::Setup);
            ResourceHandle index = mSetup->trackedResources.size();
            mSetup->trackedResources.emplace_back(index, name, desc, mAllocator);
            return mSetup->trackedResources.size() - 1;
        }
        [[nodiscard]] ResourceHandle CreateSampler(RHIDeviceSampler::SamplerDesc const& desc) const;
#pragma region Resource Binding
        void BindShader(PassHandle pass, RHIShaderStage stage, StringView entry_point,
                        Native::Path const& shader_path) const;
        void BindDescriptorBindPoint(PassHandle pass, StringView bind_point, uint32_t binding, uint32_t set);
        void BindPushConstant(PassHandle pass, RHIShaderStage stage, size_t offset, size_t size) const;
        void BindVertexInput(PassHandle pass, RHIPipelineState::PipelineStateDesc::VertexInput const& info) const;
        void BindBufferUniform(PassHandle pass, ResourceHandle buffer, RHIPipelineStage stage,
                               StringView bind_point) const;
        void BindBufferStorageRead(PassHandle pass, ResourceHandle buffer, RHIPipelineStage stage,
                               StringView bind_point) const;
        void BindBufferUnordered(PassHandle pass, ResourceHandle buffer, RHIPipelineStage stage,
                                 StringView bind_point) const;
        void BindBufferShaderRead(PassHandle pass, ResourceHandle buffer, RHIPipelineStage stage) const;
        void BindBufferCopyDst(PassHandle pass, ResourceHandle buffer) const;
        void BindBufferCopySrc(PassHandle pass, ResourceHandle buffer) const;
        void BindTextureSampler(PassHandle pass, ResourceHandle sampler, StringView bind_point) const;
        void BindDescriptorSet(PassHandle pass, StringView bind_point, RHIDeviceDescriptorSet* descriptor_set,
                               RHIDeviceDescriptorSetLayout* layout);
        ResourceHandle BindTextureSRV(PassHandle pass, ResourceHandle texture, StringView bind_point,
                                      RHIPipelineStage stage, RHITextureViewDesc const& desc) const;
        ResourceHandle BindTextureUAV(PassHandle pass, ResourceHandle texture, StringView bind_point,
                                      RHIPipelineStage stage, RHITextureViewDesc const& desc) const;
        ResourceHandle BindTextureRTV(PassHandle pass, ResourceHandle texture, RHITextureViewDesc const& desc, RHIPipelineState::PipelineStateDesc::Attachment::Blending const& blending = {}) const;
        ResourceHandle BindTextureDSV(PassHandle pass, ResourceHandle texture, RHITextureViewDesc const& desc) const;
        void BindBackbufferRTV(PassHandle pass, RHIPipelineState::PipelineStateDesc::Attachment::Blending const& blending = {}) const;
        void BindTextureCopyDst(PassHandle pass, ResourceHandle texture,
                                RHITextureSubresourceRange const& range = {}) const;
        void BindTextureCopySrc(PassHandle pass, ResourceHandle texture,
                                RHITextureSubresourceRange const& range = {}) const;
        /* TODO: Push Constants */
#pragma endregion
#pragma region PSO Flags
        void PassSetRasterizerFlags(
            PassHandle pass, 
            RHIPipelineState::PipelineStateDesc::Rasterizer const& rasterizer = {},
            RHIPipelineState::PipelineStateDesc::DepthStencil const& depth_stencil = {}
        ) const;
#pragma endregion
        void EndSetup();
#pragma endregion
#pragma region Swapchain
        [[nodiscard]] RHIExtent2D GetSwapchainExtent() const
        {
            CHECK(mSwapchain && "Swapchain not initialized");
            return mSwapchain->mDesc.extents;
        }
        [[nodiscard]] RHIExtent3D GetSwapchainExtent3D() const
        {
            CHECK(mSwapchain && "Swapchain not initialized");
            auto xy = mSwapchain->mDesc.extents;
            return {xy.x, xy.y, 1};
        }
#pragma endregion
#pragma region Render Graph Runtime
        [[nodiscard]] Variant<RHIBuffer*, RHITexture*> DerefResource(const ResourceHandle handle) const
        {
            CHECK(mResources && handle < mResources->resources.size());
            using Tv = Variant<RHIBuffer*, RHITexture*>;
            return mResources->resources[handle].Visit([](auto* ptr) -> Tv { return ptr; },
                                                        [](auto& hdl) -> Tv { return hdl.Get(); });
        }
        [[nodiscard]] RHITextureView* DerefTextureView(const ResourceHandle handle) const
        {
            CHECK(mResources && handle < mResources->views.size());
            using Tv = RHITextureView*;
            return mResources->views[handle].Visit([](auto& hdl) -> Tv { return hdl.Get(); });
        }
        [[nodiscard]] RHIDeviceSampler* DerefSampler(const ResourceHandle handle) const
        {
            CHECK(mSetup && handle < mSetup->trackedSamplers.size());
            return mResources->samplers[handle].Get();
        }
        [[nodiscard]] RHIPipelineState* DerefPipelineState(const PassHandle pass) const
        {
            CHECK(mSetup && pass < mSetup->trackedPasses.size());
            auto& tpass = mSetup->trackedPasses[pass];
            return tpass.pso.Get();
        }
        [[nodiscard]] Vector<RHIDeviceDescriptorSet*> const& DerefDescriptorSets(const PassHandle pass) const
        {
            CHECK(mSetup && pass < mSetup->trackedPasses.size());
            auto& tpass = mSetup->trackedPasses[pass];
            return tpass.pDescriptorSets;
        }
        [[nodiscard]] RHITextureView* DerefCurrentBackbufferView(const PassHandle pass) const
        {
            CHECK(mState == State::Execute);
            auto& tpass = mSetup->trackedPasses[pass];
            CHECK_MSG(tpass.writeBackbuffer, "Pass {} does not write to backbuffer", tpass.name);
            return mSwaps[GetSwap()].rtv.Get();
        }
        [[nodiscard]] Allocator* GetAllocator() const { return mAllocator; }
#pragma endregion
#pragma region Command Recording Helpers
        [[nodiscard]] RHIExtent3D CmdGetComputeLocalSize(PassHandle pass) const;
        void CmdDispatch(PassHandle pass, RHICommandList* cmd, RHIExtent3D thread_size) const;
        void CmdSetPipeline(PassHandle pass, RHICommandList* cmd) const;
        void CmdBindDescriptorSet(PassHandle pass, RHICommandList* cmd, uint32_t index,
                                  RHIDeviceDescriptorSet* descriptor_set) const;
        void CmdBeginGraphics(PassHandle pass, RHICommandList* cmd, RHIExtent2D const& extent,
                              Optional<RHIClearColor> const& clear_rtv = RHIClearColor{},
                              Optional<RHIClearDepthStencil> const& clear_dsv = RHIClearDepthStencil{1.0f, 0u});
        template <typename T>
        void CmdSetPushConstant(PassHandle pass, RHICommandList* cmd, RHIShaderStage stage, size_t offset,
                                T const& data)
        {
            CHECK(mState == State::Execute);
            auto& tpass = mSetup->trackedPasses[pass];
            cmd->PushConstant(tpass.pso.Get(), stage, static_cast<uint32_t>(offset),
                              {reinterpret_cast<const char*>(&data), sizeof(T)});
        }
#pragma endregion
#pragma region Frame Execution
        [[nodiscard]] State GetState() const { return mState; }
        [[nodiscard]] uint32_t GetFrameSwaps() const { return mFrameSwaps; }
        [[nodiscard]] uint64_t GetFrame() const { return mFrameSwapped; }
        [[nodiscard]] uint32_t GetSwap() const { return mCurrentSwap; }
        [[nodiscard]] uint64_t GetSync() const { return mCurrentSync; }
        [[nodiscard]] bool IsAsyncComputeEnabled() const { return mDesc.enableAsyncCompute; }
        [[nodiscard]] bool IsPresentEnabled() const { return mDesc.enablePresent; }
        void SetSwapchain(RHIDeviceObjectHandle<RHISwapchain> swapchain);
        void BeginExecute();
        void ExecuteFrame();
        void EndExecute();
#pragma endregion
#pragma region Debugging
        [[nodiscard]] String DbgDumpGraphviz() const;
        [[nodiscard]] String DbgDumpActivePasses() const;
        [[nodiscard]] String DbgDumpExecutionGroups() const;
#pragma endregion
    };
    ENUM_NAME_CONV_BEGIN(Renderer::State)
        ENUM_NAME(Undefined);
        ENUM_NAME(Setup);
        ENUM_NAME(PostSetup);
        ENUM_NAME(Execute);
    ENUM_NAME_CONV_END();
    /* Functional Helpers */
    template <typename T>
    [[nodiscard]] ResourceHandle createResource(Renderer* r, StringView name, T const& desc)
    {
        return r->CreateResource(name, desc);
    }
    [[nodiscard]] inline ResourceHandle createSampler(Renderer* r, RHIDeviceSampler::SamplerDesc const& desc)
    {
        return r->CreateSampler(desc);
    }
    template <typename T, typename... Args>
        requires std::is_base_of_v<RenderPass, T>
    T* createPassImplPriority(Renderer* r, StringView name, RHIDeviceQueueType queue, size_t priority, Args&&... args)
    {
        return r->CreatePassImpl<T>(name, queue, priority, std::forward<Args>(args)...);
    }
    template <typename T, typename... Args>
        requires std::is_base_of_v<RenderPass, T>
    T* createPassImpl(Renderer* r, StringView name, RHIDeviceQueueType queue, Args&&... args)
    {
        size_t pri = (queue == RHIDeviceQueueType::Graphics) ? 0 : kMaxRenderPasses; // Just a _pretty large_ value.
        return createPassImpl<T>(r, name, queue, pri, std::forward<Args>(args)...);
    }
    template <typename FSetup, typename FRecord, typename FSkip = FSkipDefault>
    LambdaPass<FSetup, FRecord, FSkip>* createPassPriority(Renderer* r, StringView name, RHIDeviceQueueType queue,
                                                           size_t priority, FSetup&& setup, FRecord&& record,
                                                           FSkip&& skip = {})
    {
        return r->CreatePass(name, queue, priority, std::forward<FSetup>(setup), std::forward<FRecord>(record),
                             std::forward<FSkip>(skip));
    }
    template <typename FSetup, typename FRecord, typename FSkip = FSkipDefault>
    LambdaPass<FSetup, FRecord, FSkip>* createPass(Renderer* r, StringView name, RHIDeviceQueueType queue,
                                                   FSetup&& setup, FRecord&& record, FSkip&& skip = {})
    {
        size_t pri = (queue == RHIDeviceQueueType::Graphics) ? 0 : kMaxRenderPasses;
        return createPassPriority(r, name, queue, pri, std::forward<FSetup>(setup), std::forward<FRecord>(record),
                                  std::forward<FSkip>(skip));
    }
} // namespace Foundation::RenderCore