Device.hpp

Go to the documentation of this file.

#pragma once
#include "Command.hpp"
#include "Descriptor.hpp"
#include "PipelineState.hpp"
#include "Resource.hpp"
#include "Shader.hpp"
#include "Swapchain.hpp"
 
namespace Foundation::RHI
{
    class RHIApplication;
    class RHIDevice;
    class RHIDeviceSemaphore;
    class RHIDeviceFence;
    class RHIDeviceQueue : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        RHIDeviceQueue(RHIDevice const& device) : mDevice(device) {}
 
        virtual void WaitIdle() const = 0;
        using TimelinePair = Pair<RHIDeviceSemaphore*, size_t>;
        struct SubmitDesc
        {
            // Semaphore(s) and the minimum values to wait on
            Span<const TimelinePair> timelineWaits;
            // Semaphore(s) and the values to signal
            Span<const TimelinePair> timelineSignals;
            // Binary semaphore(s) to wait when the command lists are done
            Span<RHIDeviceSemaphore* const> waits;
            // Stages the semaphore waits occur in [timeline_waits..., waits...]
            Span<const RHIPipelineStage> waitsStages{};
            // Binary semaphore(s) to signal when the command lists are done
            Span<RHIDeviceSemaphore* const> signals;
            // Command lists to submit
            Span<RHICommandList* const> cmdLists;
        };
        virtual void Submit(Span<const SubmitDesc> desc, RHIDeviceFence* completionFence = nullptr) const = 0;
 
        struct PresentDesc
        {
            uint32_t imageIndex;
            RHISwapchain* swapchain;
            // Binary semaphore(s) to wait
            Span<RHIDeviceSemaphore* const> waits;
        };
        virtual void Present(PresentDesc const& desc) const = 0;
        [[nodiscard]] virtual uint32_t GetVkQueueFamily() const = 0;
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    // https://docs.vulkan.org/samples/latest/samples/extensions/timeline_semaphore/README.html
    class RHIDeviceSemaphore : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        const bool mIsTimeline;
        RHIDeviceSemaphore(RHIDevice const& device, bool is_timeline) : mDevice(device), mIsTimeline(is_timeline) {}
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHIDeviceFence : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        RHIDeviceFence(RHIDevice const& device) : mDevice(device) {}
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    struct RHIDeviceDescriptorSetLayoutDesc
    {
        struct Binding
        {
            uint32_t count{1}; // Array size for array access
            RHIShaderStage stage{RHIShaderStageBits::All}; // Stage this binding is used in
            RHIDescriptorType type; // Type of this binding
        };
        // Bindings that make up this layout
        Span<const Binding> bindings;
        // Allow updating descriptors after being bound to a command buffer when
        // they are not used
        bool updateAfterBind{false};
    };
    class RHIDeviceDescriptorSetLayout : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        const RHIDeviceDescriptorSetLayoutDesc mDesc;
        RHIDeviceDescriptorSetLayout(RHIDevice const& device, RHIDeviceDescriptorSetLayoutDesc const& desc) :
            mDevice(device), mDesc(desc)
        {
        }
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHIDeviceSampler : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        struct SamplerDesc
        {
            struct Anisotropy
            {
                bool enable{false}; // Enable anisotropic filtering
                float maxLevel{16.0f}; // Max anisotropy level
            } anisotropy;
            struct AddressMode
            {
                enum Mode
                {
                    Repeat,
                    MirroredRepeat,
                    ClampToEdge,
                    ClampToBorder,
                    MirrorClampToEdge
                } u{Repeat},
                    v{Repeat}, w{Repeat}; // Address modes for U, V, W coordinates
            } addressMode;
            struct Mipmap
            {
                enum MipmapMode
                {
                    Linear,
                    Nearest
                } mipmapMode{Linear}; // Mipmap mode;
                float bias{0.0f}; // Mipmap LOD bias
            } mipmap;
            struct Filter
            {
                enum Type
                {
                    NearestNeighbor,
                    Linear,
                    Cubic
                } minFilter{Linear},
                    magFilter{Linear}; // Minification and magnification filters
            } filter;
            struct LOD
            {
                float min{0.0f}; // Minimum level of detail
                float max{16.0f}; // Maximum level of detail
            } lod; // Level of detail settings;
            enum class Reduction
            {
                WeightedAverage,
                Min,
                Max
            } reduction{Reduction::WeightedAverage};
        } const mDesc;
        RHIDeviceSampler(RHIDevice const& device, SamplerDesc const& desc) : mDevice(device), mDesc(desc) {}
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHIDeviceQueryPool : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        struct QueryPoolDesc
        {
            enum QueryType
            {
                Timestamp,
                AccelerationStructureCompactedSize
            } type;
            uint32_t count{1};
        } const mDesc;
        RHIDeviceQueryPool(RHIDevice const& device, QueryPoolDesc const& desc) : mDevice(device), mDesc(desc) {}
 
        // NOTE: In nanoseconds
        virtual const float GetTimestampResolution() = 0;
 
        virtual void Reset() = 0;
 
        virtual Span<const uint64_t> GetResults(bool wait = true) = 0;
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    struct RHIDeviceCapabilities
    {
        bool dedicatedCompute;
        bool dedicatedTransfer;
        bool shaderExecutionReordering;
        bool meshShaders;
        bool raytracingInline;
        bool raytracingPipeline;
        bool timestampQueries;
        bool integratedGPU;
        bool deviceLocalHostVisibleBuffers;
        // Direct GPU memory access thanks to either UMA or ReBAR
        // https://asawicki.info/news_1740_vulkan_memory_types_on_pc_and_how_to_use_them
        size_t deviceLocalHostVisibleHeapSize;
        size_t maxStorageBufferRange;
    };
    struct RHIDeviceMemoryHeapStat
    {
        uint32_t heapIndex{};
        bool deviceLocal{};
        size_t heapSize{};
        size_t usage{};
        size_t budget{};
        uint32_t blockCount{};
        uint32_t allocationCount{};
        size_t blockBytes{};
        size_t allocationBytes{};
    };
    struct RHIDeviceMemoryTypeStat
    {
        uint32_t typeIndex{};
        uint32_t heapIndex{};
        bool deviceLocal{};
        bool hostVisible{};
        bool hostCoherent{};
        bool hostCached{};
        bool lazilyAllocated{};
        bool protectedMemory{};
        uint32_t blockCount{};
        uint32_t allocationCount{};
        uint32_t unusedRangeCount{};
        size_t blockBytes{};
        size_t allocationBytes{};
        size_t allocationSizeMin{};
        size_t allocationSizeMax{};
        size_t unusedRangeSizeMin{};
        size_t unusedRangeSizeMax{};
    };
    struct RHIDeviceMemoryStats
    {
        Vector<RHIDeviceMemoryHeapStat> heaps;
        Vector<RHIDeviceMemoryTypeStat> memoryTypes;
        RHIDeviceMemoryTypeStat total{};
 
        explicit RHIDeviceMemoryStats(Allocator* allocator) : heaps(allocator), memoryTypes(allocator) {}
    };
    class RHIDevice : public RHIObject
    {
    protected:
        const RHIApplication& mApp;
 
    public:
        struct DeviceDesc
        {
            uint32_t id = 0;
            String name = "RHIDevice";
        };
        RHIDevice(RHIApplication const& app) : mApp(app) {}
 
        [[nodiscard]] virtual RHIDeviceCapabilities GetCapabilities() const = 0;
        [[nodiscard]] virtual RHIPipelineStateCacheKey GetPipelineCacheKey() const = 0;
        [[nodiscard]] virtual Span<RHISurfaceFormat const> GetSwapchainSupportedFormats() const = 0;
        [[nodiscard]] virtual Span<RHISwapchainPresentMode const> GetSwapchainSupportedPresentModes() const = 0;
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHISwapchain>
        CreateSwapchain(RHISwapchain::SwapchainDesc const& desc) = 0;
        [[nodiscard]] virtual RHISwapchain* GetSwapchain(Handle handle) const = 0;
        virtual void DestroySwapchain(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIPipelineStateCache>
        CreatePipelineCache(RHIPipelineStateCache::PipelineStateCacheDesc const& desc) = 0;
        [[nodiscard]] virtual RHIPipelineStateCache* GetPipelineCache(Handle handle) const = 0;
        virtual void DestroyPipelineCache(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIPipelineState>
        CreatePipelineState(RHIPipelineState::PipelineStateDesc const& desc) = 0;
        [[nodiscard]] virtual RHIPipelineState* GetPipelineState(Handle handle) const = 0;
        virtual void DestroyPipelineState(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIShaderModule>
        CreateShaderModule(RHIShaderModule::ShaderModuleDesc const& desc) = 0;
        [[nodiscard]] virtual RHIShaderModule* GetShaderModule(Handle handle) const = 0;
        virtual void DestroyShaderModule(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHICommandPool>
        CreateCommandPool(RHICommandPool::PoolDesc type) = 0;
        [[nodiscard]] virtual RHICommandPool* GetCommandPool(Handle handle) const = 0;
        virtual void DestroyCommandPool(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceQueue* GetDeviceQueue(RHIDeviceQueueType type) const = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceSemaphore> CreateSemaphore(bool is_timeline = false) = 0;
        [[nodiscard]] virtual RHIDeviceSemaphore* GetSemaphore(Handle handle) const = 0;
        virtual void DestroySemaphore(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceFence> CreateFence(bool signaled = true) = 0;
        [[nodiscard]] virtual RHIDeviceFence* GetFence(Handle handle) const = 0;
        virtual void DestroyFence(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIBuffer> CreateBuffer(RHIBufferDesc const& desc) = 0;
        [[nodiscard]] virtual RHIBuffer* GetBuffer(Handle handle) const = 0;
        virtual void DestroyBuffer(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHITexture> CreateTexture(RHITextureDesc const& desc) = 0;
        [[nodiscard]] virtual RHITexture* GetTexture(Handle handle) const = 0;
        virtual void DestroyTexture(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIAccelerationStructure>
        CreateAccelerationStructure(RHIAccelerationStructureDesc const& desc) = 0;
        [[nodiscard]] virtual RHIAccelerationStructure* GetAccelerationStructure(Handle handle) const = 0;
        virtual void DestroyAccelerationStructure(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceDescriptorSetLayout>
        CreateDescriptorSetLayout(RHIDeviceDescriptorSetLayoutDesc const& desc) = 0;
        [[nodiscard]] virtual RHIDeviceDescriptorSetLayout* GetDescriptorSetLayout(Handle handle) const = 0;
        virtual void DestroyDescriptorSetLayout(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceDescriptorPool>
        CreateDescriptorPool(RHIDeviceDescriptorPool::PoolDesc const& desc) = 0;
        [[nodiscard]] virtual RHIDeviceDescriptorPool* GetDescriptorPool(Handle handle) const = 0;
        virtual void DestroyDescriptorPool(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceSampler>
        CreateSampler(RHIDeviceSampler::SamplerDesc const& desc) = 0;
        [[nodiscard]] virtual RHIDeviceSampler* GetSampler(Handle handle) const = 0;
        virtual void DestroySampler(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIDeviceQueryPool>
        CreateQueryPool(RHIDeviceQueryPool::QueryPoolDesc const& desc) = 0;
        [[nodiscard]] virtual RHIDeviceQueryPool* GetQueryPool(Handle handle) const = 0;
        virtual void DestroyQueryPool(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIDeviceScopedHandle<RHIVirtualAllocator> CreateVirtualAllocator(uint64_t size) = 0;
        [[nodiscard]] virtual RHIVirtualAllocator* GetVirtualAllocator(Handle handle) const = 0;
        virtual void DestroyVirtualAllocator(Handle handle) = 0;
 
        [[nodiscard]] virtual RHIAccelerationStructureSizeInfo
        GetAccelerationStructureSizeInfo(RHIAccelerationStructureBuildDesc const& desc,
                                         Allocator* scratchAllocator = nullptr) const = 0;
        [[nodiscard]] virtual size_t
        WriteAccelerationStructureInstanceData(RHIAccelerationStructureGeometryInstance const& data,
                                               void* dest) const = 0;
 
        virtual void ResetFences(Span<RHIDeviceFence* const> fences) = 0;
        virtual bool WaitForFences(Span<RHIDeviceFence* const> fences, bool wait_all, size_t timeout) = 0;
 
        virtual void SignalTimelineSemaphores(Span<const Pair<RHIDeviceSemaphore*, size_t>> semaphores) = 0;
        virtual bool WaitForTimelineSemaphores(Span<const Pair<RHIDeviceSemaphore*, size_t>> semaphores,
                                               size_t timeout) = 0;
 
        virtual void WaitIdle() const = 0;
 
        virtual void QueryBudget(size_t& used, size_t& budget) const = 0;
        virtual void QueryAllocationStats(size_t& blockBytes, size_t& allocationBytes) const = 0;
        virtual void QueryMemoryStats(RHIDeviceMemoryStats& outStats) const = 0;
        virtual String QueryDeviceString() const = 0;
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    struct RHIDeviceIdleGuard
    {
        RHIDevice const* mDevice{nullptr};
        RHIDeviceIdleGuard() = delete;
        RHIDeviceIdleGuard(RHIDevice const* device) : mDevice(device) {};
        void WaitIdle() const
        {
            if (mDevice)
                mDevice->WaitIdle();
        }
        ~RHIDeviceIdleGuard() { WaitIdle(); }
    };
 
    template <>
    struct RHIObjectTraits<RHIDevice, RHISwapchain>
    {
        static RHISwapchain* Get(RHIDevice const* device, Handle handle) { return device->GetSwapchain(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroySwapchain(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIPipelineState>
    {
        static RHIPipelineState* Get(RHIDevice const* device, Handle handle)
        {
            return device->GetPipelineState(handle);
        }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyPipelineState(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIShaderModule>
    {
        static RHIShaderModule* Get(RHIDevice const* device, Handle handle) { return device->GetShaderModule(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyShaderModule(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHICommandPool>
    {
        static RHICommandPool* Get(RHIDevice const* device, Handle handle) { return device->GetCommandPool(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyCommandPool(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceSemaphore>
    {
        static RHIDeviceSemaphore* Get(RHIDevice const* device, Handle handle) { return device->GetSemaphore(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroySemaphore(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceFence>
    {
        static RHIDeviceFence* Get(RHIDevice const* device, Handle handle) { return device->GetFence(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyFence(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIBuffer>
    {
        static RHIBuffer* Get(RHIDevice const* device, Handle handle) { return device->GetBuffer(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyBuffer(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHITexture>
    {
        static RHITexture* Get(RHIDevice const* device, Handle handle) { return device->GetTexture(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyTexture(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceDescriptorSetLayout>
    {
        static RHIDeviceDescriptorSetLayout* Get(RHIDevice const* device, Handle handle)
        {
            return device->GetDescriptorSetLayout(handle);
        }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyDescriptorSetLayout(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceDescriptorPool>
    {
        static RHIDeviceDescriptorPool* Get(RHIDevice const* device, Handle handle)
        {
            return device->GetDescriptorPool(handle);
        }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyDescriptorPool(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceSampler>
    {
        static RHIDeviceSampler* Get(RHIDevice const* device, Handle handle) { return device->GetSampler(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroySampler(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIPipelineStateCache>
    {
        static RHIPipelineStateCache* Get(RHIDevice const* device, Handle handle)
        {
            return device->GetPipelineCache(handle);
        }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyPipelineCache(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIVirtualAllocator>
    {
        static RHIVirtualAllocator* Get(RHIDevice const* device, Handle handle) { return device->GetVirtualAllocator(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyVirtualAllocator(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIDeviceQueryPool>
    {
        static RHIDeviceQueryPool* Get(RHIDevice const* device, Handle handle) { return device->GetQueryPool(handle); }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyQueryPool(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIDevice, RHIAccelerationStructure>
    {
        static RHIAccelerationStructure* Get(RHIDevice const* device, Handle handle)
        {
            return device->GetAccelerationStructure(handle);
        }
        static void Destroy(RHIDevice* device, Handle handle) { device->DestroyAccelerationStructure(handle); }
    };
} // namespace Foundation::RHI