StagingBuffer.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Allocator.hpp>
#include <RenderCore/Renderer.hpp>
 
namespace Foundation::Rendering
{
    using namespace RHI;
    using namespace Core;
    using namespace RenderCore;
    // [Source Buffer (staging), Dest Buffer, CopyRegion]
    using BufferStagingItem = Tuple<RHIBuffer*, RHIBuffer*, RHICommandList::CopyBufferRegion>;
    using BufferStagingList = Vector<BufferStagingItem>;
    using BufferCopyList = Vector<RHICommandList::CopyBufferRegion>;
    class StagingBuffer
    {
        Allocator* mAllocator;
        RHIDevice* mDevice;
        RHIDeviceScopedObjectHandle<RHIBuffer> mBuffer;
        void* mMapped;
        size_t mSize;
        size_t mOffset = 0;
 
    public:
        StagingBuffer(RHIDevice* device, size_t size, Allocator* allocator);
        size_t Write(Span<const char> data, size_t alignment);
        void Seek(size_t offset, size_t alignment);
        [[nodiscard]] size_t Tell() const { return mOffset; }
        [[nodiscard]] size_t Size() const { return mSize; }
        [[nodiscard]] size_t FreeSize() const { return mSize - mOffset; }
        void Reset();
 
        [[nodiscard]] RHIBuffer* GetBuffer() const { return mBuffer.Get(); }
    };
    extern BufferStagingList& CoalesceBufferStaging(BufferStagingList& res);
    class StagedBuffer : public RHIObject /* pinned */
    {
    public:
        enum class State
        {
            Idle,
            Transfer,
        };
 
    private:
        RHIDevice* mDevice{nullptr};
        Allocator* mAllocator{nullptr};
 
        StagingBuffer mStagingBuffer;
        // Destination buffer
        RHIDeviceScopedObjectHandle<RHIBuffer> mBuffer;
 
        State mState{State::Idle};
        BufferStagingList mBufferStagings;
 
        RHIDeviceIdleGuard mIdleGuard;
        Optional<uint32_t> mClearValue;
 
    public:
        StagedBuffer(RHIDevice* device, Allocator* allocator, RHIBufferDesc const& desc = {},
                     size_t stagingBudget = kFullSize, Optional<uint32_t> clearValue = {});
        RHIBuffer* GetBuffer() { return mBuffer.Get(); }
        void BeginTransfer();
        StagingBuffer* GetStagingBuffer();
        void Transfer(size_t dst_offset, Span<const char> data, size_t alignment = 4);
        void EndTransfer();
        bool HasUpdates() { return mClearValue.has_value() || !mBufferStagings.empty(); }
        void Update(RHICommandList* cmd);
    };
    ENUM_NAME_CONV_BEGIN(StagedBuffer::State)
    ENUM_NAME(Idle)
    ENUM_NAME(Transfer)
    ENUM_NAME_CONV_END()
} // namespace Foundation::Rendering