GPUScene.hpp

Go to the documentation of this file.

#pragma once
#include <Bits/Format.hpp>
#include <Core/Pool.hpp>
#include "StagingBuffer.hpp"
#include "UploadContext.hpp"
#include "VirtualAllocator.hpp"
namespace Foundation::Rendering
{
    using namespace Foundation;
    using namespace RenderCore;
    using namespace Bits;
    struct GPUSceneBudgets
    {
        // Instance: Full update every frame, fixed allocation sizes
        size_t instanceBudget = 1_MB;
        size_t instanceAlignment = 16_B;
        // Shared: Partial update every frame, dynamic allocation
        size_t sharedBudget = 1_MB;
        size_t sharedStaging = 1_MB;
        // Const: Partial update every frame, dynamic allocation
        size_t constBudget = 128_MB;
        size_t constStaging = 16_MB;
        [[nodiscard]] constexpr size_t totalBudget() const { return instanceBudget + sharedBudget + constBudget; }
        [[nodiscard]] constexpr size_t totalStaging() const { return instanceBudget + sharedStaging; }
    };
    class GPUScene
    {
        struct StagedDoubleBuffer
        {
            Allocator* const alloc;
            char* const data;
            const size_t size;
            const size_t alignment;
 
            StagedBuffer buffer;
            Async::Mutex mutex;
 
            StagedDoubleBuffer(RHIDevice* device, size_t size, size_t stagingSize, size_t alignment, Allocator* alloc);
            ~StagedDoubleBuffer();
 
            template <typename T>
            Span<T> View()
            {
                CHECK_MSG(alignment % alignof(T) == 0,
                          "Bad alignment for type. Type must be aligned on multiples of {}", alignment);
                return {reinterpret_cast<T*>(data), size / sizeof(T)};
            }
        };
        Allocator* mAllocator;
        /* -- Instance -- */
        StagedDoubleBuffer mInstance; // Instance data [updated every frame as a whole]
        bool mInstanceDirty{false};
        Async::Mutex mInstanceMutex; // Mutex for instance data mapping
        /* -- Shared -- */
        StagedDoubleBuffer mShared; // Shared (instance) data [partially updated every frame, could be empty]
        VirtualAllocator mSharedAlloc; // Allocator for Shared data
        Vector<Pair<size_t, size_t>> mSharedUpdateRegions; // Shared regions to update next frame
        /* -- Const -- */
        StagedDoubleBuffer mConst; // Const data [updated on demand, could be empty]
        VirtualAllocator mConstAlloc; // Allocator for Const data
        Vector<Pair<size_t, size_t>> mConstUpdateRegions; // Const regions to update next frame
    public:
        GPUScene(RHIDevice* device, GPUSceneBudgets const& budgets, Allocator* alloc);
 
        void CreateUpdatePasses(Renderer* renderer, ResourceHandle& outInstanceBuffer, ResourceHandle& outSharedBuffer,
                                ResourceHandle& outConstBuffer,
                                RHIDeviceQueueType queue = RHIDeviceQueueType::Graphics);
        /* -- Instance -- */
        template <typename T>
        Span<T> MapInstanceData()
        {
            mInstanceMutex.lock();
            return mInstance.View<T>();
        }
        void UnmapInstanceData()
        {
            mInstanceMutex.unlock();
            mInstanceDirty = true;
        }
        /* -- Shared -- */
        VirtualAllocation PushShared(Span<const char> data, size_t alignment);
        Pair<size_t, size_t> QueryShared(VirtualAllocation allocation);
        void UpdateShared(VirtualAllocation allocation, Span<const char> data);
        void FreeShared(VirtualAllocation allocation);
        /* -- Const -- */
        VirtualAllocation PushConst(Span<const char> data, size_t alignment);
        Pair<size_t, size_t> QueryConst(VirtualAllocation id);
        void UpdateConst(VirtualAllocation allocation, Span<const char> data);
        void FreeConst(VirtualAllocation allocation);
    };
} // namespace Foundation::Rendering