ImmediateContext.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <RHICore/Command.hpp>
#include <RHICore/Device.hpp>
#include <RHICore/Resource.hpp>
namespace Foundation::RenderCore
{
    using namespace RHI;
 
    struct ImmediateSubmitDesc
    {
        Span<const RHIDeviceQueue::TimelinePair> timelineWaits{};
        Span<const RHIDeviceQueue::TimelinePair> timelineSignals{};
        Span<const RHIPipelineStage> waitStages{};
        RHIDeviceFence* completionFence{nullptr};
    };
 
    class ImmediateContext
    {
        RHIDevice* const mDevice;
        RHIDeviceQueue* mQueue;
 
        RHIDeviceScopedHandle<RHICommandPool> mCommandPool;
        RHICommandPoolScopedHandle<RHICommandList> mCommandList; // Persistent
    public:
        ImmediateContext(RHIDeviceQueueType type, RHIDevice* device);
        ImmediateContext(RHIDevice* device) : ImmediateContext(RHIDeviceQueueType::Graphics, device) {}
 
        [[nodiscard]] RHICommandList* Get() const { return mCommandList.Get(); }
        RHICommandList* operator->() { return mCommandList.Get(); }
 
        void Submit(RHIDeviceFence* completionFence = nullptr);
        void Submit(ImmediateSubmitDesc const& desc);
 
        void WaitIdle();
    };
 
    struct ImmediateUpload
    {
        class UploadBatch
        {
            friend struct ImmediateUpload;
            ImmediateUpload* mOwner{};
            size_t mLane{SIZE_MAX};
            size_t mCompletionValue{};
 
            UploadBatch(ImmediateUpload* owner, size_t lane) noexcept;
 
        public:
            char *begin{}, *ptr{}, *end{};
 
            UploadBatch() = default;
            UploadBatch(UploadBatch const&) = delete;
            UploadBatch& operator=(UploadBatch const&) = delete;
            UploadBatch(UploadBatch&& other) noexcept;
            UploadBatch& operator=(UploadBatch&& other) noexcept;
            ~UploadBatch() noexcept;
 
            [[nodiscard]] bool IsValid() const noexcept { return mOwner != nullptr; }
            [[nodiscard]] RHICommandList* Get() const;
            [[nodiscard]] size_t CompletionValue() const noexcept { return mCompletionValue; }
            [[nodiscard]] RHIDeviceSemaphore* CompletionTimeline() const;
 
            char* Upload(RHIBuffer* dst, size_t dataSize, size_t dstOffset);
            char* Upload(RHITexture* dst, size_t dataSize,
                         RHITextureSubresourceLayer dstLayer = {.aspect = RHITextureAspectFlagBits::Color},
                         RHIOffset2D dstOffset = {}, RHIExtent2D dstExtent = {});
            char* Upload(RHITexture* dst, size_t dataSize, RHITextureSubresourceLayer dstLayer, RHIOffset3D dstOffset,
                         RHIExtent3D dstExtent);
            bool Align(uint32_t alignment);
            void End(RHIDeviceFence* completionFence = nullptr);
            void End(ImmediateSubmitDesc const& desc);
            void Abort();
        };
 
        ImmediateUpload(RHIDevice* device, size_t capacity, RHIDeviceQueueType type = RHIDeviceQueueType::Graphics,
                        size_t buffers = 1);
 
        [[nodiscard]] size_t Capacity() const noexcept { return mCapacity; }
        [[nodiscard]] size_t LaneCount() const noexcept { return mLanes.size(); }
        [[nodiscard]] RHIDeviceSemaphore* CompletionTimeline() const { return mCompletionTimeline.Get(); }
 
        UploadBatch BeginBatch();
        [[nodiscard]] bool TryBeginBatch(UploadBatch& out);
        [[nodiscard]] bool WaitTimeline(size_t value, size_t timeout) const;
        void WaitIdle();
 
    private:
        struct UploadLane
        {
            ImmediateContext ctx;
            RHIDeviceScopedHandle<RHIBuffer> staging;
            char* begin{};
            char* end{};
            size_t signalValue{};
            bool recording{};
 
            UploadLane(RHIDevice* device, size_t capacity, RHIDeviceQueueType type);
        };
 
        RHIDevice* mDevice;
        size_t mCapacity{};
        size_t mNextLane{};
        size_t mNextSignalValue{1};
        RHIDeviceScopedHandle<RHIDeviceSemaphore> mCompletionTimeline;
        Core::Vector<Core::UniquePtr<UploadLane>> mLanes;
        Core::Vector<RHIDeviceQueue::TimelinePair> mSubmitSignals;
 
        [[nodiscard]] bool IsLaneReusable(size_t lane, size_t timeout);
        void WaitLaneReusable(size_t lane);
        [[nodiscard]] bool TryAcquireLane(size_t lane, UploadBatch& out);
        UploadBatch AcquireLane(size_t lane);
        void ReleaseRecording(size_t lane) noexcept;
    };
 
    struct ImmediateReadback
    {
        ImmediateContext ctx;
        RHIDeviceScopedHandle<RHIBuffer> staging;
 
        char *begin, *ptr, *end;
        ImmediateReadback(RHIDevice* device, size_t capacity, RHIDeviceQueueType type = RHIDeviceQueueType::Graphics) :
            ctx(type, device),
            staging(device->CreateBuffer({.resource =
                                              {
                                                  .heap = RHIDeviceHeapType::Readback,
                                                  .hostAccess = RHIResourceHostAccess::ReadWrite,
                                                  .shared = false, /* Transfer only */
                                                  .coherent = true, /* No invalidate required */
                                                  .staging = false,
                                              },
                                          .usage = RHIBufferUsageBits::TransferDestination,
                                          .size = capacity}))
        {
            begin = ptr = staging->Map<char>();
            end = ptr + capacity;
        }
 
        void Begin();
 
        char* Readback(RHIBuffer* src, size_t dataSize, size_t srcOffset = 0);
        char* Readback(RHITexture* src, size_t dataSize,
                       RHITextureSubresourceLayer srcLayer = {.aspect = RHITextureAspectFlagBits::Color},
                       RHIOffset2D srcOffset = {},
                       RHIExtent2D srcExtent = {});
        char* Readback(RHITexture* src, size_t dataSize, RHITextureSubresourceLayer srcLayer, RHIOffset3D srcOffset,
                       RHIExtent3D srcExtent);
 
        bool Align(uint32_t alignment);
        void End(RHIDeviceFence* completionFence = nullptr);
        void End(ImmediateSubmitDesc const& desc);
 
        void WaitIdle();
    };
 
    RHIDeviceScopedHandle<RHIBuffer> ImmediateCreateBuffer(RHIDevice* device, RHIBufferDesc const& desc,
                                                           void const* data, size_t bytes);
 
    RHIDeviceScopedHandle<RHITexture> ImmediateCreateTexture(RHIDevice* device, RHITextureDesc const& desc,
                                                           void const* data, size_t bytes,
                                                           RHITextureLayout finalLayout = RHITextureLayout::TransferDst);
 
} // namespace Foundation::RenderCore