Renderer.hpp

Go to the documentation of this file.

#pragma once
#include <Core/AllocatorStack.hpp>
#include <Core/JobSystem.hpp>
#include <Core/Logging.hpp>
#include <Core/ThreadPool.hpp>
#include <RHICore/Command.hpp>
#include <RHICore/Descriptor.hpp>
#include <RHICore/Device.hpp>
#include <RHICore/PipelineState.hpp>
#include "Shader.hpp"
 
using namespace Foundation;
using namespace RHI;
namespace Foundation::RenderCore
{
    class Presenter;
    class Renderer;
    using PassHandle = Handle; // Index in the pass definitions vector
    using ResourceHandle = Handle; // Index in the resource definitions vector
    class TemporalResourceHandle
    {
        friend class Renderer;
        ResourceHandle mCurrent{kInvalidHandle};
        ResourceHandle mPrevious{kInvalidHandle};
 
        TemporalResourceHandle(ResourceHandle current, ResourceHandle previous) :
            mCurrent(current), mPrevious(previous)
        {
        }
 
    public:
        TemporalResourceHandle() = default;
        [[nodiscard]] ResourceHandle Current() const { return mCurrent; }
        [[nodiscard]] ResourceHandle Previous() const { return mPrevious; }
        [[nodiscard]] bool IsValid() const
        {
            return mCurrent != kInvalidHandle && mPrevious != kInvalidHandle;
        }
    };
    struct RendererDesc
    {
        bool asyncCompute{true};
        uint32_t threadCount{4u};
        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::DepthStencilRead |
        RHIResourceAccessBits::UniformRead | RHIResourceAccessBits::TransferRead | RHIResourceAccessBits::HostRead;
    using ResourceDefinition =
        Variant<RHIBufferDesc,
                RHITextureDesc, /* RHIAccelerationStructureDesc - not yet. Do we want to do this in RG at all? */
                RHIBuffer*, RHITexture*, RHIAccelerationStructure*>;
    const size_t kTextureAspectCount = 3; // Color, depth, stencil @ref RHITextureAspectFlag
    struct TrackedResource
    {
        ResourceHandle handle; // Index to tracked resources
        String name;
        ResourceDefinition desc;
        ResourceHandle temporalFamily{kInvalidHandle};
        uint8_t temporalFramesAgo{0};
        bool hasComputeUsage{false}; // Used in a compute pass?
        bool hasGraphicsUsage{false}; // Used in a graphics pass?
        /* --- states --- */
        // (Buffer) Last known state
        // Transitions here are always global since granularity would be too fine. And seems
        // like drivers don't really care?
        // See Also: https://www.reddit.com/r/vulkan/comments/v2mswb/global_memory_barriers_vs_bufferimage_memory/
        // TODO: Investigate
        struct PreparedTransition
        {
            PassHandle consumer{kInvalidHandle};
            size_t frame{0};
            int graphicsGroupIndex{-1};
            RHIResourceAccess access{};
            RHIPipelineStage stage{};
            RHITextureLayout layout{};
        };
        struct BufferState
        {
            // Last pass to write at Setup time
            PassHandle producer{kInvalidHandle};
            // Last actual writer at Execute time
            PassHandle lastProducer{kInvalidHandle};
            size_t lastProducedFrame{0};
            RHIDeviceQueueType lastOwnerQueue{RHIDeviceQueueType::Undefined};
            PreparedTransition preparedTransition{};
            RHIResourceAccess access{};
            RHIPipelineStage stage{};
            void reset()
            {
                producer = kInvalidHandle;
                lastOwnerQueue = RHIDeviceQueueType::Undefined;
                preparedTransition = {};
                access = {};
                stage = {};
            }
        } lastBufferState{};
 
        // (Texture) Per-subresource states
        uint32_t textureLayers{0}, textureMips{0};
        struct SubresourceState
        {
            size_t layer{0}, mip{0};
            RHITextureAspectFlagBits aspect{};
            /* -- states -- */
            // Last pass to write at Setup time
            PassHandle producer{kInvalidHandle};
            // Last actual writer at Execute time
            PassHandle lastProducer{kInvalidHandle};
            size_t lastProducedFrame{0};
            RHIDeviceQueueType lastOwnerQueue{RHIDeviceQueueType::Undefined};
            PreparedTransition preparedTransition{};
            RHIResourceAccess access{};
            RHIPipelineStage stage{};
            RHITextureLayout layout{};
            void reset()
            {
                producer = kInvalidHandle;
                lastOwnerQueue = RHIDeviceQueueType::Undefined;
                preparedTransition = {};
                access = {};
                stage = {};
                layout = {};
            }
            [[nodiscard]] RHITextureSubresourceRange ToRange() const;
        };
        // [mip...,
        //   layer...,
        //      aspect...]
        Vector<SubresourceState> lastSubresourceStates;
        auto GetLastSubresourceStateOf(RHITextureSubresourceRange const& range)
        {
            auto [mip_begin, mip_end] = range.GetMipLevelRange();
            auto [layer_begin, layer_end] = range.GetArrayLayerRange();
            CHECK(mip_end < textureMips);
            CHECK(layer_end < textureLayers);
            uint32_t mip_stride = textureLayers * kTextureAspectCount;
            return std::views::all(Span<SubresourceState>(lastSubresourceStates.begin() + mip_begin * mip_stride,
                                                     lastSubresourceStates.begin() + (mip_end + 1) * mip_stride)) |
                std::views::filter(
                       [=](const SubresourceState& state)
                       {
                           return (RHITextureAspectFlag(state.aspect) & range.layer.aspect) && state.mip >= mip_begin &&
                               state.mip <= mip_end && state.layer >= layer_begin && state.layer <= layer_end;
                       });
        }
 
        using AccelerationStructureState = BufferState;
        // (Acceleration Structure) Last known state
        AccelerationStructureState lastASState{};
        void ResetStates()
        {
            lastBufferState = {};
            lastASState = {};
            for (auto& sta : lastSubresourceStates)
                sta.reset();
        }
        TrackedResource(ResourceHandle handle, StringView name, const ResourceDefinition& resourceDesc,
                        Allocator* alloc);
    };
    struct ExecuteResources
    {
        using TextureViewHandle = Variant<RHITextureScopedHandle<RHITextureView>, RHITextureHandle<RHITextureView>>;
        struct TextureViews
        {
            TextureViewHandle slots[2];
            bool temporal{false};
        };
        Vector<Variant<RHIBuffer*, RHIDeviceScopedHandle<RHIBuffer>, RHITexture*, RHIDeviceScopedHandle<RHITexture>,
                       RHIAccelerationStructure*>>
            resources;
        Vector<TextureViews> views;
        Vector<RHIDeviceScopedHandle<RHIDeviceSampler>> samplers;
        explicit ExecuteResources(Allocator* allocator) : resources(allocator), views(allocator), samplers(allocator) {}
        void fit(ResourceHandle handle)
        {
            resources.resize(std::max(resources.size(), static_cast<size_t>(handle + 1)));
            views.resize(std::max(views.size(), static_cast<size_t>(handle + 1)));
            samplers.resize(std::max(samplers.size(), static_cast<size_t>(handle + 1)));
        }
    };
    class RenderPass : public RHIObject
    {
    public:
        RenderPass() = default;
        virtual void Setup(PassHandle self, Renderer* r) = 0;
        virtual void Record(PassHandle self, Renderer* r, RHICommandList* cmd) = 0;
    };
    struct FSetupDefault
    {
        void operator()(PassHandle, Renderer*) const { /* nop */ }
    };
    struct FRecordDefault
    {
        void operator()(PassHandle, Renderer*, RHICommandList*) const { /* nop */ }
    };
    template <typename FSetup, typename FRecord>
    struct LambdaPass : RenderPass
    {
        FSetup mSetup;
        FRecord mRecord;
        LambdaPass(FSetup&& setup, FRecord&& record) :
            mSetup(std::forward<FSetup>(setup)), mRecord(std::forward<FRecord>(record))
        {
        }
        void Setup(PassHandle self, Renderer* r) override { mSetup(self, r); }
        void Record(PassHandle self, Renderer* r, RHICommandList* cmd) override { mRecord(self, r, cmd); }
    };
    struct TrackedPass
    {
        String name;
        PassHandle handle; // Index to tracked passes
        int priority{0}; // Higher priority passes are scheduled earlier
        // The queue to run this pass on
        RHIDeviceQueueType queue;
        bool used{false}; // Culled?
        bool unCullable{false}; // Acts as an additional execution root
        // Backbuffer specializations
        Optional<RHIPipelineState::PipelineStateDesc::Attachment::Blending> backbufferRTV{}; // opt: blending mode
        Optional<int> backbufferUAV; // opt: set index
        // Uses compute shader? (not necessarily in a compute queue)
        // Should be mutually exclusive with write_backbuffer and other graphics states
        bool isComputePass{false};
        // Uses RayGen/RayHit/RayMiss at all?
        // Should be compatible with most graphics states, and can be run on either queue
        bool isRayTracingPass{false};
        // Local size for compute/mesh shaders
        Tuple<uint32_t, uint32_t, uint32_t> groupLocalSize{};
        size_t depth{}; // Depth in RG
        size_t ord{}; // Execution order
        size_t frameExec{}; // Last frame this pass is executed
        /* -- Resources -- */
        Vector<PassHandle> bindPasses; // Referenced, explicit pass execute-before.
        Vector<Tuple<ResourceHandle, RHIResourceAccess, RHIPipelineStage, RHITextureSubresourceRange,
                     RHITextureLayout>>
            textureUsages; // Referenced texture sub resources
        Vector<Tuple<ResourceHandle, RHIResourceAccess,
                     RHIPipelineStage>> bufferUsages; // Referenced buffers
        Vector<Tuple<ResourceHandle, RHIResourceAccess,
                     RHIPipelineStage>>
            asUsages; // Referenced Acceleration Structures
        // Unique referenced resources (tex/buf/AS)
        Vector<ResourceHandle> resources;
        // Unique texture views
        Vector<ResourceHandle> texviews;
        /* -- Pipeline -- */
        // Shader [path, entry point, stage, specialization data, RT hit group, RT hit group type]
        Vector<Tuple<String, String, RHIShaderStage, Vector<char>, uint32_t,
                     RHIPipelineState::PipelineStateDesc::RayTracingHitGroupType>>
            shaders;
        // Bind points [view(tex) or buffer(buf), desc type, binding point]
        Vector<Tuple<ResourceHandle, RHIDescriptorType, String>> textureBindings, bufferBindings, asBindings;
        // External Bind Sets [binding point, layout ptr, set index (set when built)]
        // Sorted lexicographically if the pipeline is built.
        Vector<Tuple<String, RHIDeviceDescriptorSetLayout*, int>> externalBindings;
        // Samplers
        Vector<Pair<ResourceHandle, String>> samplers;
        // Push Constant
        Vector<RHIPipelineState::PipelineStateDesc::PushConstant> pushConstants;
        // Specialization Constants by [stage, offset, value]
        Vector<Tuple<RHIShaderStage, size_t, Vector<char>>> specializationConstants;
        // (Graphics Only) Render Target View[s], Blending Op
        Vector<Pair<ResourceHandle, RHIPipelineState::PipelineStateDesc::Attachment::Blending>> rtvs;
        // (Graphics Only) Depth Stencil View
        ResourceHandle dsv{kInvalidHandle};
        bool isDepthReadOnly{false};
        // (Graphics Only) Vertex Input assembly
        Vector<RHIPipelineState::PipelineStateDesc::VertexInput::Binding> vertexInputBindings;
        Vector<RHIVertexAttribute> vertexInputAttributes;
        /* --- */
        UniquePtr<RenderPass> pass;
        TrackedPass(Allocator* alloc, PassHandle handle, StringView name, RHIDeviceQueueType queue,
                    UniquePtr<RenderPass> renderPass, size_t priority);
        /* -- Pipeline states (built at PSO setup) -- */
        int groupIndex{}; // executionGroup index
        // All stages used in this pass
        RHIPipelineStageBits piplineStages{};
        // Pipeline states for the entire pass
        RHIDeviceScopedHandle<RHIPipelineState> pso;
        // PSO Creation parameters
        RHIPipelineState::PipelineStateDesc::Rasterizer psoRasterizer{};
        RHIPipelineState::PipelineStateDesc::DepthStencil psoDepthStencil{};
        RHIPipelineState::PipelineStateDesc::Topology psoTopology{RHIPipelineState::PipelineStateDesc::TriangleList};
        // Layouts created by ourselves
        Vector<RHIDeviceScopedHandle<RHIDeviceDescriptorSetLayout>> descriptorLayouts;
        // Pointers. Can also contain external sets
        Vector<RHIDeviceDescriptorSetLayout*> pDescriptorLayouts;
        // Sets created by ourselves, with an alternate mapping for temporal resources
        Vector<RHIDeviceDescriptorPoolScopedHandle<RHIDeviceDescriptorSet>> descriptorSets, alternateDescriptorSets;
        Vector<RHIDeviceDescriptorSet*> pDescriptorSets, pAlternateDescriptorSets;
        // [Set Index, Set, Layout], correspond to externalBindings
        Vector<Tuple<size_t, RHIDeviceDescriptorSetLayout*>> pExternalDescriptorSets;
 
 
        RHIDevicePipelineType GetPipelineType() const
        {
            if (isComputePass)
                return RHIDevicePipelineType::Compute;
            if (isRayTracingPass)
                return RHIDevicePipelineType::RayTracing;
            return RHIDevicePipelineType::Graphics;
        }
        void ResetPipeline();
    };
    class Renderer
    {
        struct RendererSetup
        {
            Vector<Vector<Pair<PassHandle, ResourceHandle>>> graph;
            Vector<PassHandle> in;
            Vector<TrackedPass> trackedPasses;
            Vector<TrackedResource> trackedResources;
            struct TemporalResourceFamily
            {
                ResourceHandle slots[2];
                uint64_t invalidatedFrame{0};
            };
            Vector<TemporalResourceFamily> temporalResources;
            // 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;
            Map<uintptr_t, PassHandle> descriptorSetWriters;
            // 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),
                temporalResources(allocator), trackedViews(allocator), trackedSamplers(allocator), activeResources(allocator),
                descriptorSetWriters(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};
        Core::JobSystem* mJobs{nullptr};
        Atomic<bool> mPipelineStateCompilationComplete{false};
 
        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};
        RHIDeviceSemaphore* mExecuteImageAcquire{nullptr};
 
        UniquePtr<ExecuteResources> mResources;
        RHIDeviceScopedHandle<RHIDeviceDescriptorPool> mDescPool;
        Mutex mDescPoolMutex;
        // Per swap primitives
        struct FrameSyncObjects
        {
            // Index of this swap
            const size_t swapIndex;
            RHIDeviceScopedHandle<RHIDeviceSemaphore> render{};
            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;
 
            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);
        Core::JobBarrier 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:
                CHECK_MSG(false, "Unhandled queue type");
                return kCommandQueueTransferIgnored;
            }
        }
        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);
        [[nodiscard]] ResourceHandle ResolveResourceHandle(ResourceHandle handle, uint64_t frame) const;
        [[nodiscard]] Variant<RHIBuffer*, RHITexture*, RHIAccelerationStructure*>
        DerefPhysicalResource(ResourceHandle handle) const;
        [[nodiscard]] Variant<RHIBuffer*, RHITexture*, RHIAccelerationStructure*>
        DerefResourceAtFrame(ResourceHandle handle, uint64_t frame) const;
        [[nodiscard]] RHITextureView* DerefTextureViewAtFrame(ResourceHandle handle, uint64_t frame) const;
        void ExecuteBarriers(TrackedPass& pass, ExecuteBarrierPCmdOrPBarrierList cmd);
        void WaitSync();
        void ResetSync();
        void AcquireSync();
        void BeginExecute(uint32_t swapImageIndex, RHIDeviceSemaphore* imageAcquire);
        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, Core::JobSystem* jobs, 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;
        }
        template <typename T>
        [[nodiscard]] TemporalResourceHandle CreateTemporalResource(StringView name, T const& desc)
        {
            static_assert(std::is_same_v<T, RHIBufferDesc> || std::is_same_v<T, RHITextureDesc>,
                          "Temporal resources currently support owned buffers and textures only");
            CHECK(mState == State::Setup);
 
            ResourceHandle current = CreateResource(Format("{} [0]", name), desc);
            ResourceHandle previous = CreateResource(Format("{} [1]", name), desc);
            ResourceHandle family = mSetup->temporalResources.size();
            mSetup->temporalResources.push_back({{current, previous}, mFrameSwapped});
            mSetup->trackedResources[current].temporalFamily = family;
            mSetup->trackedResources[current].temporalFramesAgo = 0;
            mSetup->trackedResources[previous].temporalFamily = family;
            mSetup->trackedResources[previous].temporalFramesAgo = 1;
            return TemporalResourceHandle(current, previous);
        }
        [[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, StringView shader_path,
                        Span<const char> specializationData = {}, uint32_t rtHitGroupIndex = 0,
                        RHIPipelineState::PipelineStateDesc::RayTracingHitGroupType rtHitGroupType =
                            RHIPipelineState::PipelineStateDesc::RayTracingHitGroupType::Triangles) 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 BindBufferIndirectRead(PassHandle pass, ResourceHandle buffer) 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 BindDescriptorSetWrite(PassHandle pass, StringView bind_point, RHIDeviceDescriptorSetLayout* layout,
                                    RHIDeviceDescriptorSetLayout* reading_layout = nullptr);
        void BindDescriptorSetWrite(PassHandle pass, RHIDeviceDescriptorSetLayout* layout,
                                    RHIDeviceDescriptorSetLayout* reading_layout = nullptr);
        void BindDescriptorSetRead(PassHandle pass, StringView bind_point, RHIDeviceDescriptorSetLayout* layout);
        void MakePassUncullable(PassHandle pass) const;
        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 BindTextureShaderRead(PassHandle pass, ResourceHandle texture, RHIPipelineStage stage,
                                   RHITextureSubresourceRange const& range) 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,
                            bool readOnly = false) 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;
        void PassSetTopology(PassHandle pass, RHIPipelineState::PipelineStateDesc::Topology topology) const;
#pragma endregion
        Core::JobBarrier EndSetup(bool wait = true);
#pragma endregion
#pragma region Diagnostics
        struct MemoryStat
        {
            String name;
            size_t bytes;
        };
        struct TexturePreviewStat
        {
            String name;
            ResourceHandle resourceHandle{kInvalidHandle};
            ResourceHandle viewHandle{kInvalidHandle};
            RHIResourceFormat format{RHIResourceFormat::Undefined};
            RHITextureView* view{};
        };
        void DbgGetMemoryStatistics(Vector<MemoryStat>& outStats) const;
        void DbgGetTexturePreviews(Vector<TexturePreviewStat>& outStats) const;
#pragma endregion
#pragma region Swapchain
        [[nodiscard]] RHIDevice* GetDevice() const { return mDevice.Get(); }
        [[nodiscard]] const RHIApplication* GetApplication() const { return &mDevice->mApp; }
        [[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
        {
            return DerefResourceAtFrame(handle, mFrameSwapped);
        }
        [[nodiscard]] RHITextureView* DerefTextureView(const ResourceHandle handle) const
        {
            return DerefTextureViewAtFrame(handle, mFrameSwapped);
        }
        [[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 RHIColorAttachmentLoad> rtv_loads = {},
                              RHIDepthAttachmentLoad dsv_load = {RHIAttachmentLoadOp::Clear, {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]] bool IsPreviousValid(TemporalResourceHandle resource) const;
        void InvalidateTemporalResource(TemporalResourceHandle resource);
        [[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 mSwapchain.IsValid(); }
        void SetSwapchain(RHIDeviceHandle<RHISwapchain> swapchain);
        RHISwapchain* GetSwapchain() const { return mSwapchain.Get(); }
 
        [[nodiscard]] RHIDeviceHandle<RHIDeviceSemaphore> GetRenderCompleteSemaphore() const;
 
        void WaitForFrame();
        void BeginExecute();
        RHISwapchainResult BeginExecute(Presenter* presenter);
        void ExecuteFrame();
        void EndExecute();
#pragma endregion
#pragma region Debugging
        struct DebugGraphNode
        {
            StringView name;
            PassHandle handle{kInvalidHandle};
            RHIDeviceQueueType queue{RHIDeviceQueueType::Undefined};
            bool used{};
            bool epilogue{};
            size_t depth{};
            size_t ord{};
            int groupIndex{};
        };
        struct DebugGraphEdge
        {
            PassHandle consumer{kInvalidHandle};
            PassHandle producer{kInvalidHandle};
            StringView resourceName;
        };
        void DbgGetGraph(Vector<DebugGraphNode>& outNodes, Vector<DebugGraphEdge>& outEdges) const;
        [[nodiscard]] String DbgDumpGraphviz() const;
        [[nodiscard]] String DbgDumpActivePasses() const;
        [[nodiscard]] String DbgDumpExecutionGroups() const;
        Span<const uint64_t> DbgProfilePassTiming(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