Resource.hpp

Go to the documentation of this file.

#pragma once
#include "Common.hpp"
namespace Foundation::RHI
{
    class RHIDevice;
    struct RHIResourceDesc
    {
        bool isAlias{false}; // If true, the resource is an alias of another resource.
        RHIDeviceHeapType heap{RHIDeviceHeapType::Local};
        RHIResourceHostAccess hostAccess{RHIResourceHostAccess::Invisible};
        bool shared{false};
        RHIDeviceQueueFlags sharedQueues{RHIDeviceQueueFlagsBits::Graphics | RHIDeviceQueueFlagsBits::Compute |
                                         RHIDeviceQueueFlagsBits::Transfer};
        bool coherent{false};
        bool staging{false};
    };
    struct RHIBufferDesc
    {
        RHIResourceDesc resource{};
        RHIBufferUsage usage{};
        size_t size{}; // size in bytes
        size_t alignment{4}; // alignment in bytes, may be ignored by implementations
 
        static RHIBufferDesc CreateStagingDesc(size_t size)
        {
            return {
                .resource =
                    {
                        .heap = RHIDeviceHeapType::Upload,
                        .hostAccess = RHIResourceHostAccess::WriteOnly,
                        .shared = false,
                        .coherent = true,
                        .staging = true,
                    },
                .usage = RHIBufferUsageBits::TransferSource,
                .size = size,
            };
        }
    };
    class RHIBuffer;
    template <typename T>
    using RHIBufferScopedHandle = RHIScopedHandle<RHIBuffer, T>;
    template <typename T>
    using RHIBufferHandle = RHIHandle<RHIBuffer, T>;
    class RHIBuffer : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        const RHIBufferDesc mDesc;
        RHIBuffer(RHIDevice const& device, RHIBufferDesc const& desc) : mDevice(device), mDesc(desc) {}
        virtual void* Map() = 0;
        virtual void Flush(size_t offset = 0, size_t size = kFullSize) = 0;
        virtual void Unmap() = 0;
 
        template <typename T>
        Span<T> MapSpan(size_t count = kFullSize)
        {
            void* p = Map();
            if (count == kFullSize)
                count = mDesc.size / sizeof(T);
            return {static_cast<T*>(p), count};
        }
        template <typename T>
        T* Map()
        {
            return static_cast<T*>(Map());
        }
 
        [[nodiscard]] virtual RHIBufferScopedHandle<RHIBuffer> CreateAliasedBuffer(RHIBufferDesc const& desc,
                                                                                   size_t offset = 0) = 0;
        [[nodiscard]] virtual RHIBuffer* GetAliasedBuffer(Handle handle) const = 0;
        virtual void DestroyAliasedBuffer(Handle handle) = 0;
        [[nodiscard]] virtual size_t GetAllocationSize() const = 0;
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHIVirtualAllocator : public RHIObject
    {
    public:
        static constexpr uint64_t kInvalidOffset = ~0ull;
        [[nodiscard]] virtual uint64_t Allocate(uint64_t size, uint64_t alignment) = 0;
        // Frees a range previously returned by Allocate.
        virtual void Free(uint64_t offset) = 0;
        // Frees all live allocations at once.
        virtual void Clear() = 0;
        [[nodiscard]] virtual uint64_t GetUsedBytes() const = 0;
        [[nodiscard]] virtual uint64_t GetCapacity() const = 0;
        // Highest (offset + size) ever allocated, for partial flushes of mapped buffers.
        [[nodiscard]] virtual uint64_t GetPeakUsage() const = 0;
    };
    struct RHITextureDesc
    {
        RHIResourceDesc resource{};
        RHITextureDimension dimension{RHITextureDimension::E2D};
        RHITextureUsage usage{};
        RHIExtent3D extent{1, 1, 1}; // Width, height, depth of the image.
        RHIResourceFormat format{RHIResourceFormat::Undefined};
        RHIMultisampleCount sampleCount{RHIMultisampleCount::E1}; // For MSAA
        uint32_t mipLevels{1};
        uint32_t arrayLayers{1}; // No. of images in an image array.
        RHITextureLayout initialLayout{RHITextureLayout::Undefined};
    };
    class RHITexture;
    class RHITextureView;
    template <typename T>
    using RHITextureScopedHandle = RHIScopedHandle<RHITexture, T>;
    template <typename T>
    using RHITextureHandle = RHIHandle<RHITexture, T>;
    struct RHITextureSubresourceLayer
    {
        RHITextureAspectFlag aspect{};
        uint32_t mipLevel{0};
        uint32_t baseArrayLayer{0};
        uint32_t layerCount{1};
    };
    struct RHITextureSubresourceRange
    {
        // Single mip level and array layer range
        RHITextureSubresourceLayer layer;
        // Number of mip levels in the range
        uint32_t mipCount;
        /* @brief Mip level used (inclusive) */
        [[nodiscard]] Pair<uint32_t, uint32_t> GetMipLevelRange() const
        {
            return {layer.mipLevel, layer.mipLevel + mipCount - 1};
        }
        /* @brief Array layers used (inclusive) */
        [[nodiscard]] Pair<uint32_t, uint32_t> GetArrayLayerRange() const
        {
            return {layer.baseArrayLayer, layer.baseArrayLayer + layer.layerCount - 1};
        }
        static RHITextureSubresourceRange Create(RHITextureAspectFlag aspect = RHITextureAspectFlagBits::Color,
                                                 uint32_t base_mip_level = 0, uint32_t mip_count = 1,
                                                 uint32_t base_array_layer = 0, uint32_t layer_count = 1)
        {
            RHITextureSubresourceRange res{
                .layer =
                    {
                        .aspect = aspect,
                        .mipLevel = base_mip_level,
                        .baseArrayLayer = base_array_layer,
                        .layerCount = layer_count,
                    },
                .mipCount = mip_count,
            };
            return res;
        }
        [[nodiscard]] constexpr bool IsValid() const { return layer.aspect.value && mipCount && layer.layerCount; }
    };
    struct RHITextureViewDesc
    {
        RHIResourceFormat format;
        RHITextureDimension dimension{RHITextureDimension::E2D};
        RHITextureSubresourceRange range{};
    };
    class RHITexture : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
 
    public:
        const RHITextureDesc mDesc;
        RHITexture(RHIDevice const& device, RHITextureDesc const& desc) : mDevice(device), mDesc(desc) {}
 
        [[nodiscard]] virtual RHITextureScopedHandle<RHITextureView>
        CreateTextureView(RHITextureViewDesc const& desc) = 0;
        [[nodiscard]] virtual RHITextureView* GetImageView(Handle handle) const = 0;
        virtual void DestroyImageView(Handle handle) = 0;
 
        [[nodiscard]] virtual RHITextureScopedHandle<RHITexture> CreateAliasedTexture(RHITextureDesc const& desc,
                                                                                      size_t offset = 0) = 0;
        [[nodiscard]] virtual RHITexture* GetAliasedTexture(Handle handle) const = 0;
        virtual void DestroyAliasedTexture(Handle handle) = 0;
        [[nodiscard]] virtual size_t GetAllocationSize() const = 0;
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHITextureView : public RHIObject
    {
    protected:
        const RHITexture& mImage;
        const RHITextureViewDesc& mDesc;
 
    public:
        RHITextureView(RHITexture const& image, RHITextureViewDesc const& desc) : mImage(image), mDesc(desc) {}
        [[nodiscard]] virtual RHITexture* GetTexture() const = 0;
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    class RHIAccelerationStructure;
    struct RHIAccelerationStructureSizeInfo
    {
        uint32_t accelerationStructureSize;
        uint32_t buildScratchSize;
        uint32_t updateScratchSize;
    };
    struct RHIAccelerationStructureDesc
    {
        RHIAccelerationStructureType type;
        RHIAccelerationStructureBuildFlags flags;
        RHIBuffer* buffer;
        uint32_t offset;
        uint32_t size;
    };
    struct RHIAccelerationStructureGeometryTriangleData
    {
        RHIResourceFormat vertexFormat;
        RHIBuffer* vertexBuffer;
        uint32_t vertexOffset; // Bytes
        uint32_t vertexCount;
        uint32_t vertexStride;
        RHIResourceFormat indexFormat; // Must be RHIResourceFormat::R32Uint or RHIResourceFormat::R16Uint
        RHIBuffer* indexBuffer;
        uint32_t indexOffset; // Bytes
        uint32_t indexCount;
    };
    struct RHIAccelerationStructureAABB
    {
        float minX, minY, minZ;
        float maxX, maxY, maxZ;
    };
    struct RHIAccelerationStructureGeometryAABBData
    {
        RHIBuffer* aabbBuffer;
        uint32_t offset; // Bytes
        uint32_t count;
        uint32_t stride; // Bytes. Must be >= sizeof(RHIAccelerationStructureAABB).
    };
    // For use with @ref RHIDevice::WriteAccelerationStructureInstanceData
    struct RHIAccelerationStructureGeometryInstance
    {
        RHIAccelerationStructure const* blas;
        float transformBasisRowMajor[3][3];
        float transformTranslation[3];
        uint32_t instanceID;
        uint32_t mask;
        uint32_t shaderBindingTableRecordOffset{0};
        RHIAccelerationGeometryInstanceFlags flags;
    };
    struct RHIAccelerationStructureGeometryInstanceData
    {
        RHIBuffer* instanceBuffer;
        uint32_t instanceOffset; // Bytes
        uint32_t totalPrimitives;
    };
    struct RHIAccelerationStructureGeometryInfo
    {
        RHIAccelerationGeometryType type;
        RHIAccelerationStructureGeometryTriangleData triangleData;
        RHIAccelerationStructureGeometryAABBData aabbData;
        RHIAccelerationStructureGeometryInstanceData instanceData;
        bool allowUpdate{false};
    };
    struct RHIAccelerationStructureBuildRangeInfo
    {
        uint32_t primitiveCount;
        uint32_t primitiveOffset;
        uint32_t firstVertex;
        uint32_t transformOffset;
    };
    struct RHIAccelerationStructureBuildDesc
    {
        RHIAccelerationStructureType type;
        RHIAccelerationStructureBuildFlags flags;
        RHIAccelerationStructureBuildOp operation;
        RHIAccelerationStructure* srcAS{nullptr};
        RHIAccelerationStructure* dstAS{nullptr};
        RHIBuffer* scratchBuffer{nullptr};
        uint32_t scratchBufferOffset;
        Span<const RHIAccelerationStructureGeometryInfo> geometries;
        Span<const RHIAccelerationStructureBuildRangeInfo> ranges;
    };
    class RHIAccelerationStructure : public RHIObject
    {
    protected:
        const RHIDevice& mDevice;
        const RHIAccelerationStructureDesc& mDesc;
 
    public:
        RHIAccelerationStructure(const RHIDevice& device, RHIAccelerationStructureDesc const& desc) :
            mDevice(device), mDesc(desc)
        {
        }
 
        virtual void DebugSetObjectName(const char* name) = 0;
    };
    template <>
    struct RHIObjectTraits<RHITexture, RHITextureView>
    {
        static RHITextureView* Get(RHITexture const* image, Handle handle) { return image->GetImageView(handle); }
        static void Destroy(RHITexture* image, Handle handle) { image->DestroyImageView(handle); }
    };
    template <>
    struct RHIObjectTraits<RHIBuffer, RHIBuffer>
    {
        static RHIBuffer* Get(RHIBuffer const* buffer, Handle handle) { return buffer->GetAliasedBuffer(handle); }
        static void Destroy(RHIBuffer* buffer, Handle handle) { buffer->DestroyAliasedBuffer(handle); }
    };
    template <>
    struct RHIObjectTraits<RHITexture, RHITexture>
    {
        static RHITexture* Get(RHITexture const* texture, Handle handle) { return texture->GetAliasedTexture(handle); }
        static void Destroy(RHITexture* texture, Handle handle) { texture->DestroyAliasedTexture(handle); }
    };
} // namespace Foundation::RHI