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;
 
#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,
 
        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
    };
 
    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
    };
 
    enum class ResourceUsage {
        None = 0x0000,
 
        AllowWrite = 0x0001,
 
        TransferSource = 0x0010,
 
        TransferDestination = 0x0020,
 
        RenderTarget = 0x0040,
 
        AccelerationStructureBuildInput = 0x0100,
 
        Default = TransferSource | TransferDestination,
 
        FrameBufferImage = TransferSource | RenderTarget,
    };
 
    enum class IndexType : UInt32 {
        UInt16 = 0x00000010,
 
        UInt32 = 0x00000020
    };
 
    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)
#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 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 };
    };
 
    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 };
        };
 
        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 };
 
            Byte WriteMask{ 0xFF }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
            Byte 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;
    };
 
    class LITEFX_RENDERING_API Rasterizer : public IRasterizer {
        LITEFX_IMPLEMENTATION(RasterizerImpl);
 
    protected:
        explicit Rasterizer(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) 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;
 
    protected:
        virtual PolygonMode& polygonMode() noexcept;
        virtual CullMode& cullMode() noexcept;
        virtual CullOrder& cullOrder() noexcept;
        virtual Float& lineWidth() noexcept;
        virtual DepthStencilState& depthStencilState() 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;
    };
 
    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 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;
    };
 
    class LITEFX_RENDERING_API IDeviceMemory {
    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:
        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;
 
        inline bool writable() const noexcept {
            return LITEFX_FLAG_IS_SET(this->usage(), ResourceUsage::AllowWrite);
        }
 
        virtual UInt64 virtualAddress() const noexcept = 0;
    };
 
    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;
 
            Byte 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, Byte 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, Byte 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, Byte 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, Byte 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:
        void update(UInt32 binding, const IBuffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, UInt32 firstDescriptor = 0) const {
            this->doUpdate(binding, buffer, bufferElement, elements, firstDescriptor);
        }
 
        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);
        }
 
        void update(UInt32 binding, const ISampler& sampler, UInt32 descriptor = 0) const {
            this->doUpdate(binding, sampler, descriptor);
        }
 
        void update(UInt32 binding, const IAccelerationStructure& accelerationStructure, UInt32 descriptor = 0) const {
            this->doUpdate(binding, accelerationStructure, descriptor);
        }
 
    private:
        virtual void doUpdate(UInt32 binding, const IBuffer& buffer, UInt32 bufferElement, UInt32 elements, UInt32 firstDescriptor) 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;
 
    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);
        }
    };
 
    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() const {
            return this->parsePipelineLayout();
        };
 
        [[nodiscard]] inline ShaderRecordCollection buildShaderRecordCollection() const noexcept {
            return { this->shared_from_this() };
        }
 
    private:
        virtual Enumerable<const IShaderModule&> getModules() const = 0;
        virtual SharedPtr<IPipelineLayout> parsePipelineLayout() 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;
 
    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;
 
    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 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:
        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> 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;
 
    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;
            }
        };
 
    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<EventArgs> 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_b, 128_b, 128_b };
 
        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;
 
    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();
        }
    };
 
    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:
        inline SharedPtr<IBuffer> createBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getBuffer(type, heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(descriptor.type(), heap, descriptor.elementSize(), elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(descriptor.type(), heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            return this->createBuffer(pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            return this->createBuffer(pipeline.layout()->descriptorSet(space), binding, heap, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getBuffer(name, type, heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(name, descriptor.type(), heap, descriptor.elementSize(), elements, usage);
        };
        
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IDescriptorSetLayout& descriptorSet, UInt32 binding, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            auto& descriptor = descriptorSet.descriptor(binding);
            return this->createBuffer(name, descriptor.type(), heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IBuffer> createBuffer(const String& name, const IPipeline& pipeline, UInt32 space, UInt32 binding, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            return this->createBuffer(name, pipeline.layout()->descriptorSet(space), binding, heap, elements, usage);
        };
 
        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) const {
            return this->createBuffer(name, pipeline.layout()->descriptorSet(space), binding, heap, elementSize, elements, usage);
        };
 
        inline SharedPtr<IVertexBuffer> createVertexBuffer(const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getVertexBuffer(layout, heap, elements, usage);
        }
 
        inline SharedPtr<IVertexBuffer> createVertexBuffer(const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getVertexBuffer(name, layout, heap, elements, usage);
        }
 
        inline SharedPtr<IIndexBuffer> createIndexBuffer(const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getIndexBuffer(layout, heap, elements, usage);
        }
 
        inline SharedPtr<IIndexBuffer> createIndexBuffer(const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const {
            return this->getIndexBuffer(name, layout, heap, elements, usage);
        }
 
        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) const {
            return this->getTexture(format, size, dimension, levels, layers, samples, usage);
        }
 
        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) const {
            return this->getTexture(name, format, size, dimension, levels, layers, samples, usage);
        }
 
        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) const {
            return this->getTextures(format, size, dimension, layers, levels, samples, usage);
        }
 
        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);
        }
 
    private:
        virtual SharedPtr<IBuffer> getBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IBuffer> getBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IVertexBuffer> getVertexBuffer(const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IVertexBuffer> getVertexBuffer(const String& name, const IVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IIndexBuffer> getIndexBuffer(const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IIndexBuffer> getIndexBuffer(const String& name, const IIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage) const = 0;
        virtual SharedPtr<IImage> getTexture(Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage) const = 0;
        virtual SharedPtr<IImage> getTexture(const String& name, Format format, const Size3d& size, ImageDimensions dimension, UInt32 levels, UInt32 layers, MultiSamplingLevel samples, ResourceUsage usage) const = 0;
        virtual Generator<SharedPtr<IImage>> getTextures(Format format, const Size3d& size, ImageDimensions dimension, UInt32 layers, UInt32 levels, MultiSamplingLevel samples, ResourceUsage usage) 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 };
    };
 
    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);
        }
 
    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;
 
    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>;
 
}