vulkan_api.hpp

#pragma once
 
#include <litefx/config.h>
 
#if !defined (LITEFX_VULKAN_API)
#  if defined(LiteFX_Backends_Vulkan_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_VULKAN_API __declspec(dllexport)
#  elif (defined(LiteFX_Backends_Vulkan_EXPORTS) || defined(__APPLE__)) && defined __GNUC__ && __GNUC__ >= 4
#    define LITEFX_VULKAN_API __attribute__ ((visibility ("default")))
#  elif !defined(LiteFX_Backends_Vulkan_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_VULKAN_API __declspec(dllimport)
#  endif
#endif 
 
#ifndef LITEFX_VULKAN_API
#  define LITEFX_VULKAN_API
#endif
 
#if (defined _WIN32 || defined WINCE)
#  define VK_USE_PLATFORM_WIN32_KHR
#else 
#  pragma message ("Vulkan: No supported surface platform detected.")
#endif
 
#include <litefx/rendering.hpp>
#include <vulkan/vulkan.h>
#include "vulkan_formatters.hpp"
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    constexpr StringView VULKAN_LOG = "Backend::Vulkan"sv;
 
    // Forward declarations.
    class VulkanVertexBufferLayout;
    class VulkanIndexBufferLayout;
    class VulkanDescriptorLayout;
    class VulkanDescriptorSetLayout;
    class VulkanDescriptorSet;
    class VulkanPushConstantsRange;
    class VulkanPushConstantsLayout;
    class VulkanPipelineLayout;
    class VulkanShaderModule;
    class VulkanShaderProgram;
    class VulkanCommandBuffer;
    class VulkanInputAssembler;
    class VulkanRasterizer; 
    class VulkanPipelineState;
    class VulkanRenderPipeline;
    class VulkanComputePipeline;
    class VulkanRayTracingPipeline;
    class VulkanFrameBuffer;
    class VulkanRenderPass;
    class VulkanSwapChain;
    class VulkanQueue;
    class VulkanGraphicsFactory;
    class VulkanDevice;
    class VulkanBackend;
 
    // Interface declarations.
    class IVulkanBuffer;
    class IVulkanVertexBuffer;
    class IVulkanIndexBuffer;
    class IVulkanImage;
    class IVulkanSampler;
    class IVulkanAccelerationStructure;
    class VulkanBottomLevelAccelerationStructure;
    class VulkanTopLevelAccelerationStructure;
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
    // Builder declarations.
    class VulkanVertexBufferLayoutBuilder;
    class VulkanDescriptorSetLayoutBuilder;
    class VulkanPushConstantsLayoutBuilder;
    class VulkanPipelineLayoutBuilder;
    class VulkanShaderProgramBuilder;
    class VulkanInputAssemblerBuilder;
    class VulkanRasterizerBuilder;
    class VulkanRenderPipelineBuilder;
    class VulkanComputePipelineBuilder;
    class VulkanRayTracingPipelineBuilder;
    class VulkanRenderPassBuilder;
    class VulkanBarrierBuilder;
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)
 
    namespace Vk
    {
        Format LITEFX_VULKAN_API getFormat(const VkFormat& format);
 
        VkFormat LITEFX_VULKAN_API getFormat(Format format);
 
        //BufferFormat LITEFX_VULKAN_API getFormat(const VkFormat& format);
 
        VkFormat LITEFX_VULKAN_API getFormat(BufferFormat format);
 
        PolygonMode LITEFX_VULKAN_API getPolygonMode(const VkPolygonMode& mode);
 
        VkPolygonMode LITEFX_VULKAN_API getPolygonMode(PolygonMode mode);
 
        CullMode LITEFX_VULKAN_API getCullMode(const VkCullModeFlags& mode);
 
        VkCullModeFlags LITEFX_VULKAN_API getCullMode(CullMode mode);
 
        PrimitiveTopology LITEFX_VULKAN_API getPrimitiveTopology(const VkPrimitiveTopology& topology);
 
        VkPrimitiveTopology LITEFX_VULKAN_API getPrimitiveTopology(PrimitiveTopology topology);
 
        ShaderStage LITEFX_VULKAN_API getShaderStage(const VkShaderStageFlagBits& shaderType);
 
        VkShaderStageFlagBits LITEFX_VULKAN_API getShaderStage(ShaderStage shaderType);
 
        MultiSamplingLevel LITEFX_VULKAN_API getSamples(const VkSampleCountFlagBits& samples);
 
        VkImageType LITEFX_VULKAN_API getImageType(ImageDimensions dimension);
 
        VkImageViewType LITEFX_VULKAN_API getImageViewType(ImageDimensions dimension, UInt32 layers = 1);
 
        VkSampleCountFlagBits LITEFX_VULKAN_API getSamples(MultiSamplingLevel samples);
 
        VkCompareOp LITEFX_VULKAN_API getCompareOp(CompareOperation compareOp);
 
        VkStencilOp LITEFX_VULKAN_API getStencilOp(StencilOperation stencilOp);
 
        VkBlendFactor LITEFX_VULKAN_API getBlendFactor(BlendFactor blendFactor);
 
        VkBlendOp LITEFX_VULKAN_API getBlendOperation(BlendOperation blendOperation);
 
        VkPipelineStageFlags2 LITEFX_VULKAN_API getPipelineStage(PipelineStage pipelineStage);
 
        VkAccessFlags2 LITEFX_VULKAN_API getResourceAccess(ResourceAccess resourceAccess);
 
        VkImageLayout LITEFX_VULKAN_API getImageLayout(ImageLayout imageLayout);
 
        template <typename THandle>
        constexpr UInt64 handleAddress(const THandle handle) noexcept {
            return reinterpret_cast<std::uintptr_t>(handle); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        }
 
        template <>
        constexpr UInt64 handleAddress(const UInt64 handle) noexcept {
            return handle;
        }
    }
 
    class LITEFX_VULKAN_API VulkanGraphicsAdapter final : public IGraphicsAdapter, public Resource<VkPhysicalDevice> {
        LITEFX_IMPLEMENTATION(VulkanGraphicsAdapterImpl);
        friend struct SharedObject::Allocator<VulkanGraphicsAdapter>;
 
    private:
        explicit VulkanGraphicsAdapter(VkPhysicalDevice adapter);
 
    private:
        VulkanGraphicsAdapter(VulkanGraphicsAdapter&&) noexcept = delete;
 
        VulkanGraphicsAdapter(const VulkanGraphicsAdapter&) = delete;
 
        VulkanGraphicsAdapter& operator=(VulkanGraphicsAdapter&&) noexcept = delete;
 
        VulkanGraphicsAdapter& operator=(const VulkanGraphicsAdapter&) = delete;
 
    public:
        ~VulkanGraphicsAdapter() noexcept override;
 
    public:
        static inline auto create(VkPhysicalDevice adapter) {
            return SharedObject::create<VulkanGraphicsAdapter>(adapter);
        }
 
    public:
        String name() const override;
 
        UInt64 uniqueId() const noexcept override;
 
        UInt32 vendorId() const noexcept override;
 
        UInt32 deviceId() const noexcept override;
 
        GraphicsAdapterType type() const noexcept override;
 
        UInt64 driverVersion() const noexcept override;
 
        UInt32 apiVersion() const noexcept override;
 
        UInt64 dedicatedMemory() const noexcept override;
 
    public:
        VkPhysicalDeviceLimits limits() const noexcept;
 
        bool validateDeviceExtensions(Span<const String> extensions) const;
 
        Enumerable<String> getAvailableDeviceExtensions() const;
 
        bool validateDeviceLayers(const Span<const String> validationLayers) const;
 
        Enumerable<String> deviceValidationLayers() const;
    };
 
    class LITEFX_VULKAN_API VulkanSurface final : public ISurface, public Resource<VkSurfaceKHR> {
        LITEFX_IMPLEMENTATION(VulkanSurfaceImpl)
 
    public:
#ifdef VK_USE_PLATFORM_WIN32_KHR
        VulkanSurface(const VkSurfaceKHR& surface, const VkInstance& instance, const HWND hwnd);
#else
        VulkanSurface(const VkSurfaceKHR& surface, const VkInstance& instance);
#endif // VK_USE_PLATFORM_WIN32_KHR
 
 
        VulkanSurface(VulkanSurface&&) noexcept;
 
        VulkanSurface(const VulkanSurface&) = delete;
 
        VulkanSurface& operator=(VulkanSurface&&) noexcept;
 
        VulkanSurface& operator=(const VulkanSurface&) = delete;
 
        ~VulkanSurface() noexcept override;
 
    public:
        const VkInstance& instance() const noexcept;
 
#ifdef VK_USE_PLATFORM_WIN32_KHR
        HWND windowHandle() const noexcept;
#endif // VK_USE_PLATFORM_WIN32_KHR
    };
 
    class LITEFX_VULKAN_API VulkanPlatformException : public RuntimeException {
    private:
        VkResult m_code;
 
    public:
        explicit VulkanPlatformException(VkResult result) :
            RuntimeException("Operation returned {0}.", result), m_code(result) { }
 
        explicit VulkanPlatformException(VkResult result, StringView message) :
            RuntimeException("{1} Operation returned {0}.", result, message), m_code(result) { }
 
        template <typename ...TArgs>
        explicit VulkanPlatformException(VkResult result, StringView format, TArgs&&... args) :
            VulkanPlatformException(result, std::format(format, std::forward<TArgs>(args)...)) { }
 
        VulkanPlatformException(VulkanPlatformException&&) noexcept = default;
 
        VulkanPlatformException(const VulkanPlatformException&) = default;
 
        VulkanPlatformException& operator=(VulkanPlatformException&&) noexcept = default;
 
        VulkanPlatformException& operator=(const VulkanPlatformException&) = default;
 
        ~VulkanPlatformException() noexcept override = default;
 
    public:
        VkResult code() const noexcept {
            return m_code;
        }
    };
 
    template <typename ...TArgs>
    static inline void raiseIfFailed(VkResult result, StringView message, TArgs&&... args) {
        if (result == VK_SUCCESS) [[likely]]
            return;
        else
            throw VulkanPlatformException(result, message, std::forward<TArgs>(args)...);
    }
}