rendering_api.hpp

#pragma once
 
#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>
#include <litefx/graphics.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 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 IFrameBuffer;
    class IRenderPass;
    class ISwapChain;
    class ICommandQueue;
    class IGraphicsFactory;
    class IGraphicsDevice;
    class IRenderBackend;
 
    // Define enumerations.
    enum class LITEFX_RENDERING_API GraphicsAdapterType {
        None = 0x00000000,
        
        GPU = 0x00000001,
 
        CPU = 0x00000002,
 
        Other = 0x7FFFFFFF,
    };
 
    enum class LITEFX_RENDERING_API QueueType {
        None = 0x00000000,
 
        Graphics = 0x00000001,
 
        Compute = 0x00000002,
 
        Transfer = 0x00000004,
 
        Other = 0x7FFFFFFF
    };
 
    enum class LITEFX_RENDERING_API QueuePriority {
        Normal = 33,
 
        High = 66,
 
        Realtime = 100
    };
 
    enum class LITEFX_RENDERING_API 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 LITEFX_RENDERING_API BufferFormat {
        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 LITEFX_RENDERING_API AttributeSemantic {
        Binormal = 0x00000001,
 
        BlendIndices = 0x00000002,
 
        BlendWeight = 0x00000003,
 
        Color = 0x00000004,
 
        Normal = 0x00000005,
 
        Position = 0x00000006,
 
        TransformedPosition = 0x00000007,
 
        PointSize = 0x00000008,
 
        Tangent = 0x00000009,
 
        TextureCoordinate = 0x0000000A,
 
        Unknown = 0x7FFFFFFF
    };
 
    enum class LITEFX_RENDERING_API DescriptorType {
        ConstantBuffer = 0x00000001,
 
        StructuredBuffer = 0x00000002,
 
        RWStructuredBuffer = 0x00000012,
 
        Texture = 0x00000003,
 
        RWTexture = 0x00000013,
        
        Sampler = 0x00000004,
 
        InputAttachment = 0x00000005,
 
        Buffer = 0x00000006,
 
        RWBuffer = 0x00000016,
 
        ByteAddressBuffer = 0x00000007,
 
        RWByteAddressBuffer = 0x00000017,
    };
 
    enum class LITEFX_RENDERING_API BufferType {
        Vertex = 0x00000001,
        
        Index = 0x00000002,
 
        Uniform = 0x00000003,
 
        Storage = 0x00000004,
 
        Texel = 0x00000005,
 
        Other = 0x7FFFFFFF
    };
 
    enum class LITEFX_RENDERING_API BufferUsage {
        Staging = 0x00000001,
 
        Resource = 0x00000002,
 
        Dynamic = 0x00000010,
 
        Readback = 0x00000100
    };
 
    enum class LITEFX_RENDERING_API IndexType {
        UInt16 = 0x00000010,
 
        UInt32 = 0x00000020
    };
 
    enum class LITEFX_RENDERING_API ShaderStage {
        Vertex = 0x00000001,
 
        TessellationControl = 0x00000002,
 
        TessellationEvaluation = 0x00000004,
 
        Geometry = 0x00000008,
 
        Fragment = 0x00000010,
 
        Compute = 0x00000020,
 
        Other = 0x7FFFFFFF
    };
 
    enum class LITEFX_RENDERING_API PolygonMode {
        Solid = 0x00000001,
 
        Wireframe = 0x00000002,
 
        Point = 0x00000004
    };
 
    enum class LITEFX_RENDERING_API CullMode {
        FrontFaces = 0x00000001,
 
        BackFaces = 0x00000002,
 
        Both = 0x00000004,
 
        Disabled = 0x0000000F
    };
 
    enum class LITEFX_RENDERING_API CullOrder {
        ClockWise = 0x00000001,
 
        CounterClockWise = 0x00000002
    };
 
    enum class LITEFX_RENDERING_API RenderTargetType {
        Color = 0x00000001,
 
        DepthStencil = 0x00000002,
 
        Present = 0x00000004
    };
 
    enum class LITEFX_RENDERING_API ImageDimensions {
        DIM_1 = 0x01,
 
        DIM_2 = 0x02,
 
        DIM_3 = 0x03,
 
        CUBE = 0x04
    };
 
    enum class LITEFX_RENDERING_API MultiSamplingLevel {
        x1 = 0x00000001,
 
        x2 = 0x00000002,
 
        x4 = 0x00000004,
 
        x8 = 0x00000008,
 
        x16 = 0x00000010,
 
        x32 = 0x00000020,
 
        x64 = 0x00000040
    };
 
    enum class LITEFX_RENDERING_API FilterMode {
        Nearest = 0x00000001,
 
        Linear = 0x00000002
    };
 
    enum class LITEFX_RENDERING_API MipMapMode {
        Nearest = 0x00000001,
 
        Linear = 0x00000002
    };
 
    enum class LITEFX_RENDERING_API BorderMode {
        Repeat = 0x00000001,
 
        RepeatMirrored = 0x00010001,
 
        ClampToEdge = 0x00000002,
 
        ClampToEdgeMirrored = 0x00010002,
 
        ClampToBorder = 0x00000003,
    };
 
    enum class LITEFX_RENDERING_API CompareOperation {
        Never = 0x00000000,
 
        Less = 0x00000001,
 
        Greater = 0x0000002,
 
        Equal = 0x00000003,
 
        LessEqual = 0x00000004,
 
        GreaterEqual = 0x00000005,
 
        NotEqual = 0x00000006,
 
        Always = 0x00000007
    };
 
    enum class LITEFX_RENDERING_API StencilOperation {
        Keep = 0x00000000,
        
        Zero = 0x00000001,
 
        Replace = 0x00000002,
 
        IncrementClamp = 0x00000003,
 
        DecrementClamp = 0x00000004,
 
        Invert = 0x00000005,
 
        IncrementWrap = 0x00000006,
 
        DecrementWrap = 0x00000007
    };
 
    enum class LITEFX_RENDERING_API 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 LITEFX_RENDERING_API WriteMask {
        R = 0x01,
 
        G = 0x02,
 
        B = 0x04,
 
        A = 0x08
    };
 
    enum class LITEFX_RENDERING_API BlendOperation {
        Add = 0x01,
        Subtract = 0x02,
        ReverseSubtract = 0x03,
        Minimum = 0x04,
        Maximum = 0x05
    };
 
    enum class LITEFX_RENDERING_API ResourceState {
        Common = 0x00000001,
 
        VertexBuffer = 0x00000002,
 
        IndexBuffer = 0x0000003,
 
        UniformBuffer = 0x00000004,
 
        ReadOnly = 0x00000005,
 
        GenericRead = 0x00000006,
 
        ReadWrite = 0x00000007,
 
        CopySource = 0x00000010,
 
        CopyDestination = 0x00000011,
 
        RenderTarget = 0x00000020,
 
        DepthRead = 0x00000021,
 
        DepthWrite = 0x00000022,
 
        Present = 0x00000023,
 
        ResolveSource = 0x00000024,
 
        ResolveDestination = 0x00000025,
 
        Undefined = 0x7FFFFFFF
    };
 
    // Define flags.
    LITEFX_DEFINE_FLAGS(QueueType);
    LITEFX_DEFINE_FLAGS(ShaderStage);
    LITEFX_DEFINE_FLAGS(BufferFormat);
    LITEFX_DEFINE_FLAGS(WriteMask);
 
    // Helper functions.
 
    inline UInt32 getBufferFormatChannels(const BufferFormat& format) {
        return static_cast<UInt32>(format) & 0x000000FF;
    }
 
    inline UInt32 getBufferFormatChannelSize(const BufferFormat& format) {
        return (static_cast<UInt32>(format) & 0xFF000000) >> 24;
    }
 
    inline UInt32 getBufferFormatType(const BufferFormat& format) {
        return (static_cast<UInt32>(format) & 0x0000FF00) >> 8;
    }
 
    size_t LITEFX_RENDERING_API getSize(const Format& format);
 
    bool LITEFX_RENDERING_API hasDepth(const Format& format);
 
    bool LITEFX_RENDERING_API hasStencil(const Format& format);
 
    class LITEFX_RENDERING_API IStateResource {
    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() noexcept;
 
    public:
        explicit StateResource(StringView name);
        StateResource(StateResource&&) = delete;
        StateResource(const StateResource&) = delete;
        virtual ~StateResource() noexcept;
 
    protected:
        String& name() noexcept;
 
    public:
        virtual const String& name() const noexcept override;
    };
 
    class LITEFX_RENDERING_API DeviceState {
        LITEFX_IMPLEMENTATION(DeviceStateImpl);
        friend class IGraphicsDevice;
 
    public:
        explicit DeviceState() noexcept;
        DeviceState(DeviceState&&) = delete;
        DeviceState(const DeviceState&) = delete;
        virtual ~DeviceState() noexcept;
 
    public:
        void clear();
 
        void add(UniquePtr<IRenderPass>&& renderPass);
 
        void add(const String& id, UniquePtr<IRenderPass>&& renderPass);
 
        void add(UniquePtr<IPipeline>&& pipeline);
 
        void add(const String& id, UniquePtr<IPipeline>&& pipeline);
 
        void add(UniquePtr<IBuffer>&& buffer);
 
        void add(const String& id, UniquePtr<IBuffer>&& buffer);
 
        void add(UniquePtr<IVertexBuffer>&& vertexBuffer);
 
        void add(const String& id, UniquePtr<IVertexBuffer>&& vertexBuffer);
 
        void add(UniquePtr<IIndexBuffer>&& indexBuffer);
 
        void add(const String& id, UniquePtr<IIndexBuffer>&& indexBuffer);
 
        void add(UniquePtr<IImage>&& image);
 
        void add(const String& id, UniquePtr<IImage>&& image);
 
        void add(UniquePtr<ISampler>&& sampler);
 
        void add(const String& id, UniquePtr<ISampler>&& sampler);
        
        void add(const String& id, UniquePtr<IDescriptorSet>&& descriptorSet);
 
        IRenderPass& renderPass(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;
 
        IDescriptorSet& descriptorSet(const String& id) const;
 
        bool release(const IRenderPass& renderPass);
 
        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:
        virtual ~IGraphicsAdapter() noexcept = default;
 
    public:
        virtual String name() const noexcept = 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 UInt32 driverVersion() const noexcept = 0;
 
        virtual UInt32 apiVersion() const noexcept = 0;
 
        virtual UInt64 dedicatedMemory() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API ISurface {
    public:
        virtual ~ISurface() noexcept = default;
    };
 
    class LITEFX_RENDERING_API IShaderModule {
    public:
        virtual ~IShaderModule() noexcept = default;
 
    public:
        virtual const ShaderStage& type() const noexcept = 0;
 
        virtual const String& fileName() const noexcept = 0;
 
        virtual const String& entryPoint() 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 WriteMask{ WriteMask::R | WriteMask::G | WriteMask::B | WriteMask::A };
        };
 
    public:
        virtual ~IRenderTarget() noexcept = default;
 
    public:
        virtual const String& name() const noexcept = 0;
 
        virtual const UInt32& location() const noexcept = 0;
 
        virtual const RenderTargetType& type() const noexcept = 0;
 
        virtual const Format& format() const noexcept = 0;
 
        virtual const bool& clearBuffer() const noexcept = 0;
 
        virtual const bool& clearStencil() const noexcept = 0;
 
        virtual const Vector4f& clearValues() const noexcept = 0;
 
        virtual const bool& isVolatile() const noexcept = 0;
 
        virtual const BlendState& blendState() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API RenderTarget : public IRenderTarget {
        LITEFX_IMPLEMENTATION(RenderTargetImpl);
 
    public:
        RenderTarget() noexcept;
 
        explicit RenderTarget(const UInt32& location, const RenderTargetType& type, const Format& format, const bool& clearBuffer, const Vector4f& clearValues = { 0.f , 0.f, 0.f, 0.f }, const bool& clearStencil = true, const bool& isVolatile = false, const BlendState& blendState = {});
 
        explicit RenderTarget(const String& name, const UInt32& location, const RenderTargetType& type, const Format& format, const bool& clearBuffer, const Vector4f& clearValues = { 0.f , 0.f, 0.f, 0.f }, const bool& clearStencil = true, const bool& isVolatile = false, const BlendState& blendState = {});
        RenderTarget(const RenderTarget&) noexcept;
        RenderTarget(RenderTarget&&) noexcept;
        virtual ~RenderTarget() noexcept;
 
    public:
        inline RenderTarget& operator=(const RenderTarget&) noexcept;
        inline RenderTarget& operator=(RenderTarget&&) noexcept;
 
    public:
        virtual const String& name() const noexcept override;
 
        virtual const UInt32& location() const noexcept override;
 
        virtual const RenderTargetType& type() const noexcept override;
 
        virtual const Format& format() const noexcept override;
 
        virtual const bool& clearBuffer() const noexcept override;
 
        virtual const bool& clearStencil() const noexcept override;
 
        virtual const Vector4f& clearValues() const noexcept override;
 
        virtual const bool& isVolatile() const noexcept override;
 
        virtual const BlendState& blendState() const noexcept override;
    };
 
    class LITEFX_RENDERING_API DepthStencilState {
        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 };
 
            Byte ReadMask{ 0xFF };
 
            StencilTest FrontFace{};
 
            StencilTest BackFace{};
        };
 
    public:
        explicit DepthStencilState(const DepthState& depthState, const DepthBias& depthBias, const StencilState& stencilState) noexcept;
 
        DepthStencilState() noexcept;
 
        DepthStencilState(const DepthStencilState&) noexcept;
 
        DepthStencilState(DepthStencilState&&) noexcept;
 
        virtual ~DepthStencilState() noexcept;
 
        DepthStencilState& operator=(const DepthStencilState&) noexcept;
 
        DepthStencilState& operator=(DepthStencilState&&) noexcept;
 
    public:
        virtual DepthState& depthState() const noexcept;
 
        virtual DepthBias& depthBias() const noexcept;
 
        virtual StencilState& stencilState() const noexcept;
    };
 
    class LITEFX_RENDERING_API IRasterizer {
    public:
        virtual ~IRasterizer() noexcept = default;
 
    public:
        virtual const PolygonMode& polygonMode() const noexcept = 0;
 
        virtual const CullMode& cullMode() const noexcept = 0;
 
        virtual const CullOrder& cullOrder() const noexcept = 0;
 
        virtual const Float& lineWidth() const noexcept = 0;
 
        virtual const DepthStencilState& depthStencilState() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API Rasterizer : public IRasterizer {
        LITEFX_IMPLEMENTATION(RasterizerImpl);
 
    public:
        explicit Rasterizer(const PolygonMode& polygonMode, const CullMode& cullMode, const CullOrder& cullOrder, const Float& lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) noexcept;
        Rasterizer(Rasterizer&&) noexcept;
        Rasterizer(const Rasterizer&) noexcept;
        virtual ~Rasterizer() noexcept;
 
    public:
        virtual const PolygonMode& polygonMode() const noexcept override;
 
        virtual const CullMode& cullMode() const noexcept override;
 
        virtual const CullOrder& cullOrder() const noexcept override;
 
        virtual const Float& lineWidth() const noexcept override;
 
        virtual 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 {
    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(const float& depth) const noexcept = 0;
 
        virtual float getMaxDepth() const noexcept = 0;
 
        virtual void setMaxDepth(const float& depth) const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API Viewport : public IViewport {
        LITEFX_IMPLEMENTATION(ViewportImpl);
 
    public:
        explicit Viewport(const RectF& clientRect = { }, const Float& minDepth = 0.f, const Float& maxDepth = 1.f);
 
        Viewport(Viewport&&) noexcept = delete;
        Viewport(const Viewport&) noexcept = delete;
        virtual ~Viewport() noexcept;
 
    public:
        virtual RectF getRectangle() const noexcept override;
 
        virtual void setRectangle(const RectF& rectangle) noexcept override;
 
        virtual Float getMinDepth() const noexcept override;
 
        virtual void setMinDepth(const Float& depth) const noexcept override;
 
        virtual Float getMaxDepth() const noexcept override;
 
        virtual void setMaxDepth(const Float& depth) const noexcept override;
    };
 
    class LITEFX_RENDERING_API IScissor {
    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 : public IScissor {
        LITEFX_IMPLEMENTATION(ScissorImpl);
 
    public:
        explicit Scissor(const RectF& scissorRect = { });
 
        Scissor(Scissor&&) noexcept = delete;
        Scissor(const Scissor&) noexcept = delete;
        virtual ~Scissor() noexcept;
 
    public:
        virtual RectF getRectangle() const noexcept override;
 
        virtual void setRectangle(const RectF& rectangle) noexcept override;
    };
 
    class LITEFX_RENDERING_API BufferAttribute {
        LITEFX_IMPLEMENTATION(BufferAttributeImpl);
 
    public:
        BufferAttribute();
 
        BufferAttribute(const UInt32& location, const UInt32& offset, const BufferFormat& format, const AttributeSemantic& semantic, const UInt32& semanticIndex = 0);
        BufferAttribute(BufferAttribute&&) noexcept;
        BufferAttribute(const BufferAttribute&);
        virtual ~BufferAttribute() noexcept;
 
    public:
        virtual const UInt32& location() const noexcept;
 
        virtual const BufferFormat& format() const noexcept;
 
        virtual const UInt32& offset() const noexcept;
 
        virtual const AttributeSemantic& semantic() const noexcept;
 
        virtual const UInt32& semanticIndex() const noexcept;
    };
 
    class LITEFX_RENDERING_API IBufferLayout {
    public:
        virtual ~IBufferLayout() noexcept = default;
 
    public:
        virtual size_t elementSize() const noexcept = 0;
 
        virtual const UInt32& binding() const noexcept = 0;
 
        virtual const BufferType& type() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IVertexBufferLayout : public IBufferLayout {
    public:
        virtual ~IVertexBufferLayout() noexcept = default;
 
    public:
        virtual Array<const BufferAttribute*> attributes() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IIndexBufferLayout : public IBufferLayout {
    public:
        virtual ~IIndexBufferLayout() noexcept = default;
 
    public:
        virtual const IndexType& indexType() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorLayout : public IBufferLayout {
    public:
        virtual ~IDescriptorLayout() noexcept = default;
 
    public:
        virtual const DescriptorType& descriptorType() const noexcept = 0;
 
        virtual const UInt32& descriptors() const noexcept = 0;
 
        virtual const ISampler* staticSampler() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IMappable {
    public:
        virtual ~IMappable() noexcept = default;
 
    public:
        virtual void map(const void* const data, const size_t& size, const UInt32& element = 0) = 0;
 
        virtual void map(Span<const void* const> data, const size_t& elementSize, const UInt32& firstElement = 0) = 0;
    };
 
    class LITEFX_RENDERING_API IDeviceMemory {
    public:
        virtual ~IDeviceMemory() noexcept = default;
 
    public:
        virtual const 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 const bool& writable() const noexcept = 0;
 
        virtual const ResourceState& state(const UInt32& subresource = 0) const = 0;
 
        virtual ResourceState& state(const UInt32& subresource = 0) = 0;
    };
 
    class LITEFX_RENDERING_API IBuffer : public virtual IDeviceMemory, public virtual IMappable, public virtual IStateResource {
    public:
        virtual ~IBuffer() noexcept = default;
 
    public:
        virtual const BufferType& type() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IImage : public virtual IDeviceMemory, public virtual IStateResource {
    public:
        virtual ~IImage() noexcept = default;
 
    public:
        virtual size_t size(const UInt32& level) const noexcept = 0;
 
        virtual Size3d extent(const UInt32& level = 0) const noexcept = 0;
 
        virtual const Format& format() const noexcept = 0;
 
        virtual const ImageDimensions& dimensions() const noexcept = 0;
 
        virtual const UInt32& levels() const noexcept = 0;
 
        virtual const UInt32& layers() const noexcept = 0;
 
        virtual const UInt32& planes() const noexcept = 0;
 
        virtual const MultiSamplingLevel& samples() const noexcept = 0;
 
        // TODO: getSampler() for combined samplers?
 
    public:
        inline virtual UInt32 subresourceId(const UInt32& level, const UInt32& layer, const UInt32& plane) const noexcept
        {
            return level + (layer * this->levels()) + (plane * this->levels() * this->layers());
        }
    };
 
    class LITEFX_RENDERING_API ISampler : public virtual IStateResource {
    public:
        virtual ~ISampler() noexcept = default;
 
    public:
        virtual const FilterMode& getMinifyingFilter() const noexcept = 0;
 
        virtual const FilterMode& getMagnifyingFilter() const noexcept = 0;
 
        virtual const BorderMode& getBorderModeU() const noexcept = 0;
 
        virtual const BorderMode& getBorderModeV() const noexcept = 0;
 
        virtual const BorderMode& getBorderModeW() const noexcept = 0;
 
        virtual const Float& getAnisotropy() const noexcept = 0;
 
        virtual const MipMapMode& getMipMapMode() const noexcept = 0;
 
        virtual const Float& getMipMapBias() const noexcept = 0;
 
        virtual const Float& getMaxLOD() const noexcept = 0;
 
        virtual const Float& getMinLOD() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IBarrier {
    public:
        virtual ~IBarrier() noexcept = default;
 
    public:
        void transition(IBuffer& buffer, const ResourceState& targetState) {
            this->doTransition(buffer, targetState);
        };
 
        void transition(IBuffer& buffer, const UInt32& element, const ResourceState& targetState) {
            this->doTransition(buffer, element, targetState);
        }
 
        void transition(IBuffer& buffer, const ResourceState& sourceState, const ResourceState& targetState) {
            this->doTransition(buffer, sourceState, targetState);
        }
 
        void transition(IBuffer& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) {
            this->doTransition(buffer, sourceState, element, targetState);
        }
 
        void transition(IImage& image, const ResourceState& targetState) {
            this->doTransition(image, targetState);
        }
 
        void transition(IImage& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) {
            this->doTransition(image, level, layer, plane, targetState);
        }
 
        void transition(IImage& image, const ResourceState& sourceState, const ResourceState& targetState) {
            this->doTransition(image, sourceState, targetState);
        }
 
        void transition(IImage& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) {
            this->doTransition(image, sourceState, level, layer, plane, targetState);
        }
 
        void waitFor(const IBuffer& buffer) {
            this->doWaitFor(buffer);
        }
 
        void waitFor(const IImage& image) {
            this->doWaitFor(image);
        }
 
    private:
        virtual void doTransition(IBuffer& buffer, const ResourceState& targetState) = 0;
        virtual void doTransition(IBuffer& buffer, const UInt32& element, const ResourceState& targetState) = 0;
        virtual void doTransition(IBuffer& buffer, const ResourceState& sourceState, const ResourceState& targetState) = 0;
        virtual void doTransition(IBuffer& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) = 0;
        virtual void doTransition(IImage& image, const ResourceState& targetState) = 0;
        virtual void doTransition(IImage& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) = 0;
        virtual void doTransition(IImage& image, const ResourceState& sourceState, const ResourceState& targetState) = 0;
        virtual void doTransition(IImage& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) = 0;
        virtual void doWaitFor(const IBuffer& buffer) = 0;
        virtual void doWaitFor(const IImage& image) = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorSet {
    public:
        virtual ~IDescriptorSet() noexcept = default;
 
    public:
        void update(const UInt32& binding, const IBuffer& buffer, const UInt32& bufferElement = 0, const UInt32& elements = 1, const UInt32& firstDescriptor = 0) const {
            this->doUpdate(binding, buffer, bufferElement, elements, firstDescriptor);
        }
 
        void update(const UInt32& binding, const IImage& texture, const UInt32& descriptor = 0, const UInt32& firstLevel = 0, const UInt32& levels = 0, const UInt32& firstLayer = 0, const UInt32& layers = 0) const {
            this->doUpdate(binding, texture, descriptor, firstLevel, levels, firstLayer, layers);
        }
 
        void update(const UInt32& binding, const ISampler& sampler, const UInt32& descriptor = 0) const {
            this->doUpdate(binding, sampler, descriptor);
        }
 
        void attach(const UInt32& binding, const IImage& image) const {
            this->doAttach(binding, image);
        }
 
    private:
        virtual void doUpdate(const UInt32& binding, const IBuffer& buffer, const UInt32& bufferElement, const UInt32& elements, const UInt32& firstDescriptor) const = 0;
        virtual void doUpdate(const UInt32& binding, const IImage& texture, const UInt32& descriptor, const UInt32& firstLevel, const UInt32& levels, const UInt32& firstLayer, const UInt32& layers) const = 0;
        virtual void doUpdate(const UInt32& binding, const ISampler& sampler, const UInt32& descriptor) const = 0;
        virtual void doAttach(const UInt32& binding, const IImage& image) const = 0;
    };
 
    class LITEFX_RENDERING_API IDescriptorSetLayout {
    public:
        virtual ~IDescriptorSetLayout() noexcept = default;
 
    public:
        Array<const IDescriptorLayout*> descriptors() const noexcept {
            return this->getDescriptors();
        }
 
        virtual const IDescriptorLayout& descriptor(const UInt32& binding) const = 0;
 
        virtual const UInt32& space() const noexcept = 0;
 
        virtual const 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:
        UniquePtr<IDescriptorSet> allocate(const UInt32& descriptors = 0) const {
            return this->getDescriptorSet(descriptors);
        }
 
        Array<UniquePtr<IDescriptorSet>> allocateMultiple(const UInt32& descriptorSets, const UInt32& descriptors = 0) const {
            return this->getDescriptorSets(descriptorSets, descriptors);
        }
 
        void free(const IDescriptorSet& descriptorSet) const noexcept {
            this->releaseDescriptorSet(descriptorSet);
        }
 
    private:
        virtual Array<const IDescriptorLayout*> getDescriptors() const noexcept = 0;
        virtual UniquePtr<IDescriptorSet> getDescriptorSet(const UInt32& descriptors) const = 0;
        virtual Array<UniquePtr<IDescriptorSet>> getDescriptorSets(const UInt32& descriptorSets, const UInt32& descriptors) const = 0;
        virtual void releaseDescriptorSet(const IDescriptorSet& descriptorSet) const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IPushConstantsRange {
    public:
        virtual ~IPushConstantsRange() noexcept = default;
 
    public:
        virtual const UInt32& space() const noexcept = 0;
 
        virtual const UInt32& binding() const noexcept = 0;
 
        virtual const UInt32& offset() const noexcept = 0;
 
        virtual const UInt32& size() const noexcept = 0;
 
        virtual const ShaderStage& stage() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IPushConstantsLayout {
    public:
        virtual ~IPushConstantsLayout() noexcept = default;
 
    public:
        virtual const UInt32& size() const noexcept = 0;
 
        virtual const IPushConstantsRange& range(const ShaderStage& stage) const = 0;
 
        Array<const IPushConstantsRange*> ranges() const noexcept {
            return this->getRanges();
        }
 
    private:
        virtual Array<const IPushConstantsRange*> getRanges() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IShaderProgram {
    public:
        virtual ~IShaderProgram() noexcept = default;
 
    public:
        Array<const IShaderModule*> modules() const noexcept {
            return this->getModules();
        }
 
        SharedPtr<IPipelineLayout> reflectPipelineLayout() const {
            return this->parsePipelineLayout();
        };
 
    private:
        virtual Array<const IShaderModule*> getModules() const noexcept = 0;
        virtual SharedPtr<IPipelineLayout> parsePipelineLayout() const = 0;
    };
 
    class LITEFX_RENDERING_API IPipelineLayout {
    public:
        virtual ~IPipelineLayout() noexcept = default;
 
    public:
        virtual const IDescriptorSetLayout& descriptorSet(const UInt32& space) const = 0;
 
        Array<const IDescriptorSetLayout*> descriptorSets() const noexcept {
            return this->getDescriptorSets();
        }
 
        virtual const IPushConstantsLayout* pushConstants() const noexcept = 0;
 
    private:
        virtual Array<const IDescriptorSetLayout*> getDescriptorSets() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IVertexBuffer : public virtual IBuffer {
    public:
        virtual ~IVertexBuffer() noexcept = default;
 
    public:
        virtual const IVertexBufferLayout& layout() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IIndexBuffer : public virtual IBuffer {
    public:
        virtual ~IIndexBuffer() noexcept = default;
 
    public:
        virtual const IIndexBufferLayout& layout() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IInputAssembler {
    public:
        virtual ~IInputAssembler() noexcept = default;
 
    public:
        Array<const IVertexBufferLayout*> vertexBufferLayouts() const noexcept {
            return this->getVertexBufferLayouts();
        }
 
        virtual const IVertexBufferLayout& vertexBufferLayout(const UInt32& binding) const = 0;
 
        virtual const IIndexBufferLayout& indexBufferLayout() const = 0;
 
        virtual const PrimitiveTopology& topology() const noexcept = 0;
 
    private:
        virtual Array<const IVertexBufferLayout*> getVertexBufferLayouts() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IPipeline : public virtual IStateResource {
    public:
        virtual ~IPipeline() noexcept = default;
 
    public:
        SharedPtr<const IShaderProgram> program() const noexcept {
            return this->getProgram();
        }
 
        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:
        virtual ~ICommandBuffer() noexcept = default;
 
    public:
        virtual void begin() const = 0;
 
        virtual void end() const = 0;
 
    public:
        void barrier(const IBarrier& barrier, const bool& invert = false) const noexcept {
            this->cmdBarrier(barrier, invert);
        }
 
        void generateMipMaps(IImage& image) noexcept {
            this->cmdGenerateMipMaps(image);
        }
 
        void transfer(const IBuffer& source, const IBuffer& target, const UInt32& sourceElement = 0, const UInt32& targetElement = 0, const UInt32& elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, targetElement, elements);
        }
 
        void transfer(const IBuffer& source, const IImage& target, const UInt32& sourceElement = 0, const UInt32& firstSubresource = 0, const UInt32& elements = 1) const {
            this->cmdTransfer(source, target, sourceElement, firstSubresource, elements);
        }
 
        void transfer(const IImage& source, const IImage& target, const UInt32& sourceSubresource = 0, const UInt32& targetSubresource = 0, const UInt32& subresources = 1) const {
            this->cmdTransfer(source, target, sourceSubresource, targetSubresource, subresources);
        }
 
        void transfer(const IImage& source, const IBuffer& target, const UInt32& firstSubresource = 0, const UInt32& targetElement = 0, const UInt32& subresources = 1) const {
            this->cmdTransfer(source, target, firstSubresource, targetElement, subresources);
        }
 
        void use(const IPipeline& pipeline) const noexcept {
            this->cmdUse(pipeline);
        }
 
        // TODO: Allow bind to last used pipeline (throw, if no pipeline is in use.
        //void bind(const IDescriptorSet& descriptorSet) const;
 
        void bind(const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const noexcept {
            this->cmdBind(descriptorSet, pipeline);
        }
 
        void bind(const IVertexBuffer& buffer) const noexcept {
            this->cmdBind(buffer);
        }
 
        void bind(const IIndexBuffer& buffer) const noexcept {
            this->cmdBind(buffer);
        }
 
        virtual void dispatch(const Vector3u& threadCount) const noexcept = 0;
 
        virtual void draw(const UInt32& vertices, const UInt32& instances = 1, const UInt32& firstVertex = 0, const UInt32& firstInstance = 0) const noexcept = 0;
 
        virtual void drawIndexed(const UInt32& indices, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const noexcept = 0;
 
        void pushConstants(const IPushConstantsLayout& layout, const void* const memory) const noexcept {
            this->cmdPushConstants(layout, memory);
        }
 
        void draw(const IVertexBuffer& vertexBuffer, const UInt32& instances = 1, const UInt32& firstVertex = 0, const UInt32& firstInstance = 0) const {
            this->cmdDraw(vertexBuffer, instances, firstVertex, firstInstance);
        }
 
        void drawIndexed(const IIndexBuffer& indexBuffer, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const {
            this->cmdDrawIndexed(indexBuffer, instances, firstIndex, vertexOffset, firstInstance);
        }
 
        void drawIndexed(const IVertexBuffer& vertexBuffer, const IIndexBuffer& indexBuffer, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const {
            this->cmdDrawIndexed(vertexBuffer, indexBuffer, instances, firstIndex, vertexOffset, firstInstance);
        }
 
    private:
        virtual void cmdBarrier(const IBarrier& barrier, const bool& invert) const noexcept = 0;
        virtual void cmdGenerateMipMaps(IImage& image) noexcept = 0;
        virtual void cmdTransfer(const IBuffer& source, const IBuffer& target, const UInt32& sourceElement, const UInt32& targetElement, const UInt32& elements) const = 0;
        virtual void cmdTransfer(const IBuffer& source, const IImage& target, const UInt32& sourceElement, const UInt32& firstSubresource, const UInt32& elements) const = 0;
        virtual void cmdTransfer(const IImage& source, const IImage& target, const UInt32& sourceSubresource, const UInt32& targetSubresource, const UInt32& subresources) const = 0;
        virtual void cmdTransfer(const IImage& source, const IBuffer& target, const UInt32& firstSubresource, const UInt32& targetElement, const UInt32& subresources) const = 0;
        virtual void cmdUse(const IPipeline& pipeline) const noexcept = 0;
        virtual void cmdBind(const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const noexcept = 0;
        virtual void cmdBind(const IVertexBuffer& buffer) const noexcept = 0;
        virtual void cmdBind(const IIndexBuffer& buffer) const noexcept = 0;
        virtual void cmdPushConstants(const IPushConstantsLayout& layout, const void* const memory) const noexcept = 0;
        virtual void cmdDraw(const IVertexBuffer& vertexBuffer, const UInt32& instances, const UInt32& firstVertex, const UInt32& firstInstance) const = 0;
        virtual void cmdDrawIndexed(const IIndexBuffer& indexBuffer, const UInt32& instances, const UInt32& firstIndex, const Int32& vertexOffset, const UInt32& firstInstance) const = 0;
        virtual void cmdDrawIndexed(const IVertexBuffer& vertexBuffer, const IIndexBuffer& indexBuffer, const UInt32& instances, const UInt32& firstIndex, const Int32& vertexOffset, const UInt32& firstInstance) const = 0;
    };
 
    class LITEFX_RENDERING_API IRenderPipeline : public virtual IPipeline {
    public:
        virtual ~IRenderPipeline() noexcept = default;
 
    public:
        SharedPtr<IInputAssembler> inputAssembler() const noexcept {
            return this->getInputAssembler();
        }
 
        SharedPtr<IRasterizer> rasterizer() const noexcept {
            return this->getRasterizer();
        }
 
        virtual Array<const IViewport*> viewports() const noexcept = 0;
 
        virtual Array<const IScissor*> scissors() const noexcept = 0;
 
        virtual UInt32& stencilRef() const noexcept = 0;
 
        virtual Vector4f& blendFactors() const noexcept = 0;
 
        virtual const bool& alphaToCoverage() const noexcept = 0;
 
    private:
        virtual SharedPtr<IInputAssembler> getInputAssembler() const noexcept = 0;
        virtual SharedPtr<IRasterizer> getRasterizer() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IComputePipeline : public virtual IPipeline {
    public:
        virtual ~IComputePipeline() noexcept = default;
    };
 
    class LITEFX_RENDERING_API IFrameBuffer {
    public:
        virtual ~IFrameBuffer() noexcept = default;
 
    public:
        virtual const UInt32& bufferIndex() const noexcept = 0;
 
        virtual const Size2d& size() const noexcept = 0;
 
        virtual size_t getWidth() const noexcept = 0;
 
        virtual size_t getHeight() const noexcept = 0;
 
        Array<const ICommandBuffer*> commandBuffers() const noexcept {
            return this->getCommandBuffers();
        }
 
        virtual const ICommandBuffer& commandBuffer(const UInt32& index) const = 0;
 
        Array<const IImage*> images() const noexcept {
            return this->getImages();
        }
 
        virtual const IImage& image(const UInt32& location) const = 0;
 
    public:
        virtual void resize(const Size2d& renderArea) = 0;
 
    private:
        virtual Array<const ICommandBuffer*> getCommandBuffers() const noexcept = 0;
        virtual Array<const IImage*> getImages() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IRenderPass : public virtual IStateResource {
    public:
        virtual ~IRenderPass() noexcept = default;
 
    public:
        virtual const IFrameBuffer& activeFrameBuffer() const = 0;
 
        Array<const IFrameBuffer*> frameBuffers() const noexcept {
            return this->getFrameBuffers();
        }
 
        Array<const IRenderPipeline*> pipelines() const noexcept {
            return this->getPipelines();
        }
 
        virtual const RenderTarget& renderTarget(const UInt32& location) const = 0;
 
        virtual Span<const RenderTarget> renderTargets() const noexcept = 0;
 
        virtual bool hasPresentTarget() const noexcept = 0;
 
        //virtual Span<const IInputAttachmentMapping> inputAttachments() const noexcept = 0;
 
        virtual const MultiSamplingLevel& multiSamplingLevel() const noexcept = 0;
 
    public:
        virtual void begin(const UInt32& buffer) = 0;
 
        virtual void end() const = 0;
 
        virtual void resizeFrameBuffers(const Size2d& renderArea) = 0;
 
        virtual void changeMultiSamplingLevel(const MultiSamplingLevel& samples) = 0;
 
        void updateAttachments(const IDescriptorSet& descriptorSet) const {
            this->setAttachments(descriptorSet);
        }
 
    private:
        virtual Array<const IFrameBuffer*> getFrameBuffers() const noexcept = 0;
        virtual Array<const IRenderPipeline*> getPipelines() const noexcept = 0;
        virtual void setAttachments(const IDescriptorSet& descriptorSet) const = 0;
    };
 
    class LITEFX_RENDERING_API ISwapChain {
    public:
        virtual ~ISwapChain() noexcept = default;
 
    public:
        virtual const Format& surfaceFormat() const noexcept = 0;
 
        virtual const UInt32& buffers() const noexcept = 0;
 
        virtual const Size2d& renderArea() const noexcept = 0;
 
        Array<const IImage*> images() const noexcept {
            return this->getImages();
        };
 
        virtual void present(const IFrameBuffer& frameBuffer) const = 0;
 
    public:
        virtual Array<Format> getSurfaceFormats() const noexcept = 0;
 
        virtual void reset(const Format& surfaceFormat, const Size2d& renderArea, const UInt32& buffers) = 0;
 
        [[nodiscard]] virtual UInt32 swapBackBuffer() const = 0;
 
    private:
        virtual Array<const IImage*> getImages() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API ICommandQueue {
    public:
        virtual ~ICommandQueue() noexcept = default;
 
    public:
        virtual bool isBound() const noexcept = 0;
 
        virtual const QueuePriority& priority() const noexcept = 0;
 
        virtual const QueueType& type() const noexcept = 0;
 
    public:
        virtual void bind() = 0;
 
        virtual void release() = 0;
 
        UniquePtr<ICommandBuffer> createCommandBuffer(const bool& beginRecording = false) const {
            return this->getCommandBuffer(beginRecording);
        }
 
        UInt64 submit(const ICommandBuffer& commandBuffer) const {
            return this->submitCommandBuffer(commandBuffer);
        }
 
        UInt64 submit(const Array<const ICommandBuffer*>& commandBuffers) const {
            return this->submitCommandBuffers(commandBuffers);
        }
 
        virtual void waitFor(const UInt64& fence) const noexcept = 0;
 
        virtual UInt64 currentFence() const noexcept = 0;
 
    private:
        virtual UniquePtr<ICommandBuffer> getCommandBuffer(const bool& beginRecording) const = 0;
        virtual UInt64 submitCommandBuffer(const ICommandBuffer& commandBuffer) const = 0;
        virtual UInt64 submitCommandBuffers(const Array<const ICommandBuffer*>& commandBuffers) const = 0;
    };
 
    class LITEFX_RENDERING_API IGraphicsFactory {
    public:
        virtual ~IGraphicsFactory() noexcept = default;
 
    public:
        UniquePtr<IBuffer> createBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const {
            return this->getBuffer(type, usage, elementSize, elements, allowWrite);
        };
 
        UniquePtr<IBuffer> createBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const {
            return this->getBuffer(name, type, usage, elementSize, elements, allowWrite);
        };
 
        UniquePtr<IVertexBuffer> createVertexBuffer(const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const {
            return this->getVertexBuffer(layout, usage, elements);
        }
 
        UniquePtr<IVertexBuffer> createVertexBuffer(const String& name, const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const {
            return this->getVertexBuffer(name, layout, usage, elements);
        }
 
        UniquePtr<IIndexBuffer> createIndexBuffer(const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const {
            return this->getIndexBuffer(layout, usage, elements);
        }
 
        UniquePtr<IIndexBuffer> createIndexBuffer(const String& name, const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const {
            return this->getIndexBuffer(name, layout, usage, elements);
        }
 
        UniquePtr<IImage> createAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const {
            return this->getAttachment(format, size, samples);
        }
 
        UniquePtr<IImage> createAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const {
            return this->getAttachment(name, format, size, samples);
        }
 
        UniquePtr<IImage> createTexture(const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const {
            return this->getTexture(format, size, dimension, levels, layers, samples, allowWrite);
        }
 
        UniquePtr<IImage> createTexture(const String& name, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const {
            return this->getTexture(name, format, size, dimension, levels, layers, samples, allowWrite);
        }
 
        Array<UniquePtr<IImage>> createTextures(const UInt32& elements, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& layers = 1, const UInt32& levels = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const {
            return this->getTextures(elements, format, size, dimension, layers, levels, samples, allowWrite);
        }
 
        UniquePtr<ISampler> createSampler(const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const {
            return this->getSampler(magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        UniquePtr<ISampler> createSampler(const String& name, const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const {
            return this->getSampler(name, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        Array<UniquePtr<ISampler>> createSamplers(const UInt32& elements, const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const {
            return this->getSamplers(elements, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
    private:
        virtual UniquePtr<IBuffer> getBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements, const bool& allowWrite) const = 0;
        virtual UniquePtr<IBuffer> getBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements, const bool& allowWrite) const = 0;
        virtual UniquePtr<IVertexBuffer> getVertexBuffer(const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
        virtual UniquePtr<IVertexBuffer> getVertexBuffer(const String& name, const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
        virtual UniquePtr<IIndexBuffer> getIndexBuffer(const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
        virtual UniquePtr<IIndexBuffer> getIndexBuffer(const String& name, const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
        virtual UniquePtr<IImage> getAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples) const = 0;
        virtual UniquePtr<IImage> getAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples) const = 0;
        virtual UniquePtr<IImage> getTexture(const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& levels, const UInt32& layers, const MultiSamplingLevel& samples, const bool& allowWrite) const = 0;
        virtual UniquePtr<IImage> getTexture(const String& name, const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& levels, const UInt32& layers, const MultiSamplingLevel& samples, const bool& allowWrite) const = 0;
        virtual Array<UniquePtr<IImage>> getTextures(const UInt32& elements, const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& layers, const UInt32& levels, const MultiSamplingLevel& samples, const bool& allowWrite) const = 0;
        virtual UniquePtr<ISampler> getSampler(const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const = 0;
        virtual UniquePtr<ISampler> getSampler(const String& name, const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const = 0;
        virtual Array<UniquePtr<ISampler>> getSamplers(const UInt32& elements, const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const = 0;
    };
 
    class LITEFX_RENDERING_API IGraphicsDevice {
    public:
        virtual ~IGraphicsDevice() noexcept = 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;
 
        virtual const ICommandQueue& graphicsQueue() const noexcept = 0;
 
        virtual const ICommandQueue& transferQueue() const noexcept = 0;
 
        virtual const ICommandQueue& bufferQueue() const noexcept = 0;
 
        virtual const ICommandQueue& computeQueue() const noexcept = 0;
 
        UniquePtr<IBarrier> makeBarrier() const noexcept {
            return this->getNewBarrier();
        }
 
        virtual MultiSamplingLevel maximumMultiSamplingLevel(const Format& format) const noexcept = 0;
 
    public:
        virtual void wait() const = 0;
 
    private:
        virtual UniquePtr<IBarrier> getNewBarrier() const noexcept = 0;
    };
 
    class LITEFX_RENDERING_API IRenderBackend : public IBackend {
    public:
        virtual ~IRenderBackend() noexcept = default;
 
    public:
        Array<const IGraphicsAdapter*> listAdapters() const {
            return this->getAdapters();
        }
 
        virtual const IGraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const = 0;
 
        virtual IGraphicsDevice* device(const String& name) noexcept = 0;
 
        virtual const IGraphicsDevice* device(const String& name) const noexcept = 0;
 
        virtual const IGraphicsDevice* operator[](const String& name) const noexcept {
            return this->device(name);
        };
 
        virtual IGraphicsDevice* operator[](const String& name) noexcept {
            return this->device(name);
        };
 
    private:
        virtual Array<const IGraphicsAdapter*> getAdapters() const = 0;
    };
}