Renderer.hpp

Go to the documentation of this file.

#pragma once
#include <Core/AllocatorStack.hpp>
#include <Core/Logging.hpp>
#include <Core/ThreadPool.hpp>
#include "RenderPass.hpp"
#include "RenderResource.hpp"
#include "Shader.hpp"
namespace Foundation::RenderCore
{
    struct RendererDesc
    {
        bool asyncCompute{true};
        bool present{true};
        uint32_t threadCount{std::max(1u, std::thread::hardware_concurrency() - 1)};
        RHIPipelineStateCache* pipelineCache{nullptr};
        bool profilePasses{true};
    };
    /* -- 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);
    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> in;
            Vector<TrackedPass> trackedPasses;
            Vector<TrackedResource> trackedResources;
            // Backbuffer specializations
            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;
 
                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)
            {
                CHECK(u < kMaxRenderPasses && v < kMaxRenderPasses);
                while (u >= graph.size())
                    graph.emplace_back(graph.get_allocator());
                graph[u].emplace_back(v, hdl);
                while (v >= in.size())
                    in.push_back(0);
                in[v]++;
            }
            explicit RendererSetup(Allocator* allocator) :
                graph(allocator), in(allocator), trackedPasses(allocator), trackedResources(allocator),
                trackedViews(allocator), trackedSamplers(allocator), activeResources(allocator), execution(allocator),
                bindingCounts(allocator), executionGroups(allocator)
            {
            }
        };
 
    public:
        enum class State
        {
            Undefined, // Initialized
            Setup, // During BeginSetup(), EndSetup(). No work on the GPU yet.
            PostSetup, // Safe state (with a device wait), after EndSetup(), EndExecute()
            Execute // During BeginExecute(), EndExecute()
        };
 
    private:
        State mState;
        Allocator* mAllocator{nullptr};
 
        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;
        RHIDeviceScopedHandle<RHIDeviceDescriptorPool> mDescPool;
        Mutex mDescPoolMutex;
        // Per swap primitives
        struct FrameSyncObjects
        {
            // Index of this swap
            const size_t swapIndex;
            RHIDeviceScopedHandle<RHIDeviceSemaphore> render{}, present{};
            RHIDeviceScopedHandle<RHIDeviceFence> graphicsFence{}, computeFence{};
            // Texture view for the backbuffer
            RHITextureScopedHandle<RHITextureView> view{};
            RHIDeviceDescriptorPoolScopedHandle<RHIDeviceDescriptorSet> viewSet{};
            // Tracked backbuffer handle
            ResourceHandle backbuffer{kInvalidHandle};
            // [Profiling] Timestamp Query Pool
            RHIDeviceScopedHandle<RHIDeviceQueryPool> dbgQueryPool{};
            Vector<uint64_t> dbgQueryPassTimestampsResults;
            // [Profiling] Present timings
            std::chrono::steady_clock::time_point dbgSwapLastPresentTick{};
            uint64_t dbgSwapLastPresentToPresentTicks{0};
            FrameSyncObjects(size_t swapIndex, Allocator* alloc) :
                swapIndex(swapIndex), dbgQueryPassTimestampsResults(alloc)
            {
            }
        };
        RHIDeviceScopedHandle<RHIDeviceDescriptorPool> mSwapDescriptorPool;
        RHIDeviceScopedHandle<RHIDeviceDescriptorSetLayout> mSwapDescriptorSetLayout;
 
        Vector<FrameSyncObjects> mSwaps;
        // Semaphore for async compute
        RHIDeviceScopedHandle<RHIDeviceSemaphore> mGraphicsTimeline{}, mComputeTimeline{};
        RHIApplicationHandle<RHIDevice> mDevice{};
        RHIDeviceHandle<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 BuildPipelineStateAll();
        void FinalizeResources();
        void FinalizePasses();
        // 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.
        AllocatorStack mExecuteAlloc;
        // Temporary storage for submits calls
        // This is reset every frame, and only guaranteed to be valid during Execute state.
        Vector<Pair<RHIDeviceQueueType, RHIDeviceQueue::SubmitDesc>>* mExecuteSubmits;
        // Thread pool for concurrent command list recording
        ThreadPool mExecuteThreadPool;
        struct ExecutePerThreadCommandLists
        {
            RHIDeviceScopedHandle<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();
            RHICommandList* AllocateCompute();
        };
        // [current sync][thread id]
        Vector<Vector<UniquePtr<ExecutePerThreadCommandLists>>> mExecutePerSwapCmds;
        RHICommandList* ExecuteAllocateCommandList(RHIDeviceQueueType queue, int thread_id = -1);
        [[nodiscard]] uint32_t ExecuteGetQueueFamily(RHIDeviceQueueType queue) const
        {
            switch (queue)
            {
            case RHIDeviceQueueType::Undefined:
                return kCommandQueueTransferIgnored;
            case RHIDeviceQueueType::Graphics:
                return mGraphicsQueue->GetVkQueueFamily();
            case RHIDeviceQueueType::Compute:
                return mComputeQueue->GetVkQueueFamily();
            default:
                throw std::runtime_error("Unhandled queue type");
            }
        }
        using ExecuteBarrierList = Vector<Pair<Variant<RHIBuffer*, RHITexture*, RHIAccelerationStructure*>, 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 ExecuteBarrierAccelerationStructure(PassHandle pass, TrackedResource& res,
                                             RHIResourceAccess access, RHIPipelineStage stage,
                                             ExecuteBarrierPCmdOrPBarrierList cmd);
        void ExecuteBarriers(TrackedPass& pass, ExecuteBarrierPCmdOrPBarrierList 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() = delete;
        Renderer(RendererDesc const& desc, RHIApplicationHandle<RHIDevice> device,
                 RHIDeviceHandle<RHISwapchain> swapchain, Allocator* allocator);
 
#pragma region Render Graph Setup
        void BeginSetup();
        template <typename T, typename... Args>
            requires std::is_base_of_v<RenderPass, T>
        PassHandle 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.asyncCompute)
                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 handle;
        }
        template <typename FSetup, typename FRecord>
        PassHandle CreatePass(StringView name, RHIDeviceQueueType queue, size_t priority, FSetup&& setup,
                              FRecord&& record)
        {
            return CreatePassImpl<LambdaPass<FSetup, FRecord>>(name, queue, priority, std::forward<FSetup>(setup),
                                                               std::forward<FRecord>(record));
        }
        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 BindPass(PassHandle pass, PassHandle other);
        void BindShader(PassHandle pass, RHIShaderStage stage, StringView entry_point, const char* shader_path,
                        Span<const char> specializationData = {}, uint32_t rtHitGroupIndex = 0) const;
        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, RHIDeviceDescriptorSetLayout* layout);
        void BindTextureSRV(PassHandle pass, ResourceHandle texture, StringView bind_point,
                                      RHIPipelineStage stage, RHITextureViewDesc const& desc) const;
        void BindTextureUAV(PassHandle pass, ResourceHandle texture, StringView bind_point,
                                      RHIPipelineStage stage, RHITextureViewDesc const& desc) const;
        void
        BindTextureRTV(PassHandle pass, ResourceHandle texture, RHITextureViewDesc const& desc,
                       RHIPipelineState::PipelineStateDesc::Attachment::Blending const& blending = {}) const;
        void BindTextureDSV(PassHandle pass, ResourceHandle texture, RHITextureViewDesc const& desc) const;
        void BindBackbufferRTV(PassHandle pass,
                               RHIPipelineState::PipelineStateDesc::Attachment::Blending const& blending = {}) const;
        void BindBackbufferUAV(PassHandle pass, int set_index) const;
        void BindTextureCopyDst(PassHandle pass, ResourceHandle texture,
                                RHITextureSubresourceRange const& range = {}) const;
        void BindTextureCopySrc(PassHandle pass, ResourceHandle texture,
                                RHITextureSubresourceRange const& range = {}) const;
        void BindAccelerationStructureWrite(PassHandle pass, ResourceHandle as) const;
        void BindAccelerationStructureSRV(PassHandle pass, ResourceHandle as, RHIPipelineStage stage,
                                          StringView bind_point) const;
 
#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*, RHIAccelerationStructure*>
        DerefResource(const ResourceHandle handle) const
        {
            CHECK(mResources && handle < mResources->resources.size());
            using Tv = Variant<RHIBuffer*, RHITexture*, RHIAccelerationStructure*>;
            auto& res = mResources->resources[handle];
            CHECK_MSG(!res.valueless_by_exception(), "Resource handle {} is valueless", handle);
            auto ptr = res.Visit([](auto* ptr) -> Tv { return ptr; }, [](auto& hdl) -> Tv { return hdl.Get(); });
            CHECK_MSG(!ptr.valueless_by_exception(), "Resource handle {} is null", handle);
            return ptr;
        }
        [[nodiscard]] RHITextureView* DerefTextureView(const ResourceHandle handle) const
        {
            CHECK(mResources && handle < mResources->views.size());
            using Tv = RHITextureView*;
            auto& view = mResources->views[handle];
            CHECK_MSG(!view.valueless_by_exception(), "Texture view handle {} is valueless", handle);
            return view.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]] 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 set_index,
                                  RHIDeviceDescriptorSet* descriptor_set) const;
        void CmdBindDescriptorSet(PassHandle pass, RHICommandList* cmd, StringView bind_point,
                                  RHIDeviceDescriptorSet* descriptor_set) const;
        void CmdBeginGraphics(PassHandle pass, RHICommandList* cmd, RHIExtent2D const& extent,
                              Span<const Optional<RHIClearColor>> clear_rtv = {},
                              Optional<RHIClearDepthStencil> const& clear_dsv = RHIClearDepthStencil{0.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; }
        TrackedPass const& GetTrackedPass(PassHandle pass)
        {
            CHECK_MSG(mSetup && pass < mSetup->trackedPasses.size(), "No passes available or out of bounds");
            return mSetup->trackedPasses[pass];
        }
        [[nodiscard]] bool IsAsyncComputeEnabled() const { return mDesc.asyncCompute; }
        [[nodiscard]] bool IsPresentEnabled() const { return mDesc.present; }
        void SetSwapchain(RHIDeviceHandle<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;
        Span<const uint64_t> DbgProfilePassTiming(uint64_t sync, float& resolutionNS) const;
        uint64_t DbgProfilePresentTiming(uint64_t sync, float& resolutionNS) 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();
} // namespace Foundation::RenderCore