vulkan.hpp

#pragma once
 
#include <litefx/rendering.hpp>
 
#include "vulkan_api.hpp"
#include "vulkan_formatters.hpp"
 
#pragma warning(push)
#pragma warning(disable:4250) // Base class members are inherited via dominance.
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;

    class LITEFX_VULKAN_API VulkanVertexBufferLayout final : public IVertexBufferLayout {
        LITEFX_IMPLEMENTATION(VulkanVertexBufferLayoutImpl);
        LITEFX_BUILDER(VulkanVertexBufferLayoutBuilder);
        friend struct SharedObject::Allocator<VulkanVertexBufferLayout>;
 
    private:
        explicit VulkanVertexBufferLayout(size_t vertexSize, UInt32 binding = 0, VertexBufferInputRate inputRate = VertexBufferInputRate::Vertex);

        explicit VulkanVertexBufferLayout(size_t vertexSize, const Enumerable<BufferAttribute>& attributes, UInt32 binding = 0, VertexBufferInputRate inputRate = VertexBufferInputRate::Vertex);
 
    private:
        VulkanVertexBufferLayout(VulkanVertexBufferLayout&&) noexcept = delete;

        VulkanVertexBufferLayout(const VulkanVertexBufferLayout&);

        VulkanVertexBufferLayout& operator=(VulkanVertexBufferLayout&&) noexcept = delete;

        VulkanVertexBufferLayout& operator=(const VulkanVertexBufferLayout&) = delete;
 
    public:
        ~VulkanVertexBufferLayout() noexcept override;
 
    public:
        static inline auto create(size_t vertexSize, UInt32 binding = 0, VertexBufferInputRate inputRate = VertexBufferInputRate::Vertex) {
            return SharedObject::create<VulkanVertexBufferLayout>(vertexSize, binding, inputRate);
        }

        static inline auto create(size_t vertexSize, const Enumerable<BufferAttribute>& attributes, UInt32 binding = 0, VertexBufferInputRate inputRate = VertexBufferInputRate::Vertex) {
            return SharedObject::create<VulkanVertexBufferLayout>(vertexSize, attributes, binding, inputRate);
        }

        static inline auto create(const VulkanVertexBufferLayout& other) {
            return SharedObject::create<VulkanVertexBufferLayout>(other);
        }
 
        // IVertexBufferLayout interface.
    public:
        const Array<BufferAttribute>& attributes() const override;

        VertexBufferInputRate inputRate() const noexcept override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;

        UInt32 binding() const noexcept override;

        BufferType type() const noexcept override;
    };

    class LITEFX_VULKAN_API VulkanIndexBufferLayout final : public IIndexBufferLayout {
        LITEFX_IMPLEMENTATION(VulkanIndexBufferLayoutImpl);
        friend struct SharedObject::Allocator<VulkanIndexBufferLayout>;
 
    private:
        explicit VulkanIndexBufferLayout(IndexType type);
 
    private:
        VulkanIndexBufferLayout(VulkanIndexBufferLayout&&) noexcept = delete;

        VulkanIndexBufferLayout(const VulkanIndexBufferLayout&);

        VulkanIndexBufferLayout& operator=(VulkanIndexBufferLayout&&) noexcept = delete;

        VulkanIndexBufferLayout& operator=(const VulkanIndexBufferLayout&) = delete;
 
    public:
        ~VulkanIndexBufferLayout() noexcept override;
 
    public:
        static inline auto create(IndexType type) {
            return SharedObject::create<VulkanIndexBufferLayout>(type);
        }

        static inline auto create(const VulkanIndexBufferLayout& other) {
            return SharedObject::create<VulkanIndexBufferLayout>(other);
        }
 
        // IIndexBufferLayout interface.
    public:
        IndexType indexType() const noexcept override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;

        UInt32 binding() const noexcept override;

        BufferType type() const noexcept override;
    };

    class LITEFX_VULKAN_API IVulkanBuffer : public virtual IBuffer, public virtual IResource<VkBuffer> {
    protected:
        IVulkanBuffer() noexcept = default;
        IVulkanBuffer(IVulkanBuffer&&) noexcept = default;
        IVulkanBuffer(const IVulkanBuffer&) = delete;
        IVulkanBuffer& operator=(IVulkanBuffer&&) noexcept = default;
        IVulkanBuffer& operator=(const IVulkanBuffer&) = delete;
 
    public:
        ~IVulkanBuffer() noexcept override = default;
    };

    class LITEFX_VULKAN_API IVulkanVertexBuffer : public virtual VertexBuffer<VulkanVertexBufferLayout>, public virtual IVulkanBuffer {
    protected:
        IVulkanVertexBuffer() noexcept = default;
        IVulkanVertexBuffer(IVulkanVertexBuffer&&) noexcept = default;
        IVulkanVertexBuffer(const IVulkanVertexBuffer&) = delete;
        IVulkanVertexBuffer& operator=(IVulkanVertexBuffer&&) noexcept = default;
        IVulkanVertexBuffer& operator=(const IVulkanVertexBuffer&) = delete;
 
    public:
        ~IVulkanVertexBuffer() noexcept override = default;
    };

    class LITEFX_VULKAN_API IVulkanIndexBuffer : public virtual IndexBuffer<VulkanIndexBufferLayout>, public virtual IVulkanBuffer {
    protected:
        IVulkanIndexBuffer() noexcept = default;
        IVulkanIndexBuffer(IVulkanIndexBuffer&&) noexcept = default;
        IVulkanIndexBuffer(const IVulkanIndexBuffer&) = delete;
        IVulkanIndexBuffer& operator=(IVulkanIndexBuffer&&) noexcept = default;
        IVulkanIndexBuffer& operator=(const IVulkanIndexBuffer&) = delete;
 
    public:
        ~IVulkanIndexBuffer() noexcept override = default;
    };

    class LITEFX_VULKAN_API IVulkanImage : public virtual IImage, public virtual IResource<VkImage> {
    protected:
        IVulkanImage() noexcept = default;
        IVulkanImage(IVulkanImage&&) noexcept = default;
        IVulkanImage(const IVulkanImage&) = delete;
        IVulkanImage& operator=(IVulkanImage&&) noexcept = default;
        IVulkanImage& operator=(const IVulkanImage&) = delete;
 
    public:
        ~IVulkanImage() noexcept override = default;
 
    public:
        virtual VkImageAspectFlags aspectMask() const noexcept = 0;

        virtual VkImageAspectFlags aspectMask(UInt32 plane) const = 0;
    };

    class LITEFX_VULKAN_API IVulkanSampler : public virtual ISampler, public virtual IResource<VkSampler> {
    protected:
        IVulkanSampler() noexcept = default;
        IVulkanSampler(IVulkanSampler&&) noexcept = default;
        IVulkanSampler(const IVulkanSampler&) = delete;
        IVulkanSampler& operator=(IVulkanSampler&&) noexcept = default;
        IVulkanSampler& operator=(const IVulkanSampler&) = delete;
 
    public:
        ~IVulkanSampler() noexcept override = default;
    };

    class LITEFX_VULKAN_API IVulkanAccelerationStructure : public virtual IAccelerationStructure, public virtual IResource<VkAccelerationStructureKHR> {
    protected:
        IVulkanAccelerationStructure() noexcept = default;
        IVulkanAccelerationStructure(IVulkanAccelerationStructure&&) noexcept = default;
        IVulkanAccelerationStructure(const IVulkanAccelerationStructure&) = delete;
        IVulkanAccelerationStructure& operator=(IVulkanAccelerationStructure&&) noexcept = default;
        IVulkanAccelerationStructure& operator=(const IVulkanAccelerationStructure&) = delete;
 
    public:
        ~IVulkanAccelerationStructure() noexcept override = default;
    };

    class LITEFX_VULKAN_API VulkanBottomLevelAccelerationStructure final : public IBottomLevelAccelerationStructure, public virtual IVulkanAccelerationStructure, public virtual StateResource, public virtual Resource<VkAccelerationStructureKHR> {
        LITEFX_IMPLEMENTATION(VulkanBottomLevelAccelerationStructureImpl);
        friend class VulkanDevice;
        friend class VulkanCommandBuffer;
 
        using IAccelerationStructure::build;
        using IAccelerationStructure::update;
        using IBottomLevelAccelerationStructure::copy;
 
    public:
        explicit VulkanBottomLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None, StringView name = "");

        VulkanBottomLevelAccelerationStructure(VulkanBottomLevelAccelerationStructure&&) noexcept;

        VulkanBottomLevelAccelerationStructure(const VulkanBottomLevelAccelerationStructure&) = delete;

        VulkanBottomLevelAccelerationStructure& operator=(VulkanBottomLevelAccelerationStructure&&) noexcept;

        VulkanBottomLevelAccelerationStructure& operator=(const VulkanBottomLevelAccelerationStructure&) = delete;
        
        ~VulkanBottomLevelAccelerationStructure() noexcept override;
 
        // IAccelerationStructure interface.
    public:
        AccelerationStructureFlags flags() const noexcept override;

        SharedPtr<const IVulkanBuffer> buffer() const noexcept;

        void build(const VulkanCommandBuffer& commandBuffer, const SharedPtr<const IVulkanBuffer>& scratchBuffer = nullptr, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);

        void update(const VulkanCommandBuffer& commandBuffer, const SharedPtr<const IVulkanBuffer>& scratchBuffer = nullptr, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);

        void copy(const VulkanCommandBuffer& commandBuffer, VulkanBottomLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const;

        UInt64 offset() const noexcept override;

        UInt64 size() const noexcept override;
 
        // IBottomLevelAccelerationStructure interface.
    public:
        const Array<TriangleMesh>& triangleMeshes() const noexcept override;

        void addTriangleMesh(const TriangleMesh& mesh) override;

        const Array<BoundingBoxes>& boundingBoxes() const noexcept override;

        void addBoundingBox(const BoundingBoxes& aabb) override;

        void clear() noexcept override;

        bool remove(const TriangleMesh& mesh) noexcept override;

        bool remove(const BoundingBoxes& aabb) noexcept override;
 
    private:
        Array<std::pair<UInt32, VkAccelerationStructureGeometryKHR>> buildInfo() const;
        void updateState(const VulkanDevice* device, VkAccelerationStructureKHR handle) noexcept;
 
    private:
        SharedPtr<const IBuffer> getBuffer() const noexcept override;
        void doBuild(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doUpdate(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doCopy(const ICommandBuffer& commandBuffer, IBottomLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const override;
    };

    class LITEFX_VULKAN_API VulkanTopLevelAccelerationStructure final : public ITopLevelAccelerationStructure, public virtual IVulkanAccelerationStructure, public virtual StateResource, public virtual Resource<VkAccelerationStructureKHR> {
        LITEFX_IMPLEMENTATION(VulkanTopLevelAccelerationStructureImpl);
        friend class VulkanDevice;
        friend class VulkanCommandBuffer;
 
        using IAccelerationStructure::build;
        using IAccelerationStructure::update;
        using ITopLevelAccelerationStructure::copy;
 
    public:
        explicit VulkanTopLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None, StringView name = "");

        VulkanTopLevelAccelerationStructure(VulkanTopLevelAccelerationStructure&&) noexcept;

        VulkanTopLevelAccelerationStructure(const VulkanTopLevelAccelerationStructure&) = delete;

        VulkanTopLevelAccelerationStructure& operator=(VulkanTopLevelAccelerationStructure&&) noexcept;

        VulkanTopLevelAccelerationStructure& operator=(const VulkanTopLevelAccelerationStructure&) = delete;

        ~VulkanTopLevelAccelerationStructure() noexcept override;
 
        // IAccelerationStructure interface.
    public:
        AccelerationStructureFlags flags() const noexcept override;

        SharedPtr<const IVulkanBuffer> buffer() const noexcept;

        void build(const VulkanCommandBuffer& commandBuffer, const SharedPtr<const IVulkanBuffer>& scratchBuffer = nullptr, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);

        void update(const VulkanCommandBuffer& commandBuffer, const SharedPtr<const IVulkanBuffer>& scratchBuffer = nullptr, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);

        void copy(const VulkanCommandBuffer& commandBuffer, VulkanTopLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IVulkanBuffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const;

        UInt64 offset() const noexcept override;

        UInt64 size() const noexcept override;
 
        // ITopLevelAccelerationStructure interface.
    public:
        const Array<Instance>& instances() const noexcept override;

        void addInstance(const Instance& instance) override;

        void clear() noexcept override;

        bool remove(const Instance& mesh) noexcept override;
 
    private:
        Array<VkAccelerationStructureInstanceKHR> buildInfo() const;
        void updateState(const VulkanDevice* device, VkAccelerationStructureKHR handle) noexcept;
 
    private:
        SharedPtr<const IBuffer> getBuffer() const noexcept override;
        void doBuild(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doUpdate(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doCopy(const ICommandBuffer& commandBuffer, ITopLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const override;
    };

    class LITEFX_VULKAN_API VulkanBarrier final : public Barrier<IVulkanBuffer, IVulkanImage> {
        LITEFX_IMPLEMENTATION(VulkanBarrierImpl);
        LITEFX_BUILDER(VulkanBarrierBuilder);
 
    public:
        using base_type = Barrier<IVulkanBuffer, IVulkanImage>;
        using base_type::transition;
 
    public:
        explicit VulkanBarrier(PipelineStage syncBefore, PipelineStage syncAfter) noexcept;

        VulkanBarrier(VulkanBarrier&&) noexcept;

        VulkanBarrier(const VulkanBarrier&);

        VulkanBarrier& operator=(VulkanBarrier&&) noexcept;

        VulkanBarrier& operator=(const VulkanBarrier&);

        ~VulkanBarrier() noexcept override;
 
    private:
        explicit VulkanBarrier() noexcept;
        PipelineStage& syncBefore() noexcept;
        PipelineStage& syncAfter() noexcept;
 
        // Barrier interface.
    public:
        PipelineStage syncBefore() const noexcept override;

        PipelineStage syncAfter() const noexcept override;

        void wait(ResourceAccess accessBefore, ResourceAccess accessAfter) override;

        void transition(const IVulkanBuffer& buffer, ResourceAccess accessBefore, ResourceAccess accessAfter) override;

        void transition(const IVulkanBuffer& buffer, UInt32 element, ResourceAccess accessBefore, ResourceAccess accessAfter) override;

        void transition(const IVulkanImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) override;

        void transition(const IVulkanImage& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) override;

        void transition(const IVulkanImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) override;

        void transition(const IVulkanImage& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) override;
 
    public:
        void execute(const VulkanCommandBuffer& commandBuffer) const;
    };

    class LITEFX_VULKAN_API VulkanShaderModule final : public IShaderModule, public Resource<VkShaderModule> {
        LITEFX_IMPLEMENTATION(VulkanShaderModuleImpl);
 
    public:
        explicit VulkanShaderModule(const VulkanDevice& device, ShaderStage type, const String& fileName, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt);

        explicit VulkanShaderModule(const VulkanDevice& device, ShaderStage type, std::istream& stream, const String& name, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt);

        VulkanShaderModule(VulkanShaderModule&&) noexcept;

        VulkanShaderModule(const VulkanShaderModule&) = delete;

        VulkanShaderModule& operator=(VulkanShaderModule&&) noexcept;

        VulkanShaderModule& operator=(const VulkanShaderModule&) = delete;

        ~VulkanShaderModule() noexcept override;
 
        // ShaderModule interface.
    public:
        const String& fileName() const noexcept override;

        const String& entryPoint() const noexcept override;

        ShaderStage type() const noexcept override;

        const Optional<DescriptorBindingPoint>& shaderLocalDescriptor() const noexcept override;
 
    public:
        virtual const Array<UInt32>& bytecode() const noexcept;

        virtual VkPipelineShaderStageCreateInfo shaderStageDefinition() const;
    };

    class LITEFX_VULKAN_API VulkanShaderProgram final : public ShaderProgram<VulkanShaderModule> {
        LITEFX_IMPLEMENTATION(VulkanShaderProgramImpl);
        LITEFX_BUILDER(VulkanShaderProgramBuilder);
        friend struct SharedObject::Allocator<VulkanShaderProgram>;
 
    private:
        explicit VulkanShaderProgram(const VulkanDevice& device, Enumerable<UniquePtr<VulkanShaderModule>>&& modules);

        explicit VulkanShaderProgram(const VulkanDevice& device);
 
    public:
        VulkanShaderProgram(VulkanShaderProgram&&) noexcept = delete;

        VulkanShaderProgram(const VulkanShaderProgram&) = delete;

        VulkanShaderProgram& operator=(VulkanShaderProgram&&) noexcept = delete;

        VulkanShaderProgram& operator=(const VulkanShaderProgram&) = delete;
 
    public:
        ~VulkanShaderProgram() noexcept override;
 
        // Factory method.
    public:
        static inline auto create(const VulkanDevice& device, Enumerable<UniquePtr<VulkanShaderModule>>&& modules) {
            return SharedObject::create<VulkanShaderProgram>(device, std::move(modules));
        }
 
    private:
        static inline auto create(const VulkanDevice& device) {
            return SharedObject::create<VulkanShaderProgram>(device);
        }
 
    public:
        const Array<UniquePtr<const VulkanShaderModule>>& modules() const noexcept override;

        virtual SharedPtr<VulkanPipelineLayout> reflectPipelineLayout(Enumerable<PipelineBindingHint> hints = {}) const;
 
    private:
        SharedPtr<IPipelineLayout> parsePipelineLayout(Enumerable<PipelineBindingHint> hints) const override {
            return std::static_pointer_cast<IPipelineLayout>(this->reflectPipelineLayout(hints));
        }
    };

    class LITEFX_VULKAN_API VulkanDescriptorSet final : public DescriptorSet<IVulkanBuffer, IVulkanImage, IVulkanSampler, IVulkanAccelerationStructure> {
        LITEFX_IMPLEMENTATION(VulkanDescriptorSetImpl);
        friend class VulkanDescriptorSetLayout;
 
    public:
        using base_type = DescriptorSet<IVulkanBuffer, IVulkanImage, IVulkanSampler, IVulkanAccelerationStructure>;
        using base_type::update;
 
    private:
        explicit VulkanDescriptorSet(const VulkanDescriptorSetLayout& layout, Array<Byte>&& buffer);
 
    public:
        explicit VulkanDescriptorSet(const VulkanDescriptorSetLayout& layout, UInt32 unboundedArraySize = std::numeric_limits<UInt32>::max());

        VulkanDescriptorSet(VulkanDescriptorSet&&) noexcept = delete;

        VulkanDescriptorSet(const VulkanDescriptorSet&) = delete;

        VulkanDescriptorSet& operator=(VulkanDescriptorSet&&) noexcept = delete;

        VulkanDescriptorSet& operator=(const VulkanDescriptorSet&) = delete;

        ~VulkanDescriptorSet() noexcept override;
 
    public:
        virtual const VulkanDescriptorSetLayout& layout() const noexcept;
 
    private:
        Array<Byte>&& releaseBuffer() const noexcept;
 
    public:
        Span<const Byte> descriptorBuffer() const noexcept;
 
    public:
        VirtualAllocator::Allocation globalHeapAllocation(DescriptorHeapType heapType) const noexcept override;

        UInt32 bindToHeap(DescriptorType bindingType, UInt32 descriptor, const IVulkanBuffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, Format texelFormat = Format::None) const override;

        UInt32 bindToHeap(DescriptorType bindingType, UInt32 descriptor, const IVulkanImage& image, UInt32 firstLevel = 0, UInt32 levels = 0, UInt32 firstLayer = 0, UInt32 layers = 0) const override;

        UInt32 bindToHeap(UInt32 descriptor, const IVulkanSampler& sampler) const override;

        void update(UInt32 binding, const IVulkanBuffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, UInt32 firstDescriptor = 0, Format texelFormat = Format::None) const override;

        void update(UInt32 binding, const IVulkanImage& texture, UInt32 descriptor = 0, UInt32 firstLevel = 0, UInt32 levels = 0, UInt32 firstLayer = 0, UInt32 layers = 0) const override;

        void update(UInt32 binding, const IVulkanSampler& sampler, UInt32 descriptor = 0) const override;

        void update(UInt32 binding, const IVulkanAccelerationStructure& accelerationStructure, UInt32 descriptor = 0) const override;
    };

    class LITEFX_VULKAN_API VulkanDescriptorLayout final : public IDescriptorLayout {
        LITEFX_IMPLEMENTATION(VulkanDescriptorLayoutImpl);
 
    public:
        VulkanDescriptorLayout(DescriptorType type, UInt32 binding, size_t elementSize, UInt32 descriptors = 1, bool unbounded = false);

        VulkanDescriptorLayout(const IVulkanSampler& staticSampler, UInt32 binding);

        VulkanDescriptorLayout(UInt32 binding, UInt32 inputAttachmentIndex);

        VulkanDescriptorLayout(VulkanDescriptorLayout&&) noexcept;

        VulkanDescriptorLayout(const VulkanDescriptorLayout&);

        VulkanDescriptorLayout& operator=(VulkanDescriptorLayout&&) noexcept;

        VulkanDescriptorLayout& operator=(const VulkanDescriptorLayout&);

        ~VulkanDescriptorLayout() noexcept override;
 
        // IDescriptorLayout interface.
    public:
        DescriptorType descriptorType() const noexcept override;

        UInt32 descriptors() const noexcept override;

        bool unbounded() const noexcept override;

        const IVulkanSampler* staticSampler() const noexcept override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;

        UInt32 binding() const noexcept override;

        BufferType type() const noexcept override;
 
        // VulkanDescriptorLayout
    public:
        UInt32 inputAttachmentIndex() const noexcept;
    };

    class LITEFX_VULKAN_API VulkanDescriptorSetLayout final : public DescriptorSetLayout<VulkanDescriptorLayout, VulkanDescriptorSet>, public Resource<VkDescriptorSetLayout> {
        LITEFX_IMPLEMENTATION(VulkanDescriptorSetLayoutImpl);
        LITEFX_BUILDER(VulkanDescriptorSetLayoutBuilder);
        friend struct SharedObject::Allocator<VulkanDescriptorSetLayout>;
 
    public:
        using base_type = DescriptorSetLayout<VulkanDescriptorLayout, VulkanDescriptorSet>;
        using base_type::free;
        using base_type::allocate;
 
    private:
        explicit VulkanDescriptorSetLayout(const VulkanDevice& device, const Enumerable<VulkanDescriptorLayout>& descriptorLayouts, UInt32 space, ShaderStage stages);
        
        explicit VulkanDescriptorSetLayout(const VulkanDevice& device);
 
    private:
        VulkanDescriptorSetLayout(VulkanDescriptorSetLayout&&) noexcept = delete;

        VulkanDescriptorSetLayout(const VulkanDescriptorSetLayout& other);

        VulkanDescriptorSetLayout& operator=(VulkanDescriptorSetLayout&&) noexcept = delete;

        VulkanDescriptorSetLayout& operator=(const VulkanDescriptorSetLayout&) = delete;
 
    public:
        ~VulkanDescriptorSetLayout() noexcept override;
 
    public:
        static inline auto create(const VulkanDevice& device, const Enumerable<VulkanDescriptorLayout>& descriptorLayouts, UInt32 space, ShaderStage stages) {
            return SharedObject::create<VulkanDescriptorSetLayout>(device, descriptorLayouts, space, stages);
        }

        static inline auto create(const VulkanDescriptorSetLayout& other) {
            return SharedObject::create<VulkanDescriptorSetLayout>(other);
        }
 
    private:
        static inline auto create(const VulkanDevice& device) {
            return SharedObject::create<VulkanDescriptorSetLayout>(device);
        }
 
    public:
        const VulkanDevice& device() const noexcept;

        UInt32 maxUnboundedArraySize() const noexcept;
 
    public:
        const Array<VulkanDescriptorLayout>& descriptors() const noexcept override;

        const VulkanDescriptorLayout& descriptor(UInt32 binding) const override;

        UInt32 space() const noexcept override;

        ShaderStage shaderStages() const noexcept override;

        UInt32 uniforms() const noexcept override;

        UInt32 storages() const noexcept override;

        UInt32 images() const noexcept override;

        UInt32 buffers() const noexcept override;

        UInt32 samplers() const noexcept override;

        UInt32 staticSamplers() const noexcept override;

        UInt32 inputAttachments() const noexcept override;

        bool containsUnboundedArray() const noexcept override;

        UInt32 getDescriptorOffset(UInt32 binding, UInt32 element = 0) const override;

        bool bindsResources() const noexcept override;

        bool bindsSamplers() const noexcept override;
 
    public:
        UniquePtr<VulkanDescriptorSet> allocate(UInt32 descriptors, std::initializer_list<DescriptorBinding> bindings) const override;

        UniquePtr<VulkanDescriptorSet> allocate(UInt32 descriptors, Span<DescriptorBinding> bindings) const override;

        UniquePtr<VulkanDescriptorSet> allocate(UInt32 descriptors, Generator<DescriptorBinding> bindings) const override;

        Generator<UniquePtr<VulkanDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::initializer_list<std::initializer_list<DescriptorBinding>> bindings = { }) const override;
 
#ifdef __cpp_lib_mdspan
        Generator<UniquePtr<VulkanDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::mdspan<DescriptorBinding, std::dextents<size_t, 2>> bindings) const override;
#endif

        Generator<UniquePtr<VulkanDescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::function<Generator<DescriptorBinding>(UInt32)> bindingFactory) const override;

        void free(const VulkanDescriptorSet& descriptorSet) const override;
    };

    class LITEFX_VULKAN_API VulkanPushConstantsRange final : public IPushConstantsRange {
        LITEFX_IMPLEMENTATION(VulkanPushConstantsRangeImpl);
 
    public:
        explicit VulkanPushConstantsRange(ShaderStage shaderStage, UInt32 offset, UInt32 size, UInt32 space, UInt32 binding);

        VulkanPushConstantsRange(VulkanPushConstantsRange&&) noexcept;

        VulkanPushConstantsRange(const VulkanPushConstantsRange&);

        VulkanPushConstantsRange& operator=(VulkanPushConstantsRange&&) noexcept;

        VulkanPushConstantsRange& operator=(const VulkanPushConstantsRange&);

        ~VulkanPushConstantsRange() noexcept override;
 
    public:
        UInt32 space() const noexcept override;

        UInt32 binding() const noexcept override;

        UInt32 offset() const noexcept override;

        UInt32 size() const noexcept override;

        ShaderStage stage() const noexcept override;
    };

    class LITEFX_VULKAN_API VulkanPushConstantsLayout final : public PushConstantsLayout<VulkanPushConstantsRange> {
        LITEFX_IMPLEMENTATION(VulkanPushConstantsLayoutImpl);
        LITEFX_BUILDER(VulkanPushConstantsLayoutBuilder);
        friend class VulkanPipelineLayout;
 
    public:
        explicit VulkanPushConstantsLayout(Enumerable<UniquePtr<VulkanPushConstantsRange>>&& ranges, UInt32 size);
        
        VulkanPushConstantsLayout(VulkanPushConstantsLayout&&) noexcept;

        VulkanPushConstantsLayout(const VulkanPushConstantsLayout&) = delete;

        VulkanPushConstantsLayout& operator=(VulkanPushConstantsLayout&&) noexcept;

        VulkanPushConstantsLayout& operator=(const VulkanPushConstantsLayout&) = delete;

        ~VulkanPushConstantsLayout() noexcept override;
 
    private:
        explicit VulkanPushConstantsLayout(UInt32 size);
    
    public:
        UInt32 size() const noexcept override;

        const VulkanPushConstantsRange& range(ShaderStage stage) const override;

        const Array<UniquePtr<VulkanPushConstantsRange>>& ranges() const override;
    };

    class LITEFX_VULKAN_API VulkanPipelineLayout final : public PipelineLayout<VulkanDescriptorSetLayout, VulkanPushConstantsLayout>, public Resource<VkPipelineLayout> {
        LITEFX_IMPLEMENTATION(VulkanPipelineLayoutImpl);
        LITEFX_BUILDER(VulkanPipelineLayoutBuilder);
        friend struct SharedObject::Allocator<VulkanPipelineLayout>;
 
    private:
        explicit VulkanPipelineLayout(const VulkanDevice& device, const Enumerable<SharedPtr<VulkanDescriptorSetLayout>>& descriptorSetLayouts, UniquePtr<VulkanPushConstantsLayout>&& pushConstantsLayout);

        explicit VulkanPipelineLayout(const VulkanDevice& device) noexcept;
 
    private:
        VulkanPipelineLayout(VulkanPipelineLayout&&) noexcept = delete;

        VulkanPipelineLayout(const VulkanPipelineLayout&) = delete;

        VulkanPipelineLayout& operator=(VulkanPipelineLayout&&) noexcept = delete;

        VulkanPipelineLayout& operator=(const VulkanPipelineLayout&) = delete;
 
    public:
        ~VulkanPipelineLayout() noexcept override;
 
    public:
        static inline auto create(const VulkanDevice& device, const Enumerable<SharedPtr<VulkanDescriptorSetLayout>>& descriptorSetLayouts, UniquePtr<VulkanPushConstantsLayout>&& pushConstantsLayout) {
            return SharedObject::create<VulkanPipelineLayout>(device, descriptorSetLayouts, std::move(pushConstantsLayout));
        }
 
    private:
        static inline auto create(const VulkanDevice& device) {
            return SharedObject::create<VulkanPipelineLayout>(device);
        }
 
        // PipelineLayout interface.
    public:
        const VulkanDevice& device() const noexcept /*override*/;

        const VulkanDescriptorSetLayout& descriptorSet(UInt32 space) const override;

        const Array<SharedPtr<const VulkanDescriptorSetLayout>>& descriptorSets() const override;

        const VulkanPushConstantsLayout* pushConstants() const noexcept override;

        bool dynamicResourceHeapAccess() const override;

        bool dynamicSamplerHeapAccess() const override;
    };

    class LITEFX_VULKAN_API VulkanInputAssembler final : public InputAssembler<VulkanVertexBufferLayout, VulkanIndexBufferLayout> {
        LITEFX_IMPLEMENTATION(VulkanInputAssemblerImpl);
        LITEFX_BUILDER(VulkanInputAssemblerBuilder);
        friend struct SharedObject::Allocator<VulkanInputAssembler>;
 
    private:
        explicit VulkanInputAssembler(Enumerable<SharedPtr<VulkanVertexBufferLayout>>&& vertexBufferLayouts, SharedPtr<VulkanIndexBufferLayout>&& indexBufferLayout = nullptr, PrimitiveTopology primitiveTopology = PrimitiveTopology::TriangleList);

        explicit VulkanInputAssembler();
 
    private:
        VulkanInputAssembler(VulkanInputAssembler&&) noexcept = delete;

        VulkanInputAssembler(const VulkanInputAssembler&);

        VulkanInputAssembler& operator=(VulkanInputAssembler&&) noexcept = delete;

        VulkanInputAssembler& operator=(const VulkanInputAssembler&) = delete;
 
    public:
        ~VulkanInputAssembler() noexcept override;
 
    public:
        static inline auto create(Enumerable<SharedPtr<VulkanVertexBufferLayout>>&& vertexBufferLayouts, SharedPtr<VulkanIndexBufferLayout>&& indexBufferLayout = nullptr, PrimitiveTopology primitiveTopology = PrimitiveTopology::TriangleList) {
            return SharedObject::create<VulkanInputAssembler>(std::move(vertexBufferLayouts), std::move(indexBufferLayout), primitiveTopology);
        }

        static inline auto create(const VulkanInputAssembler& other) {
            return SharedObject::create<VulkanInputAssembler>(other);
        }
 
    private:
        static inline auto create() {
            return SharedObject::create<VulkanInputAssembler>();
        }
 
    public:
        Enumerable<const VulkanVertexBufferLayout&> vertexBufferLayouts() const override;

        const VulkanVertexBufferLayout& vertexBufferLayout(UInt32 binding) const override;

        const VulkanIndexBufferLayout* indexBufferLayout() const noexcept override;

        PrimitiveTopology topology() const noexcept override;
    };

    class LITEFX_VULKAN_API VulkanRasterizer final : public Rasterizer {
        LITEFX_BUILDER(VulkanRasterizerBuilder);
        friend struct SharedObject::Allocator<VulkanRasterizer>;
 
    private:
        explicit VulkanRasterizer(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, bool depthClip = true, const DepthStencilState& depthStencilState = {}, bool conservativeRasterization = false) noexcept;

        explicit VulkanRasterizer() noexcept;
 
    private:
        VulkanRasterizer(VulkanRasterizer&&) noexcept = delete;

        VulkanRasterizer(const VulkanRasterizer&) = default;

        VulkanRasterizer& operator=(VulkanRasterizer&&) noexcept = delete;

        VulkanRasterizer& operator=(const VulkanRasterizer&) = delete;
 
    public:
        ~VulkanRasterizer() noexcept override;
 
    public:
        static inline auto create(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, bool depthClip = true, const DepthStencilState& depthStencilState = {}, bool conservativeRasterization = false) {
            return SharedObject::create<VulkanRasterizer>(polygonMode, cullMode, cullOrder, lineWidth, depthClip, depthStencilState, conservativeRasterization);
        }

        static inline auto create(const VulkanRasterizer& other) {
            return SharedObject::create<VulkanRasterizer>(other);
        }
 
    private:
        static inline auto create() {
            return SharedObject::create<VulkanRasterizer>();
        }
 
    public:
        virtual void updateLineWidth(Float lineWidth) noexcept;
    };

    class LITEFX_VULKAN_API VulkanPipelineState : public virtual Pipeline<VulkanPipelineLayout, VulkanShaderProgram>, public Resource<VkPipeline> {
    protected:
        using Resource<VkPipeline>::Resource;
 
        VulkanPipelineState(VulkanPipelineState&&) noexcept = default;
        VulkanPipelineState(const VulkanPipelineState&) = delete;
        VulkanPipelineState& operator=(VulkanPipelineState&&) noexcept = default;
        VulkanPipelineState& operator=(const VulkanPipelineState&) = delete;
 
    public:
        ~VulkanPipelineState() noexcept override = default;
 
    public:
        virtual VkPipelineBindPoint pipelineType() const noexcept = 0;

        virtual void use(const VulkanCommandBuffer& commandBuffer) const = 0;
    };

    class LITEFX_VULKAN_API VulkanCommandBuffer final : public CommandBuffer<VulkanCommandBuffer, IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, VulkanBarrier, VulkanPipelineState, VulkanBottomLevelAccelerationStructure, VulkanTopLevelAccelerationStructure>, public Resource<VkCommandBuffer> {
        LITEFX_IMPLEMENTATION(VulkanCommandBufferImpl);
        friend struct SharedObject::Allocator<VulkanCommandBuffer>;
 
    public:
        using base_type = CommandBuffer<VulkanCommandBuffer, IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, VulkanBarrier, VulkanPipelineState, VulkanBottomLevelAccelerationStructure, VulkanTopLevelAccelerationStructure>;
        using base_type::dispatch;
        using base_type::dispatchIndirect;
        using base_type::dispatchMesh;
        using base_type::draw;
        using base_type::drawIndirect;
        using base_type::drawIndexed;
        using base_type::drawIndexedIndirect;
        using base_type::barrier;
        using base_type::transfer;
        using base_type::bind;
        using base_type::use;
        using base_type::pushConstants;
        using base_type::buildAccelerationStructure;
        using base_type::updateAccelerationStructure;
        using base_type::copyAccelerationStructure;
 
    private:
        explicit VulkanCommandBuffer(const VulkanQueue& queue, bool begin = false, bool primary = true);
 
    private:
        VulkanCommandBuffer(VulkanCommandBuffer&&) noexcept = delete;

        VulkanCommandBuffer(const VulkanCommandBuffer&) = delete;

        VulkanCommandBuffer& operator=(VulkanCommandBuffer&&) noexcept = delete;

        VulkanCommandBuffer& operator=(const VulkanCommandBuffer&) = delete;
        
    public:
        ~VulkanCommandBuffer() noexcept override;
 
        // Factory method.
    public:
        static inline SharedPtr<VulkanCommandBuffer> create(const VulkanQueue& queue, bool begin = false, bool primary = true) {
            return SharedObject::create<VulkanCommandBuffer>(queue, begin, primary);
        }
 
        // Vulkan Command Buffer interface.
    public:
        virtual void begin(const VulkanRenderPass& renderPass) const;
 
        // CommandBuffer interface.
    public:
        SharedPtr<const VulkanQueue> queue() const noexcept;

        void begin() const override;

        void end() const override;

        void track(SharedPtr<const IBuffer> buffer) const override;

        void track(SharedPtr<const IImage> image) const override;

        void track(SharedPtr<const ISampler> sampler) const override;

        void track(UniquePtr<const IDescriptorSet>&& descriptorSet) const override;

        bool isSecondary() const noexcept override;

        void setViewports(Span<const IViewport*> viewports) const override;

        void setViewports(const IViewport* viewport) const override;

        void setScissors(Span<const IScissor*> scissors) const override;

        void setScissors(const IScissor* scissor) const override;

        void setBlendFactors(const Vector4f& blendFactors) const noexcept override;

        void setStencilRef(UInt32 stencilRef) const noexcept override;

        void setDepthBounds(Float minBounds, Float maxBounds) const noexcept override;

        UInt64 submit() const override;

        [[nodiscard]] UniquePtr<VulkanBarrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const override;

        void barrier(const VulkanBarrier& barrier) const noexcept override;

        void transfer(const IVulkanBuffer& source, const IVulkanBuffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const override;

        void transfer(const void* const data, size_t size, const IVulkanBuffer& target, UInt32 targetElement = 0, UInt32 elements = 1) const override;

        void transfer(Span<const void* const> data, size_t elementSize, const IVulkanBuffer& target, UInt32 firstElement = 0) const override;

        void transfer(const IVulkanBuffer& source, const IVulkanImage& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 subresources = 1) const override;

        void transfer(const void* const data, size_t size, const IVulkanImage& target, UInt32 subresource = 0) const override;

        void transfer(Span<const void* const> data, size_t elementSize, const IVulkanImage& target, UInt32 firstSubresource = 0, UInt32 subresources = 1) const override;

        void transfer(const IVulkanImage& source, const IVulkanImage& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const override;

        void transfer(const IVulkanImage& source, const IVulkanBuffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const override;

        void transfer(const SharedPtr<const IVulkanBuffer>& source, const IVulkanBuffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const override;

        void transfer(const SharedPtr<const IVulkanBuffer>& source, const IVulkanImage& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 elements = 1) const override;

        void transfer(const SharedPtr<const IVulkanImage>& source, const IVulkanImage& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const override;

        void transfer(const SharedPtr<const IVulkanImage>& source, const IVulkanBuffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const override;

        void use(const VulkanPipelineState& pipeline) const noexcept override;

        void bind(const VulkanDescriptorSet& descriptorSet) const override;

        void bind(Span<const VulkanDescriptorSet*> descriptorSets) const override;

        void bind(const VulkanDescriptorSet& descriptorSet, const VulkanPipelineState& pipeline) const override;

        void bind(Span<const VulkanDescriptorSet*> descriptorSets, const VulkanPipelineState& pipeline) const override;

        void bind(const IVulkanVertexBuffer& buffer) const noexcept override;

        void bind(const IVulkanIndexBuffer& buffer) const noexcept override;

        void dispatch(const Vector3u& threadCount) const noexcept override;

        void dispatchIndirect(const IVulkanBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;

        void dispatchMesh(const Vector3u& threadCount) const noexcept override;

        void dispatchMeshIndirect(const IVulkanBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;

        void dispatchMeshIndirect(const IVulkanBuffer& batchBuffer, const IVulkanBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;

        void draw(UInt32 vertices, UInt32 instances = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) const noexcept override;

        void drawIndirect(const IVulkanBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;

        void drawIndirect(const IVulkanBuffer& batchBuffer, const IVulkanBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;

        void drawIndexed(UInt32 indices, UInt32 instances = 1, UInt32 firstIndex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) const noexcept override;

        void drawIndexedIndirect(const IVulkanBuffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;

        void drawIndexedIndirect(const IVulkanBuffer& batchBuffer, const IVulkanBuffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;

        void pushConstants(const VulkanPushConstantsLayout& layout, const void* const memory) const override;

        void writeTimingEvent(const SharedPtr<const TimingEvent>& timingEvent) const override;

        void execute(const SharedPtr<const VulkanCommandBuffer>& commandBuffer) const override;

        void execute(Enumerable<SharedPtr<const VulkanCommandBuffer>> commandBuffers) const override;

        void buildAccelerationStructure(VulkanBottomLevelAccelerationStructure& blas, const SharedPtr<const IVulkanBuffer>& scratchBuffer, const IVulkanBuffer& buffer, UInt64 offset) const override;

        void buildAccelerationStructure(VulkanTopLevelAccelerationStructure& tlas, const SharedPtr<const IVulkanBuffer>& scratchBuffer, const IVulkanBuffer& buffer, UInt64 offset) const override;

        void updateAccelerationStructure(VulkanBottomLevelAccelerationStructure& blas, const SharedPtr<const IVulkanBuffer>& scratchBuffer, const IVulkanBuffer& buffer, UInt64 offset) const override;

        void updateAccelerationStructure(VulkanTopLevelAccelerationStructure& tlas, const SharedPtr<const IVulkanBuffer>& scratchBuffer, const IVulkanBuffer& buffer, UInt64 offset) const override;

        void copyAccelerationStructure(const VulkanBottomLevelAccelerationStructure& from, const VulkanBottomLevelAccelerationStructure& to, bool compress = false) const noexcept override;

        void copyAccelerationStructure(const VulkanTopLevelAccelerationStructure& from, const VulkanTopLevelAccelerationStructure& to, bool compress = false) const noexcept override;

        void traceRays(UInt32 width, UInt32 height, UInt32 depth, const ShaderBindingTableOffsets& offsets, const IVulkanBuffer& rayGenerationShaderBindingTable, const IVulkanBuffer* missShaderBindingTable, const IVulkanBuffer* hitShaderBindingTable, const IVulkanBuffer* callableShaderBindingTable) const noexcept override;
 
    private:
        inline SharedPtr<const ICommandQueue> getQueue() const noexcept override {
            return std::static_pointer_cast<const ICommandQueue>(this->queue());
        }
 
        void releaseSharedState() const override;
    };

    class LITEFX_VULKAN_API VulkanQueue final : public CommandQueue<VulkanCommandBuffer>, public Resource<VkQueue> {
        LITEFX_IMPLEMENTATION(VulkanQueueImpl);
        friend struct SharedObject::Allocator<VulkanQueue>;
 
    public:
        using base_type = CommandQueue<VulkanCommandBuffer>;
        using base_type::submit;
 
    private:
        explicit VulkanQueue(const VulkanDevice& device, QueueType type, QueuePriority priority, UInt32 familyId, UInt32 queueId);
 
    private:
        VulkanQueue(VulkanQueue&&) noexcept = delete;

        VulkanQueue(const VulkanQueue&) = delete;

        VulkanQueue& operator=(VulkanQueue&&) noexcept = delete;

        VulkanQueue& operator=(const VulkanQueue&) = delete;
 
    public:
        ~VulkanQueue() noexcept override;
 
    public:
        static inline SharedPtr<VulkanQueue> create(const VulkanDevice& device, QueueType type, QueuePriority priority, UInt32 familyId, UInt32 queueId) {
            return SharedObject::create<VulkanQueue>(device, type, priority, familyId, queueId);
        }
 
        // VulkanQueue interface.
    public:
        SharedPtr<const VulkanDevice> device() const noexcept;

        UInt32 familyId() const noexcept;

        UInt32 queueId() const noexcept;

        const VkSemaphore& timelineSemaphore() const noexcept;
 
        // CommandQueue interface.
    public:
        QueuePriority priority() const noexcept override;

        QueueType type() const noexcept override;
 
#ifdef LITEFX_BUILD_SUPPORT_DEBUG_MARKERS
    public:
        void beginDebugRegion(const String& label, const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept override;

        void endDebugRegion() const noexcept override;

        void setDebugMarker(const String& label, const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept override;
#endif // LITEFX_BUILD_SUPPORT_DEBUG_MARKERS
 
    public:
        SharedPtr<VulkanCommandBuffer> createCommandBuffer(bool beginRecording = false, bool secondary = false) const override;

        UInt64 submit(const SharedPtr<const VulkanCommandBuffer>& commandBuffer) const override;

        UInt64 submit(Enumerable<SharedPtr<const VulkanCommandBuffer>> commandBuffers) const override;

        void waitFor(UInt64 fence) const override;

        void waitFor(const VulkanQueue& queue, UInt64 fence) const noexcept;

        UInt64 currentFence() const noexcept override;
        
        UInt64 lastCompletedFence() const noexcept override;
 
    private:
        inline void waitForQueue(const ICommandQueue& queue, UInt64 fence) const override {
            auto vkQueue = dynamic_cast<const VulkanQueue*>(&queue);
 
            if (vkQueue == nullptr) [[unlikely]]
                throw InvalidArgumentException("queue", "Cannot wait for queues from other backends.");
 
            this->waitFor(*vkQueue, fence);
        }
    };

    class LITEFX_VULKAN_API VulkanRenderPipeline final : public virtual VulkanPipelineState, public RenderPipeline<VulkanPipelineLayout, VulkanShaderProgram, VulkanInputAssembler, VulkanRasterizer> {
        LITEFX_IMPLEMENTATION(VulkanRenderPipelineImpl);
        LITEFX_BUILDER(VulkanRenderPipelineBuilder);
 
    public:
        explicit VulkanRenderPipeline(const VulkanRenderPass& renderPass, const SharedPtr<VulkanShaderProgram>& shaderProgram, const SharedPtr<VulkanPipelineLayout>& layout, const SharedPtr<VulkanInputAssembler>& inputAssembler, const SharedPtr<VulkanRasterizer>& rasterizer, MultiSamplingLevel samples = MultiSamplingLevel::x1, bool enableAlphaToCoverage = false, const String& name = "");

        VulkanRenderPipeline(VulkanRenderPipeline&&) noexcept = delete;

        VulkanRenderPipeline(const VulkanRenderPipeline&) = delete;

        VulkanRenderPipeline& operator=(VulkanRenderPipeline&&) noexcept = delete;

        VulkanRenderPipeline& operator=(const VulkanRenderPipeline&) = delete;

        ~VulkanRenderPipeline() noexcept override;
 
    private:
        VulkanRenderPipeline(const VulkanRenderPass& renderPass, const String& name = "");
 
        // Pipeline interface.
    public:
        SharedPtr<const VulkanShaderProgram> program() const noexcept override;

        SharedPtr<const VulkanPipelineLayout> layout() const noexcept override;
 
        // RenderPipeline interface.
    public:
        SharedPtr<VulkanInputAssembler> inputAssembler() const noexcept override;

        SharedPtr<VulkanRasterizer> rasterizer() const noexcept override;

        bool alphaToCoverage() const noexcept override;

        MultiSamplingLevel samples() const noexcept override;

        void updateSamples(MultiSamplingLevel samples) override;
 
        // VulkanPipelineState interface.
    public:
        VkPipelineBindPoint pipelineType() const noexcept override;

        void use(const VulkanCommandBuffer& commandBuffer) const override;
    };

    class LITEFX_VULKAN_API VulkanComputePipeline final : public virtual VulkanPipelineState, public ComputePipeline<VulkanPipelineLayout, VulkanShaderProgram> {
        LITEFX_IMPLEMENTATION(VulkanComputePipelineImpl);
        LITEFX_BUILDER(VulkanComputePipelineBuilder);
 
    public:
        explicit VulkanComputePipeline(const VulkanDevice& device, const SharedPtr<VulkanPipelineLayout>& layout, const SharedPtr<VulkanShaderProgram>& shaderProgram, const String& name = "");

        VulkanComputePipeline(VulkanComputePipeline&&) noexcept;

        VulkanComputePipeline(const VulkanComputePipeline&) = delete;

        VulkanComputePipeline& operator=(VulkanComputePipeline&&) noexcept;

        VulkanComputePipeline& operator=(const VulkanComputePipeline&) = delete;

        ~VulkanComputePipeline() noexcept override;
 
    private:
        VulkanComputePipeline(const VulkanDevice& device) noexcept;
 
        // Pipeline interface.
    public:
        SharedPtr<const VulkanShaderProgram> program() const noexcept override;

        SharedPtr<const VulkanPipelineLayout> layout() const noexcept override;
 
        // VulkanPipelineState interface.
    public:
        VkPipelineBindPoint pipelineType() const noexcept override;

        void use(const VulkanCommandBuffer& commandBuffer) const override;
    };
    
    class LITEFX_VULKAN_API VulkanRayTracingPipeline final : public virtual VulkanPipelineState, public RayTracingPipeline<VulkanPipelineLayout, VulkanShaderProgram> {
        LITEFX_IMPLEMENTATION(VulkanRayTracingPipelineImpl);
        LITEFX_BUILDER(VulkanRayTracingPipelineBuilder);
 
    public:
        explicit VulkanRayTracingPipeline(const VulkanDevice& device, const SharedPtr<VulkanPipelineLayout>& layout, const SharedPtr<VulkanShaderProgram>& shaderProgram, ShaderRecordCollection&& shaderRecords, UInt32 maxRecursionDepth = 10, UInt32 maxPayloadSize = 0, UInt32 maxAttributeSize = 32, const String& name = ""); // NOLINT(cppcoreguidelines-avoid-magic-numbers)

        VulkanRayTracingPipeline(VulkanRayTracingPipeline&&) noexcept;

        VulkanRayTracingPipeline(const VulkanRayTracingPipeline&) = delete;

        VulkanRayTracingPipeline& operator=(VulkanRayTracingPipeline&&) noexcept;

        VulkanRayTracingPipeline& operator=(const VulkanRayTracingPipeline&) = delete;

        ~VulkanRayTracingPipeline() noexcept override;
 
    private:
        VulkanRayTracingPipeline(const VulkanDevice& device, ShaderRecordCollection&& shaderRecords) noexcept;
 
        // Pipeline interface.
    public:
        SharedPtr<const VulkanShaderProgram> program() const noexcept override;

        SharedPtr<const VulkanPipelineLayout> layout() const noexcept override;
 
        // RayTracingPipeline interface.
    public:
        const ShaderRecordCollection& shaderRecords() const noexcept override;

        UInt32 maxRecursionDepth() const noexcept override;

        UInt32 maxPayloadSize() const noexcept override;

        UInt32 maxAttributeSize() const noexcept override;

        SharedPtr<IVulkanBuffer> allocateShaderBindingTable(ShaderBindingTableOffsets& offsets, ShaderBindingGroup groups = ShaderBindingGroup::All) const override;
 
        // VulkanPipelineState interface.
    public:
        VkPipelineBindPoint pipelineType() const noexcept override;

        void use(const VulkanCommandBuffer& commandBuffer) const override;
    };

    class LITEFX_VULKAN_API VulkanFrameBuffer final : public FrameBuffer<IVulkanImage> {
        LITEFX_IMPLEMENTATION(VulkanFrameBufferImpl);
        friend struct SharedObject::Allocator<VulkanFrameBuffer>;
 
    public:
        using FrameBuffer::allocation_callback_type;
        using FrameBuffer::addImage;
        using FrameBuffer::mapRenderTarget;
        using FrameBuffer::mapRenderTargets;
 
    private:
        VulkanFrameBuffer(const VulkanDevice& device, const Size2d& renderArea, StringView name = "");

        VulkanFrameBuffer(const VulkanDevice& device, const Size2d& renderArea, allocation_callback_type allocationCallback, StringView name = "");
 
    private:
        VulkanFrameBuffer(VulkanFrameBuffer&&) noexcept = delete;
        
        VulkanFrameBuffer(const VulkanFrameBuffer&) = delete;

        VulkanFrameBuffer& operator=(VulkanFrameBuffer&&) noexcept = delete;

        VulkanFrameBuffer& operator=(const VulkanFrameBuffer&) = delete;
 
    public:
        ~VulkanFrameBuffer() noexcept override;
 
    public:
        static inline SharedPtr<VulkanFrameBuffer> create(const VulkanDevice& device, const Size2d& renderArea, StringView name = "") {
            return SharedObject::create<VulkanFrameBuffer>(device, renderArea, name);
        }

        static inline SharedPtr<VulkanFrameBuffer> create(const VulkanDevice& device, const Size2d& renderArea, allocation_callback_type allocationCallback, StringView name = "") {
            return SharedObject::create<VulkanFrameBuffer>(device, renderArea, std::move(allocationCallback), name);
        }
 
        // Vulkan frame buffer interface.
    public:
        VkImageView imageView(UInt32 imageIndex) const;

        VkImageView imageView(StringView imageName) const;

        VkImageView imageView(const RenderTarget& renderTarget) const;
 
        // FrameBuffer interface.
    public:
        const Size2d& size() const noexcept override;

        size_t getWidth() const noexcept override;

        size_t getHeight() const noexcept override;

        void mapRenderTarget(const RenderTarget& renderTarget, UInt32 index) override;

        void mapRenderTarget(const RenderTarget& renderTarget, StringView name) override;

        void unmapRenderTarget(const RenderTarget& renderTarget) noexcept override;

        const Array<SharedPtr<const IVulkanImage>>& images() const override;

        inline const IVulkanImage& operator[](UInt32 index) const override {
            return this->image(index);
        }

        const IVulkanImage& image(UInt32 index) const override;

        inline const IVulkanImage& operator[](const RenderTarget& renderTarget) const override {
            return this->image(renderTarget);
        }

        const IVulkanImage& image(const RenderTarget& renderTarget) const override;

        inline const IVulkanImage& operator[](StringView renderTargetName) const override {
            return this->resolveImage(hash(renderTargetName));
        }

        inline const IVulkanImage& image(StringView renderTargetName) const override {
            return this->resolveImage(hash(renderTargetName));
        }

        const IVulkanImage& resolveImage(UInt64 hash) const override;

        void addImage(const String& name, Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) override;

        void addImage(const String& name, const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) override;

        void resize(const Size2d& renderArea) override;
    };

    class LITEFX_VULKAN_API VulkanRenderPass final : public RenderPass<VulkanQueue, VulkanFrameBuffer> {
        LITEFX_IMPLEMENTATION(VulkanRenderPassImpl);
        LITEFX_BUILDER(VulkanRenderPassBuilder);
        friend struct SharedObject::Allocator<VulkanRenderPass>;
 
    public:
        using base_type = RenderPass<VulkanQueue, VulkanFrameBuffer>;
 
    private:
        explicit VulkanRenderPass(const VulkanDevice& device, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000);

        explicit VulkanRenderPass(const VulkanDevice& device, const String& name, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000);

        explicit VulkanRenderPass(const VulkanDevice& device, const VulkanQueue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000);

        explicit VulkanRenderPass(const VulkanDevice& device, const String& name, const VulkanQueue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000);
 
    private:
        VulkanRenderPass(VulkanRenderPass&&) noexcept = delete;

        VulkanRenderPass(const VulkanRenderPass&) = delete;

        VulkanRenderPass& operator=(VulkanRenderPass&&) noexcept = delete;

        VulkanRenderPass& operator=(const VulkanRenderPass&) = delete;
 
    public:
        ~VulkanRenderPass() noexcept override;
 
    public:
        static inline SharedPtr<VulkanRenderPass> create(const VulkanDevice& device, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000) {
            return SharedObject::create<VulkanRenderPass>(device, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers, viewMask);
        }

        static inline SharedPtr<VulkanRenderPass> create(const VulkanDevice& device, const String& name, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000) {
            return SharedObject::create<VulkanRenderPass>(device, name, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers, viewMask);
        }

        static inline SharedPtr<VulkanRenderPass> create(const VulkanDevice& device, const VulkanQueue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000) {
            return SharedObject::create<VulkanRenderPass>(device, queue, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers, viewMask);
        }

        static inline SharedPtr<VulkanRenderPass> create(const VulkanDevice& device, const String& name, const VulkanQueue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u, UInt32 viewMask = 0b0000) {
            return SharedObject::create<VulkanRenderPass>(device, name, queue, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers, viewMask);
        }
 
    private:
        explicit VulkanRenderPass(const VulkanDevice& device, const String& name = "");

        static inline SharedPtr<VulkanRenderPass> create(const VulkanDevice& device, const String& name = "") {
            return SharedObject::create<VulkanRenderPass>(device, name);
        }
 
        // RenderPass interface.
    public:
        const VulkanDevice& device() const noexcept /*override*/;

        SharedPtr<const VulkanFrameBuffer> activeFrameBuffer() const noexcept override;

        const VulkanQueue& commandQueue() const noexcept override;

        Enumerable<SharedPtr<const VulkanCommandBuffer>> commandBuffers() const override;

        SharedPtr<const VulkanCommandBuffer> commandBuffer(UInt32 index) const override;

        UInt32 secondaryCommandBuffers() const noexcept override;

        const Array<RenderTarget>& renderTargets() const noexcept override;

        const RenderTarget& renderTarget(UInt32 location) const override;

        bool hasPresentTarget() const noexcept override;

        const Array<RenderPassDependency>& inputAttachments() const noexcept override;

        const RenderPassDependency& inputAttachment(UInt32 location) const override;
        
        const Optional<DescriptorBindingPoint>& inputAttachmentSamplerBinding() const noexcept override;

        void begin(const VulkanFrameBuffer& frameBuffer) const override;

        UInt64 end() const override;

        UInt32 viewMask() const noexcept override;
    };

    class LITEFX_VULKAN_API VulkanSwapChain final : public SwapChain<IVulkanImage> {
        LITEFX_IMPLEMENTATION(VulkanSwapChainImpl);
        friend class VulkanImage;
        friend class VulkanDevice;
 
    public:
        using base_type = SwapChain<IVulkanImage>;
 
    private:
        explicit VulkanSwapChain(const VulkanDevice& device, Format surfaceFormat = Format::B8G8R8A8_SRGB, const Size2d& renderArea = { 800, 600 }, UInt32 buffers = 3, bool enableVsync = false); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
    public:
        VulkanSwapChain(VulkanSwapChain&&) noexcept = delete;

        VulkanSwapChain(const VulkanSwapChain&) = delete;

        VulkanSwapChain& operator=(VulkanSwapChain&&) noexcept = delete;

        VulkanSwapChain& operator=(const VulkanSwapChain&) = delete;

        ~VulkanSwapChain() noexcept override;
 
        // Vulkan Swap Chain interface.
    public:
        virtual const VkQueryPool& timestampQueryPool() const noexcept;
 
        // SwapChain interface.
    public:
        const Array<SharedPtr<const TimingEvent>>& timingEvents() const override;

        SharedPtr<const TimingEvent> timingEvent(UInt32 queryId) const override;

        UInt64 readTimingEvent(SharedPtr<const TimingEvent> timingEvent) const override;

        UInt32 resolveQueryId(SharedPtr<const TimingEvent> timingEvent) const override;

        const IGraphicsDevice& device() const override;

        Format surfaceFormat() const noexcept override;

        UInt32 buffers() const noexcept override;

        const Size2d& renderArea() const noexcept override;

        bool verticalSynchronization() const noexcept override;

        IVulkanImage* image(UInt32 backBuffer) const override;

        const IVulkanImage& image() const noexcept override;

        const Array<SharedPtr<IVulkanImage>>& images() const noexcept override;

        void present(UInt64 fence) const override;
 
    public:
        Enumerable<Format> getSurfaceFormats() const override;

        void addTimingEvent(SharedPtr<const TimingEvent> timingEvent) override;

        void reset(Format surfaceFormat, const Size2d& renderArea, UInt32 buffers, bool enableVsync = false) override;

        [[nodiscard]] UInt32 swapBackBuffer() const override;
    };

    class LITEFX_VULKAN_API VulkanGraphicsFactory final : public GraphicsFactory<VulkanDescriptorLayout, IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, IVulkanSampler, VulkanBottomLevelAccelerationStructure, VulkanTopLevelAccelerationStructure> {
        LITEFX_IMPLEMENTATION(VulkanGraphicsFactoryImpl);
        friend class VulkanDevice;
        friend struct SharedObject::Allocator<VulkanGraphicsFactory>;
 
    public:
        using base_type = GraphicsFactory<VulkanDescriptorLayout, IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, IVulkanSampler, VulkanBottomLevelAccelerationStructure, VulkanTopLevelAccelerationStructure>;
        using base_type::createBuffer;
        using base_type::tryCreateBuffer;
        using base_type::createVertexBuffer;
        using base_type::tryCreateVertexBuffer;
        using base_type::createIndexBuffer;
        using base_type::tryCreateIndexBuffer;
        using base_type::createTexture;
        using base_type::tryCreateTexture;
        using base_type::createTextures;
        using base_type::createSampler;
        using base_type::createSamplers;
        using base_type::allocate;
 
    private:
        explicit VulkanGraphicsFactory(const VulkanDevice& device);
 
    private:
        VulkanGraphicsFactory(VulkanGraphicsFactory&&) noexcept = delete;

        VulkanGraphicsFactory(const VulkanGraphicsFactory&) = delete;

        VulkanGraphicsFactory& operator=(VulkanGraphicsFactory&&) noexcept = delete;

        VulkanGraphicsFactory& operator=(const VulkanGraphicsFactory&) = delete;
 
    public:
        ~VulkanGraphicsFactory() noexcept override;
 
    private:
        static inline SharedPtr<VulkanGraphicsFactory> create(const VulkanDevice& device) {
            return SharedObject::create<VulkanGraphicsFactory>(device);
        }

        SharedPtr<IVulkanBuffer> createDescriptorHeap(size_t heapSize) const;

        SharedPtr<IVulkanBuffer> createDescriptorHeap(const String& name, size_t heapSize) const;
 
    public:
        [[nodiscard]] VirtualAllocator createAllocator(UInt64 overallMemory, AllocationAlgorithm algorithm = AllocationAlgorithm::Default) const override;

        void beginDefragmentation(const ICommandQueue& queue, DefragmentationStrategy strategy = DefragmentationStrategy::Balanced, UInt64 maxBytesToMove = 0u, UInt32 maxAllocationsToMove = 0u) const override;

        UInt64 beginDefragmentationPass() const override;

        bool endDefragmentationPass() const override;

        Generator<ResourceAllocationResult> allocate(Enumerable<const ResourceAllocationInfo&> allocationInfos, AllocationBehavior allocationBehavior = AllocationBehavior::Default, bool alias = false) const override;

        bool canAlias(Enumerable<const ResourceAllocationInfo&> allocationInfos) const override;

        SharedPtr<IVulkanBuffer> createBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanBuffer> createBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanVertexBuffer> createVertexBuffer(const VulkanVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanVertexBuffer> createVertexBuffer(const String& name, const VulkanVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanIndexBuffer> createIndexBuffer(const VulkanIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanIndexBuffer> createIndexBuffer(const String& name, const VulkanIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanImage> createTexture(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanImage> createTexture(const String& name, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateBuffer(SharedPtr<IVulkanBuffer>& buffer, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateBuffer(SharedPtr<IVulkanBuffer>& buffer, const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateVertexBuffer(SharedPtr<IVulkanVertexBuffer>& buffer, const VulkanVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateVertexBuffer(SharedPtr<IVulkanVertexBuffer>& buffer, const String& name, const VulkanVertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateIndexBuffer(SharedPtr<IVulkanIndexBuffer>& buffer, const VulkanIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateIndexBuffer(SharedPtr<IVulkanIndexBuffer>& buffer, const String& name, const VulkanIndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateTexture(SharedPtr<IVulkanImage>& image, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        bool tryCreateTexture(SharedPtr<IVulkanImage>& image, const String& name, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        Generator<SharedPtr<IVulkanImage>> createTextures(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default, AllocationBehavior allocationBehavior = AllocationBehavior::Default) const override;

        SharedPtr<IVulkanSampler> 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 override;

        SharedPtr<IVulkanSampler> 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 override;

        Generator<SharedPtr<IVulkanSampler>> 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 override;

        UniquePtr<VulkanBottomLevelAccelerationStructure> createBottomLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const override;

        UniquePtr<VulkanTopLevelAccelerationStructure> createTopLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const override;

        bool supportsResizableBaseAddressRegister() const noexcept override;

        Array<MemoryHeapStatistics> memoryStatistics() const override;

        DetailedMemoryStatistics detailedMemoryStatistics() const override;
    };

    class LITEFX_VULKAN_API VulkanDevice final : public GraphicsDevice<VulkanGraphicsFactory, VulkanSurface, VulkanGraphicsAdapter, VulkanSwapChain, VulkanQueue, VulkanRenderPass, VulkanRenderPipeline, VulkanComputePipeline, VulkanRayTracingPipeline, VulkanBarrier>, public Resource<VkDevice> {
        LITEFX_IMPLEMENTATION(VulkanDeviceImpl);
        friend struct SharedObject::Allocator<VulkanDevice>;
        friend class VulkanBackend;
 
    public:
        static const size_t DEFAULT_DESCRIPTOR_HEAP_SIZE = 134'217'728;   // equals 128 Mb
 
    private:
        explicit VulkanDevice(const VulkanBackend& backend, const VulkanGraphicsAdapter& adapter, UniquePtr<VulkanSurface>&& surface, GraphicsDeviceFeatures features = { }, Span<String> extensions = { }, size_t globalDescriptorHeapSize = DEFAULT_DESCRIPTOR_HEAP_SIZE);
 
    private:
        VulkanDevice(VulkanDevice&&) noexcept = delete;

        VulkanDevice(const VulkanDevice&) = delete;

        VulkanDevice& operator=(VulkanDevice&&) noexcept = delete;

        VulkanDevice& operator=(const VulkanDevice&) = delete;
 
    public:
        ~VulkanDevice() noexcept override;
 
        // Factory methods.
    public:
        static inline SharedPtr<VulkanDevice> create(const VulkanBackend& backend, const VulkanGraphicsAdapter& adapter, UniquePtr<VulkanSurface>&& surface, GraphicsDeviceFeatures features = { }, Span<String> extensions = { }, size_t globalDescriptorHeapSize = DEFAULT_DESCRIPTOR_HEAP_SIZE) {
            return SharedObject::create<VulkanDevice>(backend, adapter, std::move(surface), features, extensions, globalDescriptorHeapSize)->initialize(Format::B8G8R8A8_SRGB, { 800, 600 }, 3, false, features); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        }

        static inline SharedPtr<VulkanDevice> create(const VulkanBackend& backend, const VulkanGraphicsAdapter& adapter, UniquePtr<VulkanSurface>&& surface, Format format, const Size2d& renderArea, UInt32 backBuffers, bool enableVsync = false, GraphicsDeviceFeatures features = { }, Span<String> extensions = { }, size_t globalDescriptorHeapSize = DEFAULT_DESCRIPTOR_HEAP_SIZE) {
            return SharedObject::create<VulkanDevice>(backend, adapter, std::move(surface), features, extensions, globalDescriptorHeapSize)->initialize(format, renderArea, backBuffers, enableVsync, features);
        }
 
    private:
        SharedPtr<VulkanDevice> initialize(Format format, const Size2d& renderArea, UInt32 backBuffers, bool enableVsync = false, GraphicsDeviceFeatures features = { });

        void release() noexcept;
 
        // Vulkan Device interface.
    private:
        void setDebugName(VkDebugReportObjectTypeEXT objectType, UInt64 objectHandle, StringView name) const noexcept;
 
    public:
        Span<const String> enabledExtensions() const noexcept;

        template <typename THandle>
        inline void setDebugName(THandle objectHandle, VkDebugReportObjectTypeEXT objectType, StringView name) const noexcept {
            this->setDebugName(objectType, Vk::handleAddress(objectHandle), name); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        }

        Enumerable<UInt32> queueFamilyIndices(QueueType type = QueueType::None) const;

        UInt32 descriptorSize(DescriptorType type) const;
 
        // GraphicsDevice interface.
    public:
        DeviceState& state() const noexcept override;

        const VulkanSwapChain& swapChain() const noexcept override;

        VulkanSwapChain& swapChain() noexcept override;

        const VulkanSurface& surface() const noexcept override;

        const VulkanGraphicsAdapter& adapter() const noexcept override;

        const VulkanGraphicsFactory& factory() const noexcept override;

        const VulkanQueue& defaultQueue(QueueType type) const override;

        SharedPtr<const VulkanQueue> createQueue(QueueType type, QueuePriority priority = QueuePriority::Normal) override;

        [[nodiscard]] UniquePtr<VulkanBarrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const override;

        [[nodiscard]] SharedPtr<VulkanFrameBuffer> makeFrameBuffer(StringView name, const Size2d& renderArea) const override;

        [[nodiscard]] SharedPtr<VulkanFrameBuffer> makeFrameBuffer(StringView name, const Size2d& renderArea, VulkanFrameBuffer::allocation_callback_type allocationCallback) const override;

        MultiSamplingLevel maximumMultiSamplingLevel(Format format) const noexcept override;

        double ticksPerMillisecond() const noexcept override;

        void wait() const override;

        void computeAccelerationStructureSizes(const VulkanBottomLevelAccelerationStructure& blas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const override;

        void computeAccelerationStructureSizes(const VulkanTopLevelAccelerationStructure& tlas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const override;

        [[nodiscard]] VirtualAllocator::Allocation allocateGlobalDescriptors(const VulkanDescriptorSet& descriptorSet, DescriptorHeapType heapType) const override;

        void releaseGlobalDescriptors(const VulkanDescriptorSet& descriptorSet) const override;

        void updateGlobalDescriptors(const VulkanDescriptorSet& descriptorSet, UInt32 binding, UInt32 offset, UInt32 descriptors) const override;

        void bindDescriptorSet(const VulkanCommandBuffer& commandBuffer, const VulkanDescriptorSet& descriptorSet, const VulkanPipelineState& pipeline) const noexcept override;

        void bindGlobalDescriptorHeaps(const VulkanCommandBuffer& commandBuffer) const noexcept override;
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
    public:
        [[nodiscard]] VulkanRenderPassBuilder buildRenderPass(UInt32 commandBuffers = 1) const override;

        [[nodiscard]] VulkanRenderPassBuilder buildRenderPass(const String& name, UInt32 commandBuffers = 1) const override;

        //[[nodiscard]] VulkanRenderPipelineBuilder buildRenderPipeline(const String& name) const override;

        [[nodiscard]] VulkanRenderPipelineBuilder buildRenderPipeline(const VulkanRenderPass& renderPass, const String& name) const override;

        [[nodiscard]] VulkanComputePipelineBuilder buildComputePipeline(const String& name) const override;

        [[nodiscard]] VulkanRayTracingPipelineBuilder buildRayTracingPipeline(ShaderRecordCollection&& shaderRecords) const override;

        [[nodiscard]] VulkanRayTracingPipelineBuilder buildRayTracingPipeline(const String& name, ShaderRecordCollection&& shaderRecords) const override;
        
        [[nodiscard]] VulkanPipelineLayoutBuilder buildPipelineLayout() const override;

        [[nodiscard]] VulkanInputAssemblerBuilder buildInputAssembler() const override;

        [[nodiscard]] VulkanRasterizerBuilder buildRasterizer() const override;

        [[nodiscard]] VulkanShaderProgramBuilder buildShaderProgram() const override;

        [[nodiscard]] VulkanBarrierBuilder buildBarrier() const override;
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)
    };

    class LITEFX_VULKAN_API VulkanBackend final : public RenderBackend<VulkanDevice>, public Resource<VkInstance> {
        LITEFX_IMPLEMENTATION(VulkanBackendImpl);
 
    public:
        explicit VulkanBackend(const App& app, const Span<String> extensions = { }, const Span<String> validationLayers = { });

        VulkanBackend(VulkanBackend&&) noexcept;

        VulkanBackend(const VulkanBackend&) = delete;

        VulkanBackend& operator=(VulkanBackend&&) noexcept;

        VulkanBackend& operator=(const VulkanBackend&) = delete;

        ~VulkanBackend() noexcept override;
 
    public:
        virtual Span<const String> getEnabledValidationLayers() const noexcept;
 
#ifdef VK_USE_PLATFORM_WIN32_KHR
        UniquePtr<VulkanSurface> createSurface(const HWND& hwnd) const;
#else
        typedef std::function<VkSurfaceKHR(const VkInstance&)> surface_callback;

        UniquePtr<VulkanSurface> createSurface(surface_callback predicate) const;
#endif // VK_USE_PLATFORM_WIN32_KHR
 
    public:
        static bool validateInstanceExtensions(Span<const String> extensions);

        static Enumerable<String> getAvailableInstanceExtensions();

        static bool validateInstanceLayers(const Span<const String> validationLayers);

        static Enumerable<String> getInstanceValidationLayers();
 
        // IBackend interface.
    public:
        BackendType type() const noexcept override;

        StringView name() const noexcept override;
 
    protected:
        void activate() override;

        void deactivate() override;
 
        // RenderBackend interface.
    public:
        const Array<SharedPtr<const VulkanGraphicsAdapter>>& adapters() const override;

        const VulkanGraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const noexcept override;

        void registerDevice(const String& name, SharedPtr<VulkanDevice>&& device) override;

        void releaseDevice(const String& name) override;

        VulkanDevice* device(const String& name) noexcept override;

        const VulkanDevice* device(const String& name) const noexcept override;
    };
 
}
 
#pragma warning(pop)