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
    {
        struct UploadLane
        {
            ImmediateContext ctx;
            RHIDeviceScopedHandle<RHIBuffer> staging;
            char* begin;
            char* end;
            size_t signalValue{0};
 
            UploadLane(RHIDevice* device, size_t capacity, RHIDeviceQueueType type);
        };
 
        ImmediateContext ctx;
        RHIDeviceScopedHandle<RHIBuffer> staging;
 
        char *begin, *ptr, *end;
        ImmediateUpload(RHIDevice* device, size_t capacity,
                        RHIDeviceQueueType type = RHIDeviceQueueType::Graphics,
                        size_t buffers = 1);
 
        [[nodiscard]] RHICommandList* Get() const;
 
        void Begin();
 
        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 WaitIdle();
 
    private:
        RHIDevice* mDevice;
        size_t mLaneCount{1};
        size_t mCurrentLane{0};
        size_t mNextSignalValue{1};
        size_t mLane0SignalValue{0};
        char* mLane0Begin{nullptr};
        char* mLane0End{nullptr};
        RHIDeviceScopedHandle<RHIDeviceSemaphore> mCompletionTimeline;
        Core::Vector<Core::UniquePtr<UploadLane>> mLanes;
        Core::Vector<RHIDeviceQueue::TimelinePair> mSubmitSignals;
 
        [[nodiscard]] ImmediateContext& CurrentContext();
        [[nodiscard]] ImmediateContext const& CurrentContext() const;
        [[nodiscard]] RHIBuffer* CurrentStaging() const;
        [[nodiscard]] char* CurrentBegin() const;
        [[nodiscard]] char* CurrentEnd() const;
        [[nodiscard]] size_t& CurrentSignalValue();
        void WaitCurrentLaneReusable();
        void SelectCurrentLane();
    };
 
    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();
    };
 
} // namespace Foundation::RenderCore