vulkan_api.hpp

#pragma once
 
#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/config.h>
#include <litefx/rendering.hpp>
#include <vulkan/vulkan.h>
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    constexpr char VULKAN_LOG[] = "Backend::Vulkan";
 
    // 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 VulkanFrameBuffer;
    class VulkanRenderPass;
    class VulkanInputAttachmentMapping;
    class VulkanSwapChain;
    class VulkanQueue;
    class VulkanGraphicsFactory;
    class VulkanDevice;
    class VulkanBackend;
 
    // Interface declarations.
    class IVulkanBuffer;
    class IVulkanVertexBuffer;
    class IVulkanIndexBuffer;
    class IVulkanImage;
    class IVulkanSampler;
 
#if defined(BUILD_DEFINE_BUILDERS)
    // Builder declarations.
    class VulkanVertexBufferLayoutBuilder;
    class VulkanDescriptorSetLayoutBuilder;
    class VulkanPushConstantsLayoutBuilder;
    class VulkanPipelineLayoutBuilder;
    class VulkanShaderProgramBuilder;
    class VulkanInputAssemblerBuilder;
    class VulkanRasterizerBuilder;
    class VulkanRenderPipelineBuilder;
    class VulkanComputePipelineBuilder;
    class VulkanRenderPassBuilder;
#endif // defined(BUILD_DEFINE_BUILDERS)
 
    namespace Vk
    {
        Format LITEFX_VULKAN_API getFormat(const VkFormat& format);
 
        VkFormat LITEFX_VULKAN_API getFormat(const Format& format);
 
        //BufferFormat LITEFX_VULKAN_API getFormat(const VkFormat& format);
 
        VkFormat LITEFX_VULKAN_API getFormat(const BufferFormat& format);
 
        PolygonMode LITEFX_VULKAN_API getPolygonMode(const VkPolygonMode& mode);
 
        VkPolygonMode LITEFX_VULKAN_API getPolygonMode(const PolygonMode& mode);
 
        CullMode LITEFX_VULKAN_API getCullMode(const VkCullModeFlags& mode);
 
        VkCullModeFlags LITEFX_VULKAN_API getCullMode(const CullMode& mode);
 
        PrimitiveTopology LITEFX_VULKAN_API getPrimitiveTopology(const VkPrimitiveTopology& topology);
 
        VkPrimitiveTopology LITEFX_VULKAN_API getPrimitiveTopology(const PrimitiveTopology& topology);
 
        ShaderStage LITEFX_VULKAN_API getShaderStage(const VkShaderStageFlagBits& shaderType);
 
        VkShaderStageFlagBits LITEFX_VULKAN_API getShaderStage(const ShaderStage& shaderType);
 
        MultiSamplingLevel LITEFX_VULKAN_API getSamples(const VkSampleCountFlagBits& samples);
 
        VkImageType LITEFX_VULKAN_API getImageType(const ImageDimensions& dimension);
 
        VkImageViewType LITEFX_VULKAN_API getImageViewType(const ImageDimensions& dimension, const UInt32& layers = 1);
 
        VkSampleCountFlagBits LITEFX_VULKAN_API getSamples(const MultiSamplingLevel& samples);
 
        VkCompareOp LITEFX_VULKAN_API getCompareOp(const CompareOperation& compareOp);
 
        VkStencilOp LITEFX_VULKAN_API getStencilOp(const StencilOperation& stencilOp);
 
        VkBlendFactor LITEFX_VULKAN_API getBlendFactor(const BlendFactor& blendFactor);
 
        VkBlendOp LITEFX_VULKAN_API getBlendOperation(const BlendOperation& blendOperation);
 
        VkImageLayout LITEFX_VULKAN_API getImageLayout(const ResourceState& resourceState);
 
        VkAccessFlags LITEFX_VULKAN_API getAccessFlags(const ResourceState& resourceState);
    }
 
    class LITEFX_VULKAN_API VulkanGraphicsAdapter : public IGraphicsAdapter, public Resource<VkPhysicalDevice> {
        LITEFX_IMPLEMENTATION(VulkanGraphicsAdapterImpl);
 
    public:
        explicit VulkanGraphicsAdapter(VkPhysicalDevice adapter);
        VulkanGraphicsAdapter(const VulkanGraphicsAdapter&) = delete;
        VulkanGraphicsAdapter(VulkanGraphicsAdapter&&) = delete;
        virtual ~VulkanGraphicsAdapter() noexcept;
 
    public:
        virtual String name() const noexcept override;
 
        virtual UInt64 uniqueId() const noexcept override;
 
        virtual UInt32 vendorId() const noexcept override;
 
        virtual UInt32 deviceId() const noexcept override;
 
        virtual GraphicsAdapterType type() const noexcept override;
 
        virtual UInt32 driverVersion() const noexcept override;
 
        virtual UInt32 apiVersion() const noexcept override;
 
        virtual UInt64 dedicatedMemory() const noexcept override;
 
    public:
        VkPhysicalDeviceLimits limits() const noexcept;
 
        bool validateDeviceExtensions(Span<const String> extensions) const noexcept;
 
        Array<String> getAvailableDeviceExtensions() const noexcept;
 
        bool validateDeviceLayers(const Span<const String> validationLayers) const noexcept;
 
        Array<String> deviceValidationLayers() const noexcept;
    };
 
    class LITEFX_VULKAN_API VulkanSurface : 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(const VulkanSurface&) = delete;
        VulkanSurface(VulkanSurface&&) = delete;
        virtual ~VulkanSurface() noexcept;
 
    public:
        const VkInstance& instance() const noexcept;
 
#ifdef VK_USE_PLATFORM_WIN32_KHR
        const HWND windowHandle() const noexcept;
#endif // VK_USE_PLATFORM_WIN32_KHR
    };
 
    DEFINE_EXCEPTION(VulkanPlatformException, std::runtime_error);
 
    template <typename TException, typename ...TArgs>
    inline void raiseIfFailed(VkResult result, StringView message, TArgs&&... args) {
        if (result == VK_SUCCESS) [[likely]]
            return;
 
        throw TException(VulkanPlatformException("Result: {0}", result), fmt::format(fmt::runtime(message), std::forward<TArgs>(args)...));
    }
}