vulkan.hpp

#pragma once
 
#include <litefx/rendering.hpp>
 
#include "vulkan_api.hpp"
#include "vulkan_formatters.hpp"
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    class LITEFX_VULKAN_API VulkanVertexBufferLayout : public IVertexBufferLayout {
        LITEFX_IMPLEMENTATION(VulkanVertexBufferLayoutImpl);
        LITEFX_BUILDER(VulkanVertexBufferLayoutBuilder);
 
    public:
        explicit VulkanVertexBufferLayout(const size_t& vertexSize, const UInt32& binding = 0);
        VulkanVertexBufferLayout(VulkanVertexBufferLayout&&) = delete;
        VulkanVertexBufferLayout(const VulkanVertexBufferLayout&) = delete;
        virtual ~VulkanVertexBufferLayout() noexcept;
 
        // IVertexBufferLayout interface.
    public:
        virtual Array<const BufferAttribute*> attributes() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanIndexBufferLayout : public IIndexBufferLayout {
        LITEFX_IMPLEMENTATION(VulkanIndexBufferLayoutImpl);
 
    public:
        explicit VulkanIndexBufferLayout(const IndexType& type);
        VulkanIndexBufferLayout(VulkanIndexBufferLayout&&) = delete;
        VulkanIndexBufferLayout(const VulkanIndexBufferLayout&) = delete;
        virtual ~VulkanIndexBufferLayout() noexcept;
 
        // IIndexBufferLayout interface.
    public:
        virtual const IndexType& indexType() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_VULKAN_API IVulkanBuffer : public virtual IBuffer, public virtual IResource<VkBuffer> {
    public:
        virtual ~IVulkanBuffer() noexcept = default;
    };
 
    class LITEFX_VULKAN_API IVulkanVertexBuffer : public virtual VertexBuffer<VulkanVertexBufferLayout>, public virtual IVulkanBuffer {
    public:
        virtual ~IVulkanVertexBuffer() noexcept = default;
    };
 
    class LITEFX_VULKAN_API IVulkanIndexBuffer : public virtual IndexBuffer<VulkanIndexBufferLayout>, public virtual IVulkanBuffer {
    public:
        virtual ~IVulkanIndexBuffer() noexcept = default;
    };
 
    class LITEFX_VULKAN_API IVulkanImage : public virtual IImage, public virtual IResource<VkImage> {
    public:
        virtual ~IVulkanImage() noexcept = default;
 
    public:
        virtual VkImageAspectFlags aspectMask() const noexcept = 0;
 
        virtual VkImageAspectFlags aspectMask(const UInt32& plane) const = 0;
 
        virtual void resolveSubresource(const UInt32& subresource, UInt32& plane, UInt32& layer, UInt32& level) const = 0;
 
        virtual const VkImageView& imageView(const UInt32& plane = 0) const = 0;
    };
 
    class LITEFX_VULKAN_API IVulkanSampler : public virtual ISampler, public virtual IResource<VkSampler> {
    public:
        virtual ~IVulkanSampler() noexcept = default;
    };
 
    class LITEFX_VULKAN_API VulkanBarrier : public Barrier<IVulkanBuffer, IVulkanImage> {
        LITEFX_IMPLEMENTATION(VulkanBarrierImpl);
 
    public:
        explicit VulkanBarrier() noexcept;
        VulkanBarrier(const VulkanBarrier&) = delete;
        VulkanBarrier(VulkanBarrier&&) = delete;
        virtual ~VulkanBarrier() noexcept;
 
        // Barrier interface.
    public:
        virtual void transition(IVulkanBuffer& buffer, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanBuffer& buffer, const UInt32& element, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanBuffer& buffer, const ResourceState& sourceState, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanBuffer& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanImage& image, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanImage& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanImage& image, const ResourceState& sourceState, const ResourceState& targetState) override;
 
        virtual void transition(IVulkanImage& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override;
 
        virtual void waitFor(const IVulkanBuffer& buffer) override;
 
        virtual void waitFor(const IVulkanImage& image) override;
 
    public:
        virtual void execute(const VulkanCommandBuffer& commandBuffer) const noexcept;
 
        virtual void executeInverse(const VulkanCommandBuffer& commandBuffer) const noexcept;
    };
 
    class LITEFX_VULKAN_API VulkanShaderModule : public IShaderModule, public Resource<VkShaderModule> {
        LITEFX_IMPLEMENTATION(VulkanShaderModuleImpl);
 
    public:
        explicit VulkanShaderModule(const VulkanDevice& device, const ShaderStage& type, const String& fileName, const String& entryPoint = "main");
 
        explicit VulkanShaderModule(const VulkanDevice& device, const ShaderStage& type, std::istream& stream, const String& name, const String& entryPoint = "main");
        VulkanShaderModule(const VulkanShaderModule&) noexcept = delete;
        VulkanShaderModule(VulkanShaderModule&&) noexcept = delete;
        virtual ~VulkanShaderModule() noexcept;
 
        // ShaderModule interface.
    public:
        virtual const String& fileName() const noexcept override;
 
        virtual const String& entryPoint() const noexcept override;
 
        virtual const ShaderStage& type() const noexcept override;
 
    public:
        virtual const String& bytecode() const noexcept;
 
        virtual VkPipelineShaderStageCreateInfo shaderStageDefinition() const;
    };
 
    class LITEFX_VULKAN_API VulkanShaderProgram : public ShaderProgram<VulkanShaderModule> {
        LITEFX_IMPLEMENTATION(VulkanShaderProgramImpl);
        LITEFX_BUILDER(VulkanShaderProgramBuilder);
 
    public:
        explicit VulkanShaderProgram(const VulkanDevice& device, Array<UniquePtr<VulkanShaderModule>>&& modules);
        VulkanShaderProgram(VulkanShaderProgram&&) noexcept = delete;
        VulkanShaderProgram(const VulkanShaderProgram&) noexcept = delete;
        virtual ~VulkanShaderProgram() noexcept;
 
    private:
        explicit VulkanShaderProgram(const VulkanDevice& device) noexcept;
 
    public:
        virtual Array<const VulkanShaderModule*> modules() const noexcept override;
 
        virtual SharedPtr<VulkanPipelineLayout> reflectPipelineLayout() const;
 
    private:
        virtual SharedPtr<IPipelineLayout> parsePipelineLayout() const override {
            return std::static_pointer_cast<IPipelineLayout>(this->reflectPipelineLayout());
        }
    };
 
    class LITEFX_VULKAN_API VulkanDescriptorSet : public DescriptorSet<IVulkanBuffer, IVulkanImage, IVulkanSampler>, public Resource<VkDescriptorSet> {
        LITEFX_IMPLEMENTATION(VulkanDescriptorSetImpl);
 
    public:
        explicit VulkanDescriptorSet(const VulkanDescriptorSetLayout& layout, VkDescriptorSet descriptorSet);
        VulkanDescriptorSet(VulkanDescriptorSet&&) = delete;
        VulkanDescriptorSet(const VulkanDescriptorSet&) = delete;
        virtual ~VulkanDescriptorSet() noexcept;
 
    public:
        virtual const VulkanDescriptorSetLayout& layout() const noexcept;
 
    public:
        virtual void update(const UInt32& binding, const IVulkanBuffer& buffer, const UInt32& bufferElement = 0, const UInt32& elements = 1, const UInt32& firstDescriptor = 0) const override;
 
        virtual void update(const UInt32& binding, const IVulkanImage& texture, const UInt32& descriptor = 0, const UInt32& firstLevel = 0, const UInt32& levels = 0, const UInt32& firstLayer = 0, const UInt32& layers = 0) const override;
 
        virtual void update(const UInt32& binding, const IVulkanSampler& sampler, const UInt32& descriptor = 0) const override;
 
        virtual void attach(const UInt32& binding, const IVulkanImage& image) const override;
    };
 
    class LITEFX_VULKAN_API VulkanDescriptorLayout : public IDescriptorLayout {
        LITEFX_IMPLEMENTATION(VulkanDescriptorLayoutImpl);
 
    public:
        explicit VulkanDescriptorLayout(const DescriptorType& type, const UInt32& binding, const size_t& elementSize, const UInt32& descriptors = 1);
 
        explicit VulkanDescriptorLayout(UniquePtr<IVulkanSampler>&& staticSampler, const UInt32& binding);
 
        VulkanDescriptorLayout(VulkanDescriptorLayout&&) = delete;
        VulkanDescriptorLayout(const VulkanDescriptorLayout&) = delete;
        virtual ~VulkanDescriptorLayout() noexcept;
 
        // IDescriptorLayout interface.
    public:
        virtual const DescriptorType& descriptorType() const noexcept override;
 
        virtual const UInt32& descriptors() const noexcept override;
 
        virtual const IVulkanSampler* staticSampler() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanDescriptorSetLayout : public DescriptorSetLayout<VulkanDescriptorLayout, VulkanDescriptorSet>, public Resource<VkDescriptorSetLayout> {
        LITEFX_IMPLEMENTATION(VulkanDescriptorSetLayoutImpl);
        LITEFX_BUILDER(VulkanDescriptorSetLayoutBuilder);
 
    public:
        explicit VulkanDescriptorSetLayout(const VulkanDevice& device, Array<UniquePtr<VulkanDescriptorLayout>>&& descriptorLayouts, const UInt32& space, const ShaderStage& stages, const UInt32& poolSize = 1024, const UInt32& maxUnboundedArraySize = 104857);
        VulkanDescriptorSetLayout(VulkanDescriptorSetLayout&&) = delete;
        VulkanDescriptorSetLayout(const VulkanDescriptorSetLayout&) = delete;
        virtual ~VulkanDescriptorSetLayout() noexcept;
 
    private:
        explicit VulkanDescriptorSetLayout(const VulkanDevice& device) noexcept;
 
    public:
        virtual const VulkanDevice& device() const noexcept;
 
    public:
        virtual Array<const VulkanDescriptorLayout*> descriptors() const noexcept override;
 
        virtual const VulkanDescriptorLayout& descriptor(const UInt32& binding) const override;
 
        virtual const UInt32& space() const noexcept override;
 
        virtual const ShaderStage& shaderStages() const noexcept override;
 
        virtual UInt32 uniforms() const noexcept override;
 
        virtual UInt32 storages() const noexcept override;
 
        virtual UInt32 images() const noexcept override;
 
        virtual UInt32 buffers() const noexcept override;
 
        virtual UInt32 samplers() const noexcept override;
 
        virtual UInt32 staticSamplers() const noexcept override;
 
        virtual UInt32 inputAttachments() const noexcept override;
 
    public:
        virtual UniquePtr<VulkanDescriptorSet> allocate(const UInt32& descriptors = 0) const override;
 
        virtual Array<UniquePtr<VulkanDescriptorSet>> allocateMultiple(const UInt32& descriptorSets, const UInt32& descriptors = 0) const override;
 
        virtual void free(const VulkanDescriptorSet& descriptorSet) const noexcept override;
 
    public:
        virtual const UInt32& poolSize() const noexcept;
 
        virtual size_t pools() const noexcept;
    };
 
    class LITEFX_VULKAN_API VulkanPushConstantsRange : public IPushConstantsRange {
        LITEFX_IMPLEMENTATION(VulkanPushConstantsRangeImpl);
 
    public:
        explicit VulkanPushConstantsRange(const ShaderStage& shaderStage, const UInt32& offset, const UInt32& size, const UInt32& space, const UInt32& binding);
        VulkanPushConstantsRange(const VulkanPushConstantsRange&) = delete;
        VulkanPushConstantsRange(VulkanPushConstantsRange&&) = delete;
        virtual ~VulkanPushConstantsRange() noexcept;
 
    public:
        virtual const UInt32& space() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const UInt32& offset() const noexcept override;
 
        virtual const UInt32& size() const noexcept override;
 
        virtual const ShaderStage& stage() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanPushConstantsLayout : public PushConstantsLayout<VulkanPushConstantsRange> {
        LITEFX_IMPLEMENTATION(VulkanPushConstantsLayoutImpl);
        LITEFX_BUILDER(VulkanPushConstantsLayoutBuilder);
        friend class VulkanPipelineLayout;
 
    public:
        explicit VulkanPushConstantsLayout(Array<UniquePtr<VulkanPushConstantsRange>>&& ranges, const UInt32& size);
        VulkanPushConstantsLayout(const VulkanPushConstantsLayout&) = delete;
        VulkanPushConstantsLayout(VulkanPushConstantsLayout&&) = delete;
        virtual ~VulkanPushConstantsLayout() noexcept;
 
    private:
        explicit VulkanPushConstantsLayout(const UInt32& size);
 
    public:
        virtual const VulkanPipelineLayout& pipelineLayout() const;
 
    private:
        virtual void pipelineLayout(const VulkanPipelineLayout& pipelineLayout);
    
    public:
        virtual const UInt32& size() const noexcept override;
 
        virtual const VulkanPushConstantsRange& range(const ShaderStage& stage) const override;
 
        virtual Array<const VulkanPushConstantsRange*> ranges() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanPipelineLayout : public PipelineLayout<VulkanDescriptorSetLayout, VulkanPushConstantsLayout>, public Resource<VkPipelineLayout> {
        LITEFX_IMPLEMENTATION(VulkanPipelineLayoutImpl);
        LITEFX_BUILDER(VulkanPipelineLayoutBuilder);
 
    public:
        explicit VulkanPipelineLayout(const VulkanDevice& device, Array<UniquePtr<VulkanDescriptorSetLayout>>&& descriptorSetLayouts, UniquePtr<VulkanPushConstantsLayout>&& pushConstantsLayout);
        VulkanPipelineLayout(VulkanPipelineLayout&&) noexcept = delete;
        VulkanPipelineLayout(const VulkanPipelineLayout&) noexcept = delete;
        virtual ~VulkanPipelineLayout() noexcept;
 
    private:
        explicit VulkanPipelineLayout(const VulkanDevice& device) noexcept;
 
    public:
        virtual const VulkanDevice& device() const noexcept;
 
        // PipelineLayout interface.
    public:
        virtual const VulkanDescriptorSetLayout& descriptorSet(const UInt32& space) const override;
 
        virtual Array<const VulkanDescriptorSetLayout*> descriptorSets() const noexcept override;
 
        virtual const VulkanPushConstantsLayout* pushConstants() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanInputAssembler : public InputAssembler<VulkanVertexBufferLayout, VulkanIndexBufferLayout> {
        LITEFX_IMPLEMENTATION(VulkanInputAssemblerImpl);
        LITEFX_BUILDER(VulkanInputAssemblerBuilder);
 
    public:
        explicit VulkanInputAssembler(Array<UniquePtr<VulkanVertexBufferLayout>>&& vertexBufferLayouts, UniquePtr<VulkanIndexBufferLayout>&& indexBufferLayout, const PrimitiveTopology& primitiveTopology = PrimitiveTopology::TriangleList);
        VulkanInputAssembler(VulkanInputAssembler&&) noexcept = delete;
        VulkanInputAssembler(const VulkanInputAssembler&) noexcept = delete;
        virtual ~VulkanInputAssembler() noexcept;
 
    private:
        explicit VulkanInputAssembler() noexcept;
 
    public:
        virtual Array<const VulkanVertexBufferLayout*> vertexBufferLayouts() const noexcept override;
 
        virtual const VulkanVertexBufferLayout& vertexBufferLayout(const UInt32& binding) const override;
 
        virtual const VulkanIndexBufferLayout& indexBufferLayout() const override;
 
        virtual const PrimitiveTopology& topology() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanRasterizer : public Rasterizer {
        LITEFX_BUILDER(VulkanRasterizerBuilder);
 
    public:
        explicit VulkanRasterizer(const PolygonMode& polygonMode, const CullMode& cullMode, const CullOrder& cullOrder, const Float& lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) noexcept;
        VulkanRasterizer(VulkanRasterizer&&) noexcept = delete;
        VulkanRasterizer(const VulkanRasterizer&) noexcept = delete;
        virtual ~VulkanRasterizer() noexcept;
 
    private:
        explicit VulkanRasterizer() noexcept;
 
    public:
        virtual void updateLineWidth(const Float& lineWidth) noexcept;
    };
 
    class LITEFX_VULKAN_API VulkanPipelineState : public virtual Pipeline<VulkanPipelineLayout, VulkanShaderProgram>, public Resource<VkPipeline> {
    public:
        using Resource<VkPipeline>::Resource;
        virtual ~VulkanPipelineState() noexcept = default;
 
    public:
        virtual void use(const VulkanCommandBuffer& commandBuffer) const noexcept = 0;
 
        virtual void bind(const VulkanCommandBuffer& commandBuffer, const VulkanDescriptorSet& descriptorSet) const noexcept = 0;
    };
 
    class LITEFX_VULKAN_API VulkanCommandBuffer : public CommandBuffer<IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, VulkanBarrier, VulkanPipelineState>, public Resource<VkCommandBuffer> {
        LITEFX_IMPLEMENTATION(VulkanCommandBufferImpl);
 
    public:
        explicit VulkanCommandBuffer(const VulkanQueue& queue, const bool& begin = false, const bool& primary = true);
        VulkanCommandBuffer(const VulkanCommandBuffer&) = delete;
        VulkanCommandBuffer(VulkanCommandBuffer&&) = delete;
        virtual ~VulkanCommandBuffer() noexcept;
 
        // Vulkan Command Buffer interface.
    public:
        virtual void begin(const VulkanRenderPass& renderPass) const noexcept;
 
        // CommandBuffer interface.
    public:
        virtual void begin() const override;
 
        virtual void end() const override;
 
        virtual void generateMipMaps(IVulkanImage& image) noexcept override;
 
        virtual void barrier(const VulkanBarrier& barrier, const bool& invert = false) const noexcept override;
 
        virtual void transfer(const IVulkanBuffer& source, const IVulkanBuffer& target, const UInt32& sourceElement = 0, const UInt32& targetElement = 0, const UInt32& elements = 1) const override;
 
        virtual void transfer(const IVulkanBuffer& source, const IVulkanImage& target, const UInt32& sourceElement = 0, const UInt32& firstSubresource = 0, const UInt32& elements = 1) const override;
 
        virtual void transfer(const IVulkanImage& source, const IVulkanImage& target, const UInt32& sourceSubresource = 0, const UInt32& targetSubresource = 0, const UInt32& subresources = 1) const override;
 
        virtual void transfer(const IVulkanImage& source, const IVulkanBuffer& target, const UInt32& firstSubresource = 0, const UInt32& targetElement = 0, const UInt32& subresources = 1) const override;
 
        virtual void use(const VulkanPipelineState& pipeline) const noexcept override;
 
        virtual void bind(const VulkanDescriptorSet& descriptorSet, const VulkanPipelineState& pipeline) const noexcept override;
 
        virtual void bind(const IVulkanVertexBuffer& buffer) const noexcept override;
 
        virtual void bind(const IVulkanIndexBuffer& buffer) const noexcept override;
 
        virtual void dispatch(const Vector3u& threadCount) const noexcept override;
 
        virtual void draw(const UInt32& vertices, const UInt32& instances = 1, const UInt32& firstVertex = 0, const UInt32& firstInstance = 0) const noexcept override;
 
        virtual void drawIndexed(const UInt32& indices, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const noexcept override;
 
        virtual void pushConstants(const VulkanPushConstantsLayout& layout, const void* const memory) const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanRenderPipeline : public RenderPipeline<VulkanPipelineLayout, VulkanShaderProgram, VulkanInputAssembler, VulkanRasterizer>, public VulkanPipelineState {
        LITEFX_IMPLEMENTATION(VulkanRenderPipelineImpl);
        LITEFX_BUILDER(VulkanRenderPipelineBuilder);
 
    public:
        explicit VulkanRenderPipeline(const VulkanRenderPass& renderPass, SharedPtr<VulkanShaderProgram> shaderProgram, SharedPtr<VulkanPipelineLayout> layout, SharedPtr<VulkanInputAssembler> inputAssembler, SharedPtr<VulkanRasterizer> rasterizer, Array<SharedPtr<IViewport>> viewports, Array<SharedPtr<IScissor>> scissors, const bool& enableAlphaToCoverage = false, const String& name = "");
        VulkanRenderPipeline(VulkanRenderPipeline&&) noexcept = delete;
        VulkanRenderPipeline(const VulkanRenderPipeline&) noexcept = delete;
        virtual ~VulkanRenderPipeline() noexcept;
 
    private:
        VulkanRenderPipeline(const VulkanRenderPass& renderPass, const String& name = "") noexcept;
 
        // Pipeline interface.
    public:
        virtual SharedPtr<const VulkanShaderProgram> program() const noexcept override;
 
        virtual SharedPtr<const VulkanPipelineLayout> layout() const noexcept override;
 
        // RenderPipeline interface.
    public:
        virtual SharedPtr<VulkanInputAssembler> inputAssembler() const noexcept override;
 
        virtual SharedPtr<VulkanRasterizer> rasterizer() const noexcept override;
 
        virtual Array<const IViewport*> viewports() const noexcept override;
 
        virtual Array<const IScissor*> scissors() const noexcept override;
 
        virtual UInt32& stencilRef() const noexcept override;
 
        virtual Vector4f& blendFactors() const noexcept override;
 
        virtual const bool& alphaToCoverage() const noexcept override;
 
        // VulkanPipelineState interface.
    public:
        virtual void use(const VulkanCommandBuffer& commandBuffer) const noexcept override;
 
        virtual void bind(const VulkanCommandBuffer& commandBuffer, const VulkanDescriptorSet& descriptorSet) const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanComputePipeline : public ComputePipeline<VulkanPipelineLayout, VulkanShaderProgram>, public VulkanPipelineState {
        LITEFX_IMPLEMENTATION(VulkanComputePipelineImpl);
        LITEFX_BUILDER(VulkanComputePipelineBuilder);
 
    public:
        explicit VulkanComputePipeline(const VulkanDevice& device, SharedPtr<VulkanShaderProgram> shaderProgram, SharedPtr<VulkanPipelineLayout> layout, const String& name = "");
        VulkanComputePipeline(VulkanComputePipeline&&) noexcept = delete;
        VulkanComputePipeline(const VulkanComputePipeline&) noexcept = delete;
        virtual ~VulkanComputePipeline() noexcept;
 
    private:
        VulkanComputePipeline(const VulkanDevice& device) noexcept;
 
        // Pipeline interface.
    public:
        virtual SharedPtr<const VulkanShaderProgram> program() const noexcept override;
 
        virtual SharedPtr<const VulkanPipelineLayout> layout() const noexcept override;
 
        // VulkanPipelineState interface.
    public:
        virtual void use(const VulkanCommandBuffer& commandBuffer) const noexcept override;
 
        virtual void bind(const VulkanCommandBuffer& commandBuffer, const VulkanDescriptorSet& descriptorSet) const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanFrameBuffer : public FrameBuffer<VulkanCommandBuffer>, public Resource<VkFramebuffer> {
        LITEFX_IMPLEMENTATION(VulkanFrameBufferImpl);
 
    public:
        VulkanFrameBuffer(const VulkanRenderPass& renderPass, const UInt32& bufferIndex, const Size2d& renderArea, const UInt32& commandBuffers = 1);
        VulkanFrameBuffer(const VulkanFrameBuffer&) noexcept = delete;
        VulkanFrameBuffer(VulkanFrameBuffer&&) noexcept = delete;
        virtual ~VulkanFrameBuffer() noexcept;
 
        // Vulkan frame buffer interface.
    public:
        virtual const VkSemaphore& semaphore() const noexcept;
 
        virtual UInt64& lastFence() const noexcept;
 
        // FrameBuffer interface.
    public:
        virtual const UInt32& bufferIndex() const noexcept override;
 
        virtual const Size2d& size() const noexcept override;
 
        virtual size_t getWidth() const noexcept override;
 
        virtual size_t getHeight() const noexcept override;
 
        virtual const VulkanCommandBuffer& commandBuffer(const UInt32& index) const override;
 
        virtual Array<const VulkanCommandBuffer*> commandBuffers() const noexcept override;
 
        virtual Array<const IVulkanImage*> images() const noexcept override;
 
        virtual const IVulkanImage& image(const UInt32& location) const override;
 
    public:
        virtual void resize(const Size2d& renderArea) override;
    };
 
    class LITEFX_VULKAN_API VulkanRenderPass : public RenderPass<VulkanRenderPipeline, VulkanFrameBuffer, VulkanInputAttachmentMapping>, public Resource<VkRenderPass> {
        LITEFX_IMPLEMENTATION(VulkanRenderPassImpl);
        LITEFX_BUILDER(VulkanRenderPassBuilder);
 
    public:
        explicit VulkanRenderPass(const VulkanDevice& device, Span<RenderTarget> renderTargets, const UInt32& commandBuffers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, Span<VulkanInputAttachmentMapping> inputAttachments = { });
 
        explicit VulkanRenderPass(const VulkanDevice& device, const String& name, Span<RenderTarget> renderTargets, const UInt32& commandBuffers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, Span<VulkanInputAttachmentMapping> inputAttachments = { });
        
        VulkanRenderPass(const VulkanRenderPass&) = delete;
        VulkanRenderPass(VulkanRenderPass&&) = delete;
        virtual ~VulkanRenderPass() noexcept;
 
    private:
        explicit VulkanRenderPass(const VulkanDevice& device, const String& name = "") noexcept;
 
        // IInputAttachmentMappingSource interface.
    public:
        virtual const VulkanFrameBuffer& frameBuffer(const UInt32& buffer) const override;
 
        // RenderPass interface.
    public:
        virtual const VulkanDevice& device() const noexcept;
 
        virtual const VulkanFrameBuffer& activeFrameBuffer() const override;
 
        virtual Array<const VulkanFrameBuffer*> frameBuffers() const noexcept override;
 
        virtual Array<const VulkanRenderPipeline*> pipelines() const noexcept override;
 
        virtual const RenderTarget& renderTarget(const UInt32& location) const override;
 
        virtual Span<const RenderTarget> renderTargets() const noexcept override;
 
        virtual bool hasPresentTarget() const noexcept override;
 
        virtual Span<const VulkanInputAttachmentMapping> inputAttachments() const noexcept override;
 
        virtual const MultiSamplingLevel& multiSamplingLevel() const noexcept override;
 
    public:
        virtual void begin(const UInt32& buffer) override;
        
        virtual void end() const override;
 
        virtual void resizeFrameBuffers(const Size2d& renderArea) override;
 
        virtual void changeMultiSamplingLevel(const MultiSamplingLevel& samples) override;
 
        virtual void updateAttachments(const VulkanDescriptorSet& descriptorSet) const override;
    };
 
    class LITEFX_VULKAN_API VulkanInputAttachmentMapping : public IInputAttachmentMapping<VulkanRenderPass> {
        LITEFX_IMPLEMENTATION(VulkanInputAttachmentMappingImpl);
 
    public:
        VulkanInputAttachmentMapping() noexcept;
 
        VulkanInputAttachmentMapping(const VulkanRenderPass& renderPass, const RenderTarget& renderTarget, const UInt32& location);
 
        VulkanInputAttachmentMapping(const VulkanInputAttachmentMapping&) noexcept;
 
        VulkanInputAttachmentMapping(VulkanInputAttachmentMapping&&) noexcept;
 
        virtual ~VulkanInputAttachmentMapping() noexcept;
 
    public:
        inline VulkanInputAttachmentMapping& operator=(const VulkanInputAttachmentMapping&) noexcept;
 
        inline VulkanInputAttachmentMapping& operator=(VulkanInputAttachmentMapping&&) noexcept;
 
    public:
        virtual const VulkanRenderPass* inputAttachmentSource() const noexcept override;
 
        virtual const RenderTarget& renderTarget() const noexcept override;
 
        virtual const UInt32& location() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanSwapChain : public SwapChain<IVulkanImage, VulkanFrameBuffer> {
        LITEFX_IMPLEMENTATION(VulkanSwapChainImpl);
 
    public:
        explicit VulkanSwapChain(const VulkanDevice& device, const Format& surfaceFormat = Format::B8G8R8A8_SRGB, const Size2d& renderArea = { 800, 600 }, const UInt32& buffers = 3);
        VulkanSwapChain(const VulkanSwapChain&) = delete;
        VulkanSwapChain(VulkanSwapChain&&) = delete;
        virtual ~VulkanSwapChain() noexcept;
 
        // Vulkan Swap Chain interface.
    public:
        virtual const VkSemaphore& semaphore() const noexcept;
 
        // SwapChain interface.
    public:
        virtual const Format& surfaceFormat() const noexcept override;
 
        virtual const UInt32& buffers() const noexcept override;
 
        virtual const Size2d& renderArea() const noexcept override;
 
        virtual Array<const IVulkanImage*> images() const noexcept override;
 
        virtual void present(const VulkanFrameBuffer& frameBuffer) const override;
 
    public:
        virtual Array<Format> getSurfaceFormats() const noexcept override;
 
        virtual void reset(const Format& surfaceFormat, const Size2d& renderArea, const UInt32& buffers) override;
 
        [[nodiscard]] virtual UInt32 swapBackBuffer() const override;
    };
 
    class LITEFX_VULKAN_API VulkanQueue : public CommandQueue<VulkanCommandBuffer>, public Resource<VkQueue> {
        LITEFX_IMPLEMENTATION(VulkanQueueImpl);
    
    public:
        explicit VulkanQueue(const VulkanDevice& device, const QueueType& type, const QueuePriority& priority, const UInt32& familyId, const UInt32& queueId);
        VulkanQueue(const VulkanQueue&) = delete;
        VulkanQueue(VulkanQueue&&) = delete;
        virtual ~VulkanQueue() noexcept;
 
        // VulkanQueue interface.
    public:
        virtual const VulkanDevice& device() const noexcept;
 
        virtual const VkCommandPool& commandPool() const noexcept;
 
        virtual const UInt32& familyId() const noexcept;
 
        virtual const UInt32& queueId() const noexcept;
 
        virtual const VkSemaphore& timelineSemaphore() const noexcept;
 
        virtual UInt64 submit(const VulkanCommandBuffer& commandBuffer, Span<VkSemaphore> waitForSemaphores, Span<VkPipelineStageFlags> waitForStages, Span<VkSemaphore> signalSemaphores = { }) const;
 
        virtual UInt64 submit(const Array<const VulkanCommandBuffer*>& commandBuffers, Span<VkSemaphore> waitForSemaphores, Span<VkPipelineStageFlags> waitForStages, Span<VkSemaphore> signalSemaphores = { }) const;
 
        virtual UniquePtr<VulkanCommandBuffer> createCommandBuffer(const bool& secondary, const bool& beginRecording) const;
 
        // CommandQueue interface.
    public:
        virtual bool isBound() const noexcept override;
 
        virtual const QueuePriority& priority() const noexcept override;
 
        virtual const QueueType& type() const noexcept override;
 
    public:
        virtual void bind() override;
 
        virtual void release() override;
 
        virtual UniquePtr<VulkanCommandBuffer> createCommandBuffer(const bool& beginRecording = false) const override;
 
        virtual UInt64 submit(const VulkanCommandBuffer& commandBuffer) const override;
 
        virtual UInt64 submit(const Array<const VulkanCommandBuffer*>& commandBuffers) const override;
 
        virtual void waitFor(const UInt64& fence) const noexcept override;
 
        virtual UInt64 currentFence() const noexcept override;
    };
 
    class LITEFX_VULKAN_API VulkanGraphicsFactory : public GraphicsFactory<VulkanDescriptorLayout, IVulkanBuffer, IVulkanVertexBuffer, IVulkanIndexBuffer, IVulkanImage, IVulkanSampler> {
        LITEFX_IMPLEMENTATION(VulkanGraphicsFactoryImpl);
 
    public:
        explicit VulkanGraphicsFactory(const VulkanDevice& device);
        VulkanGraphicsFactory(const VulkanGraphicsFactory&) = delete;
        VulkanGraphicsFactory(VulkanGraphicsFactory&&) = delete;
        virtual ~VulkanGraphicsFactory() noexcept;
 
    public:
        virtual UniquePtr<IVulkanBuffer> createBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IVulkanBuffer> createBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IVulkanVertexBuffer> createVertexBuffer(const VulkanVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const override;
 
        virtual UniquePtr<IVulkanVertexBuffer> createVertexBuffer(const String& name, const VulkanVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const override;
 
        virtual UniquePtr<IVulkanIndexBuffer> createIndexBuffer(const VulkanIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override;
 
        virtual UniquePtr<IVulkanIndexBuffer> createIndexBuffer(const String& name, const VulkanIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override;
 
        virtual UniquePtr<IVulkanImage> createAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const override;
 
        virtual UniquePtr<IVulkanImage> createAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const override;
 
        virtual UniquePtr<IVulkanImage> 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 override;
 
        virtual UniquePtr<IVulkanImage> 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 override;
 
        virtual Array<UniquePtr<IVulkanImage>> createTextures(const UInt32& elements, 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 override;
 
        virtual UniquePtr<IVulkanSampler> 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 override;
 
        virtual UniquePtr<IVulkanSampler> 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 override;
 
        virtual Array<UniquePtr<IVulkanSampler>> 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 override;
    };
 
    class LITEFX_VULKAN_API VulkanDevice : public GraphicsDevice<VulkanGraphicsFactory, VulkanSurface, VulkanGraphicsAdapter, VulkanSwapChain, VulkanQueue, VulkanRenderPass, VulkanComputePipeline, VulkanBarrier>, public Resource<VkDevice> {
        LITEFX_IMPLEMENTATION(VulkanDeviceImpl);
 
    public:
        explicit VulkanDevice(const VulkanBackend& backend, const VulkanGraphicsAdapter& adapter, UniquePtr<VulkanSurface>&& surface, Span<String> extensions = { });
 
        explicit VulkanDevice(const VulkanBackend& backend, const VulkanGraphicsAdapter& adapter, UniquePtr<VulkanSurface>&& surface, const Format& format, const Size2d& frameBufferSize, const UInt32& frameBuffers, Span<String> extensions = { });
 
        VulkanDevice(const VulkanDevice&) = delete;
        VulkanDevice(VulkanDevice&&) = delete;
        virtual ~VulkanDevice() noexcept;
 
        // Vulkan Device interface.
    public:
        virtual Span<const String> enabledExtensions() const noexcept;
 
        virtual void setDebugName(UInt64 objectHandle, VkDebugReportObjectTypeEXT objectType, StringView name) const noexcept;
 
        // GraphicsDevice interface.
    public:
        virtual DeviceState& state() const noexcept override;
 
        virtual const VulkanSwapChain& swapChain() const noexcept override;
 
        virtual VulkanSwapChain& swapChain() noexcept override;
 
        virtual const VulkanSurface& surface() const noexcept override;
 
        virtual const VulkanGraphicsAdapter& adapter() const noexcept override;
 
        virtual const VulkanGraphicsFactory& factory() const noexcept override;
        
        virtual const VulkanQueue& graphicsQueue() const noexcept override;
        
        virtual const VulkanQueue& transferQueue() const noexcept override;
 
        virtual const VulkanQueue& bufferQueue() const noexcept override;
 
        virtual const VulkanQueue& computeQueue() const noexcept override;
 
        virtual UniquePtr<VulkanBarrier> makeBarrier() const noexcept override;
 
        virtual MultiSamplingLevel maximumMultiSamplingLevel(const Format& format) const noexcept override;
 
        virtual void wait() const override;
 
#if defined(BUILD_DEFINE_BUILDERS)
    public:
        [[nodiscard]] virtual VulkanRenderPassBuilder buildRenderPass(const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const override;
 
        [[nodiscard]] virtual VulkanRenderPassBuilder buildRenderPass(const String& name, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const override;
 
        //[[nodiscard]] virtual VulkanRenderPipelineBuilder buildRenderPipeline(const String& name) const override;
 
        [[nodiscard]] virtual VulkanRenderPipelineBuilder buildRenderPipeline(const VulkanRenderPass& renderPass, const String& name) const override;
 
        [[nodiscard]] virtual VulkanComputePipelineBuilder buildComputePipeline(const String& name) const override;
        
        [[nodiscard]] virtual VulkanPipelineLayoutBuilder buildPipelineLayout() const override;
 
        [[nodiscard]] virtual VulkanInputAssemblerBuilder buildInputAssembler() const override;
 
        [[nodiscard]] virtual VulkanRasterizerBuilder buildRasterizer() const override;
 
        [[nodiscard]] virtual VulkanShaderProgramBuilder buildShaderProgram() const override;
#endif // defined(BUILD_DEFINE_BUILDERS)
    };
 
    class LITEFX_VULKAN_API VulkanBackend : public RenderBackend<VulkanBackend, VulkanDevice>, public Resource<VkInstance> {
        LITEFX_IMPLEMENTATION(VulkanBackendImpl);
 
    public:
        explicit VulkanBackend(const App& app, const Span<String> extensions = { }, const Span<String> validationLayers = { });
        VulkanBackend(const VulkanBackend&) noexcept = delete;
        VulkanBackend(VulkanBackend&&) noexcept = delete;
        virtual ~VulkanBackend() noexcept;
 
 
    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) noexcept;
 
        static Array<String> getAvailableInstanceExtensions() noexcept;
 
        static bool validateInstanceLayers(const Span<const String> validationLayers) noexcept;
 
        static Array<String> getInstanceValidationLayers() noexcept;
 
        // IBackend interface.
    public:
        virtual BackendType type() const noexcept override;
 
        virtual String name() const noexcept override;
 
    protected:
        virtual void activate() override;
 
        virtual void deactivate() override;
 
        // RenderBackend interface.
    public:
        virtual Array<const VulkanGraphicsAdapter*> listAdapters() const override;
 
        virtual const VulkanGraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const override;
 
        virtual void registerDevice(String name, UniquePtr<VulkanDevice>&& device) override;
 
        virtual void releaseDevice(const String& name) override;
 
        virtual VulkanDevice* device(const String& name) noexcept override;
 
        virtual const VulkanDevice* device(const String& name) const noexcept override;
    };
}