rendering_api.hpp

#pragma once
 
#include <litefx/config.h>
 
#if !defined (LITEFX_RENDERING_API)
#  if defined(LiteFX_Rendering_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_RENDERING_API __declspec(dllexport)
#  elif (defined(LiteFX_Rendering_EXPORTS) || defined(__APPLE__)) && defined __GNUC__ && __GNUC__ >= 4
#    define LITEFX_RENDERING_API __attribute__ ((visibility ("default")))
#  elif !defined(LiteFX_Rendering_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_RENDERING_API __declspec(dllimport)
#  endif
#endif 
 
#ifndef LITEFX_RENDERING_API
#  define LITEFX_RENDERING_API
#endif
 
#include <litefx/app.hpp>
#include <litefx/math.hpp>
 
namespace LiteFX::Rendering {
    using namespace LiteFX;
    using namespace LiteFX::Math;
 
    class IGraphicsAdapter;
    class ISurface;
    class IShaderModule;
    class IRenderTarget;
    class IRasterizer;
    class IViewport;
    class IScissor;
    class IBufferLayout;
    class IVertexBufferLayout;
    class IIndexBufferLayout;
    class IDescriptorLayout;
    class IMappable;
    class IDeviceMemory;
    class IBuffer;
    class IImage;
    class ISampler;
    class IAccelerationStructure;
    class IBottomLevelAccelerationStructure;
    class ITopLevelAccelerationStructure;
    class IBarrier;
    class IDescriptorSet;
    class IDescriptorSetLayout;
    class IPushConstantsRange;
    class IPushConstantsLayout;
    class IShaderProgram;
    class IPipelineLayout;
    class IVertexBuffer;
    class IIndexBuffer;
    class IInputAssembler;
    class IPipeline;
    class ICommandBuffer;
    class IRenderPipeline;
    class IComputePipeline;
    class IRayTracingPipeline;
    class IFrameBuffer;
    class IRenderPass;
    class ISwapChain;
    class ICommandQueue;
    class IGraphicsFactory;
    class IGraphicsDevice;
    class IRenderBackend;
    class VirtualAllocator;
 
#pragma region "Enumerations"
 
    // NOLINTBEGIN(performance-enum-size)
 
    enum class GraphicsAdapterType {
        None = 0x00000000,
        
        GPU = 0x00000001,
 
        CPU = 0x00000002,
 
        Other = 0x7FFFFFFF,
    };
 
    enum class QueueType : UInt32 {
        None = 0x00000000,
 
        Graphics = 0x00000001,
 
        Compute = 0x00000002,
 
        Transfer = 0x00000004,
 
        VideoDecode = 0x00000010,
 
        VideoEncode = 0x00000020,
 
        Other = 0x7FFFFFFF
    };
 
    enum class QueuePriority {
        Normal = 33,
 
        High = 66,
 
        Realtime = 100
    };
 
    enum class Format {
        None = 0x00000000,
        R4G4_UNORM,
        R4G4B4A4_UNORM,
        B4G4R4A4_UNORM,
        R5G6B5_UNORM,
        B5G6R5_UNORM,
        R5G5B5A1_UNORM,
        B5G5R5A1_UNORM,
        A1R5G5B5_UNORM,
        R8_UNORM,
        R8_SNORM,
        R8_USCALED,
        R8_SSCALED,
        R8_UINT,
        R8_SINT,
        R8_SRGB,
        R8G8_UNORM,
        R8G8_SNORM,
        R8G8_USCALED,
        R8G8_SSCALED,
        R8G8_UINT,
        R8G8_SINT,
        R8G8_SRGB,
        R8G8B8_UNORM,
        R8G8B8_SNORM,
        R8G8B8_USCALED,
        R8G8B8_SSCALED,
        R8G8B8_UINT,
        R8G8B8_SINT,
        R8G8B8_SRGB,
        B8G8R8_UNORM,
        B8G8R8_SNORM,
        B8G8R8_USCALED,
        B8G8R8_SSCALED,
        B8G8R8_UINT,
        B8G8R8_SINT,
        B8G8R8_SRGB,
        R8G8B8A8_UNORM,
        R8G8B8A8_SNORM,
        R8G8B8A8_USCALED,
        R8G8B8A8_SSCALED,
        R8G8B8A8_UINT,
        R8G8B8A8_SINT,
        R8G8B8A8_SRGB,
        B8G8R8A8_UNORM,
        B8G8R8A8_SNORM,
        B8G8R8A8_USCALED,
        B8G8R8A8_SSCALED,
        B8G8R8A8_UINT,
        B8G8R8A8_SINT,
        B8G8R8A8_SRGB,
        A8B8G8R8_UNORM,
        A8B8G8R8_SNORM,
        A8B8G8R8_USCALED,
        A8B8G8R8_SSCALED,
        A8B8G8R8_UINT,
        A8B8G8R8_SINT,
        A8B8G8R8_SRGB,
        A2R10G10B10_UNORM,
        A2R10G10B10_SNORM,
        A2R10G10B10_USCALED,
        A2R10G10B10_SSCALED,
        A2R10G10B10_UINT,
        A2R10G10B10_SINT,
        A2B10G10R10_UNORM,
        A2B10G10R10_SNORM,
        A2B10G10R10_USCALED,
        A2B10G10R10_SSCALED,
        A2B10G10R10_UINT,
        A2B10G10R10_SINT,
        R16_UNORM,
        R16_SNORM,
        R16_USCALED,
        R16_SSCALED,
        R16_UINT,
        R16_SINT,
        R16_SFLOAT,
        R16G16_UNORM,
        R16G16_SNORM,
        R16G16_USCALED,
        R16G16_SSCALED,
        R16G16_UINT,
        R16G16_SINT,
        R16G16_SFLOAT,
        R16G16B16_UNORM,
        R16G16B16_SNORM,
        R16G16B16_USCALED,
        R16G16B16_SSCALED,
        R16G16B16_UINT,
        R16G16B16_SINT,
        R16G16B16_SFLOAT,
        R16G16B16A16_UNORM,
        R16G16B16A16_SNORM,
        R16G16B16A16_USCALED,
        R16G16B16A16_SSCALED,
        R16G16B16A16_UINT,
        R16G16B16A16_SINT,
        R16G16B16A16_SFLOAT,
        R32_UINT,
        R32_SINT,
        R32_SFLOAT,
        R32G32_UINT,
        R32G32_SINT,
        R32G32_SFLOAT,
        R32G32B32_UINT,
        R32G32B32_SINT,
        R32G32B32_SFLOAT,
        R32G32B32A32_UINT,
        R32G32B32A32_SINT,
        R32G32B32A32_SFLOAT,
        R64_UINT,
        R64_SINT,
        R64_SFLOAT,
        R64G64_UINT,
        R64G64_SINT,
        R64G64_SFLOAT,
        R64G64B64_UINT,
        R64G64B64_SINT,
        R64G64B64_SFLOAT,
        R64G64B64A64_UINT,
        R64G64B64A64_SINT,
        R64G64B64A64_SFLOAT,
        B10G11R11_UFLOAT,
        E5B9G9R9_UFLOAT,
        D16_UNORM,
        X8_D24_UNORM,
        D32_SFLOAT,
        S8_UINT,
        D16_UNORM_S8_UINT,
        D24_UNORM_S8_UINT,
        D32_SFLOAT_S8_UINT,
        BC1_RGB_UNORM,
        BC1_RGB_SRGB,
        BC1_RGBA_UNORM,
        BC1_RGBA_SRGB,
        BC2_UNORM,
        BC2_SRGB,
        BC3_UNORM,
        BC3_SRGB,
        BC4_UNORM,
        BC4_SNORM,
        BC5_UNORM,
        BC5_SNORM,
        BC6H_UFLOAT,
        BC6H_SFLOAT,
        BC7_UNORM,
        BC7_SRGB,
        Other = 0x7FFFFFFF
    };
 
    enum class BufferFormat : UInt32 {
        None = 0x00000000,
        X16F = 0x10000101,
        X16I = 0x10000201,
        X16U = 0x10000401,
        XY16F = 0x10000102,
        XY16I = 0x10000202,
        XY16U = 0x10000402,
        XYZ16F = 0x10000103,
        XYZ16I = 0x10000203,
        XYZ16U = 0x10000403,
        XYZW16F = 0x10000104,
        XYZW16I = 0x10000204,
        XYZW16U = 0x10000404,
        X32F = 0x20000101,
        X32I = 0x20000201,
        X32U = 0x20000401,
        XY32F = 0x20000102,
        XY32I = 0x20000202,
        XY32U = 0x20000402,
        XYZ32F = 0x20000103,
        XYZ32I = 0x20000203,
        XYZ32U = 0x20000403,
        XYZW32F = 0x20000104,
        XYZW32I = 0x20000204,
        XYZW32U = 0x20000404
    };
 
    enum class AttributeSemantic : UInt32 {
        Binormal = 0x00000001,
 
        BlendIndices = 0x00000002,
 
        BlendWeight = 0x00000003,
 
        Color = 0x00000004,
 
        Normal = 0x00000005,
 
        Position = 0x00000006,
 
        TransformedPosition = 0x00000007,
 
        PointSize = 0x00000008,
 
        Tangent = 0x00000009,
 
        TextureCoordinate = 0x0000000A,
 
        Arbitrary = 0x0000000B,
 
        Unknown = 0x7FFFFFFF
    };
 
    enum class DescriptorType {
        ConstantBuffer = 0x00000001,
 
        StructuredBuffer = 0x00000002,
 
        RWStructuredBuffer = 0x00000012,
 
        Texture = 0x00000003,
 
        RWTexture = 0x00000013,
        
        Sampler = 0x00000004,
 
        InputAttachment = 0x00000005,
 
        Buffer = 0x00000006,
 
        RWBuffer = 0x00000016,
 
        ByteAddressBuffer = 0x00000007,
 
        RWByteAddressBuffer = 0x00000017,
 
        AccelerationStructure = 0x00000008,
 
        ResourceDescriptorHeap = 0x00000009,
 
        SamplerDescriptorHeap = 0x0000000A
    };
 
    enum class DescriptorHeapType {
        None = 0x00,
 
        Resource = 0x01,
 
        Sampler = 0x02
    };
 
    enum class BufferType {
        Vertex = 0x00000001,
        
        Index = 0x00000002,
 
        Uniform = 0x00000003,
 
        Storage = 0x00000004,
 
        Texel = 0x00000005,
 
        AccelerationStructure = 0x00000006,
 
        ShaderBindingTable = 0x00000007,
 
        Indirect = 0x00000008,
 
        Other = 0x7FFFFFFF
    };
 
    enum class ResourceHeap {
        Staging = 0x00000001,
 
        Resource = 0x00000002,
 
        Dynamic = 0x00000010,
 
        Readback = 0x00000100,
 
        GPUUpload = 0x00001000
    };
 
    enum class ResourceUsage {
        None = 0x0000,
 
        AllowWrite = 0x0001,
 
        TransferSource = 0x0010,
 
        TransferDestination = 0x0020,
 
        RenderTarget = 0x0040,
 
        AccelerationStructureBuildInput = 0x0100,
 
        Default = TransferSource | TransferDestination,
 
        FrameBufferImage = TransferSource | RenderTarget,
 
        Volatile = 0x1000
    };
 
    enum class AllocationBehavior : UInt32 {
        Default = 0x00,
 
        StayWithinBudget = 0x01,
 
        DontExpandCache = 0x02
    };
 
    enum class AllocationAlgorithm : UInt32 {
        Default = 0x01,
 
        Linear = 0x02
    };
 
    enum class AllocationStrategy : UInt32 {
        OptimizePacking = 0x01,
 
        OptimizeTime = 0x02,
    };
 
    enum class DefragmentationStrategy : UInt32 {
        Fast = 0x01,
 
        Balanced = 0x02,
 
        Full = 0x03
    };
 
    enum class IndexType : UInt32 {
        UInt16 = 0x00000010,
 
        UInt32 = 0x00000020
    };
 
    enum class VertexBufferInputRate : UInt32 {
        Vertex = 0,
 
        Instance = 1
    };
 
    enum class PrimitiveTopology {
        PointList = 0x00010001,
 
        LineList = 0x00020001,
 
        TriangleList = 0x00040001,
 
        LineStrip = 0x00020002,
        
        TriangleStrip = 0x00040002
    };
 
    enum class ShaderStage : UInt32 {
        Vertex = 0x00000001,
 
        TessellationControl = 0x00000002,
 
        TessellationEvaluation = 0x00000004,
 
        Geometry = 0x00000008,
 
        Fragment = 0x00000010,
 
        Compute = 0x00000020,
 
        Task = 0x00000040,
 
        Mesh = 0x00000080,
 
        RayGeneration = 0x00000100,
 
        AnyHit = 0x00000200,
 
        ClosestHit = 0x00000400,
 
        Miss = 0x00000800,
 
        Intersection = 0x00001000,
 
        Callable = 0x00002000,
 
        RasterizationPipeline = Vertex | Geometry | TessellationControl | TessellationEvaluation | Fragment,
 
        MeshPipeline = Task | Mesh | Fragment,
 
        RayTracingPipeline = RayGeneration | AnyHit | ClosestHit | Miss | Intersection | Callable,
 
        Any = Vertex | TessellationControl | TessellationEvaluation | Geometry | Fragment | Compute | Task | Mesh | RayGeneration | AnyHit | ClosestHit | Miss | Intersection | Callable,
 
        Other = 0x7FFFFFFF
    };
 
    enum class ShaderRecordType {
        RayGeneration = 0x01,
 
        HitGroup = 0x02,
 
        Intersection = 0x03,
 
        Miss = 0x04,
 
        Callable = 0x05,
 
        Invalid = 0x7FFFFFFF
    };
 
    enum class ShaderBindingGroup : UInt32 {
        RayGeneration = 0x01,
 
        HitGroup = 0x02,
 
        Miss = 0x04,
 
        Callable = 0x08,
 
        All = RayGeneration | HitGroup | Miss | Callable
    };
 
    enum class PolygonMode {
        Solid = 0x00000001,
 
        Wireframe = 0x00000002,
 
        Point = 0x00000004
    };
 
    enum class CullMode {
        FrontFaces = 0x00000001,
 
        BackFaces = 0x00000002,
 
        Both = 0x00000004,
 
        Disabled = 0x0000000F
    };
 
    enum class CullOrder {
        ClockWise = 0x00000001,
 
        CounterClockWise = 0x00000002
    };
 
    enum class RenderTargetType {
        Color = 0x00000001,
 
        DepthStencil = 0x00000002,
 
        Present = 0x00000004
    };
 
    enum class RenderTargetFlags {
        None = 0x00,
 
        Clear = 0x01,
 
        ClearStencil = 0x02,
 
        Volatile = 0x04
    };
 
    enum class ImageDimensions {
        DIM_1 = 0x01,
 
        DIM_2 = 0x02,
 
        DIM_3 = 0x03,
 
        CUBE = 0x04
    };
 
    enum class MultiSamplingLevel : UInt32 {
        x1 = 0x00000001,
 
        x2 = 0x00000002,
 
        x4 = 0x00000004,
 
        x8 = 0x00000008,
 
        x16 = 0x00000010,
 
        x32 = 0x00000020,
 
        x64 = 0x00000040
    };
 
    enum class FilterMode {
        Nearest = 0x00000001,
 
        Linear = 0x00000002
    };
 
    enum class MipMapMode {
        Nearest = 0x00000001,
 
        Linear = 0x00000002
    };
 
    enum class BorderMode {
        Repeat = 0x00000001,
 
        RepeatMirrored = 0x00010001,
 
        ClampToEdge = 0x00000002,
 
        ClampToEdgeMirrored = 0x00010002,
 
        ClampToBorder = 0x00000003,
    };
 
    enum class CompareOperation {
        Never = 0x00000000,
 
        Less = 0x00000001,
 
        Greater = 0x0000002,
 
        Equal = 0x00000003,
 
        LessEqual = 0x00000004,
 
        GreaterEqual = 0x00000005,
 
        NotEqual = 0x00000006,
 
        Always = 0x00000007
    };
 
    enum class StencilOperation {
        Keep = 0x00000000,
        
        Zero = 0x00000001,
 
        Replace = 0x00000002,
 
        IncrementClamp = 0x00000003,
 
        DecrementClamp = 0x00000004,
 
        Invert = 0x00000005,
 
        IncrementWrap = 0x00000006,
 
        DecrementWrap = 0x00000007
    };
 
    enum class BlendFactor {
        Zero = 0,
        One = 1,
        SourceColor = 2,
        OneMinusSourceColor = 3,
        DestinationColor = 4,
        OneMinusDestinationColor = 5,
        SourceAlpha = 6,
        OneMinusSourceAlpha = 7,
        DestinationAlpha = 8,
        OneMinusDestinationAlpha = 9,
        ConstantColor = 10,
        OneMinusConstantColor = 11,
        ConstantAlpha = 12,
        OneMinusConstantAlpha = 13,
        SourceAlphaSaturate = 14,
        Source1Color = 15,
        OneMinusSource1Color = 16,
        Source1Alpha = 17,
        OneMinusSource1Alpha = 18
    };
 
    enum class WriteMask {
        R = 0x01,
 
        G = 0x02,
 
        B = 0x04,
 
        A = 0x08
    };
 
    enum class BlendOperation {
        Add = 0x01,
        Subtract = 0x02,
        ReverseSubtract = 0x03,
        Minimum = 0x04,
        Maximum = 0x05
    };
 
    enum class PipelineStage {
        None = 0x00000000,
 
        All = 0x00000001,
 
        Draw = 0x00000002,
 
        InputAssembly = 0x00000004,
 
        Vertex = 0x00000006,
 
        TessellationControl = 0x00000008,
 
        TessellationEvaluation = 0x00000010,
 
        Geometry = 0x00000020,
 
        Fragment = 0x00000040,
 
        DepthStencil = 0x00000080,
 
        Indirect = 0x00000100,
 
        RenderTarget = 0x00000200,
 
        Compute = 0x00000400,
 
        Transfer = 0x00000800,
 
        Resolve = 0x00001000,
 
        AccelerationStructureBuild = 0x00010000,
 
        AccelerationStructureCopy = 0x00020000,
 
        Raytracing = 0x00040000,
    };
 
    enum class ResourceAccess {
        None = 0x7FFFFFFF,
 
        VertexBuffer = 0x00000001,
 
        IndexBuffer = 0x00000002,
 
        UniformBuffer = 0x00000004,
 
        RenderTarget = 0x00000008,
 
        DepthStencilRead = 0x00000010,
 
        DepthStencilWrite = 0x00000020,
 
        ShaderRead = 0x00000040,
 
        ShaderReadWrite = 0x00000080,
 
        Indirect = 0x00000100,
 
        TransferRead = 0x00000200,
 
        TransferWrite = 0x00000400,
 
        ResolveRead = 0x00000800,
 
        ResolveWrite = 0x00001000,
        
        Common = 0x00002000,
 
        AccelerationStructureRead = 0x00010000,
 
        AccelerationStructureWrite = 0x00020000,
    };
 
    enum class ImageLayout {
        Common = 0x00000001,
 
        ShaderResource = 0x00000002,
 
        ReadWrite = 0x00000003,
 
        CopySource = 0x00000010,
 
        CopyDestination = 0x00000011,
 
        RenderTarget = 0x00000020,
 
        DepthRead = 0x00000021,
 
        DepthWrite = 0x00000022,
 
        Present = 0x00000023,
 
        ResolveSource = 0x00000024,
 
        ResolveDestination = 0x00000025,
 
        Undefined = 0x7FFFFFFF
    };
 
    enum class GeometryFlags {
        None = 0x00,
 
        Opaque = 0x01,
 
        OneShotAnyHit = 0x02
    };
 
    enum class AccelerationStructureFlags {
        None = 0x0000,
 
        AllowUpdate = 0x0001,
 
        AllowCompaction = 0x0002,
 
        PreferFastTrace = 0x0004,
 
        PreferFastBuild = 0x0008,
 
        MinimizeMemory = 0x0010
    };
 
    enum class InstanceFlags {
        None = 0x00,
 
        DisableCull = 0x01,
 
        FlipWinding = 0x02,
 
        ForceOpaque = 0x04,
 
        ForceNonOpaque = 0x08
    };
 
    // NOLINTEND(performance-enum-size)
 
#pragma endregion
 
#pragma region "Flags"
 
    LITEFX_DEFINE_FLAGS(QueueType);
    LITEFX_DEFINE_FLAGS(ShaderStage);
    LITEFX_DEFINE_FLAGS(PipelineStage);
    LITEFX_DEFINE_FLAGS(ResourceAccess);
    LITEFX_DEFINE_FLAGS(BufferFormat);
    LITEFX_DEFINE_FLAGS(WriteMask);
    LITEFX_DEFINE_FLAGS(RenderTargetFlags);
    LITEFX_DEFINE_FLAGS(GeometryFlags);
    LITEFX_DEFINE_FLAGS(ResourceUsage);
    LITEFX_DEFINE_FLAGS(AccelerationStructureFlags);
    LITEFX_DEFINE_FLAGS(InstanceFlags);
    LITEFX_DEFINE_FLAGS(ShaderBindingGroup);
 
#pragma endregion
 
#pragma region "Helper Functions"
 
    constexpr UInt32 getBufferFormatChannels(BufferFormat format) {
        return static_cast<UInt32>(format) & 0x000000FF; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
    }
 
    constexpr UInt32 getBufferFormatChannelSize(BufferFormat format) {
        return (static_cast<UInt32>(format) & 0xFF000000) >> 24; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
    }
 
    constexpr UInt32 getBufferFormatType(BufferFormat format) {
        return (static_cast<UInt32>(format) & 0x0000FF00) >> 8; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
    }
 
    constexpr size_t getSize(Format format) {
        switch (format) {
            using enum Format;
        case None:
            return 0; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R4G4_UNORM:
        case R8_UNORM:
        case R8_SNORM:
        case R8_USCALED:
        case R8_SSCALED:
        case R8_UINT:
        case R8_SINT:
        case R8_SRGB:
        case S8_UINT:
            return 1; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R4G4B4A4_UNORM:
        case B4G4R4A4_UNORM:
        case R5G6B5_UNORM:
        case B5G6R5_UNORM:
        case R5G5B5A1_UNORM:
        case B5G5R5A1_UNORM:
        case A1R5G5B5_UNORM:
        case R8G8_UNORM:
        case R8G8_SNORM:
        case R8G8_USCALED:
        case R8G8_SSCALED:
        case R8G8_UINT:
        case R8G8_SINT:
        case R8G8_SRGB:
        case R16_UNORM:
        case R16_SNORM:
        case R16_USCALED:
        case R16_SSCALED:
        case R16_UINT:
        case R16_SINT:
        case R16_SFLOAT:
        case D16_UNORM:
            return 2; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R8G8B8_UNORM:
        case R8G8B8_SNORM:
        case R8G8B8_USCALED:
        case R8G8B8_SSCALED:
        case R8G8B8_UINT:
        case R8G8B8_SINT:
        case R8G8B8_SRGB:
        case B8G8R8_UNORM:
        case B8G8R8_SNORM:
        case B8G8R8_USCALED:
        case B8G8R8_SSCALED:
        case B8G8R8_UINT:
        case B8G8R8_SINT:
        case B8G8R8_SRGB:
        case D16_UNORM_S8_UINT:
            return 3; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R8G8B8A8_UNORM:
        case R8G8B8A8_SNORM:
        case R8G8B8A8_USCALED:
        case R8G8B8A8_SSCALED:
        case R8G8B8A8_UINT:
        case R8G8B8A8_SINT:
        case R8G8B8A8_SRGB:
        case B8G8R8A8_UNORM:
        case B8G8R8A8_SNORM:
        case B8G8R8A8_USCALED:
        case B8G8R8A8_SSCALED:
        case B8G8R8A8_UINT:
        case B8G8R8A8_SINT:
        case B8G8R8A8_SRGB:
        case A8B8G8R8_UNORM:
        case A8B8G8R8_SNORM:
        case A8B8G8R8_USCALED:
        case A8B8G8R8_SSCALED:
        case A8B8G8R8_UINT:
        case A8B8G8R8_SINT:
        case A8B8G8R8_SRGB:
        case A2R10G10B10_UNORM:
        case A2R10G10B10_SNORM:
        case A2R10G10B10_USCALED:
        case A2R10G10B10_SSCALED:
        case A2R10G10B10_UINT:
        case A2R10G10B10_SINT:
        case A2B10G10R10_UNORM:
        case A2B10G10R10_SNORM:
        case A2B10G10R10_USCALED:
        case A2B10G10R10_SSCALED:
        case A2B10G10R10_UINT:
        case A2B10G10R10_SINT:
        case R16G16_UNORM:
        case R16G16_SNORM:
        case R16G16_USCALED:
        case R16G16_SSCALED:
        case R16G16_UINT:
        case R16G16_SINT:
        case R16G16_SFLOAT:
        case R32_UINT:
        case R32_SINT:
        case R32_SFLOAT:
        case B10G11R11_UFLOAT:
        case E5B9G9R9_UFLOAT:
        case X8_D24_UNORM:
        case D32_SFLOAT:
        case D24_UNORM_S8_UINT:
            return 4; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R16G16B16_UNORM:
        case R16G16B16_SNORM:
        case R16G16B16_USCALED:
        case R16G16B16_SSCALED:
        case R16G16B16_UINT:
        case R16G16B16_SINT:
        case R16G16B16_SFLOAT:
            return 6; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R16G16B16A16_UNORM:
        case R16G16B16A16_SNORM:
        case R16G16B16A16_USCALED:
        case R16G16B16A16_SSCALED:
        case R16G16B16A16_UINT:
        case R16G16B16A16_SINT:
        case R16G16B16A16_SFLOAT:
        case R32G32_UINT:
        case R32G32_SINT:
        case R32G32_SFLOAT:
        case R64_UINT:
        case R64_SINT:
        case R64_SFLOAT:
        case D32_SFLOAT_S8_UINT:    // NOTE: This may be wrong here - spec states, however, that 24 bits are unused.
        case BC1_RGB_UNORM:
        case BC1_RGB_SRGB:
        case BC1_RGBA_UNORM:
        case BC1_RGBA_SRGB:
        case BC4_UNORM:
        case BC4_SNORM:
            return 8; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R32G32B32_UINT:
        case R32G32B32_SINT:
        case R32G32B32_SFLOAT:
            return 12; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R32G32B32A32_UINT:
        case R32G32B32A32_SINT:
        case R32G32B32A32_SFLOAT:
        case R64G64_UINT:
        case R64G64_SINT:
        case R64G64_SFLOAT:
        case BC2_UNORM:
        case BC2_SRGB:
        case BC3_UNORM:
        case BC3_SRGB:
        case BC5_UNORM:
        case BC5_SNORM:
        case BC6H_UFLOAT:
        case BC6H_SFLOAT:
        case BC7_UNORM:
        case BC7_SRGB:
            return 16; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R64G64B64_UINT:
        case R64G64B64_SINT:
        case R64G64B64_SFLOAT:
            return 24; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        case R64G64B64A64_UINT:
        case R64G64B64A64_SINT:
        case R64G64B64A64_SFLOAT:
            return 32; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        default:
            throw InvalidArgumentException("format", "Unsupported format: {0}.", std::to_underlying(format)); // An invalid format will not have a formatter anyway, but it also would be illegal to use it here.
        }
    }
 
    constexpr bool hasDepth(Format format) noexcept {
        constexpr std::array<Format, 6> depthFormats {
            Format::D16_UNORM,
            Format::D32_SFLOAT,
            Format::X8_D24_UNORM,
            Format::D16_UNORM_S8_UINT,
            Format::D24_UNORM_S8_UINT,
            Format::D32_SFLOAT_S8_UINT
        };
 
        return std::any_of(std::begin(depthFormats), std::end(depthFormats), [&](Format f) { return f == format; });
    }
 
    constexpr bool hasStencil(Format format) noexcept {
        constexpr std::array<Format, 4> stencilFormats {
            Format::D16_UNORM_S8_UINT,
            Format::D24_UNORM_S8_UINT,
            Format::D32_SFLOAT_S8_UINT,
            Format::S8_UINT
        };
 
        return std::any_of(std::begin(stencilFormats), std::end(stencilFormats), [&](Format f) { return f == format; });
    }
 
#pragma endregion
 
#pragma region "Data Types"
 
    struct LITEFX_RENDERING_API alignas(16) IndirectBatch { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        UInt32 VertexCount{ };
 
        UInt32 InstanceCount{ };
 
        UInt32 FirstVertex{ };
 
        UInt32 FirstInstance{ };
    };
 
#pragma warning(push)
#pragma warning(disable: 4324) // Structure was padded due to alignment specifier
    struct LITEFX_RENDERING_API alignas(16) IndirectIndexedBatch { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        UInt32 IndexCount{ };
 
        UInt32 InstanceCount{ };
 
        UInt32 FirstIndex{ };
 
        Int32 VertexOffset{ };
 
        UInt32 FirstInstance{ };
    };
 
    struct LITEFX_RENDERING_API alignas(16) IndirectDispatchBatch { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        UInt32 X{ 1 };
 
        UInt32 Y{ 1 };
 
        UInt32 Z{ 1 };
    };
#pragma warning(pop)
 
    struct LITEFX_RENDERING_API ResourceAllocationInfo final {
    public:
        struct BufferInfo 
        {
            BufferType Type{ BufferType::Uniform };
 
            size_t ElementSize{ 0u };
 
            UInt32 Elements{ 1u };
            
            ResourceHeap Heap{ ResourceHeap::Dynamic };
 
            SharedPtr<const IVertexBufferLayout> VertexBufferLayout{ nullptr };
 
            SharedPtr<const IIndexBufferLayout> IndexBufferLayout{ nullptr };
        };
 
        struct ImageInfo 
        {
            Format Format{ Format::R8G8B8A8_SRGB };
 
            ImageDimensions Dimensions{ ImageDimensions::DIM_2 };
 
            Size3d Size{ };
 
            UInt32 Levels{ 1u };
 
            UInt32 Layers{ 1u };
 
            MultiSamplingLevel Samples{ MultiSamplingLevel::x1 };
        };
 
    public:
        Variant<BufferInfo, ImageInfo> ResourceInfo{};
 
        ResourceUsage Usage{ ResourceUsage::Default };
 
        String Name{ };
 
        size_t AliasingOffset{ 0u };
 
    public:
        ResourceAllocationInfo() = default;
 
        explicit ResourceAllocationInfo(const BufferInfo& bufferInfo, ResourceUsage usage = ResourceUsage::Default, String name = "", size_t aliasingOffset = 0u) :
            ResourceInfo(bufferInfo), Usage(usage), Name(std::move(name)), AliasingOffset(aliasingOffset) { }
 
        explicit ResourceAllocationInfo(const ImageInfo& imageInfo, ResourceUsage usage = ResourceUsage::Default, String name = "", size_t aliasingOffset = 0u) :
            ResourceInfo(imageInfo), Usage(usage), Name(std::move(name)), AliasingOffset(aliasingOffset) { }
        
        ResourceAllocationInfo(const ResourceAllocationInfo&) = default;
        ResourceAllocationInfo(ResourceAllocationInfo&&) noexcept = default;
        ResourceAllocationInfo& operator=(const ResourceAllocationInfo&) = default;
        ResourceAllocationInfo& operator=(ResourceAllocationInfo&&) noexcept = default;
        ~ResourceAllocationInfo() noexcept = default;
    };
 
    struct LITEFX_RENDERING_API ResourceAllocationResult final {
    private:
        Variant<SharedPtr<IImage>, SharedPtr<IBuffer>> m_resource;
 
    public:
        ResourceAllocationResult(SharedPtr<IImage>&& image) noexcept :
            m_resource(std::move(image)) { }
        
        ResourceAllocationResult(SharedPtr<IBuffer>&& buffer) noexcept :
            m_resource(std::move(buffer)) { }
 
        ResourceAllocationResult() = delete;
        ResourceAllocationResult(const ResourceAllocationResult&) = delete;
        ResourceAllocationResult(ResourceAllocationResult&&) noexcept = default;
        ResourceAllocationResult& operator=(const ResourceAllocationResult&) = delete;
        ResourceAllocationResult& operator=(ResourceAllocationResult&&) noexcept = default;
        ~ResourceAllocationResult() noexcept = default;
 
    public:
        template <std::derived_from<IImage> TImage>
        SharedPtr<TImage> image() const {
            if (!std::holds_alternative<SharedPtr<IImage>>(m_resource)) [[unlikely]]
                throw RuntimeException("The allocation result does not contain an image.");
            
            auto image = std::dynamic_pointer_cast<TImage>(std::get<SharedPtr<IImage>>(m_resource));
 
            if (image == nullptr)
                throw RuntimeException("The allocated image resource is not of the requested image type.");
            
            return image;
        }
 
        template <std::derived_from<IBuffer> TBuffer>
        SharedPtr<TBuffer> buffer() const {
            if (!std::holds_alternative<SharedPtr<IBuffer>>(m_resource)) [[unlikely]]
                throw RuntimeException("The allocation result does not contain a buffer.");
 
            auto buffer = std::dynamic_pointer_cast<TBuffer>(std::get<SharedPtr<IBuffer>>(m_resource));
 
            if (buffer == nullptr)
                throw RuntimeException("The allocated buffer resource is not of the requested buffer type.");
 
            return buffer;
        }
    };
#pragma endregion
 
    class LITEFX_RENDERING_API IStateResource {
    protected:
        IStateResource() noexcept = default;
        IStateResource(const IStateResource&) = delete;
        IStateResource(IStateResource&&) noexcept = default;
        IStateResource& operator=(const IStateResource&) = delete;
        IStateResource& operator=(IStateResource&&) noexcept = default;
 
    public:
        virtual ~IStateResource() noexcept = default;
 
    public:
        virtual const String& name() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API StateResource : public virtual IStateResource {
        LITEFX_IMPLEMENTATION(StateResourceImpl);
 
    protected:
        StateResource();
 
        explicit StateResource(StringView name);
 
        StateResource(StateResource&&) noexcept;
        StateResource& operator=(StateResource&&) noexcept;
 
        StateResource(const StateResource&) = delete;
        StateResource& operator=(const StateResource&) = delete;
 
    public:
        ~StateResource() noexcept override;
 
    protected:
        String& name() noexcept;
 
    public:
        const String& name() const noexcept override;
    };
 
    class LITEFX_RENDERING_API DeviceState {
        LITEFX_IMPLEMENTATION(DeviceStateImpl);
        friend class IGraphicsDevice;
 
    public:
        explicit DeviceState();
 
        DeviceState(DeviceState&& _other) noexcept;
 
        DeviceState& operator=(DeviceState&& _other) noexcept;
 
        virtual ~DeviceState() noexcept;
 
        DeviceState(const DeviceState&) = delete;
        DeviceState& operator=(const DeviceState&) = delete;
 
    public:
        void clear();
 
        void add(SharedPtr<IRenderPass>&& renderPass);
 
        void add(const String& id, SharedPtr<IRenderPass>&& renderPass);
 
        void add(SharedPtr<IFrameBuffer>&& frameBuffer);
 
        void add(const String& id, SharedPtr<IFrameBuffer>&& frameBuffer);
 
        void add(UniquePtr<IPipeline>&& pipeline);
 
        void add(const String& id, UniquePtr<IPipeline>&& pipeline);
 
        void add(SharedPtr<IBuffer>&& buffer);
 
        void add(const String& id, SharedPtr<IBuffer>&& buffer);
 
        void add(SharedPtr<IVertexBuffer>&& vertexBuffer);
 
        void add(const String& id, SharedPtr<IVertexBuffer>&& vertexBuffer);
 
        void add(SharedPtr<IIndexBuffer>&& indexBuffer);
 
        void add(const String& id, SharedPtr<IIndexBuffer>&& indexBuffer);
 
        void add(SharedPtr<IImage>&& image);
 
        void add(const String& id, SharedPtr<IImage>&& image);
 
        void add(SharedPtr<ISampler>&& sampler);
 
        void add(const String& id, SharedPtr<ISampler>&& sampler);
 
        void add(UniquePtr<IAccelerationStructure>&& accelerationStructure);
 
        void add(const String& id, UniquePtr<IAccelerationStructure>&& accelerationStructure);
        
        void add(const String& id, UniquePtr<IDescriptorSet>&& descriptorSet);
 
        IRenderPass& renderPass(const String& id) const;
 
        IFrameBuffer& frameBuffer(const String& id) const;
 
        IPipeline& pipeline(const String& id) const;
 
        IBuffer& buffer(const String& id) const;
 
        IVertexBuffer& vertexBuffer(const String& id) const;
 
        IIndexBuffer& indexBuffer(const String& id) const;
 
        IImage& image(const String& id) const;
 
        ISampler& sampler(const String& id) const;
 
        IAccelerationStructure& accelerationStructure(const String& id) const;
 
        IDescriptorSet& descriptorSet(const String& id) const;
 
        bool release(const IRenderPass& renderPass);
 
        bool release(const IFrameBuffer& frameBuffer);
 
        bool release(const IPipeline& pipeline);
 
        bool release(const IBuffer& buffer);
 
        bool release(const IVertexBuffer& buffer);
 
        bool release(const IIndexBuffer& buffer);
 
        bool release(const IImage& image);
 
        bool release(const ISampler& sampler);
 
        bool release(const IDescriptorSet& descriptorSet);
    };
 
    class LITEFX_RENDERING_API VirtualAllocator final {
    public:
        struct Allocation final {
            UInt64 Handle { 0u };
 
            UInt64 Size { 0u };
 
            UInt64 Offset { std::numeric_limits<UInt64>::max() };
        };
 
    private:
        struct AllocatorImplBase {
        private:
            UInt64 m_size;
            AllocationAlgorithm m_algorithm;
 
        protected:
            AllocatorImplBase(UInt64 overallMemory, AllocationAlgorithm algorithm) :
                m_size(overallMemory), m_algorithm(algorithm)
            {
            }
 
            AllocatorImplBase(const AllocatorImplBase&) = delete;
            AllocatorImplBase(AllocatorImplBase&&) noexcept = delete;
            AllocatorImplBase& operator=(const AllocatorImplBase&) = delete;
            AllocatorImplBase& operator=(AllocatorImplBase&&) noexcept = delete;
 
        public:
            virtual ~AllocatorImplBase() noexcept = default;
 
        public:
            inline UInt64 size() const noexcept {
                return m_size;
            }
 
            inline AllocationAlgorithm algorithm() const noexcept {
                return m_algorithm;
            }
 
            [[nodiscard]] virtual Allocation allocate(UInt64 size, UInt32 alignment = 1u, AllocationStrategy strategy = AllocationStrategy::OptimizePacking, void* privateData = nullptr) const = 0;
 
            virtual void free(Allocation&& allocation) const = 0;
 
            virtual void* privateData(const Allocation& allocation) const = 0;
        };
 
        template <typename TBackend>
        struct AllocatorImpl final : public AllocatorImplBase { 
            static_assert(false, "Attempting to use a non-specialized virtual allocator is invalid.");
        };
 
        UniquePtr<AllocatorImplBase> m_impl;
 
        VirtualAllocator(UniquePtr<AllocatorImplBase>&& pImpl) :
            m_impl(std::move(pImpl))
        {
        }
 
    public:
        VirtualAllocator(const VirtualAllocator&) = delete;
        VirtualAllocator(VirtualAllocator&&) noexcept = delete;
        VirtualAllocator& operator=(const VirtualAllocator&) = delete;
        VirtualAllocator& operator=(VirtualAllocator&&) noexcept = delete;
        ~VirtualAllocator() noexcept = default;
 
    public:
        template <typename TBackend>
        [[nodiscard]] static inline VirtualAllocator create(UInt64 overallMemory, AllocationAlgorithm algorithm = AllocationAlgorithm::Default) {
            return VirtualAllocator(UniquePtr<AllocatorImplBase>(new AllocatorImpl<TBackend>(overallMemory, algorithm)));
        }
 
    public:
        inline UInt64 size() const noexcept {
            return m_impl->size();
        }
 
        inline AllocationAlgorithm algorithm() const noexcept {
            return m_impl->algorithm();
        }
 
        [[nodiscard]] inline Allocation allocate(UInt64 size, UInt32 alignment = 1u, AllocationStrategy strategy = AllocationStrategy::OptimizePacking, void* privateData = nullptr) const {
            return m_impl->allocate(size, alignment, strategy, privateData);
        }
 
        inline void free(Allocation&& allocation) const { // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
            m_impl->free(std::forward<Allocation>(allocation));
        }
 
        inline void* privateData(const Allocation& allocation) const {
            return m_impl->privateData(allocation);
        };
    };
 
    class LITEFX_RENDERING_API IGraphicsAdapter : public SharedObject {
    protected:
        IGraphicsAdapter() noexcept = default;
        IGraphicsAdapter(const IGraphicsAdapter&) = default;
        IGraphicsAdapter(IGraphicsAdapter&&) noexcept = default;
        IGraphicsAdapter& operator=(const IGraphicsAdapter&) = default;
        IGraphicsAdapter& operator=(IGraphicsAdapter&&) noexcept = default;
 
    public:
        ~IGraphicsAdapter() noexcept override= default;
 
    public:
        virtual String name() const = 0;
 
        virtual UInt64 uniqueId() const noexcept = 0;
 
        virtual UInt32 vendorId() const noexcept = 0;
 
        virtual UInt32 deviceId() const noexcept = 0;
 
        virtual GraphicsAdapterType type() const noexcept = 0;
 
        virtual UInt64 driverVersion() const noexcept = 0;
 
        virtual UInt32 apiVersion() const noexcept = 0;
 
        virtual UInt64 dedicatedMemory() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API ISurface {
    protected:
        ISurface() noexcept = default;
        ISurface(const ISurface&) = default;
        ISurface(ISurface&&) noexcept = default;
        ISurface& operator=(const ISurface&) = default;
        ISurface& operator=(ISurface&&) noexcept = default;
 
    public:
        virtual ~ISurface() noexcept = default;
    };
    
    struct LITEFX_RENDERING_API DescriptorBindingPoint final {
    public:
        UInt32 Register { 0 };
 
        UInt32 Space { 0 };
 
    public:
        inline auto operator<=>(const DescriptorBindingPoint& other) const noexcept {
            // NOLINTBEGIN(bugprone-branch-clone)
            if (this->Space < other.Space)
                return std::strong_ordering::less;
            else if (this->Space > other.Space)
                return std::strong_ordering::greater;
            else if (this->Register < other.Register)
                return std::strong_ordering::less;
            else if(this->Register > other.Register)
                return std::strong_ordering::greater;
            else // Space and Register are equal.
                return std::strong_ordering::equal;
            // NOLINTEND(bugprone-branch-clone)
        }
 
        inline bool operator==(const DescriptorBindingPoint& other) const noexcept {
            return other.Space == this->Space && other.Register == this->Register;
        }
    };
 
    class LITEFX_RENDERING_API IShaderModule {
    protected:
        IShaderModule() noexcept = default;
        IShaderModule(const IShaderModule&) = default;
        IShaderModule(IShaderModule&&) noexcept = default;
        IShaderModule& operator=(const IShaderModule&) = default;
        IShaderModule& operator=(IShaderModule&&) noexcept = default;
 
    public:
        virtual ~IShaderModule() noexcept = default;
 
    public:
        virtual ShaderStage type() const noexcept = 0;
 
        virtual const String& fileName() const noexcept = 0;
 
        virtual const String& entryPoint() const noexcept = 0;
 
        virtual const Optional<DescriptorBindingPoint>& shaderLocalDescriptor() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IRenderTarget {
    public:
        struct BlendState {
        public:
            bool Enable{ false };
 
            BlendFactor SourceColor{ BlendFactor::One };
 
            BlendFactor DestinationColor{ BlendFactor::Zero };
 
            BlendFactor SourceAlpha{ BlendFactor::One };
 
            BlendFactor DestinationAlpha{ BlendFactor::Zero };
 
            BlendOperation ColorOperation{ BlendOperation::Add };
 
            BlendOperation AlphaOperation{ BlendOperation::Add };
 
            WriteMask ChannelWriteMask{ WriteMask::R | WriteMask::G | WriteMask::B | WriteMask::A };
        };
 
    protected:
        IRenderTarget() noexcept = default;
        IRenderTarget(const IRenderTarget&) = default;
        IRenderTarget(IRenderTarget&&) noexcept = default;
        IRenderTarget& operator=(const IRenderTarget&) = default;
        IRenderTarget& operator=(IRenderTarget&&) noexcept = default;
 
    public:
        virtual ~IRenderTarget() noexcept = default;
 
    public:
        virtual UInt64 identifier() const noexcept = 0;
 
        virtual const String& name() const noexcept = 0;
 
        virtual UInt32 location() const noexcept = 0;
 
        virtual RenderTargetType type() const noexcept = 0;
 
        virtual Format format() const noexcept = 0;
 
        virtual RenderTargetFlags flags() const noexcept = 0;
 
        virtual bool clearBuffer() const noexcept = 0;
 
        virtual bool clearStencil() const noexcept = 0;
 
        virtual const Vector4f& clearValues() const noexcept = 0;
 
        virtual bool isVolatile() const noexcept = 0;
 
        virtual const BlendState& blendState() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API RenderTarget : public IRenderTarget {
        LITEFX_IMPLEMENTATION(RenderTargetImpl);
 
    public:
        explicit RenderTarget(UInt64 uid, UInt32 location, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.f , 0.f, 0.f, 0.f }, const BlendState& blendState = {});
 
        explicit RenderTarget(StringView name, UInt32 location, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.f , 0.f, 0.f, 0.f }, const BlendState& blendState = {});
        
        RenderTarget(const RenderTarget& _other);
 
        RenderTarget(RenderTarget&& _other) noexcept;
 
        RenderTarget& operator=(const RenderTarget& _other);
 
        RenderTarget& operator=(RenderTarget&& _other) noexcept;
        
        ~RenderTarget() noexcept override;
 
    public:
        UInt64 identifier() const noexcept override;
 
        const String& name() const noexcept override;
 
        UInt32 location() const noexcept override;
 
        RenderTargetType type() const noexcept override;
 
        Format format() const noexcept override;
 
        RenderTargetFlags flags() const noexcept override;
 
        bool clearBuffer() const noexcept override;
 
        bool clearStencil() const noexcept override;
 
        const Vector4f& clearValues() const noexcept override;
 
        bool isVolatile() const noexcept override;
 
        const BlendState& blendState() const noexcept override;
    };
 
    class LITEFX_RENDERING_API RenderPassDependency {
        LITEFX_IMPLEMENTATION(RenderPassDependencyImpl);
 
    public:
        RenderPassDependency(const RenderTarget& renderTarget, const DescriptorBindingPoint& descriptorBinding) noexcept;
 
        RenderPassDependency(const RenderTarget& renderTarget, UInt32 bindingRegister, UInt32 space) noexcept;
 
        RenderPassDependency(const RenderPassDependency& _other);
 
        RenderPassDependency(RenderPassDependency&& _other) noexcept;
 
        RenderPassDependency& operator=(const RenderPassDependency& _other);
 
        RenderPassDependency& operator=(RenderPassDependency&& _other) noexcept;
 
        ~RenderPassDependency() noexcept;
 
    public:
        const RenderTarget& renderTarget() const noexcept;
 
        const DescriptorBindingPoint& binding() const noexcept;
    };
 
    class LITEFX_RENDERING_API DepthStencilState final {
        LITEFX_IMPLEMENTATION(DepthStencilStateImpl);
 
    public:
        struct DepthState {
        public:
            bool Enable{ true };
 
            bool Write{ true };
 
            CompareOperation Operation{ CompareOperation::Always };
 
            bool DepthBoundsTestEnable{ false };
        };
 
        struct DepthBias {
        public:
            bool Enable{ false };
 
            Float Clamp{ 0.f };
 
            Float SlopeFactor{ 0.f };
 
            Float ConstantFactor{ 0.f };
        };
 
        struct StencilTest {
        public:
            StencilOperation StencilFailOp{ StencilOperation::Keep };
 
            StencilOperation StencilPassOp{ StencilOperation::Replace };
 
            StencilOperation DepthFailOp{ StencilOperation::Keep };
 
            CompareOperation Operation{ CompareOperation::Never };
        };
 
        struct StencilState {
        public:
            bool Enable{ false };
 
            UInt8 WriteMask{ 0xFF }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
            UInt8 ReadMask{ 0xFF }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
            StencilTest FrontFace{};
 
            StencilTest BackFace{};
        };
 
    public:
        explicit DepthStencilState(const DepthState& depthState, const DepthBias& depthBias, const StencilState& stencilState) noexcept;
 
        DepthStencilState() noexcept;
 
        DepthStencilState(const DepthStencilState&);
 
        DepthStencilState(DepthStencilState&&) noexcept;
 
        DepthStencilState& operator=(const DepthStencilState&);
 
        DepthStencilState& operator=(DepthStencilState&&) noexcept;
 
        virtual ~DepthStencilState() noexcept;
 
    public:
        virtual DepthState& depthState() const noexcept;
 
        virtual DepthBias& depthBias() const noexcept;
 
        virtual StencilState& stencilState() const noexcept;
    };
 
    class LITEFX_RENDERING_API IRasterizer : public SharedObject {
    protected:
        IRasterizer() noexcept = default;
        IRasterizer(const IRasterizer&) = default;
        IRasterizer(IRasterizer&&) noexcept = default;
        IRasterizer& operator=(const IRasterizer&) = default;
        IRasterizer& operator=(IRasterizer&&) noexcept = default;
 
    public:
        ~IRasterizer() noexcept override = default;
 
    public:
        virtual PolygonMode polygonMode() const noexcept = 0;
 
        virtual CullMode cullMode() const noexcept = 0;
 
        virtual CullOrder cullOrder() const noexcept = 0;
 
        virtual Float lineWidth() const noexcept = 0;
 
        virtual const DepthStencilState& depthStencilState() const noexcept = 0;
 
        virtual bool depthClip() const noexcept = 0;
 
        virtual bool conservativeRasterization() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API Rasterizer : public IRasterizer {
        LITEFX_IMPLEMENTATION(RasterizerImpl);
 
    protected:
        explicit Rasterizer(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, bool depthClip = true, const DepthStencilState& depthStencilState = {}, bool conservativeRasterization = false) noexcept;
 
        Rasterizer(const Rasterizer& _other);
 
        Rasterizer(Rasterizer&& _other) noexcept;
 
        Rasterizer& operator=(const Rasterizer& _other);
 
        Rasterizer& operator=(Rasterizer&& _other) noexcept;
 
    public:
        ~Rasterizer() noexcept override;
 
    public:
        PolygonMode polygonMode() const noexcept override;
 
        CullMode cullMode() const noexcept override;
 
        CullOrder cullOrder() const noexcept override;
 
        Float lineWidth() const noexcept override;
 
        const DepthStencilState& depthStencilState() const noexcept override;
 
        bool depthClip() const noexcept override;
 
        bool conservativeRasterization() const noexcept override;
 
    protected:
        virtual PolygonMode& polygonMode() noexcept;
        virtual CullMode& cullMode() noexcept;
        virtual CullOrder& cullOrder() noexcept;
        virtual Float& lineWidth() noexcept;
        virtual bool& depthClip() noexcept;
        virtual DepthStencilState& depthStencilState() noexcept;
        virtual bool& conservativeRasterization() noexcept;
    };
 
    class LITEFX_RENDERING_API IViewport {
    protected:
        IViewport() noexcept = default;
        IViewport(const IViewport&) = default;
        IViewport(IViewport&&) noexcept = default;
        IViewport& operator=(const IViewport&) = default;
        IViewport& operator=(IViewport&&) noexcept = default;
 
    public:
        virtual ~IViewport() noexcept = default;
 
    public:
        virtual RectF getRectangle() const noexcept = 0;
 
        virtual void setRectangle(const RectF& rectangle) noexcept = 0;
 
        virtual float getMinDepth() const noexcept = 0;
 
        virtual void setMinDepth(Float depth) const noexcept = 0;
 
        virtual float getMaxDepth() const noexcept = 0;
 
        virtual void setMaxDepth(Float depth) const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API Viewport : public IViewport {
        LITEFX_IMPLEMENTATION(ViewportImpl);
 
    public:
        explicit Viewport(const RectF& clientRect = { }, Float minDepth = 0.f, Float maxDepth = 1.f) noexcept;
 
        Viewport(const Viewport& _other);
 
        Viewport(Viewport&& _other) noexcept;
 
        Viewport& operator=(const Viewport& _other);
 
        Viewport& operator=(Viewport&& _other) noexcept;
 
        ~Viewport() noexcept override;
 
    public:
        RectF getRectangle() const noexcept override;
 
        void setRectangle(const RectF& rectangle) noexcept override;
 
        Float getMinDepth() const noexcept override;
 
        void setMinDepth(Float depth) const noexcept override;
 
        Float getMaxDepth() const noexcept override;
 
        void setMaxDepth(Float depth) const noexcept override;
    };
 
    class LITEFX_RENDERING_API IScissor {
    protected:
        IScissor() noexcept = default;
        IScissor(IScissor&&) noexcept = default;
        IScissor(const IScissor&) = default;
        IScissor& operator=(IScissor&&) noexcept = default;
        IScissor& operator=(const IScissor&) = default;
 
    public:
        virtual ~IScissor() noexcept = default;
 
    public:
        virtual RectF getRectangle() const noexcept = 0;
 
        virtual void setRectangle(const RectF& rectangle) noexcept = 0;
    };
 
    class LITEFX_RENDERING_API Scissor final : public IScissor {
        LITEFX_IMPLEMENTATION(ScissorImpl);
 
    public:
        explicit Scissor(const RectF& scissorRect = { }) noexcept;
 
        Scissor(const Scissor& _other);
 
        Scissor(Scissor&& _other) noexcept;
 
        Scissor& operator=(const Scissor& _other);
 
        Scissor& operator=(Scissor&& _other) noexcept;
 
        ~Scissor() noexcept override;
 
    public:
        RectF getRectangle() const noexcept override;
 
        void setRectangle(const RectF& rectangle) noexcept override;
    };
 
    struct LITEFX_RENDERING_API ShaderBindingTableOffsets {
        UInt64 RayGenerationGroupOffset { std::numeric_limits<UInt64>::max() };
 
        UInt64 RayGenerationGroupSize { 0 };
 
        UInt64 RayGenerationGroupStride { 0 };
 
        UInt64 HitGroupOffset { std::numeric_limits<UInt64>::max() };
 
        UInt64 HitGroupSize { 0 };
 
        UInt64 HitGroupStride { 0 };
 
        UInt64 MissGroupOffset{ std::numeric_limits<UInt64>::max() };
 
        UInt64 MissGroupSize { 0 };
 
        UInt64 MissGroupStride { 0 };
 
        UInt64 CallableGroupOffset { std::numeric_limits<UInt64>::max() };
 
        UInt64 CallableGroupSize { 0 };
 
        UInt64 CallableGroupStride { 0 };
    };
 
    class LITEFX_RENDERING_API TimingEvent final : public SharedObject {
        LITEFX_IMPLEMENTATION(TimingEventImpl);
        friend class ISwapChain;
        friend struct SharedObject::Allocator<TimingEvent>;
 
    private:
        explicit TimingEvent(const ISwapChain& swapChain, StringView name = "");
 
    public:
        ~TimingEvent() noexcept override;
 
        TimingEvent(TimingEvent&&) noexcept = delete;
        TimingEvent(const TimingEvent&) = delete;
        auto operator=(TimingEvent&&) noexcept = delete;
        auto operator=(const TimingEvent&) = delete;
 
    private:
        static inline auto create(const ISwapChain& swapChain, StringView name = "") {
            return SharedObject::create<TimingEvent>(swapChain, name);
        }
 
    public:
        StringView name() const noexcept;
 
        UInt64 readTimestamp() const;
 
        UInt32 queryId() const;
    };
 
    class LITEFX_RENDERING_API BufferAttribute final {
        LITEFX_IMPLEMENTATION(BufferAttributeImpl);
 
    public:
        BufferAttribute() noexcept;
 
        BufferAttribute(UInt32 location, UInt32 offset, BufferFormat format, AttributeSemantic semantic, UInt32 semanticIndex = 0) noexcept;
 
        BufferAttribute(const BufferAttribute& _other);
 
        BufferAttribute(BufferAttribute&& _other) noexcept;
 
        BufferAttribute& operator=(const BufferAttribute& _other);
 
        BufferAttribute& operator=(BufferAttribute&& _other) noexcept;
 
        virtual ~BufferAttribute() noexcept;
 
    public:
        virtual UInt32 location() const noexcept;
 
        virtual BufferFormat format() const noexcept;
 
        virtual UInt32 offset() const noexcept;
 
        virtual AttributeSemantic semantic() const noexcept;
 
        virtual UInt32 semanticIndex() const noexcept;
    };
 
    class LITEFX_RENDERING_API IBufferLayout {
    protected:
        IBufferLayout() noexcept = default;
        IBufferLayout(IBufferLayout&&) noexcept = default;
        IBufferLayout(const IBufferLayout&) = default;
        IBufferLayout& operator=(IBufferLayout&&) noexcept = default;
        IBufferLayout& operator=(const IBufferLayout&) = default;
 
    public:
        virtual ~IBufferLayout() noexcept = default;
 
    public:
        virtual size_t elementSize() const noexcept = 0;
 
        virtual UInt32 binding() const noexcept = 0;
 
        virtual BufferType type() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IVertexBufferLayout : public IBufferLayout, public SharedObject {
    protected:
        IVertexBufferLayout() noexcept = default;
        IVertexBufferLayout(IVertexBufferLayout&&) noexcept = default;
        IVertexBufferLayout(const IVertexBufferLayout&) = default;
        IVertexBufferLayout& operator=(IVertexBufferLayout&&) noexcept = default;
        IVertexBufferLayout& operator=(const IVertexBufferLayout&) = default;
 
    public:
        ~IVertexBufferLayout() noexcept override = default;
 
    public:
        virtual const Array<BufferAttribute>& attributes() const = 0;
 
        virtual VertexBufferInputRate inputRate() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IIndexBufferLayout : public IBufferLayout, public SharedObject {
    protected:
        IIndexBufferLayout() noexcept = default;
        IIndexBufferLayout(IIndexBufferLayout&&) noexcept = default;
        IIndexBufferLayout(const IIndexBufferLayout&) = default;
        IIndexBufferLayout& operator=(IIndexBufferLayout&&) noexcept = default;
        IIndexBufferLayout& operator=(const IIndexBufferLayout&) = default;
 
    public:
        ~IIndexBufferLayout() noexcept override = default;
 
    public:
        virtual IndexType indexType() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorLayout : public IBufferLayout {
    protected:
        IDescriptorLayout() noexcept = default;
        IDescriptorLayout(IDescriptorLayout&&) noexcept = default;
        IDescriptorLayout(const IDescriptorLayout&) = default;
        IDescriptorLayout& operator=(IDescriptorLayout&&) noexcept = default;
        IDescriptorLayout& operator=(const IDescriptorLayout&) = default;
 
    public:
        ~IDescriptorLayout() noexcept override = default;
 
    public:
        virtual DescriptorType descriptorType() const noexcept = 0;
 
        virtual UInt32 descriptors() const noexcept = 0;
 
        virtual bool unbounded() const noexcept = 0;
 
        virtual const ISampler* staticSampler() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IMappable {
    protected:
        IMappable() noexcept = default;
        IMappable(IMappable&&) noexcept = default;
        IMappable(const IMappable&) = default;
        IMappable& operator=(IMappable&&) noexcept = default;
        IMappable& operator=(const IMappable&) = default;
 
    public:
        virtual ~IMappable() noexcept = default;
 
    public:
        virtual void map(const void* const data, size_t size, UInt32 element = 0) = 0;
 
        virtual void map(Span<const void* const> data, size_t elementSize, UInt32 firstElement = 0) = 0;
 
        virtual void map(void* data, size_t size, UInt32 element = 0, bool write = true) = 0;
 
        virtual void map(Span<void*> data, size_t elementSize, UInt32 firstElement = 0, bool write = true) = 0;
 
        virtual void write(const void* const data, size_t size, size_t offset = 0) = 0;
 
        virtual void read(void* data, size_t size, size_t offset = 0) = 0;
    };
 
    class LITEFX_RENDERING_API IDeviceMemory {
    public:
        struct PrepareMoveEventArgs final {
        private:
            IBarrier& m_barrier;
 
        public:
            PrepareMoveEventArgs() = delete;
            PrepareMoveEventArgs(const PrepareMoveEventArgs&) = delete;
            PrepareMoveEventArgs(PrepareMoveEventArgs&&) noexcept = delete;
            PrepareMoveEventArgs& operator=(const PrepareMoveEventArgs&) = delete;
            PrepareMoveEventArgs& operator=(PrepareMoveEventArgs&&) noexcept = delete;
            ~PrepareMoveEventArgs() noexcept = default;
            
            PrepareMoveEventArgs(IBarrier& barrier) :
                m_barrier(barrier) { 
            }
 
        public:
            IBarrier& barrier() const noexcept {
                return m_barrier;
            }
        };
 
        struct ResourceMovingEventArgs final {
        private:
            SharedPtr<const ICommandQueue> m_queue{};
            UInt64 m_fence{};
 
        public:
            ResourceMovingEventArgs(SharedPtr<const ICommandQueue> queue, UInt64 fence) noexcept :
                m_queue(std::move(queue)), m_fence(fence)
            {
            }
 
            ResourceMovingEventArgs(const ResourceMovingEventArgs&) = default;
            ResourceMovingEventArgs(ResourceMovingEventArgs&&) noexcept = default;
            ResourceMovingEventArgs& operator=(const ResourceMovingEventArgs&) = default;
            ResourceMovingEventArgs& operator=(ResourceMovingEventArgs&&) noexcept = default;
            ~ResourceMovingEventArgs() noexcept = default;
 
        public:
            SharedPtr<const ICommandQueue> queue() const noexcept {
                return m_queue;
            }
 
            UInt64 fence() const noexcept {
                return m_fence;
            }
        };
 
    protected:
        IDeviceMemory() noexcept = default;
        IDeviceMemory(IDeviceMemory&&) noexcept = default;
        IDeviceMemory(const IDeviceMemory&) = default;
        IDeviceMemory& operator=(IDeviceMemory&&) noexcept = default;
        IDeviceMemory& operator=(const IDeviceMemory&) = default;
 
    public:
        virtual ~IDeviceMemory() noexcept = default;
 
    public:
        mutable Event<const PrepareMoveEventArgs&> prepareMove;
 
        mutable Event<ResourceMovingEventArgs> moving;
 
        mutable Event<EventArgs> moved;
 
    public:
        virtual UInt32 elements() const noexcept = 0;
 
        virtual size_t size() const noexcept = 0;
 
        virtual size_t elementSize() const noexcept = 0;
 
        virtual size_t elementAlignment() const noexcept = 0;
 
        virtual size_t alignedElementSize() const noexcept = 0;
 
        virtual ResourceUsage usage() const noexcept = 0;
 
        virtual UInt64 virtualAddress() const noexcept = 0;
 
        virtual inline bool writable() const noexcept {
            return LITEFX_FLAG_IS_SET(this->usage(), ResourceUsage::AllowWrite);
        }
 
        virtual inline bool volatileMove() const noexcept {
            return LITEFX_FLAG_IS_SET(this->usage(), ResourceUsage::Volatile);
        }
    };
 
    class LITEFX_RENDERING_API IBuffer : public virtual IDeviceMemory, public virtual IMappable, public virtual IStateResource, public SharedObject {
    protected:
        IBuffer() noexcept = default;
        IBuffer(IBuffer&&) noexcept = default;
        IBuffer(const IBuffer&) = delete;
        IBuffer& operator=(IBuffer&&) noexcept = default;
        IBuffer& operator=(const IBuffer&) = delete;
 
    public:
        ~IBuffer() noexcept override = default;
 
    public:
        virtual BufferType type() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IImage : public virtual IDeviceMemory, public virtual IStateResource, public SharedObject {
    public:
        using IDeviceMemory::size;
 
    protected:
        IImage() noexcept = default;
        IImage(IImage&&) noexcept = default;
        IImage(const IImage&) = delete;
        IImage& operator=(IImage&&) noexcept = default;
        IImage& operator=(const IImage&) = delete;
 
    public:
        ~IImage() noexcept override = default;
 
    public:
        virtual size_t size(UInt32 level) const noexcept = 0;
 
        virtual Size3d extent(UInt32 level = 0) const noexcept = 0;
 
        virtual Format format() const noexcept = 0;
 
        virtual ImageDimensions dimensions() const noexcept = 0;
 
        virtual UInt32 levels() const noexcept = 0;
 
        virtual UInt32 layers() const noexcept = 0;
 
        virtual UInt32 planes() const noexcept = 0;
 
        virtual MultiSamplingLevel samples() const noexcept = 0;
 
        // TODO: getSampler() for combined samplers?
 
    public:
        virtual inline UInt32 subresourceId(UInt32 level, UInt32 layer, UInt32 plane) const noexcept {
            return level + (layer * this->levels()) + (plane * this->levels() * this->layers());
        }
 
        virtual inline void resolveSubresource(UInt32 subresource, UInt32& plane, UInt32& layer, UInt32& level) const noexcept {
            const auto levels = this->levels();
            const UInt32 resourcesPerPlane = levels * this->layers();
            plane = subresource / resourcesPerPlane;
            layer = (subresource % resourcesPerPlane) / levels;
            level = subresource % levels;
        }
    };
 
    class LITEFX_RENDERING_API ISampler : public virtual IStateResource, public SharedObject {
    protected:
        ISampler() noexcept = default;
        ISampler(ISampler&&) noexcept = default;
        ISampler(const ISampler&) = delete;
        ISampler& operator=(ISampler&&) noexcept = default;
        ISampler& operator=(const ISampler&) = delete;
 
    public:
        ~ISampler() noexcept override = default;
 
    public:
        virtual FilterMode getMinifyingFilter() const noexcept = 0;
 
        virtual FilterMode getMagnifyingFilter() const noexcept = 0;
 
        virtual BorderMode getBorderModeU() const noexcept = 0;
 
        virtual BorderMode getBorderModeV() const noexcept = 0;
 
        virtual BorderMode getBorderModeW() const noexcept = 0;
 
        virtual Float getAnisotropy() const noexcept = 0;
 
        virtual MipMapMode getMipMapMode() const noexcept = 0;
 
        virtual Float getMipMapBias() const noexcept = 0;
 
        virtual Float getMaxLOD() const noexcept = 0;
 
        virtual Float getMinLOD() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IVertexBuffer : public virtual IBuffer {
    protected:
        IVertexBuffer() noexcept = default;
        IVertexBuffer(const IVertexBuffer&) = delete;
        IVertexBuffer(IVertexBuffer&&) noexcept = default;
        IVertexBuffer& operator=(const IVertexBuffer&) = delete;
        IVertexBuffer& operator=(IVertexBuffer&&) noexcept = default;
 
    public:
        ~IVertexBuffer() noexcept override = default;
 
    public:
        virtual const IVertexBufferLayout& layout() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IIndexBuffer : public virtual IBuffer {
    protected:
        IIndexBuffer() noexcept = default;
        IIndexBuffer(const IIndexBuffer&) = delete;
        IIndexBuffer(IIndexBuffer&&) noexcept = default;
        IIndexBuffer& operator=(const IIndexBuffer&) = delete;
        IIndexBuffer& operator=(IIndexBuffer&&) noexcept = default;
 
    public:
        ~IIndexBuffer() noexcept override = default;
 
    public:
        virtual const IIndexBufferLayout& layout() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IAccelerationStructure : public virtual IStateResource {
    protected:
        IAccelerationStructure() noexcept = default;
        IAccelerationStructure(IAccelerationStructure&&) noexcept = default;
        IAccelerationStructure(const IAccelerationStructure&) = delete;
        IAccelerationStructure& operator=(IAccelerationStructure&&) noexcept = default;
        IAccelerationStructure& operator=(const IAccelerationStructure&) = delete;
 
    public:
        ~IAccelerationStructure() noexcept override = default;
 
    public:
        virtual AccelerationStructureFlags flags() const noexcept = 0;
 
        inline void build(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer = nullptr, const SharedPtr<const IBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0) {
            this->doBuild(commandBuffer, scratchBuffer, buffer, offset, maxSize);
        }
 
        inline void update(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer = nullptr, const SharedPtr<const IBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0) {
            this->doUpdate(commandBuffer, scratchBuffer, buffer, offset, maxSize);
        }
 
        inline SharedPtr<const IBuffer> buffer() const noexcept {
            return this->getBuffer();
        }
 
        virtual UInt64 offset() const noexcept = 0;
 
        virtual UInt64 size() const noexcept = 0;
 
    private:
        virtual SharedPtr<const IBuffer> getBuffer() const noexcept = 0;
        virtual void doBuild(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) = 0;
        virtual void doUpdate(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) = 0;
    };
 
    class LITEFX_RENDERING_API IBottomLevelAccelerationStructure : public virtual IAccelerationStructure {
    public:
        struct TriangleMesh final {
        public:
            TriangleMesh(const SharedPtr<const IVertexBuffer>& vertexBuffer, const SharedPtr<const IIndexBuffer>& indexBuffer = nullptr, const SharedPtr<const IBuffer>& transformBuffer = nullptr, GeometryFlags flags = GeometryFlags::None) :
                VertexBuffer(vertexBuffer), IndexBuffer(indexBuffer), TransformBuffer(transformBuffer), Flags(flags) { 
                if (vertexBuffer == nullptr) [[unlikely]]
                    throw ArgumentNotInitializedException("vertexBuffer", "The vertex buffer must be initialized.");
            }
 
            TriangleMesh(TriangleMesh&& other) noexcept = default;
 
            TriangleMesh(const TriangleMesh& other) = default;
 
            TriangleMesh& operator=(TriangleMesh&& other) noexcept = default;
 
            TriangleMesh& operator=(const TriangleMesh& other) = default;
 
            ~TriangleMesh() noexcept = default;
 
        public:
            SharedPtr<const IVertexBuffer> VertexBuffer;
 
            SharedPtr<const IIndexBuffer> IndexBuffer;
 
            SharedPtr<const IBuffer> TransformBuffer;
 
            GeometryFlags Flags;
        };
 
        struct BoundingBoxes final {
            SharedPtr<const IBuffer> Buffer;
 
            GeometryFlags Flags;
        };
 
    protected:
        IBottomLevelAccelerationStructure() noexcept = default;
        IBottomLevelAccelerationStructure(IBottomLevelAccelerationStructure&&) noexcept = default;
        IBottomLevelAccelerationStructure(const IBottomLevelAccelerationStructure&) = delete;
        IBottomLevelAccelerationStructure& operator=(IBottomLevelAccelerationStructure&&) noexcept = default;
        IBottomLevelAccelerationStructure& operator=(const IBottomLevelAccelerationStructure&) = delete;
 
    public:
        ~IBottomLevelAccelerationStructure() noexcept override = default;
 
    public:
        virtual const Array<TriangleMesh>& triangleMeshes() const noexcept = 0;
 
        virtual void addTriangleMesh(const TriangleMesh& mesh) = 0;
 
        inline void addTriangleMesh(const SharedPtr<const IVertexBuffer>& vertexBuffer, const SharedPtr<const IIndexBuffer>& indexBuffer = nullptr, const SharedPtr<const IBuffer>& transformBuffer = nullptr, GeometryFlags flags = GeometryFlags::None) {
            this->addTriangleMesh(TriangleMesh(vertexBuffer, indexBuffer, transformBuffer, flags));
        }
 
        virtual const Array<BoundingBoxes>& boundingBoxes() const noexcept = 0;
 
        virtual void addBoundingBox(const BoundingBoxes& aabbs) = 0;
 
        inline void addBoundingBox(const SharedPtr<const IBuffer>& buffer, GeometryFlags flags = GeometryFlags::None) {
            this->addBoundingBox(BoundingBoxes { .Buffer = buffer, .Flags = flags });
        }
 
        virtual void clear() noexcept = 0;
 
        virtual bool remove(const TriangleMesh& mesh) noexcept = 0;
 
        virtual bool remove(const BoundingBoxes& aabb) noexcept = 0;
 
        inline void copy(const ICommandBuffer& commandBuffer, IBottomLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IBuffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const {
            this->doCopy(commandBuffer, destination, compress, buffer, offset, copyBuildInfo);
        }
 
    public:
        template <typename TSelf>
        inline auto withTriangleMesh(this TSelf&& self, const TriangleMesh& mesh) -> TSelf&& {
            self.addTriangleMesh(mesh);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        inline auto withTriangleMesh(this TSelf&& self, const SharedPtr<const IVertexBuffer>& vertexBuffer, const SharedPtr<const IIndexBuffer>& indexBuffer = nullptr, const SharedPtr<const IBuffer>& transformBuffer = nullptr, GeometryFlags flags = GeometryFlags::None) -> TSelf&& {
            return std::forward<TSelf>(self).withTriangleMesh(TriangleMesh(vertexBuffer, indexBuffer, transformBuffer, flags));
        }
 
        template <typename TSelf>
        inline auto withBoundingBox(this TSelf&& self, const BoundingBoxes& aabb) -> TSelf&& {
            self.addBoundingBox(aabb);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        inline auto withBoundingBox(this TSelf&& self, const SharedPtr<const IBuffer>& buffer, GeometryFlags flags = GeometryFlags::None) -> TSelf&& {
            return std::forward<TSelf>(self).withBoundingBox(BoundingBoxes { .Buffer = buffer, .Flags = flags });
        }
 
    private:
        virtual void doCopy(const ICommandBuffer& commandBuffer, IBottomLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const = 0;
    };
 
    class LITEFX_RENDERING_API ITopLevelAccelerationStructure : public virtual IAccelerationStructure {
    public:
#pragma warning(push)
#pragma warning(disable: 4324) // Structure was padded due to alignment specifier
        struct alignas(16) Instance final { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
            SharedPtr<const IBottomLevelAccelerationStructure> BottomLevelAccelerationStructure;
 
            TMatrix3x4<Float> Transform = TMatrix3x4<Float>::identity();
 
            UInt32 Id : 24 = 0;
 
            UInt8 Mask : 8 = 0xFF;
 
            UInt32 HitGroupOffset : 24 = 0;
 
            InstanceFlags Flags : 8 = InstanceFlags::None;
        };
#pragma warning(pop)
 
    protected:
        ITopLevelAccelerationStructure() noexcept = default;
        ITopLevelAccelerationStructure(ITopLevelAccelerationStructure&&) noexcept = default;
        ITopLevelAccelerationStructure(const ITopLevelAccelerationStructure&) = delete;
        ITopLevelAccelerationStructure& operator=(ITopLevelAccelerationStructure&&) noexcept = default;
        ITopLevelAccelerationStructure& operator=(const ITopLevelAccelerationStructure&) = delete;
 
    public:
        ~ITopLevelAccelerationStructure() noexcept override = default;
 
    public:
        virtual const Array<Instance>& instances() const noexcept = 0;
 
        virtual void addInstance(const Instance& instance) = 0;
 
        inline void addInstance(const SharedPtr<const IBottomLevelAccelerationStructure>& blas, UInt32 id, UInt32 hitGroupOffset = 0, UInt8 mask = 0xFF, InstanceFlags flags = InstanceFlags::None) noexcept { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
            this->addInstance(Instance { .BottomLevelAccelerationStructure = blas, .Id = id, .Mask = mask, .HitGroupOffset = hitGroupOffset, .Flags = flags });
        }
        
        inline void addInstance(const SharedPtr<const IBottomLevelAccelerationStructure>& blas, const TMatrix3x4<Float>& transform, UInt32 id, UInt32 hitGroupOffset = 0, UInt8 mask = 0xFF, InstanceFlags flags = InstanceFlags::None) noexcept { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
            this->addInstance(Instance { .BottomLevelAccelerationStructure = blas, .Transform = transform, .Id = id, .Mask = mask, .HitGroupOffset = hitGroupOffset, .Flags = flags });
        }
 
        virtual void clear() noexcept = 0;
 
        virtual bool remove(const Instance& instance) noexcept = 0;
 
        inline void copy(const ICommandBuffer& commandBuffer, ITopLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IBuffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const {
            this->doCopy(commandBuffer, destination, compress, buffer, offset, copyBuildInfo);
        }
 
    public:
        template<typename TSelf>
        inline auto withInstance(this TSelf&& self, const Instance& instance) noexcept -> TSelf&& {
            self.addInstance(instance);
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        inline auto withInstance(this TSelf&& self, const SharedPtr<const IBottomLevelAccelerationStructure>& blas, UInt32 id, UInt32 hitGroupOffset = 0, UInt8 mask = 0xFF, InstanceFlags flags = InstanceFlags::None) noexcept -> TSelf&& { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
            self.addInstance(Instance { .BottomLevelAccelerationStructure = blas, .Id = id, .Mask = mask, .HitGroupOffset = hitGroupOffset, .Flags = flags });
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        inline auto withInstance(this TSelf&& self, const SharedPtr<const IBottomLevelAccelerationStructure>& blas, const TMatrix3x4<Float>& transform, UInt32 id, UInt32 hitGroupOffset = 0, UInt8 mask = 0xFF, InstanceFlags flags = InstanceFlags::None) noexcept -> TSelf&& { // NOLINT(cppcoreguidelines-avoid-magic-numbers)
            self.addInstance(Instance { .BottomLevelAccelerationStructure = blas, .Transform = transform, .Id = id, .Mask = mask, .HitGroupOffset = hitGroupOffset, .Flags = flags });
            return std::forward<TSelf>(self);
        }
 
    private:
        virtual void doCopy(const ICommandBuffer& commandBuffer, ITopLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const = 0;
    };
 
    class LITEFX_RENDERING_API IBarrier {
    protected:
        IBarrier() noexcept = default;
        IBarrier(const IBarrier&) = default;
        IBarrier(IBarrier&&) noexcept = default;
        IBarrier& operator=(const IBarrier&) = default;
        IBarrier& operator=(IBarrier&&) noexcept = default;
 
    public:
        virtual ~IBarrier() noexcept = default;
 
    public:
        constexpr virtual PipelineStage syncBefore() const noexcept = 0;
        
        constexpr virtual PipelineStage syncAfter() const noexcept = 0;
 
        constexpr virtual void wait(ResourceAccess accessBefore, ResourceAccess accessAfter) = 0;
 
        constexpr void transition(const IBuffer& buffer, ResourceAccess accessBefore, ResourceAccess accessAfter) {
            this->doTransition(buffer, accessBefore, accessAfter);
        };
 
        constexpr void transition(const IBuffer& buffer, UInt32 element, ResourceAccess accessBefore, ResourceAccess accessAfter) {
            this->doTransition(buffer, element, accessBefore, accessAfter);
        }
 
        constexpr void transition(const IImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) {
            this->doTransition(image, accessBefore, accessAfter, layout);
        }
 
        constexpr void transition(const IImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) {
            this->doTransition(image, level, levels, layer, layers, plane, accessBefore, accessAfter, layout);
        }
 
        constexpr void transition(const IImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) {
            this->doTransition(image, accessBefore, accessAfter, fromLayout, toLayout);
        }
 
        constexpr void transition(const IImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) {
            this->doTransition(image, level, levels, layer, layers, plane, accessBefore, accessAfter, fromLayout, toLayout);
        }
 
    private:
        constexpr virtual void doTransition(const IBuffer& buffer, ResourceAccess accessBefore, ResourceAccess accessAfter) = 0;
        constexpr virtual void doTransition(const IBuffer& buffer, UInt32 element, ResourceAccess accessBefore, ResourceAccess accessAfter) = 0;
        constexpr virtual void doTransition(const IImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) = 0;
        constexpr virtual void doTransition(const IImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) = 0;
        constexpr virtual void doTransition(const IImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) = 0;
        constexpr virtual void doTransition(const IImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorSet {
    protected:
        IDescriptorSet() noexcept = default;
        IDescriptorSet(const IDescriptorSet&) = default;
        IDescriptorSet(IDescriptorSet&&) noexcept = default;
        IDescriptorSet& operator=(const IDescriptorSet&) = default;
        IDescriptorSet& operator=(IDescriptorSet&&) noexcept = default;
 
    public:
        virtual ~IDescriptorSet() noexcept = default;
 
    public:
        virtual VirtualAllocator::Allocation globalHeapAllocation(DescriptorHeapType heapType) const noexcept = 0;
 
        inline UInt32 bindToHeap(DescriptorType bindingType, UInt32 descriptor, const IBuffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, Format texelFormat = Format::None) const {
            return this->doBind(bindingType, descriptor, buffer, bufferElement, elements, texelFormat);
        }
 
        inline UInt32 bindToHeap(DescriptorType bindingType, UInt32 descriptor, const IImage& image, UInt32 firstLevel = 0, UInt32 levels = 0, UInt32 firstLayer = 0, UInt32 layers = 0) const {
            return this->doBind(bindingType, descriptor, image, firstLevel, levels, firstLayer, layers);
        }
 
        inline UInt32 bindToHeap(UInt32 descriptor, const ISampler& sampler) const {
            return this->doBind(descriptor, sampler);
        }
 
        inline void update(UInt32 binding, const IBuffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, UInt32 firstDescriptor = 0, Format texelFormat = Format::None) const {
            this->doUpdate(binding, buffer, bufferElement, elements, firstDescriptor, texelFormat);
        }
 
        inline void update(UInt32 binding, const IImage& texture, UInt32 descriptor = 0, UInt32 firstLevel = 0, UInt32 levels = 0, UInt32 firstLayer = 0, UInt32 layers = 0) const {
            this->doUpdate(binding, texture, descriptor, firstLevel, levels, firstLayer, layers);
        }
 
        inline void update(UInt32 binding, const ISampler& sampler, UInt32 descriptor = 0) const {
            this->doUpdate(binding, sampler, descriptor);
        }
 
        inline void update(UInt32 binding, const IAccelerationStructure& accelerationStructure, UInt32 descriptor = 0) const {
            this->doUpdate(binding, accelerationStructure, descriptor);
        }
 
    private:
        virtual UInt32 doBind(DescriptorType bindingType, UInt32 descriptor, const IBuffer& buffer, UInt32 bufferElement, UInt32 elements, Format texelFormat) const = 0;
        virtual UInt32 doBind(DescriptorType bindingType, UInt32 descriptor, const IImage& image, UInt32 firstLevel, UInt32 levels, UInt32 firstLayer, UInt32 layers) const = 0;
        virtual UInt32 doBind(UInt32 descriptor, const ISampler& sampler) const = 0;
        virtual void doUpdate(UInt32 binding, const IBuffer& buffer, UInt32 bufferElement, UInt32 elements, UInt32 firstDescriptor, Format texelFormat) const = 0;
        virtual void doUpdate(UInt32 binding, const IImage& texture, UInt32 descriptor, UInt32 firstLevel, UInt32 levels, UInt32 firstLayer, UInt32 layers) const = 0;
        virtual void doUpdate(UInt32 binding, const ISampler& sampler, UInt32 descriptor) const = 0;
        virtual void doUpdate(UInt32 binding, const IAccelerationStructure& accelerationStructure, UInt32 descriptor) const = 0;
    };
 
    struct LITEFX_RENDERING_API DescriptorBinding {
    public:
        using resource_container = Variant<std::monostate, Ref<const IBuffer>, Ref<const IImage>, Ref<const ISampler>, Ref<const IAccelerationStructure>>;
        
    public:
        Optional<UInt32> binding = std::nullopt;
 
        resource_container resource = {};
 
        UInt32 firstDescriptor = 0;
 
        UInt32 firstElement = 0;
 
        UInt32 elements = 0;
 
        UInt32 firstLevel = 0;
 
        UInt32 levels = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorSetLayout : public SharedObject {
    protected:
        IDescriptorSetLayout() noexcept = default;
        IDescriptorSetLayout(const IDescriptorSetLayout&) = default;
        IDescriptorSetLayout(IDescriptorSetLayout&&) noexcept = default;
        IDescriptorSetLayout& operator=(const IDescriptorSetLayout&) = default;
        IDescriptorSetLayout& operator=(IDescriptorSetLayout&&) noexcept = default;
 
    public:
        ~IDescriptorSetLayout() noexcept override = default;
 
    public:
        inline Enumerable<const IDescriptorLayout&> descriptors() const noexcept {
            return this->getDescriptors();
        }
 
        virtual const IDescriptorLayout& descriptor(UInt32 binding) const = 0;
 
        virtual UInt32 space() const noexcept = 0;
 
        virtual ShaderStage shaderStages() const noexcept = 0;
 
        virtual UInt32 uniforms() const noexcept = 0;
 
        virtual UInt32 storages() const noexcept = 0;
 
        virtual UInt32 images() const noexcept = 0;
 
        virtual UInt32 buffers() const noexcept = 0;
 
        virtual UInt32 samplers() const noexcept = 0;
 
        virtual UInt32 staticSamplers() const noexcept = 0;
 
        virtual UInt32 inputAttachments() const noexcept = 0;
 
        virtual bool containsUnboundedArray() const noexcept = 0;
 
        virtual UInt32 getDescriptorOffset(UInt32 binding, UInt32 element = 0) const = 0;
 
        virtual bool bindsResources() const noexcept = 0;
 
        virtual bool bindsSamplers() const noexcept = 0;
 
    public:
        inline UniquePtr<IDescriptorSet> allocate(std::initializer_list<DescriptorBinding> bindings = { }) const {
            return this->getDescriptorSet(0, bindings);
        }
 
        inline UniquePtr<IDescriptorSet> allocate(Span<DescriptorBinding> bindings) const {
            return this->getDescriptorSet(0, bindings);
        }
 
        inline UniquePtr<IDescriptorSet> allocate(Generator<DescriptorBinding> bindings) const {
            return this->getDescriptorSet(0, std::move(bindings));
        }
 
        inline UniquePtr<IDescriptorSet> allocate(UInt32 descriptors, std::initializer_list<DescriptorBinding> bindings) const {
            return this->getDescriptorSet(descriptors, bindings);
        }
 
        inline UniquePtr<IDescriptorSet> allocate(UInt32 descriptors, Span<DescriptorBinding> bindings) const {
            return this->getDescriptorSet(descriptors, bindings);
        }
 
        inline UniquePtr<IDescriptorSet> allocate(UInt32 descriptors, Generator<DescriptorBinding> bindings) const {
            return this->getDescriptorSet(descriptors, std::move(bindings));
        }
 
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, std::initializer_list<std::initializer_list<DescriptorBinding>> bindings = { }) const {
            return this->getDescriptorSets(descriptorSets, 0, bindings);
        }
 
#ifdef __cpp_lib_mdspan
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, std::mdspan<DescriptorBinding, std::dextents<size_t, 2>> bindings) const {
            return this->getDescriptorSets(descriptorSets, 0, bindings);
        }
#endif
 
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, std::function<Generator<DescriptorBinding>(UInt32)> bindingFactory) const {
            return this->getDescriptorSets(descriptorSets, 0, std::move(bindingFactory));
        }
 
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::initializer_list<std::initializer_list<DescriptorBinding>> bindings = { }) const {
            return this->getDescriptorSets(descriptorSets, descriptors, bindings);
        }
 
#ifdef __cpp_lib_mdspan
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::mdspan<DescriptorBinding, std::dextents<size_t, 2>> bindings) const {
            return this->getDescriptorSets(descriptorSets, descriptors, bindings);
        }
#endif
 
        inline Generator<UniquePtr<IDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::function<Generator<DescriptorBinding>(UInt32)> bindingFactory) const {
            return this->getDescriptorSets(descriptorSets, descriptors, std::move(bindingFactory));
        }
 
        inline void free(const IDescriptorSet& descriptorSet) const {
            this->releaseDescriptorSet(descriptorSet);
        }
 
    private:
        virtual Enumerable<const IDescriptorLayout&> getDescriptors() const noexcept = 0;
        virtual UniquePtr<IDescriptorSet> getDescriptorSet(UInt32 descriptors, std::initializer_list<DescriptorBinding> bindings) const = 0;
        virtual UniquePtr<IDescriptorSet> getDescriptorSet(UInt32 descriptors, Span<DescriptorBinding> bindings) const = 0;
        virtual UniquePtr<IDescriptorSet> getDescriptorSet(UInt32 descriptors, Generator<DescriptorBinding> bindings) const = 0;
        virtual Generator<UniquePtr<IDescriptorSet>> getDescriptorSets(UInt32 descriptorSets, UInt32 descriptors, std::initializer_list<std::initializer_list<DescriptorBinding>> bindings) const = 0;
#ifdef __cpp_lib_mdspan
        virtual Generator<UniquePtr<IDescriptorSet>> getDescriptorSets(UInt32 descriptorSets, UInt32 descriptors, std::mdspan<DescriptorBinding, std::dextents<size_t, 2>> bindings) const = 0;
#endif
        virtual Generator<UniquePtr<IDescriptorSet>> getDescriptorSets(UInt32 descriptorSets, UInt32 descriptors, std::function<Generator<DescriptorBinding>(UInt32)> bindingFactory) const = 0;
        virtual void releaseDescriptorSet(const IDescriptorSet& descriptorSet) const = 0;
    };
 
    class LITEFX_RENDERING_API IPushConstantsRange {
    protected:
        IPushConstantsRange() noexcept = default;
        IPushConstantsRange(const IPushConstantsRange&) = default;
        IPushConstantsRange(IPushConstantsRange&&) noexcept = default;
        IPushConstantsRange& operator=(const IPushConstantsRange&) = default;
        IPushConstantsRange& operator=(IPushConstantsRange&&) noexcept = default;
 
    public:
        virtual ~IPushConstantsRange() noexcept = default;
 
    public:
        virtual UInt32 space() const noexcept = 0;
 
        virtual UInt32 binding() const noexcept = 0;
 
        virtual UInt32 offset() const noexcept = 0;
 
        virtual UInt32 size() const noexcept = 0;
 
        virtual ShaderStage stage() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IPushConstantsLayout {
    protected:
        IPushConstantsLayout() noexcept = default;
        IPushConstantsLayout(const IPushConstantsLayout&) = default;
        IPushConstantsLayout(IPushConstantsLayout&&) noexcept = default;
        IPushConstantsLayout& operator=(const IPushConstantsLayout&) = default;
        IPushConstantsLayout& operator=(IPushConstantsLayout&&) noexcept = default;
 
    public:
        virtual ~IPushConstantsLayout() noexcept = default;
 
    public:
        virtual UInt32 size() const noexcept = 0;
 
        virtual const IPushConstantsRange& range(ShaderStage stage) const = 0;
 
        inline Enumerable<const IPushConstantsRange&> ranges() const {
            return this->getRanges();
        }
 
    private:
        virtual Enumerable<const IPushConstantsRange&> getRanges() const = 0;
    };
 
    struct LITEFX_RENDERING_API IShaderRecord {
    public:
        struct MeshGeometryHitGroup {
            const IShaderModule* ClosestHitShader;
 
            const IShaderModule* AnyHitShader;
        };
 
        using shader_group_type = Variant<const IShaderModule*, MeshGeometryHitGroup>;
 
    protected:
        IShaderRecord() noexcept = default;
        IShaderRecord(const IShaderRecord&) = default;
        IShaderRecord(IShaderRecord&&) noexcept = default;
        IShaderRecord& operator=(const IShaderRecord&) = default;
        IShaderRecord& operator=(IShaderRecord&&) noexcept = default;
 
    public:
        constexpr virtual ~IShaderRecord() noexcept = default;
 
    public:
        constexpr ShaderRecordType type() const noexcept {
            const auto& group = this->shaderGroup();
 
            if (std::holds_alternative<MeshGeometryHitGroup>(group))
            {
                return ShaderRecordType::HitGroup;
            }
            else if (std::holds_alternative<const IShaderModule*>(group))
            {
                switch (std::get<const IShaderModule*>(group)->type())
                {
                case ShaderStage::RayGeneration: return ShaderRecordType::RayGeneration;
                case ShaderStage::Miss: return ShaderRecordType::Miss;
                case ShaderStage::Callable: return ShaderRecordType::Callable;
                case ShaderStage::Intersection: return ShaderRecordType::Intersection;
                default: return ShaderRecordType::Invalid;
                }
            }
 
            std::unreachable();
        }
 
    public:
        constexpr virtual const shader_group_type& shaderGroup() const noexcept = 0;
 
        constexpr virtual const void* localData() const noexcept = 0;
 
        constexpr virtual UInt64 localDataSize() const noexcept = 0;
    };
 
    template <typename... TLocalData>
    struct ShaderRecord;
 
    const size_t SHADER_RECORD_LOCAL_DATA_ALIGNMENT { 8 };
 
    template <typename TLocalData> requires 
        (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT) &&
        std::is_standard_layout_v<TLocalData>
    struct ShaderRecord<TLocalData> final : public IShaderRecord {
    public:
        using shader_group_type = IShaderRecord::shader_group_type;
 
    private:
        TLocalData m_payload;
        
        shader_group_type m_shaderGroup;
 
    public:
        constexpr const shader_group_type& shaderGroup() const noexcept override {
            return m_shaderGroup;
        }
 
        constexpr const void* localData() const noexcept override {
            return static_cast<const void*>(&m_payload);
        }
 
        constexpr UInt64 localDataSize() const noexcept override {
            return sizeof(TLocalData);
        }
 
    public:
        ShaderRecord() = delete;
 
        constexpr ~ShaderRecord() noexcept override = default;
 
        ShaderRecord(const shader_group_type& group, TLocalData payload) noexcept :
            m_payload(payload), m_shaderGroup(group) { }
 
        constexpr ShaderRecord(const ShaderRecord& _other) = default;
 
        constexpr ShaderRecord(ShaderRecord&& _other) noexcept = default;
 
        constexpr ShaderRecord& operator=(const ShaderRecord& _other) = default;
 
        constexpr ShaderRecord& operator=(ShaderRecord&& _other) noexcept = default;
    };
 
    template <>
    struct ShaderRecord<> final : public IShaderRecord {
    public:
        using shader_group_type = IShaderRecord::shader_group_type;
 
    private:
        shader_group_type m_shaderGroup;
 
    public:
        constexpr const shader_group_type& shaderGroup() const noexcept override {
            return m_shaderGroup;
        }
 
        constexpr const void* localData() const noexcept override {
            return nullptr;
        }
 
        constexpr UInt64 localDataSize() const noexcept override {
            return 0_ui64;
        }
 
    public:
        ShaderRecord() = delete;
 
        constexpr ~ShaderRecord() noexcept override = default;
 
        ShaderRecord(const shader_group_type& group) noexcept :
            m_shaderGroup(group) { }
 
        constexpr ShaderRecord(const ShaderRecord& _other) = default;
 
        constexpr ShaderRecord(ShaderRecord&& _other) noexcept = default;
 
        constexpr ShaderRecord& operator=(const ShaderRecord& _other) = default;
 
        constexpr ShaderRecord& operator=(ShaderRecord&& _other) noexcept = default;
    };
 
    class LITEFX_RENDERING_API ShaderRecordCollection final {
        friend class IShaderProgram;
 
    private:
        SharedPtr<const IShaderProgram> m_program;
        Array<UniquePtr<const IShaderRecord>> m_records;
 
        ShaderRecordCollection(SharedPtr<const IShaderProgram> shaderProgram) noexcept : 
            m_program(std::move(shaderProgram)) 
        {
            // This can only be built from a shader program, which passes the pointer to itself, which must not be nullptr. If more factory methods are added,
            // we must validate the program pointer here.
        }
 
    public:
        ShaderRecordCollection() = delete;
 
        ShaderRecordCollection(ShaderRecordCollection&&) noexcept = default;
        ShaderRecordCollection& operator=(ShaderRecordCollection&&) noexcept = default;
        ShaderRecordCollection(const ShaderRecordCollection&) = delete;
        ShaderRecordCollection& operator=(const ShaderRecordCollection&) = delete;
        ~ShaderRecordCollection() noexcept = default;
 
    private:
        const IShaderModule* findShaderModule(StringView name) const noexcept;
 
    public:
        inline SharedPtr<const IShaderProgram> program() const noexcept {
            return m_program;
        }
 
        const Array<UniquePtr<const IShaderRecord>>& shaderRecords() const noexcept;
 
        void addShaderRecord(UniquePtr<const IShaderRecord>&& record);
 
    public:
        inline void addShaderRecord(StringView shaderName) {
            auto shaderModule = this->findShaderModule(shaderName);
 
            if (shaderModule == nullptr) [[unlikely]]
                throw InvalidArgumentException("shaderName", "The parent shader program does not contain a shader named \"{}\".", shaderName);
 
            if (shaderModule->type() == ShaderStage::AnyHit)
                this->addShaderRecord(makeUnique<ShaderRecord<>>(IShaderRecord::MeshGeometryHitGroup{ .AnyHitShader = shaderModule }));
            else if (shaderModule->type() == ShaderStage::ClosestHit)
                this->addShaderRecord(makeUnique<ShaderRecord<>>(IShaderRecord::MeshGeometryHitGroup{ .ClosestHitShader = shaderModule }));
            else
                this->addShaderRecord(makeUnique<ShaderRecord<>>(shaderModule));
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline void addShaderRecord(StringView shaderName, TLocalData payload) {
            auto shaderModule = this->findShaderModule(shaderName);
 
            if (shaderModule == nullptr) [[unlikely]]
                throw InvalidArgumentException("shaderName", "The parent shader program does not contain a shader named \"{}\".", shaderName);
                
            if (shaderModule->type() == ShaderStage::AnyHit)
                this->addShaderRecord(makeUnique<ShaderRecord<TLocalData>>(IShaderRecord::MeshGeometryHitGroup{ .AnyHitShader = shaderModule }, payload));
            else if (shaderModule->type() == ShaderStage::ClosestHit)
                this->addShaderRecord(makeUnique<ShaderRecord<TLocalData>>(IShaderRecord::MeshGeometryHitGroup{ .ClosestHitShader = shaderModule }, payload));
            else
                this->addShaderRecord(makeUnique<ShaderRecord<TLocalData>>(shaderModule, payload));
        }
 
        inline void addMeshGeometryShaderHitGroupRecord(std::optional<StringView> anyHitShaderName, std::optional<StringView> closestHitShaderName) {
            IShaderRecord::MeshGeometryHitGroup hitGroup = { 
                .ClosestHitShader = closestHitShaderName.has_value() ? this->findShaderModule(closestHitShaderName.value()) : nullptr,
                .AnyHitShader = anyHitShaderName.has_value() ? this->findShaderModule(anyHitShaderName.value()) : nullptr
            };
 
            this->addShaderRecord(makeUnique<ShaderRecord<>>(hitGroup));
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline void addMeshGeometryShaderHitGroupRecord(std::optional<StringView> anyHitShaderName, std::optional<StringView> closestHitShaderName, TLocalData payload) {
            IShaderRecord::MeshGeometryHitGroup hitGroup = { 
                .ClosestHitShader = closestHitShaderName.has_value() ? this->findShaderModule(closestHitShaderName.value()) : nullptr,
                .AnyHitShader = anyHitShaderName.has_value() ? this->findShaderModule(anyHitShaderName.value()) : nullptr
            };
 
            this->addShaderRecord(makeUnique<ShaderRecord<TLocalData>>(hitGroup, payload));
        }
 
        inline void addShaderRecord(const ShaderRecord<>::shader_group_type& shaderGroup) {
            this->addShaderRecord(makeUnique<ShaderRecord<>>(shaderGroup));
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline void addShaderRecord(ShaderRecord<TLocalData>::shader_group_type shaderGroup, TLocalData payload) {
            this->addShaderRecord(makeUnique<ShaderRecord<TLocalData>>(shaderGroup, payload));
        }
 
        inline ShaderRecordCollection&& withShaderRecord(StringView shaderName) {
            this->addShaderRecord(shaderName);
            return std::forward<ShaderRecordCollection>(*this);
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline ShaderRecordCollection&& withShaderRecord(StringView shaderName, TLocalData payload) {
            this->addShaderRecord(shaderName, payload);
            return std::forward<ShaderRecordCollection>(*this);
        }
 
        inline ShaderRecordCollection&& withMeshGeometryHitGroupRecord(std::optional<StringView> anyHitShaderName, std::optional<StringView> closestHitShaderName) {
            this->addMeshGeometryShaderHitGroupRecord(anyHitShaderName, closestHitShaderName);
            return std::forward<ShaderRecordCollection>(*this);
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline ShaderRecordCollection&& withMeshGeometryHitGroupRecord(std::optional<StringView> anyHitShaderName, std::optional<StringView> closestHitShaderName, TLocalData payload) {
            this->addMeshGeometryShaderHitGroupRecord(anyHitShaderName, closestHitShaderName, payload);
            return std::forward<ShaderRecordCollection>(*this);
        }
 
        inline ShaderRecordCollection&& withShaderRecord(ShaderRecord<>::shader_group_type shaderGroup) {
            this->addShaderRecord(shaderGroup);
            return std::forward<ShaderRecordCollection>(*this);
        }
 
        template <typename TLocalData> requires (std::alignment_of_v<TLocalData> == SHADER_RECORD_LOCAL_DATA_ALIGNMENT)
        inline ShaderRecordCollection&& withShaderRecord(ShaderRecord<TLocalData>::shader_group_type shaderGroup, TLocalData payload) {
            this->addShaderRecord(shaderGroup, payload);
            return std::forward<ShaderRecordCollection>(*this);
        }
    };
 
    struct LITEFX_RENDERING_API PipelineBindingHint {
 
        struct UnboundedArrayHint {
            UInt32 MaxDescriptors{ 0 };
        };
 
        struct PushConstantsHint {
            bool AsPushConstants{ false };
        };
 
        struct StaticSamplerHint {
            SharedPtr<ISampler> StaticSampler{ nullptr };
        };
 
        struct DescriptorHeapHint {
            DescriptorHeapType Type{ DescriptorHeapType::None };
 
            UInt32 HeapSize{ 1u };
        };
 
        struct ShaderStageHint {
            ShaderStage Stages{ };
        };
 
        using hint_type = Variant<std::monostate, UnboundedArrayHint, PushConstantsHint, StaticSamplerHint, DescriptorHeapHint, ShaderStageHint>;
 
        DescriptorBindingPoint Binding{ };
 
        hint_type Hint = std::monostate{ };
 
    public:
        static inline auto runtimeArray(DescriptorBindingPoint at, UInt32 maxDescriptors) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = UnboundedArrayHint { maxDescriptors } };
        }
 
        static inline auto runtimeArray(UInt32 space, UInt32 binding, UInt32 maxDescriptors) noexcept -> PipelineBindingHint {
            return { .Binding = { .Register = binding, .Space = space }, .Hint = UnboundedArrayHint { maxDescriptors } };
        }
 
        static inline auto pushConstants(DescriptorBindingPoint at) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = PushConstantsHint { true } };
        }
 
        static inline auto pushConstants(UInt32 space, UInt32 binding) noexcept -> PipelineBindingHint {
            return { .Binding = { .Register = binding, .Space = space }, .Hint = PushConstantsHint { true } };
        }
 
        static inline auto staticSampler(DescriptorBindingPoint at, SharedPtr<ISampler> sampler) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = StaticSamplerHint { std::move(sampler) } };
        }
 
        static inline auto staticSampler(UInt32 space, UInt32 binding, SharedPtr<ISampler> sampler) noexcept -> PipelineBindingHint {
            return { .Binding = { .Register = binding, .Space = space }, .Hint = StaticSamplerHint { std::move(sampler) } };
        }
 
        static inline auto resourceHeap(DescriptorBindingPoint at, UInt32 heapSize) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = DescriptorHeapHint { DescriptorHeapType::Resource, heapSize } };
        }
 
        static inline auto resourceHeap(UInt32 space, UInt32 binding, UInt32 heapSize) noexcept -> PipelineBindingHint {
            return { .Binding = { .Register = binding, .Space = space }, .Hint = DescriptorHeapHint { DescriptorHeapType::Resource, heapSize } };
        }
 
        static inline auto samplerHeap(DescriptorBindingPoint at, UInt32 heapSize) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = DescriptorHeapHint { DescriptorHeapType::Sampler, heapSize } };
        }
 
        static inline auto samplerHeap(UInt32 space, UInt32 binding, UInt32 heapSize) noexcept -> PipelineBindingHint {
            return { .Binding = { .Register = binding, .Space = space }, .Hint = DescriptorHeapHint { DescriptorHeapType::Sampler, heapSize } };
        }
 
        static inline auto shaderStage(DescriptorBindingPoint at, ShaderStage shaderStages) noexcept -> PipelineBindingHint {
            return { .Binding = at, .Hint = ShaderStageHint { shaderStages } };
        }
 
        static inline auto shaderStage(UInt32 space, UInt32 binding, ShaderStage shaderStages) noexcept -> PipelineBindingHint {
            return { .Binding = {.Register = binding, .Space = space }, .Hint = ShaderStageHint { shaderStages } };
        }
    };
 
    class LITEFX_RENDERING_API IShaderProgram : public SharedObject {
    protected:
        IShaderProgram() noexcept = default;
 
    public:
        ~IShaderProgram() noexcept override = default;
 
        IShaderProgram(const IShaderProgram&) = delete;
        IShaderProgram(IShaderProgram&&) noexcept = delete;
        auto operator=(const IShaderProgram&) = delete;
        auto operator=(IShaderProgram&&) noexcept = delete;
 
    public:
        inline const IShaderModule* operator[](StringView name) const {
            auto modules = this->getModules();
 
            if (auto match = std::ranges::find_if(modules, [name](auto& module) { return module.fileName().compare(name) == 0; }); match != modules.end())
                return std::addressof(*match);
 
            return nullptr;
        }
 
        inline bool contains(StringView name) const {
            auto modules = this->getModules();
            return std::ranges::find_if(modules, [name](const auto& module) { return module.fileName().compare(name) == 0; }) != modules.end();
        };
 
        inline bool contains(const IShaderModule& module) const {
            auto modules = this->getModules();
            return std::ranges::find_if(modules, [&module](const auto& m) { return std::addressof(m) == std::addressof(module); }) != modules.end();
        };
 
        inline Enumerable<const IShaderModule&> modules() const {
            return this->getModules();
        }
 
        inline SharedPtr<IPipelineLayout> reflectPipelineLayout(Enumerable<PipelineBindingHint> hints = {}) const {
            return this->parsePipelineLayout(hints);
        };
 
        [[nodiscard]] inline ShaderRecordCollection buildShaderRecordCollection() const noexcept {
            return { this->shared_from_this() };
        }
 
    private:
        virtual Enumerable<const IShaderModule&> getModules() const = 0;
        virtual SharedPtr<IPipelineLayout> parsePipelineLayout(Enumerable<PipelineBindingHint> hints) const = 0;
    };
 
    class LITEFX_RENDERING_API IPipelineLayout : public SharedObject {
    protected:
        IPipelineLayout() noexcept = default;
        IPipelineLayout(const IPipelineLayout&) = default;
        IPipelineLayout(IPipelineLayout&&) noexcept = default;
        IPipelineLayout& operator=(const IPipelineLayout&) = default;
        IPipelineLayout& operator=(IPipelineLayout&&) noexcept = default;
 
    public:
        ~IPipelineLayout() noexcept override = default;
 
    public:
        //virtual const IGraphicsDevice& device() const noexcept;
 
        virtual const IDescriptorSetLayout& descriptorSet(UInt32 space) const = 0;
 
        inline Enumerable<SharedPtr<const IDescriptorSetLayout>> descriptorSets() const {
            return this->getDescriptorSets();
        }
 
        virtual const IPushConstantsLayout* pushConstants() const noexcept = 0;
 
        virtual bool dynamicResourceHeapAccess() const = 0;
 
        virtual bool dynamicSamplerHeapAccess() const = 0;
 
    private:
        virtual Enumerable<SharedPtr<const IDescriptorSetLayout>> getDescriptorSets() const = 0;
    };
 
    class LITEFX_RENDERING_API IInputAssembler : public SharedObject {
    protected:
        IInputAssembler() noexcept = default;
        IInputAssembler(const IInputAssembler&) = default;
        IInputAssembler(IInputAssembler&&) noexcept = default;
        IInputAssembler& operator=(const IInputAssembler&) = default;
        IInputAssembler& operator=(IInputAssembler&&) noexcept = default;
 
    public:
        ~IInputAssembler() noexcept override = default;
 
    public:
        inline Enumerable<const IVertexBufferLayout&> vertexBufferLayouts() const {
            return this->getVertexBufferLayouts();
        }
 
        virtual const IVertexBufferLayout& vertexBufferLayout(UInt32 binding) const = 0;
 
        virtual const IIndexBufferLayout* indexBufferLayout() const noexcept = 0;
 
        virtual PrimitiveTopology topology() const noexcept = 0;
 
    private:
        virtual Enumerable<const IVertexBufferLayout&> getVertexBufferLayouts() const = 0;
    };
 
    class LITEFX_RENDERING_API IPipeline : public virtual IStateResource {
    protected:
        IPipeline() noexcept = default;
        IPipeline(const IPipeline&) = delete;
        IPipeline(IPipeline&&) noexcept = default;
        IPipeline& operator=(const IPipeline&) = delete;
        IPipeline& operator=(IPipeline&&) noexcept = default;
 
    public:
        ~IPipeline() noexcept override = default;
 
    public:
        inline SharedPtr<const IShaderProgram> program() const noexcept {
            return this->getProgram();
        }
 
        inline SharedPtr<const IPipelineLayout> layout() const noexcept {
            return this->getLayout();
        }
 
    private:
        virtual SharedPtr<const IShaderProgram> getProgram() const noexcept = 0;
        virtual SharedPtr<const IPipelineLayout> getLayout() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API ICommandBuffer : public SharedObject {
    public:
        friend class ICommandQueue;
 
    protected:
        ICommandBuffer() noexcept = default;
        ICommandBuffer(ICommandBuffer&&) noexcept = default;
        ICommandBuffer(const ICommandBuffer&) = default;
        ICommandBuffer& operator=(const ICommandBuffer&) = default;
        ICommandBuffer& operator=(ICommandBuffer&&) noexcept = default;
 
    public:
        ~ICommandBuffer() noexcept override = default;
 
    public:
        virtual void begin() const = 0;
 
        virtual void end() const = 0;
 
        virtual bool isSecondary() const noexcept = 0;
 
        virtual void track(SharedPtr<const IBuffer> buffer) const = 0;
 
        virtual void track(SharedPtr<const IImage> image) const = 0;
 
        virtual void track(SharedPtr<const ISampler> sampler) const = 0;
 
        virtual void track(UniquePtr<const IDescriptorSet>&& descriptorSet) const = 0;
 
    public:
        inline SharedPtr<const ICommandQueue> queue() const noexcept {
            return this->getQueue();
        }
 
        [[nodiscard]] inline UniquePtr<IBarrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const {
            return this->getBarrier(syncBefore, syncAfter);
        }
 
        inline void barrier(const IBarrier& barrier) const noexcept {
            this->cmdBarrier(barrier);
        }
 
        inline void transfer(const IBuffer& source, const IBuffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, targetElement, elements);
        }
        
        inline void transfer(const SharedPtr<const IBuffer>& source, const IBuffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, targetElement, elements);
        }
 
        inline void transfer(const void* const data, size_t size, const IBuffer& target, UInt32 targetElement = 0, UInt32 elements = 1) const {
            this->cmdTransfer(data, size, target, targetElement, elements);
        }
 
        inline void transfer(Span<const void* const> data, size_t elementSize, const IBuffer& target, UInt32 targetElement = 0) const {
            this->cmdTransfer(data, elementSize, target, targetElement);
        }
 
        inline void transfer(const IBuffer& source, const IImage& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, firstSubresource, elements);
        }
 
        inline void transfer(const SharedPtr<const IBuffer>& source, const IImage& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, firstSubresource, elements);
        }
 
        inline void transfer(const void* const data, size_t size, const IImage& target, UInt32 subresource = 0) const {
            this->cmdTransfer(data, size, target, subresource);
        }
 
        inline void transfer(Span<const void* const> data, size_t elementSize, const IImage& target, UInt32 firstSubresource = 0, UInt32 elements = 1) const {
            this->cmdTransfer(data, elementSize, target, firstSubresource, elements);
        }
 
        inline void transfer(const IImage& source, const IImage& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const {
            this->cmdTransfer(source, target, sourceSubresource, targetSubresource, subresources);
        }
 
        inline void transfer(const SharedPtr<const IImage>& source, const IImage& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const {
            this->cmdTransfer(source, target, sourceSubresource, targetSubresource, subresources);
        }
 
        inline void transfer(const IImage& source, const IBuffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const {
            this->cmdTransfer(source, target, firstSubresource, targetElement, subresources);
        }
 
        inline void transfer(const SharedPtr<const IImage>& source, const IBuffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const {
            this->cmdTransfer(source, target, firstSubresource, targetElement, subresources);
        }
 
        inline void use(const IPipeline& pipeline) const noexcept {
            this->cmdUse(pipeline);
        }
 
        inline void bind(const IDescriptorSet& descriptorSet) const {
            this->cmdBind(descriptorSet);
        }
 
        template <typename TSelf, typename T>
        inline void bind(this const TSelf& self, std::initializer_list<const T*> descriptorSets) requires
            std::derived_from<T, IDescriptorSet>
        {
            // NOTE: In the future we might be able to remove this method, if P2447R4 is added to the language.
            Array<const T*> sets = descriptorSets;
            self.bind(Span<const T*>(sets));
        }
 
        template <typename TSelf>
        inline void bind(this const TSelf& self, std::ranges::input_range auto&& descriptorSets) requires 
            std::derived_from<std::remove_cv_t<std::remove_pointer_t<std::iter_value_t<std::ranges::iterator_t<std::remove_cv_t<std::remove_reference_t<decltype(descriptorSets)>>>>>>, IDescriptorSet>
        {
            using descriptor_set_type = std::remove_cv_t<std::remove_pointer_t<std::iter_value_t<std::ranges::iterator_t<std::remove_cv_t<std::remove_reference_t<decltype(descriptorSets)>>>>>>;
            auto sets = descriptorSets | std::ranges::to<Array<const descriptor_set_type*>>();
            self.bind(Span<const descriptor_set_type*>(sets));
        }
 
        inline void bind(Span<const IDescriptorSet*> descriptorSets) const {
            this->cmdBind(descriptorSets);
        }
 
        inline void bind(const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const {
            this->cmdBind(descriptorSet, pipeline);
        }
 
        template <typename TSelf, typename T>
        inline void bind(this const TSelf& self, std::initializer_list<const T*> descriptorSets, const typename TSelf::pipeline_type& pipeline) 
        {
            // NOTE: In the future we might be able to remove this method, if P2447R4 is added to the language.
            Array<const T*> sets = descriptorSets;
            self.bind(Span<const T*>(sets), pipeline);
        }
 
        template <typename TSelf>
        inline void bind(this const TSelf& self, std::ranges::input_range auto&& descriptorSets, const typename TSelf::pipeline_type& pipeline) requires 
            std::derived_from<std::remove_cv_t<std::remove_pointer_t<std::iter_value_t<std::ranges::iterator_t<std::remove_cv_t<std::remove_reference_t<decltype(descriptorSets)>>>>>>, IDescriptorSet>
        {
            using descriptor_set_type = std::remove_cv_t<std::remove_pointer_t<std::iter_value_t<std::ranges::iterator_t<std::remove_cv_t<std::remove_reference_t<decltype(descriptorSets)>>>>>>;
            auto sets = descriptorSets | std::ranges::to<Array<const descriptor_set_type*>>();
            self.bind(Span<const descriptor_set_type*>(sets), pipeline);
        }
 
        inline void bind(Span<const IDescriptorSet*> descriptorSets, const IPipeline& pipeline) const {
            this->cmdBind(descriptorSets, pipeline);
        }
 
        inline void bind(const IVertexBuffer& buffer) const {
            this->cmdBind(buffer);
        }
 
        inline void bind(const IIndexBuffer& buffer) const {
            this->cmdBind(buffer);
        }
 
        virtual void dispatch(const Vector3u& threadGroupCount) const noexcept = 0;
 
        inline void dispatch(UInt32 x, UInt32 y, UInt32 z) const noexcept {
            this->dispatch({ x, y, z });
        }
 
        inline void dispatchIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept {
            this->cmdDispatchIndirect(batchBuffer, batchCount, offset);
        }
        
        virtual void dispatchMesh(const Vector3u& threadGroupCount) const noexcept = 0;
 
        inline void dispatchMesh(UInt32 x, UInt32 y, UInt32 z) const noexcept {
            this->dispatchMesh({ x, y, z });
        }
 
        inline void dispatchMeshIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept {
            this->cmdDispatchMeshIndirect(batchBuffer, batchCount, offset);
        }
 
        inline void dispatchMeshIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept {
            this->cmdDispatchMeshIndirect(batchBuffer, countBuffer, offset, countOffset, maxBatches);
        }
 
        inline void traceRays(UInt32 width, UInt32 height, UInt32 depth, const ShaderBindingTableOffsets& offsets, const IBuffer& rayGenerationShaderBindingTable, const IBuffer* missShaderBindingTable = nullptr, const IBuffer* hitShaderBindingTable = nullptr, const IBuffer* callableShaderBindingTable = nullptr) const noexcept {
            this->cmdTraceRays(width, height, depth, offsets, rayGenerationShaderBindingTable, missShaderBindingTable, hitShaderBindingTable, callableShaderBindingTable);
        }
 
        inline void traceRays(const Vector3u& dimensions, const ShaderBindingTableOffsets& offsets, const IBuffer& rayGenerationShaderBindingTable, const IBuffer* missShaderBindingTable = nullptr, const IBuffer* hitShaderBindingTable = nullptr, const IBuffer* callableShaderBindingTable = nullptr) const noexcept {
            this->traceRays(dimensions.x(), dimensions.y(), dimensions.z(), offsets, rayGenerationShaderBindingTable, missShaderBindingTable, hitShaderBindingTable, callableShaderBindingTable);
        }
 
        virtual void draw(UInt32 vertices, UInt32 instances = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) const noexcept = 0;
 
        inline void draw(const IVertexBuffer& vertexBuffer, UInt32 instances = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) const {
            this->cmdDraw(vertexBuffer, instances, firstVertex, firstInstance);
        }
 
        inline void drawIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept {
            this->cmdDrawIndirect(batchBuffer, batchCount, offset);
        }
 
        inline void drawIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept {
            this->cmdDrawIndirect(batchBuffer, countBuffer, offset, countOffset, maxBatches);
        }
 
        virtual void drawIndexed(UInt32 indices, UInt32 instances = 1, UInt32 firstIndex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) const noexcept = 0;
 
        inline void drawIndexed(const IIndexBuffer& indexBuffer, UInt32 instances = 1, UInt32 firstIndex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) const {
            this->cmdDrawIndexed(indexBuffer, instances, firstIndex, vertexOffset, firstInstance);
        }
 
        inline void drawIndexed(const IVertexBuffer& vertexBuffer, const IIndexBuffer& indexBuffer, UInt32 instances = 1, UInt32 firstIndex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) const {
            this->cmdDrawIndexed(vertexBuffer, indexBuffer, instances, firstIndex, vertexOffset, firstInstance);
        }
 
        inline void drawIndexedIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept {
            this->cmdDrawIndexedIndirect(batchBuffer, batchCount, offset);
        }
 
        inline void drawIndexedIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept {
            this->cmdDrawIndexedIndirect(batchBuffer, countBuffer, offset, countOffset, maxBatches);
        }
 
        inline void pushConstants(const IPushConstantsLayout& layout, const void* const memory) const {
            this->cmdPushConstants(layout, memory);
        }
 
        virtual void setViewports(Span<const IViewport*> viewports) const = 0;
 
        virtual void setViewports(const IViewport* viewport) const = 0;
 
        virtual void setScissors(Span<const IScissor*> scissors) const = 0;
 
        virtual void setScissors(const IScissor* scissor) const = 0;
 
        virtual void setBlendFactors(const Vector4f& blendFactors) const noexcept = 0;
 
        virtual void setStencilRef(UInt32 stencilRef) const noexcept = 0;
 
        virtual void setDepthBounds(Float minBounds, Float maxBounds) const noexcept = 0;
 
        virtual UInt64 submit() const = 0;
 
        virtual void writeTimingEvent(const SharedPtr<const TimingEvent>& timingEvent) const = 0;
 
        inline void execute(const SharedPtr<const ICommandBuffer>& commandBuffer) const {
            this->cmdExecute(commandBuffer);
        }
 
        inline void execute(Enumerable<SharedPtr<const ICommandBuffer>> commandBuffers) const {
            this->cmdExecute(std::move(commandBuffers));
        }
 
        inline void buildAccelerationStructure(IBottomLevelAccelerationStructure& blas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset = 0) const {
            this->cmdBuildAccelerationStructure(blas, scratchBuffer, buffer, offset);
        }
 
        inline void buildAccelerationStructure(ITopLevelAccelerationStructure& tlas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset = 0) const {
            this->cmdBuildAccelerationStructure(tlas, scratchBuffer, buffer, offset);
        }
 
        inline void updateAccelerationStructure(IBottomLevelAccelerationStructure& blas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset = 0) const {
            this->cmdUpdateAccelerationStructure(blas, scratchBuffer, buffer, offset);
        }
 
        inline void updateAccelerationStructure(ITopLevelAccelerationStructure& tlas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset = 0) const {
            this->cmdUpdateAccelerationStructure(tlas, scratchBuffer, buffer, offset);
        }
 
        inline void copyAccelerationStructure(const IBottomLevelAccelerationStructure& from, const IBottomLevelAccelerationStructure& to, bool compress = false) const noexcept {
            this->cmdCopyAccelerationStructure(from, to, compress);
        }
 
        inline void copyAccelerationStructure(const ITopLevelAccelerationStructure& from, const ITopLevelAccelerationStructure& to, bool compress = false) const noexcept {
            this->cmdCopyAccelerationStructure(from, to, compress);
        }
 
    protected:
        virtual void releaseSharedState() const = 0;
 
    private:
        virtual SharedPtr<const ICommandQueue> getQueue() const noexcept = 0;
        virtual UniquePtr<IBarrier> getBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const = 0;
        virtual void cmdBarrier(const IBarrier& barrier) const noexcept = 0;
        virtual void cmdTransfer(const IBuffer& source, const IBuffer& target, UInt32 sourceElement, UInt32 targetElement, UInt32 elements) const = 0;
        virtual void cmdTransfer(const IBuffer& source, const IImage& target, UInt32 sourceElement, UInt32 firstSubresource, UInt32 elements) const = 0;
        virtual void cmdTransfer(const IImage& source, const IImage& target, UInt32 sourceSubresource, UInt32 targetSubresource, UInt32 subresources) const = 0;
        virtual void cmdTransfer(const IImage& source, const IBuffer& target, UInt32 firstSubresource, UInt32 targetElement, UInt32 subresources) const = 0;
        virtual void cmdTransfer(const SharedPtr<const IBuffer>& source, const IBuffer& target, UInt32 sourceElement, UInt32 targetElement, UInt32 elements) const = 0;
        virtual void cmdTransfer(const SharedPtr<const IBuffer>& source, const IImage& target, UInt32 sourceElement, UInt32 firstSubresource, UInt32 elements) const = 0;
        virtual void cmdTransfer(const SharedPtr<const IImage>& source, const IImage& target, UInt32 sourceSubresource, UInt32 targetSubresource, UInt32 subresources) const = 0;
        virtual void cmdTransfer(const SharedPtr<const IImage>& source, const IBuffer& target, UInt32 firstSubresource, UInt32 targetElement, UInt32 subresources) const = 0;
        virtual void cmdTransfer(const void* const data, size_t size, const IBuffer& target, UInt32 targetElement, UInt32 elements) const = 0;
        virtual void cmdTransfer(Span<const void* const> data, size_t elementSize, const IBuffer& target, UInt32 targetElement) const = 0;
        virtual void cmdTransfer(const void* const data, size_t size, const IImage& target, UInt32 subresource) const = 0;
        virtual void cmdTransfer(Span<const void* const> data, size_t elementSize, const IImage& target, UInt32 firstSubresource, UInt32 elements) const = 0;
        virtual void cmdUse(const IPipeline& pipeline) const noexcept = 0;
        virtual void cmdBind(const IDescriptorSet& descriptorSet) const = 0;
        virtual void cmdBind(Span<const IDescriptorSet*> descriptorSets) const = 0;
        virtual void cmdBind(const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const = 0;
        virtual void cmdBind(Span<const IDescriptorSet*> descriptorSets, const IPipeline& pipeline) const = 0;
        virtual void cmdBind(const IVertexBuffer& buffer) const = 0;
        virtual void cmdBind(const IIndexBuffer& buffer) const = 0;
        virtual void cmdPushConstants(const IPushConstantsLayout& layout, const void* const memory) const = 0;
        virtual void cmdDispatchIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset) const noexcept = 0;
        virtual void cmdDispatchMeshIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset) const noexcept = 0;
        virtual void cmdDispatchMeshIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset, UInt64 countOffset, UInt32 maxBatches) const noexcept = 0;
        virtual void cmdDraw(const IVertexBuffer& vertexBuffer, UInt32 instances, UInt32 firstVertex, UInt32 firstInstance) const = 0;
        virtual void cmdDrawIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset) const noexcept = 0;
        virtual void cmdDrawIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset, UInt64 countOffset, UInt32 maxBatches) const noexcept = 0;
        virtual void cmdDrawIndexed(const IIndexBuffer& indexBuffer, UInt32 instances, UInt32 firstIndex, Int32 vertexOffset, UInt32 firstInstance) const = 0;
        virtual void cmdDrawIndexed(const IVertexBuffer& vertexBuffer, const IIndexBuffer& indexBuffer, UInt32 instances, UInt32 firstIndex, Int32 vertexOffset, UInt32 firstInstance) const = 0;
        virtual void cmdDrawIndexedIndirect(const IBuffer& batchBuffer, UInt32 batchCount, UInt64 offset) const noexcept = 0;
        virtual void cmdDrawIndexedIndirect(const IBuffer& batchBuffer, const IBuffer& countBuffer, UInt64 offset, UInt64 countOffset, UInt32 maxBatches) const noexcept = 0;
        virtual void cmdExecute(const SharedPtr<const ICommandBuffer>& commandBuffer) const = 0;
        virtual void cmdExecute(Enumerable<SharedPtr<const ICommandBuffer>> commandBuffer) const = 0;
        virtual void cmdBuildAccelerationStructure(IBottomLevelAccelerationStructure& blas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset) const = 0;
        virtual void cmdBuildAccelerationStructure(ITopLevelAccelerationStructure& tlas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset) const = 0;
        virtual void cmdUpdateAccelerationStructure(IBottomLevelAccelerationStructure& blas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset) const = 0;
        virtual void cmdUpdateAccelerationStructure(ITopLevelAccelerationStructure& tlas, const SharedPtr<const IBuffer>& scratchBuffer, const IBuffer& buffer, UInt64 offset) const = 0;
        virtual void cmdCopyAccelerationStructure(const IBottomLevelAccelerationStructure& from, const IBottomLevelAccelerationStructure& to, bool compress) const noexcept = 0;
        virtual void cmdCopyAccelerationStructure(const ITopLevelAccelerationStructure& from, const ITopLevelAccelerationStructure& to, bool compress) const noexcept = 0;
        virtual void cmdTraceRays(UInt32 width, UInt32 height, UInt32 depth, const ShaderBindingTableOffsets& offsets, const IBuffer& rayGenerationShaderBindingTable, const IBuffer* missShaderBindingTable, const IBuffer* hitShaderBindingTable, const IBuffer* callableShaderBindingTable) const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IRenderPipeline : public virtual IPipeline {
    protected:
        IRenderPipeline() noexcept = default;
        IRenderPipeline(IRenderPipeline&&) noexcept = default;
        IRenderPipeline(const IRenderPipeline&) = delete;
        IRenderPipeline& operator=(IRenderPipeline&&) noexcept = default;
        IRenderPipeline& operator=(const IRenderPipeline&) = delete;
 
    public:
        ~IRenderPipeline() noexcept override = default;
 
    public:
        inline SharedPtr<IInputAssembler> inputAssembler() const noexcept {
            return this->getInputAssembler();
        }
 
        inline SharedPtr<IRasterizer> rasterizer() const noexcept {
            return this->getRasterizer();
        }
 
        virtual bool alphaToCoverage() const noexcept = 0;
 
        virtual MultiSamplingLevel samples() const noexcept = 0;
 
        virtual void updateSamples(MultiSamplingLevel samples) = 0;
 
    private:
        virtual SharedPtr<IInputAssembler> getInputAssembler() const noexcept = 0;
        virtual SharedPtr<IRasterizer> getRasterizer() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IComputePipeline : public virtual IPipeline {
    protected:
        IComputePipeline() noexcept = default;
        IComputePipeline(IComputePipeline&&) noexcept = default;
        IComputePipeline(const IComputePipeline&) = delete;
        IComputePipeline& operator=(IComputePipeline&&) noexcept = default;
        IComputePipeline& operator=(const IComputePipeline&) = delete;
 
    public:
        ~IComputePipeline() noexcept override = default;
    };
 
    class LITEFX_RENDERING_API IRayTracingPipeline : public virtual IPipeline {
    protected:
        IRayTracingPipeline() noexcept = default;
        IRayTracingPipeline(IRayTracingPipeline&&) noexcept = default;
        IRayTracingPipeline(const IRayTracingPipeline&) = delete;
        IRayTracingPipeline& operator=(IRayTracingPipeline&&) noexcept = default;
        IRayTracingPipeline& operator=(const IRayTracingPipeline&) = delete;
 
    public:
        ~IRayTracingPipeline() noexcept override = default;
 
    public:
        virtual const ShaderRecordCollection& shaderRecords() const noexcept = 0;
 
        virtual UInt32 maxRecursionDepth() const noexcept = 0;
 
        virtual UInt32 maxPayloadSize() const noexcept = 0;
 
        virtual UInt32 maxAttributeSize() const noexcept = 0;
 
        inline SharedPtr<IBuffer> allocateShaderBindingTable(ShaderBindingTableOffsets& offsets, ShaderBindingGroup groups = ShaderBindingGroup::All) const {
            return this->getShaderBindingTable(offsets, groups);
        }
 
    private:
        virtual SharedPtr<IBuffer> getShaderBindingTable(ShaderBindingTableOffsets& offsets, ShaderBindingGroup groups) const = 0;
    };
 
    class LITEFX_RENDERING_API IFrameBuffer : public virtual IStateResource, public SharedObject {
    public:
        template <typename TImage>
        using allocation_callback_type = std::function<SharedPtr<const TImage>(Optional<UInt64>, Size2d, ResourceUsage, Format, MultiSamplingLevel, const String&)>;
 
    public:
        struct ResizeEventArgs : public EventArgs {
        private:
            Size2d m_newSize;
 
        public:
            ResizeEventArgs(Size2d newSize) noexcept :
                EventArgs(), m_newSize(std::move(newSize)) { }
            ResizeEventArgs(const ResizeEventArgs&) = default;
            ResizeEventArgs(ResizeEventArgs&&) noexcept = default;
            ResizeEventArgs& operator=(const ResizeEventArgs&) = default;
            ResizeEventArgs& operator=(ResizeEventArgs&&) noexcept = default;
            ~ResizeEventArgs() noexcept override = default;
 
        public:
            inline const Size2d& newSize() const noexcept {
                return m_newSize;
            }
        };
 
        struct ReleasedEventArgs : public EventArgs {
        public:
            ReleasedEventArgs() noexcept :
                EventArgs() { }
            ReleasedEventArgs(const ReleasedEventArgs&) = default;
            ReleasedEventArgs(ReleasedEventArgs&&) noexcept = default;
            ReleasedEventArgs& operator=(const ReleasedEventArgs&) = default;
            ReleasedEventArgs& operator=(ReleasedEventArgs&&) noexcept = default;
            ~ReleasedEventArgs() noexcept override = default;
        };
 
    protected:
        IFrameBuffer() noexcept = default;
        IFrameBuffer(IFrameBuffer&&) noexcept = default;
        IFrameBuffer(const IFrameBuffer&) = delete;
        IFrameBuffer& operator=(IFrameBuffer&&) noexcept = default;
        IFrameBuffer& operator=(const IFrameBuffer&) = delete;
 
    public:
        inline ~IFrameBuffer() noexcept override {
            released.invoke(this, { });
        }
 
    public:
        mutable Event<ResizeEventArgs> resizing;
 
        mutable Event<ResizeEventArgs> resized;
 
        mutable Event<ReleasedEventArgs> released;
 
    public:
        virtual const Size2d& size() const noexcept = 0;
 
        virtual size_t getWidth() const noexcept = 0;
 
        virtual size_t getHeight() const noexcept = 0;
 
        virtual void mapRenderTarget(const RenderTarget& renderTarget, UInt32 index) = 0;
 
        virtual void mapRenderTarget(const RenderTarget& renderTarget, StringView imageName) = 0;
 
        inline void mapRenderTarget(const RenderTarget& renderTarget) {
            this->mapRenderTarget(renderTarget, renderTarget.name());
        }
 
        inline void mapRenderTargets(Span<const RenderTarget> renderTargets) {
            std::ranges::for_each(renderTargets, [this](auto& renderTarget) { this->mapRenderTarget(renderTarget); });
        }
 
        virtual void unmapRenderTarget(const RenderTarget& renderTarget) noexcept = 0;
 
        inline Enumerable<const IImage&> images() const {
            return this->getImages();
        }
 
        virtual const IImage& operator[](UInt32 index) const = 0;
 
        virtual const IImage& image(UInt32 index) const = 0;
 
        virtual const IImage& operator[](const RenderTarget& renderTarget) const = 0;
 
        virtual const IImage& image(const RenderTarget& renderTarget) const = 0;
 
        virtual const IImage& operator[](StringView renderTargetName) const = 0;
 
        virtual const IImage& image(StringView renderTargetName) const = 0;
 
        virtual const IImage& resolveImage(UInt64 hash) const = 0;
 
        template <typename TSelf>
        inline auto addImage(this TSelf&& self, Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) -> TSelf&& {
            self.addImage(format, samples, usage);
            return std::forward<TSelf>(self);
        }
 
        inline void addImage(Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) {
            this->addImage("", format, samples, usage);
        }
 
        template <typename TSelf>
        inline auto addImage(this TSelf&& self, StringView name, Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) -> TSelf&& {
            self.addImage(name, format, samples, usage);
            return std::forward<TSelf>(self);
        }
 
        virtual void addImage(const String& name, Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) = 0;
 
        template <typename TSelf>
        inline auto addImage(this TSelf&& self, const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) -> TSelf&& {
            self.addImage(renderTarget, samples, usage);
            return std::forward<TSelf>(self);
        }
 
        inline void addImage(const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) {
            this->addImage(renderTarget.name(), renderTarget, samples, usage);
        }
 
        template <typename TSelf>
        inline auto addImage(this TSelf&& self, StringView name, const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) -> TSelf&& {
            self.addImage(name, renderTarget, samples, usage);
            return std::forward<TSelf>(self);
        }
 
        virtual void addImage(const String& name, const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) = 0;
 
        template <typename TSelf>
        inline auto addImages(this TSelf&& self, Span<const RenderTarget> renderTargets, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) -> TSelf&& {
            std::ranges::for_each(renderTargets, [&](auto& renderTarget) { self.addImage(renderTarget.name(), renderTarget, samples, usage); });
            return std::forward<TSelf>(self);
        }
 
        virtual void resize(const Size2d& renderArea) = 0;
 
    private:
        virtual Enumerable<const IImage&> getImages() const = 0;
    };
 
    class LITEFX_RENDERING_API IRenderPass : public virtual IStateResource, public SharedObject {
    public:
        struct BeginEventArgs : public EventArgs {
        private:
            const IFrameBuffer* m_frameBuffer;
 
        public:
            BeginEventArgs(const IFrameBuffer& frameBuffer) noexcept :
                EventArgs(), m_frameBuffer(&frameBuffer) { }
            BeginEventArgs(const BeginEventArgs&) = default;
            BeginEventArgs(BeginEventArgs&&) noexcept = default;
            BeginEventArgs& operator=(const BeginEventArgs&) = default;
            BeginEventArgs& operator=(BeginEventArgs&&) noexcept = default;
            ~BeginEventArgs() noexcept override = default;
 
        public:
            inline const IFrameBuffer& frameBuffer() const noexcept {
                return *m_frameBuffer;
            }
        };
 
    protected:
        IRenderPass() noexcept = default;
        IRenderPass(IRenderPass&&) noexcept = default;
        IRenderPass(const IRenderPass&) = delete;
        IRenderPass& operator=(IRenderPass&&) noexcept = default;
        IRenderPass& operator=(const IRenderPass&) = delete;
 
    public:
        ~IRenderPass() noexcept override = default;
 
    public:
        mutable Event<BeginEventArgs> beginning;
 
        mutable Event<EventArgs> ending;
 
    public:
        //virtual const IGraphicsDevice& device() const noexcept;
 
        inline SharedPtr<const IFrameBuffer> activeFrameBuffer() const noexcept {
            return this->getActiveFrameBuffer();
        }
 
        inline const ICommandQueue& commandQueue() const noexcept {
            return this->getCommandQueue();
        }
 
        inline Enumerable<SharedPtr<const ICommandBuffer>> commandBuffers() const {
            return this->getCommandBuffers();
        }
 
        inline SharedPtr<const ICommandBuffer> commandBuffer(UInt32 index) const {
            return this->getCommandBuffer(index);
        }
 
        virtual UInt32 secondaryCommandBuffers() const noexcept = 0;
 
        virtual const Array<RenderTarget>& renderTargets() const noexcept = 0;
 
        virtual const RenderTarget& renderTarget(UInt32 location) const = 0;
 
        virtual bool hasPresentTarget() const noexcept = 0;
 
        virtual const Array<RenderPassDependency>& inputAttachments() const noexcept = 0;
 
        virtual const RenderPassDependency& inputAttachment(UInt32 location) const = 0;
 
        virtual const Optional<DescriptorBindingPoint>& inputAttachmentSamplerBinding() const noexcept = 0;
 
        inline void begin(const IFrameBuffer& frameBuffer) const {
            this->beginRenderPass(frameBuffer);
        };
 
        virtual UInt64 end() const = 0;
 
        virtual UInt32 viewMask() const noexcept = 0;
 
    private:
        virtual SharedPtr<const IFrameBuffer> getActiveFrameBuffer() const noexcept = 0;
        virtual void beginRenderPass(const IFrameBuffer& frameBuffer) const = 0;
        virtual const ICommandQueue& getCommandQueue() const noexcept = 0;
        virtual SharedPtr<const ICommandBuffer> getCommandBuffer(UInt32 index) const noexcept = 0;
        virtual Enumerable<SharedPtr<const ICommandBuffer>> getCommandBuffers() const = 0;
    };
 
    class LITEFX_RENDERING_API ISwapChain {
    public:
        struct ResetEventArgs : public EventArgs {
        private:
            Format m_surfaceFormat;
            Size2d m_renderArea;
            UInt32 m_buffers;
            bool m_vsync;
 
        public:
            ResetEventArgs(Format surfaceFormat, Size2d renderArea, UInt32 buffers, bool enableVsync) noexcept :
                EventArgs(), m_surfaceFormat(surfaceFormat), m_renderArea(std::move(renderArea)), m_buffers(buffers), m_vsync(enableVsync) { }
            ResetEventArgs(const ResetEventArgs&) = default;
            ResetEventArgs(ResetEventArgs&&) noexcept = default;
            ResetEventArgs& operator=(const ResetEventArgs&) = default;
            ResetEventArgs& operator=(ResetEventArgs&&) noexcept = default;
            ~ResetEventArgs() noexcept override = default;
 
        public:
            inline Format surfaceFormat() const noexcept {
                return m_surfaceFormat;
            }
 
            inline const Size2d& renderArea() const noexcept {
                return m_renderArea;
            }
 
            inline UInt32 buffers() const noexcept {
                return m_buffers;
            }
 
            inline bool enableVsync() const noexcept {
                return m_vsync;
            }
        };
 
        struct BackBufferSwapEventArgs : public EventArgs {
        private:
            UInt32 m_backBuffer;
 
        public:
            explicit BackBufferSwapEventArgs(UInt32 backBuffer) noexcept :
                EventArgs(), m_backBuffer(backBuffer) {
            }
            BackBufferSwapEventArgs(const BackBufferSwapEventArgs&) = default;
            BackBufferSwapEventArgs(BackBufferSwapEventArgs&&) noexcept = default;
            BackBufferSwapEventArgs& operator=(const BackBufferSwapEventArgs&) = default;
            BackBufferSwapEventArgs& operator=(BackBufferSwapEventArgs&&) noexcept = default;
            ~BackBufferSwapEventArgs() noexcept override = default;
 
        public:
            UInt32 backBuffer() const noexcept {
                return m_backBuffer;
            }
        };
 
    protected:
        ISwapChain() noexcept = default;
        ISwapChain(ISwapChain&&) noexcept = default;
        ISwapChain(const ISwapChain&) = default;
        ISwapChain& operator=(const ISwapChain&) = default;
        ISwapChain& operator=(ISwapChain&&) noexcept = default;
 
    public:
        virtual ~ISwapChain() noexcept = default;
 
    public:
        [[nodiscard]] inline SharedPtr<const TimingEvent> registerTimingEvent(StringView name = "") {
            auto timingEvent = TimingEvent::create(*this, name);
            this->addTimingEvent(timingEvent);
            return timingEvent;
        }
 
        virtual const Array<SharedPtr<const TimingEvent>>& timingEvents() const = 0;
 
        virtual SharedPtr<const TimingEvent> timingEvent(UInt32 queryId) const = 0;
 
        virtual UInt64 readTimingEvent(SharedPtr<const TimingEvent> timingEvent) const = 0;
 
        virtual UInt32 resolveQueryId(SharedPtr<const TimingEvent> timingEvent) const = 0;
 
        virtual const IGraphicsDevice& device() const  = 0;
 
    public:
        virtual Format surfaceFormat() const noexcept = 0;
 
        virtual UInt32 buffers() const noexcept = 0;
 
        virtual const Size2d& renderArea() const noexcept = 0;
 
        virtual bool verticalSynchronization() const noexcept = 0;
 
        virtual IImage* image(UInt32 backBuffer) const = 0;
 
        virtual const IImage& image() const noexcept = 0;
 
        inline Enumerable<IImage&> images() const {
            return this->getImages();
        };
 
        virtual void present(UInt64 fence) const = 0;
 
    public:
        mutable Event<BackBufferSwapEventArgs> swapped;
 
       mutable Event<ResetEventArgs> reseted;
 
        virtual Enumerable<Format> getSurfaceFormats() const = 0;
 
        virtual void reset(Format surfaceFormat, const Size2d& renderArea, UInt32 buffers, bool enableVsync = false) = 0;
 
        [[nodiscard]] virtual UInt32 swapBackBuffer() const = 0;
 
    private:
        virtual Enumerable<IImage&> getImages() const = 0;
        virtual void addTimingEvent(SharedPtr<const TimingEvent> timingEvent) = 0;
    };
 
    class LITEFX_RENDERING_API ICommandQueue : public SharedObject {
    public:
        struct QueueSubmittingEventArgs : public EventArgs {
        private:
            Array<SharedPtr<const ICommandBuffer>> m_commandBuffers;
 
        public:
            QueueSubmittingEventArgs(Array<SharedPtr<const ICommandBuffer>>&& commandBuffers) :
                EventArgs(), m_commandBuffers(std::move(commandBuffers)) { }
 
            QueueSubmittingEventArgs(const QueueSubmittingEventArgs&) = default;
            QueueSubmittingEventArgs(QueueSubmittingEventArgs&&) noexcept = default;
            QueueSubmittingEventArgs& operator=(const QueueSubmittingEventArgs&) = default;
            QueueSubmittingEventArgs& operator=(QueueSubmittingEventArgs&&) noexcept = default;
            ~QueueSubmittingEventArgs() noexcept override = default;
 
        public:
            inline const Array<SharedPtr<const ICommandBuffer>>& commandBuffers() const noexcept {
                return m_commandBuffers;
            }
        };
 
        struct QueueSubmittedEventArgs : public EventArgs {
        private:
            UInt64 m_fence;
 
        public:
            QueueSubmittedEventArgs(UInt64 fence) noexcept :
                EventArgs(), m_fence(fence) { }
            QueueSubmittedEventArgs(const QueueSubmittedEventArgs&) = default;
            QueueSubmittedEventArgs(QueueSubmittedEventArgs&&) noexcept = default;
            QueueSubmittedEventArgs& operator=(const QueueSubmittedEventArgs&) = default;
            QueueSubmittedEventArgs& operator=(QueueSubmittedEventArgs&&) noexcept = default;
            ~QueueSubmittedEventArgs() noexcept override = default;
 
        public:
            inline UInt64 fence() const noexcept {
                return m_fence;
            }
        };
 
    protected:
        ICommandQueue() noexcept = default;
        ICommandQueue(const ICommandQueue&) = default;
        ICommandQueue(ICommandQueue&&) noexcept = default;
        ICommandQueue& operator=(const ICommandQueue&) = default;
        ICommandQueue& operator=(ICommandQueue&&) noexcept = default;
 
    public:
        ~ICommandQueue() noexcept override = default;
 
    public:
        virtual QueuePriority priority() const noexcept = 0;
 
        virtual QueueType type() const noexcept = 0;
 
    public:
        static constexpr Vectors::ByteVector3 DEFAULT_DEBUG_COLOR = { 128_ui8, 128_ui8, 128_ui8 };
 
        virtual void beginDebugRegion([[maybe_unused]] const String& label, [[maybe_unused]] const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept { };
        
        virtual void endDebugRegion() const noexcept { };
 
        virtual void setDebugMarker([[maybe_unused]] const String& label, [[maybe_unused]] const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept { };
 
    public:
        mutable Event<QueueSubmittingEventArgs> submitting;
 
        mutable Event<QueueSubmittedEventArgs> submitted;
 
        inline SharedPtr<ICommandBuffer> createCommandBuffer(bool beginRecording = false, bool secondary = false) const {
            return this->getCommandBuffer(beginRecording, secondary);
        }
 
        inline UInt64 submit(const SharedPtr<const ICommandBuffer>& commandBuffer) const {
            return this->submitCommandBuffer(commandBuffer);
        }
 
        inline UInt64 submit(const SharedPtr<ICommandBuffer>& commandBuffer) const {
            return this->submitCommandBuffer(commandBuffer);
        }
 
        inline UInt64 submit(Enumerable<SharedPtr<const ICommandBuffer>> commandBuffers) const {
            return this->submitCommandBuffers(std::move(commandBuffers));
        }
 
        virtual void waitFor(UInt64 fence) const = 0;
 
        inline void waitFor(const ICommandQueue& queue, UInt64 fence) const {
            this->waitForQueue(queue, fence);
        }
 
        virtual UInt64 currentFence() const noexcept = 0;
 
        virtual UInt64 lastCompletedFence() const noexcept = 0;
 
    private:
        virtual SharedPtr<ICommandBuffer> getCommandBuffer(bool beginRecording, bool secondary) const = 0;
        virtual UInt64 submitCommandBuffer(const SharedPtr<const ICommandBuffer>& commandBuffer) const = 0;
        virtual UInt64 submitCommandBuffers(Enumerable<SharedPtr<const ICommandBuffer>> commandBuffers) const = 0;
        virtual void waitForQueue(const ICommandQueue& queue, UInt64 fence) const = 0;
        
    protected:
        inline void releaseSharedState(const ICommandBuffer& commandBuffer) const {
            commandBuffer.releaseSharedState();
        }
    };
 
    struct LITEFX_RENDERING_API MemoryHeapStatistics {
        bool onGpu{ false };
 
        bool cpuVisible{ false };
 
        UInt32 blocks{};
 
        UInt32 allocations{};
 
        UInt64 blockSize{};
 
        UInt64 allocationSize{};
 
        UInt64 usedMemory{};
 
        UInt64 availableMemory{};
    };
 
    struct LITEFX_RENDERING_API DetailedMemoryStatistics {
        struct StatisticsBlock {
            bool onGpu{ false };
 
            bool cpuVisible{ false };
 
            UInt32 blocks{};
 
            UInt32 allocations{};
 
            UInt64 blockSize{};
 
            UInt64 allocationSize{};
 
            UInt32 unusedRangeCount{};
 
            UInt64 minAllocationSize{};
 
            UInt64 maxAllocationSize{};
 
            UInt64 minUnusedRangeSize{};
 
            UInt64 maxUnusedRangeSize{};
        };
 
        Array<StatisticsBlock> perLocation{};
 
        Array<StatisticsBlock> perResourceHeap{};
 
        StatisticsBlock total{};
    };
 
    class LITEFX_RENDERING_API IGraphicsFactory : public SharedObject {
    protected:
        IGraphicsFactory() noexcept = default;
        IGraphicsFactory(IGraphicsFactory&&) noexcept = default;
        IGraphicsFactory(const IGraphicsFactory&) = default;
        IGraphicsFactory& operator=(const IGraphicsFactory&) = default;
        IGraphicsFactory& operator=(IGraphicsFactory&&) noexcept = default;
 
    public:
        ~IGraphicsFactory() noexcept override = default;
 
    public:
        [[nodiscard]] virtual VirtualAllocator createAllocator(UInt64 overallMemory, AllocationAlgorithm algorithm = AllocationAlgorithm::Default) const = 0;
 
        virtual void beginDefragmentation(const ICommandQueue& queue, DefragmentationStrategy strategy = DefragmentationStrategy::Balanced, UInt64 maxBytesToMove = 0u, UInt32 maxAllocationsToMove = 0u) const = 0;
 
        virtual UInt64 beginDefragmentationPass() const = 0;
 
        virtual bool endDefragmentationPass() const = 0;
 
        virtual ResourceAllocationResult allocate(const ResourceAllocationInfo& allocationInfo, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            if (std::holds_alternative<ResourceAllocationInfo::ImageInfo>(allocationInfo.ResourceInfo))
            {
                auto& imageInfo = std::get<ResourceAllocationInfo::ImageInfo>(allocationInfo.ResourceInfo);
                return this->createTexture(allocationInfo.Name, imageInfo.Format, imageInfo.Size, imageInfo.Dimensions, imageInfo.Levels, imageInfo.Layers, imageInfo.Samples, allocationInfo.Usage, allocationBehavior);
            }
            else
            {
                auto& bufferInfo = std::get<ResourceAllocationInfo::BufferInfo>(allocationInfo.ResourceInfo);
 
                if (bufferInfo.Type == BufferType::Vertex && bufferInfo.VertexBufferLayout != nullptr)
                    return std::dynamic_pointer_cast<IBuffer>(
                        this->createVertexBuffer(allocationInfo.Name, *bufferInfo.VertexBufferLayout, bufferInfo.Heap, bufferInfo.Elements, allocationInfo.Usage, allocationBehavior));
                else if (bufferInfo.Type == BufferType::Index && bufferInfo.IndexBufferLayout != nullptr)
                    return std::dynamic_pointer_cast<IBuffer>(
                        this->createIndexBuffer(allocationInfo.Name, *bufferInfo.IndexBufferLayout, bufferInfo.Heap, bufferInfo.Elements, allocationInfo.Usage, allocationBehavior));
                else
                    return this->createBuffer(allocationInfo.Name, bufferInfo.Type, bufferInfo.Heap, bufferInfo.ElementSize, bufferInfo.Elements, allocationInfo.Usage, allocationBehavior);
            }
        }
 
        virtual Generator<ResourceAllocationResult> allocate(Enumerable<const ResourceAllocationInfo&> allocationInfos, AllocationBehavior allocationBehavior = AllocationBehavior::Default, bool alias = false) const = 0;
 
        virtual bool canAlias(Enumerable<const ResourceAllocationInfo&> allocationInfos) const = 0;
 
        inline SharedPtr<IBuffer> createBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getBuffer(type, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetBuffer(buffer, type, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(descriptor.type(), heap, descriptor.elementSize(), elements, usage, allocationBehavior);
        };
        
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer,const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->tryCreateBuffer(buffer, descriptor.type(), heap, descriptor.elementSize(), elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(descriptor.type(), heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->tryCreateBuffer(buffer, descriptor.type(), heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->createBuffer(pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryCreateBuffer(buffer, pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->createBuffer(pipeline.layout()->descriptorSet(space), binding, heap, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryCreateBuffer(buffer, pipeline.layout()->descriptorSet(space), binding, heap, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getBuffer(name, type, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetBuffer(buffer, name, type, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(name, descriptor.type(), heap, descriptor.elementSize(), elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->tryCreateBuffer(buffer, name, descriptor.type(), heap, descriptor.elementSize(), elements, usage, allocationBehavior);
        };
        
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(name, descriptor.type(), heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->tryCreateBuffer(buffer, name, descriptor.type(), heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->createBuffer(name, pipeline.layout()->descriptorSet(space), binding, heap, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const String& name, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryCreateBuffer(buffer, name, pipeline.layout()->descriptorSet(space), binding, heap, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->createBuffer(name, pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline bool tryCreateBuffer(SharedPtr<IBuffer>& buffer, const String& name, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryCreateBuffer(buffer, name, pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage, allocationBehavior);
        };
 
        inline SharedPtr<IVertexBuffer> createVertexBuffer(const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getVertexBuffer(layout, heap, elements, usage, allocationBehavior);
        }
 
        inline bool tryCreateVertexBuffer(SharedPtr<IVertexBuffer>& buffer, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetVertexBuffer(buffer, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline SharedPtr<IVertexBuffer> createVertexBuffer(const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getVertexBuffer(name, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline bool tryCreateVertexBuffer(SharedPtr<IVertexBuffer>& buffer, const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetVertexBuffer(buffer, name, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline SharedPtr<IIndexBuffer> createIndexBuffer(const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getIndexBuffer(layout, heap, elements, usage, allocationBehavior);
        }
 
        inline bool tryCreateIndexBuffer(SharedPtr<IIndexBuffer>& buffer, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetIndexBuffer(buffer, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline SharedPtr<IIndexBuffer> createIndexBuffer(const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getIndexBuffer(name, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline bool tryCreateIndexBuffer(SharedPtr<IIndexBuffer>& buffer, const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetIndexBuffer(buffer, name, layout, heap, elements, usage, allocationBehavior);
        }
 
        inline SharedPtr<IImage> createTexture(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getTexture(format, size, dimension, levels, layers, samples, usage, allocationBehavior);
        }
 
        inline bool tryCreateTexture(SharedPtr<IImage>& image, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetTexture(image, format, size, dimension, levels, layers, samples, usage, allocationBehavior);
        }
 
        inline SharedPtr<IImage> createTexture(const String& name, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getTexture(name, format, size, dimension, levels, layers, samples, usage, allocationBehavior);
        }
 
        inline bool tryCreateTexture(SharedPtr<IImage>& image, const String& name, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->tryGetTexture(image, name, format, size, dimension, levels, layers, samples, usage, allocationBehavior);
        }
 
        inline Generator<SharedPtr<IImage>> createTextures(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 layers = 1, UInt32 levels = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const {
            return this->getTextures(format, size, dimension, layers, levels, samples, usage, allocationBehavior);
        }
 
        inline SharedPtr<ISampler> createSampler(FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const {
            return this->getSampler(magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        inline SharedPtr<ISampler> createSampler(const String& name, FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const {
            return this->getSampler(name, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        inline Generator<SharedPtr<ISampler>> createSamplers(FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const {
            return this->getSamplers(magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        inline UniquePtr<IBottomLevelAccelerationStructure> createBottomLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None) const {
            return this->createBottomLevelAccelerationStructure("", flags);
        }
 
        inline UniquePtr<IBottomLevelAccelerationStructure> createBottomLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const {
            return this->getBlas(name, flags);
        }
 
        inline UniquePtr<ITopLevelAccelerationStructure> createTopLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None) const {
            return this->createTopLevelAccelerationStructure("", flags);
        }
 
        inline UniquePtr<ITopLevelAccelerationStructure> createTopLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const {
            return this->getTlas(name, flags);
        }
 
        virtual bool supportsResizableBaseAddressRegister() const noexcept = 0;
 
        virtual Array<MemoryHeapStatistics> memoryStatistics() const = 0;
 
        virtual DetailedMemoryStatistics detailedMemoryStatistics() const = 0;
 
    private:
        virtual SharedPtr<IBuffer> getBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IBuffer> getBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IVertexBuffer> getVertexBuffer(const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IVertexBuffer> getVertexBuffer(const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IIndexBuffer> getIndexBuffer(const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IIndexBuffer> getIndexBuffer(const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IImage> getTexture(Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<IImage> getTexture(const String& name, Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetBuffer(SharedPtr<IBuffer>& buffer, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetBuffer(SharedPtr<IBuffer>& buffer, const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetVertexBuffer(SharedPtr<IVertexBuffer>& buffer, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetVertexBuffer(SharedPtr<IVertexBuffer>& buffer, const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetIndexBuffer(SharedPtr<IIndexBuffer>& buffer, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetIndexBuffer(SharedPtr<IIndexBuffer>& buffer, const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetTexture(SharedPtr<IImage>& image, Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual bool tryGetTexture(SharedPtr<IImage>& image, const String& name, Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual Generator<SharedPtr<IImage>> getTextures(Format format, const Size3d& size, ImageDimensions dimension, UInt32 layers, UInt32 levels, MultiSamplingLevel samples, ResourceUsage usage, AllocationBehavior allocationBehavior) const = 0;
        virtual SharedPtr<ISampler> getSampler(FilterMode magFilter, FilterMode minFilter, BorderMode borderU, BorderMode borderV, BorderMode borderW, MipMapMode mipMapMode, Float mipMapBias, Float maxLod, Float minLod, Float anisotropy) const = 0;
        virtual SharedPtr<ISampler> getSampler(const String& name, FilterMode magFilter, FilterMode minFilter, BorderMode borderU, BorderMode borderV, BorderMode borderW, MipMapMode mipMapMode, Float mipMapBias, Float maxLod, Float minLod, Float anisotropy) const = 0;
        virtual Generator<SharedPtr<ISampler>> getSamplers(FilterMode magFilter, FilterMode minFilter, BorderMode borderU, BorderMode borderV, BorderMode borderW, MipMapMode mipMapMode, Float mipMapBias, Float maxLod, Float minLod, Float anisotropy) const = 0;
        virtual UniquePtr<IBottomLevelAccelerationStructure> getBlas(StringView name, AccelerationStructureFlags flags) const = 0;
        virtual UniquePtr<ITopLevelAccelerationStructure> getTlas(StringView name, AccelerationStructureFlags flags) const = 0;
    };
 
    struct LITEFX_RENDERING_API GraphicsDeviceFeatures {
    public:
        bool MeshShaders { false };
 
        bool RayTracing { false };
 
        bool RayQueries { false };
 
        bool DrawIndirect { false };
 
        bool DynamicDescriptors { false };
 
        bool DepthBoundsTest { false };
 
        bool ConservativeRasterization { false };
 
        bool ViewInstancing { false };
    };
 
    class LITEFX_RENDERING_API IGraphicsDevice : public SharedObject {
    protected:
        IGraphicsDevice() noexcept = default;
        IGraphicsDevice(IGraphicsDevice&&) noexcept = default;
        IGraphicsDevice(const IGraphicsDevice&) = default;
        IGraphicsDevice& operator=(const IGraphicsDevice&) = default;
        IGraphicsDevice& operator=(IGraphicsDevice&&) noexcept = default;
 
    public:
        ~IGraphicsDevice() noexcept override = default;
 
    public:
        virtual DeviceState& state() const noexcept = 0;
 
        virtual const ISurface& surface() const noexcept = 0;
 
        virtual const IGraphicsAdapter& adapter() const noexcept = 0;
 
        virtual const ISwapChain& swapChain() const noexcept = 0;
 
        virtual ISwapChain& swapChain() noexcept = 0;
 
        virtual const IGraphicsFactory& factory() const noexcept = 0;
 
        inline const ICommandQueue& defaultQueue(QueueType type) const {
            return this->getDefaultQueue(type);
        }
 
        inline SharedPtr<const ICommandQueue> createQueue(QueueType type, QueuePriority priority = QueuePriority::Normal) {
            return this->getNewQueue(type, priority);
        }
 
        [[nodiscard]] inline UniquePtr<IBarrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const {
            return this->getNewBarrier(syncBefore, syncAfter);
        }
 
        [[nodiscard]] inline SharedPtr<IFrameBuffer> makeFrameBuffer(const Size2d& renderArea) const {
            return this->makeFrameBuffer("", renderArea);
        }
 
        [[nodiscard]] inline SharedPtr<IFrameBuffer> makeFrameBuffer(StringView name, const Size2d& renderArea) const {
            return this->getNewFrameBuffer(name, renderArea);
        }
 
        virtual MultiSamplingLevel maximumMultiSamplingLevel(Format format) const noexcept = 0;
 
        virtual double ticksPerMillisecond() const noexcept = 0;
 
        inline void computeAccelerationStructureSizes(const IBottomLevelAccelerationStructure& blas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const {
            this->getAccelerationStructureSizes(blas, bufferSize, scratchSize, forUpdate);
        }
 
        inline void computeAccelerationStructureSizes(const ITopLevelAccelerationStructure& tlas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const {
            this->getAccelerationStructureSizes(tlas, bufferSize, scratchSize, forUpdate);
        }
 
        [[nodiscard]] inline VirtualAllocator::Allocation allocateGlobalDescriptors(const IDescriptorSet& descriptorSet, DescriptorHeapType heapType) const {
            return this->doAllocateGlobalDescriptors(descriptorSet, heapType);
        }
 
        inline void releaseGlobalDescriptors(const IDescriptorSet& descriptorSet) const {
            this->doReleaseGlobalDescriptors(descriptorSet);
        }
 
        inline void updateGlobalDescriptors(const IDescriptorSet& descriptorSet, UInt32 binding, UInt32 offset, UInt32 descriptors) const {
            this->doUpdateGlobalDescriptors(descriptorSet, binding, offset, descriptors);
        }
 
        inline void bindDescriptorSet(const ICommandBuffer& commandBuffer, const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const noexcept {
            this->doBindDescriptorSet(commandBuffer, descriptorSet, pipeline);
        }
 
        inline void bindGlobalDescriptorHeaps(const ICommandBuffer& commandBuffer) const noexcept {
            this->doBindGlobalDescriptorHeaps(commandBuffer);
        }
 
    private:
        virtual void getAccelerationStructureSizes(const IBottomLevelAccelerationStructure& blas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate) const = 0;
        virtual void getAccelerationStructureSizes(const ITopLevelAccelerationStructure& tlas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate) const = 0;
        virtual VirtualAllocator::Allocation doAllocateGlobalDescriptors(const IDescriptorSet& descriptorSet, DescriptorHeapType heapType) const = 0;
        virtual void doReleaseGlobalDescriptors(const IDescriptorSet& descriptorSet) const = 0;
        virtual void doUpdateGlobalDescriptors(const IDescriptorSet& descriptorSet, UInt32 binding, UInt32 offset, UInt32 descriptors) const = 0;
        virtual void doBindDescriptorSet(const ICommandBuffer& commandBuffer, const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const noexcept = 0;
        virtual void doBindGlobalDescriptorHeaps(const ICommandBuffer& commandBuffer) const noexcept = 0;
 
    public:
        virtual void wait() const = 0;
 
    private:
        virtual UniquePtr<IBarrier> getNewBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const = 0;
        virtual SharedPtr<IFrameBuffer> getNewFrameBuffer(StringView name, const Size2d& renderArea) const = 0;
        virtual const ICommandQueue& getDefaultQueue(QueueType type) const = 0;
        virtual SharedPtr<const ICommandQueue> getNewQueue(QueueType type, QueuePriority priority) = 0;
    };
 
    class LITEFX_RENDERING_API IRenderBackend : public IBackend {
    protected:
        IRenderBackend() noexcept = default;
        IRenderBackend(IRenderBackend&&) noexcept = default;
        IRenderBackend(const IRenderBackend&) = default;
        IRenderBackend& operator=(const IRenderBackend&) = default;
        IRenderBackend& operator=(IRenderBackend&&) noexcept = default;
 
    public:
        ~IRenderBackend() noexcept override = default;
 
    public:
        inline Enumerable<SharedPtr<const IGraphicsAdapter>> listAdapters() const {
            return this->getAdapters();
        }
 
        virtual const IGraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const noexcept = 0;
 
        virtual IGraphicsDevice* device(const String& name) noexcept = 0;
 
        virtual const IGraphicsDevice* device(const String& name) const noexcept = 0;
 
        virtual inline const IGraphicsDevice* operator[](const String& name) const noexcept {
            return this->device(name);
        };
 
        virtual inline IGraphicsDevice* operator[](const String& name) noexcept {
            return this->device(name);
        };
 
    private:
        virtual Enumerable<SharedPtr<const IGraphicsAdapter>> getAdapters() const = 0;
    };
 
    template <typename T>
    concept render_backend = meta::implements<T, IRenderBackend>;
 
}