BackendRendererVulkan.hpp

//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2026 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef TGUI_BACKEND_RENDERER_VULKAN_HPP
#define TGUI_BACKEND_RENDERER_VULKAN_HPP
 
#include <TGUI/Backend/Renderer/BackendRenderer.hpp>
#include <TGUI/Backend/Renderer/Vulkan/BackendRenderTargetVulkan.hpp>
#include <TGUI/Backend/Renderer/Vulkan/BackendTextureVulkan.hpp>
#include <TGUI/Backend/Renderer/Vulkan/CanvasVulkan.hpp>
 
#include <functional>
#include <memory>
#include <vector>
#include <vulkan/vulkan.h>

 
namespace tgui
{
    struct VulkanContext
    {
        VkInstance instance = VK_NULL_HANDLE;             
        VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; 
        std::uint32_t queueFamilyIndex = 0;               
        VkDevice device = VK_NULL_HANDLE;                 
        VkQueue queue = VK_NULL_HANDLE;                   

        PFN_vkGetInstanceProcAddr getInstanceProcAddr = nullptr;
    };

    class TGUI_API BackendRendererVulkan : public BackendRenderer, public std::enable_shared_from_this<BackendRendererVulkan>
    {
    public:
        struct Functions
        {
            // Instance-level functions
            PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = nullptr;
            PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = nullptr;
            PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = nullptr;
 
            // Instance-level functions from VK_KHR_surface
            PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = nullptr;
            PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr;
            PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr;
            PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = nullptr;
 
            // Device-level functions
            PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = nullptr;
            PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = nullptr;
            PFN_vkAllocateMemory vkAllocateMemory = nullptr;
            PFN_vkBeginCommandBuffer vkBeginCommandBuffer = nullptr;
            PFN_vkBindBufferMemory vkBindBufferMemory = nullptr;
            PFN_vkBindImageMemory vkBindImageMemory = nullptr;
            PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = nullptr;
            PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = nullptr;
            PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = nullptr;
            PFN_vkCmdBindPipeline vkCmdBindPipeline = nullptr;
            PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = nullptr;
            PFN_vkCmdClearColorImage vkCmdClearColorImage = nullptr;
            PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = nullptr;
            PFN_vkCmdDrawIndexed vkCmdDrawIndexed = nullptr;
            PFN_vkCmdEndRenderPass vkCmdEndRenderPass = nullptr;
            PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = nullptr;
            PFN_vkCmdSetScissor vkCmdSetScissor = nullptr;
            PFN_vkCmdSetViewport vkCmdSetViewport = nullptr;
            PFN_vkCreateBuffer vkCreateBuffer = nullptr;
            PFN_vkCreateCommandPool vkCreateCommandPool = nullptr;
            PFN_vkCreateDescriptorPool vkCreateDescriptorPool = nullptr;
            PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = nullptr;
            PFN_vkCreateFence vkCreateFence = nullptr;
            PFN_vkCreateFramebuffer vkCreateFramebuffer = nullptr;
            PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = nullptr;
            PFN_vkCreateImage vkCreateImage = nullptr;
            PFN_vkCreateImageView vkCreateImageView = nullptr;
            PFN_vkCreatePipelineLayout vkCreatePipelineLayout = nullptr;
            PFN_vkCreateRenderPass vkCreateRenderPass = nullptr;
            PFN_vkCreateSampler vkCreateSampler = nullptr;
            PFN_vkCreateSemaphore vkCreateSemaphore = nullptr;
            PFN_vkCreateShaderModule vkCreateShaderModule = nullptr;
            PFN_vkDestroyBuffer vkDestroyBuffer = nullptr;
            PFN_vkDestroyCommandPool vkDestroyCommandPool = nullptr;
            PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = nullptr;
            PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = nullptr;
            PFN_vkDestroyFence vkDestroyFence = nullptr;
            PFN_vkDestroyFramebuffer vkDestroyFramebuffer = nullptr;
            PFN_vkDestroyImage vkDestroyImage = nullptr;
            PFN_vkDestroyImageView vkDestroyImageView = nullptr;
            PFN_vkDestroyPipeline vkDestroyPipeline = nullptr;
            PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = nullptr;
            PFN_vkDestroyRenderPass vkDestroyRenderPass = nullptr;
            PFN_vkDestroySampler vkDestroySampler = nullptr;
            PFN_vkDestroySemaphore vkDestroySemaphore = nullptr;
            PFN_vkDestroyShaderModule vkDestroyShaderModule = nullptr;
            PFN_vkEndCommandBuffer vkEndCommandBuffer = nullptr;
            PFN_vkFreeCommandBuffers vkFreeCommandBuffers = nullptr;
            PFN_vkFreeDescriptorSets vkFreeDescriptorSets = nullptr;
            PFN_vkFreeMemory vkFreeMemory = nullptr;
            PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = nullptr;
            PFN_vkGetFenceStatus vkGetFenceStatus = nullptr;
            PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = nullptr;
            PFN_vkMapMemory vkMapMemory = nullptr;
            PFN_vkQueueSubmit vkQueueSubmit = nullptr;
            PFN_vkQueueWaitIdle vkQueueWaitIdle = nullptr;
            PFN_vkResetCommandBuffer vkResetCommandBuffer = nullptr;
            PFN_vkResetFences vkResetFences = nullptr;
            PFN_vkUnmapMemory vkUnmapMemory = nullptr;
            PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = nullptr;
            PFN_vkWaitForFences vkWaitForFences = nullptr;
 
            // Device-level function from the VK_EXT_debug_utils instance extension
            PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = nullptr;
 
            // Device-level functions from VK_KHR_swapchain
            PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = nullptr;
            PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = nullptr;
            PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = nullptr;
            PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = nullptr;
            PFN_vkQueuePresentKHR vkQueuePresentKHR = nullptr;
        };

        BackendRendererVulkan(const VulkanContext& vulkanContext);

        ~BackendRendererVulkan() override;

        [[nodiscard]] std::shared_ptr<BackendTexture> createTexture() override;

        [[nodiscard]] unsigned int getMaximumTextureSize() override;

        [[nodiscard]] const VulkanContext& getVulkanContext() const;

        [[nodiscard]] const Functions& getFunctions() const;

        [[nodiscard]] static bool isSrgbFormat(VkFormat format);

        [[nodiscard]] VkPipeline createPipeline(
            VkRenderPass renderPass,
            std::uint32_t subpass,
            VkFormat colorFormat,
            VkFormat depthFormat,
            VkFormat stencilFormat,
            VkSampleCountFlagBits samples) const;

        [[nodiscard]] VkPipelineLayout getPipelineLayout() const;

        [[nodiscard]] VkDescriptorSet getSamplerDescriptorSet(bool smooth) const;

        [[nodiscard]] VkDescriptorSet allocateTextureDescriptorSet(VkImageView imageView, VkDescriptorPool& pool);

        void freeTextureDescriptorSet(VkDescriptorSet descriptorSet, VkDescriptorPool pool);

        [[nodiscard]] bool createBuffer(VkDeviceSize size,
                                        VkBufferUsageFlags usage,
                                        VkMemoryPropertyFlags memoryProperties,
                                        VkBuffer& buffer,
                                        VkDeviceMemory& memory) const;

        [[nodiscard]] std::uint32_t findMemoryType(std::uint32_t memoryTypeBits, VkMemoryPropertyFlags properties) const;

        [[nodiscard]] std::uint64_t submitUploadCommands(const std::function<void(VkCommandBuffer)>& recordFunc,
                                                         VkBuffer stagingBuffer,
                                                         VkDeviceMemory stagingMemory);

        void waitForUpload(std::uint64_t uploadId);

        void releaseFinishedUploads();

        template <typename HandleType>
        void setObjectName(VkObjectType objectType, HandleType handle, const char* name) const
        {
            if (!m_functions.vkSetDebugUtilsObjectNameEXT || (handle == VK_NULL_HANDLE))
                return;
 
            VkDebugUtilsObjectNameInfoEXT nameInfo = {};
            nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
            nameInfo.objectType = objectType;
            nameInfo.objectHandle = reinterpret_cast<std::uint64_t>(handle);
            nameInfo.pObjectName = name;
            m_functions.vkSetDebugUtilsObjectNameEXT(m_vulkanContext.device, &nameInfo);
        }

 
    private:
        struct Upload
        {
            VkCommandBuffer cmdBuffer = VK_NULL_HANDLE;
            VkFence fence = VK_NULL_HANDLE; // Unsignaled while the upload slot isn't in use
            VkBuffer stagingBuffer = VK_NULL_HANDLE;
            VkDeviceMemory stagingMemory = VK_NULL_HANDLE;
            std::uint64_t id = 0; // 0 when the upload slot isn't in use
        };

        // Destroys the staging buffer of an upload that finished executing and marks the upload slot as unused
        void finishUpload(Upload& upload);

        // Creates the Vulkan objects that are shared between all textures and render targets
        void createVulkanObjects();

        // Destroys the objects that were created in createVulkanObjects
        void destroyVulkanObjects();

 
    private:
        struct DescriptorPool
        {
            VkDescriptorPool pool;
            std::uint32_t allocatedSets;
        };
 
        VulkanContext m_vulkanContext;
        Functions m_functions;
        VkPhysicalDeviceMemoryProperties m_memoryProperties = {};
        unsigned int m_maxTextureSize = 0;
 
        VkShaderModule m_vertexShaderModule = VK_NULL_HANDLE;
        VkShaderModule m_fragmentShaderModule = VK_NULL_HANDLE;
        VkDescriptorSetLayout m_textureDescriptorSetLayout = VK_NULL_HANDLE;
        VkDescriptorSetLayout m_samplerDescriptorSetLayout = VK_NULL_HANDLE;
        VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE;
 
        VkSampler m_samplerNearest = VK_NULL_HANDLE;
        VkSampler m_samplerLinear = VK_NULL_HANDLE;
        VkDescriptorPool m_samplerDescriptorPool = VK_NULL_HANDLE;
        VkDescriptorSet m_samplerDescriptorSetNearest = VK_NULL_HANDLE;
        VkDescriptorSet m_samplerDescriptorSetLinear = VK_NULL_HANDLE;
        std::vector<DescriptorPool> m_textureDescriptorPools;
 
        VkCommandPool m_commandPool = VK_NULL_HANDLE;
        std::vector<Upload> m_uploads;
        std::uint64_t m_lastUploadId = 0;
    };
} // namespace tgui
 
#endif // TGUI_BACKEND_RENDERER_VULKAN_HPP