Bindless.hpp

Go to the documentation of this file.

#pragma once
#include <RHICore/Resource.hpp>
#include <RHICore/Command.hpp>
#include <Core/AtomicPool.hpp>
namespace Foundation::RenderCore
{
    using namespace RHI;
    // TODO: Buffers?
    class BindlessPool
    {
        using Resource = Variant<
            RHITexture*,
            RHIDeviceScopedHandle<RHITexture>
        >;
        using View = Variant<
            // Texture Views
            RHITextureView*,
            RHITextureScopedHandle<RHITextureView>
        >;
        struct Binding
        {
            uint32_t id;
            Resource resource;
            View view;
            size_t referencedTextureBytes{};
            size_t ownedTextureBytes{};
        };
 
        RHIDevice* const mDevice;
        Allocator* const mAllocator;
 
        AtomicPool<Binding> mBindings;
 
        RHIDeviceScopedHandle<RHIDeviceDescriptorSetLayout> mDescLayout;
        RHIDeviceScopedHandle<RHIDeviceDescriptorPool> mDescPool;
        RHIDeviceDescriptorPoolScopedHandle<RHIDeviceDescriptorSet> mDescSet;
        RHIDeviceScopedHandle<RHIDeviceDescriptorSetLayout> mStorageDescLayout;
        RHIDeviceScopedHandle<RHIDeviceDescriptorPool> mStorageDescPool;
        RHIDeviceDescriptorPoolScopedHandle<RHIDeviceDescriptorSet> mStorageDescSet;
 
        Mutex mDescMutex;
        uint32_t mActiveBindings{0};
        uint32_t mOwnedTextureBindings{0};
        size_t mReferencedTextureBytes{0};
        size_t mOwnedTextureBytes{0};
 
        RHIDeviceIdleGuard mIdleGuard;
 
        uint32_t UpdateDescriptor(uint32_t id, RHITextureView* view);
        void UpdateStorageDescriptor(uint32_t id, RHITextureView* view);
        void AddStats(Binding const& binding);
        void RemoveStats(Binding const& binding);
    public:
        struct BindlessPoolDesc
        {
            uint32_t maxBindings = 1024;
        };
        struct Stats
        {
            uint32_t activeBindings{};
            uint32_t capacity{};
            uint32_t ownedTextureBindings{};
            size_t referencedTextureBytes{};
            size_t ownedTextureBytes{};
        };
        const BindlessPoolDesc mDesc;
        BindlessPool(RHIDevice* device, Allocator * allocator, BindlessPoolDesc const& desc);
 
        uint32_t Allocate(RHITextureView* view);
        uint32_t Allocate(RHIDeviceScopedHandle<RHITexture>&& texture, RHITextureScopedHandle<RHITextureView>&& view);
        uint32_t Update(uint32_t id, RHIDeviceScopedHandle<RHITexture>&& texture, RHITextureScopedHandle<RHITextureView>&& view);
        void Free(uint32_t id);
 
        RHITexture* GetResource(uint32_t id);
        RHITextureView* GetView(uint32_t id);
        [[nodiscard]] Stats GetStats() const;
 
        RHIDeviceDescriptorSetLayout* GetDescriptorSetLayout() const { return mDescLayout.Get(); }
        RHIDeviceDescriptorSet* GetDescriptorSet() const { return mDescSet.Get(); }
        RHIDeviceDescriptorSetLayout* GetStorageDescriptorSetLayout() const { return mStorageDescLayout.Get(); }
        RHIDeviceDescriptorSet* GetStorageDescriptorSet() const { return mStorageDescSet.Get(); }
        void UpdateStorageView(uint32_t id, RHITextureView* view);
        void ClearStorageView(uint32_t id) { UpdateStorageView(id, nullptr); }
    };
}