ImmediateContext.hpp

Go to the documentation of this file.

#pragma once
#include <Core/AtomicPool.hpp>
#include <Core/Variant.hpp>
#include <RHICore/Command.hpp>
#include <RHICore/Resource.hpp>
namespace Foundation::RenderCore
{
    using namespace RHI;
    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 WaitIdle();
    };
 
    struct ImmediateUpload
    {
        ImmediateContext ctx;
        RHIDeviceScopedHandle<RHIBuffer> staging;
 
        char *begin, *ptr, *end;
        ImmediateUpload(RHIDevice* device, size_t capacity) :
            ctx(RHIDeviceQueueType::Graphics, device),
            staging(device->CreateBuffer({.resource =
                                              {
                                                  .heap = RHIDeviceHeapType::Upload,
                                                  .shared = false, /* Transfer only */
                                                  .coherent = true, /* No flush required */
                                                  .staging = true,
                                              },
                                          .usage = RHIBufferUsageBits::TransferSource,
                                          .size = capacity}))
        {
            begin = ptr = staging->Map<char>();
            end = ptr + capacity;
        }
 
        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 = {});
 
        bool Align(uint32_t alignment);
        void End(RHIDeviceFence* completionFence = nullptr);
 
        void WaitIdle();
    };
 
} // namespace Foundation::RenderCore