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
 
        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;
 
        virtual void DebugSetObjectName(const char* name) = 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;
 
        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 RHIAccelerationStructureDesc
    {
        RHIAccelerationStructureType type;
        RHIBuffer* buffer;
        uint32_t offset;
        uint32_t size;
    };
    struct RHIAccelerationStructureGeometryDesc
    {
        RHIAccelerationGeometryType type;
        struct TriangleData
        {
            RHIResourceFormat vertexFormat;
            RHIBuffer* vertexBuffer;
            uint32_t vertexOffset; // Bytes
            uint32_t vertexCount;
            uint32_t vertexStride;
            RHIBuffer* indexBuffer;
            uint32_t indexOffset; // Bytes
            uint32_t indexCount;
 
        } triangleData;
        struct InstanceData
        {
            RHIAccelerationStructure* accelerationStructure;
            float xformBasisRowMajor[3][3];
            float xformTranslation[3];
            uint32_t instanceID;
        } instanceData;
        bool allowUpdate{false};
    };
    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);
        }
    };
}