BackendRenderTargetVulkan.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_RENDER_TARGET_VULKAN_HPP
#define TGUI_BACKEND_RENDER_TARGET_VULKAN_HPP
 
#include <TGUI/Backend/Renderer/BackendRenderTarget.hpp>
#include <TGUI/Backend/Renderer/Vulkan/BackendTextureVulkan.hpp>
 
#include <vulkan/vulkan.h>

 
namespace tgui
{
    class BackendRendererVulkan;

    class TGUI_API BackendRenderTargetVulkan : public BackendRenderTarget
    {
    public:
        BackendRenderTargetVulkan(std::shared_ptr<BackendRendererVulkan> renderer);

        ~BackendRenderTargetVulkan() override;

        void setClearColor(const Color& color) override;

        void clearScreen() override;

        void setView(FloatRect view, FloatRect viewport, Vector2f targetSize) override;

        void drawGui(const std::shared_ptr<RootContainer>&) override
        {
            TGUI_ASSERT(false, "The Vulkan backend requires that you pass a VkCommandBuffer to the draw function");
            throw Exception("The Vulkan backend requires that you pass a VkCommandBuffer to the draw function");
        }

        void setRenderPass(VkRenderPass renderPass,
                           VkFormat colorFormat,
                           std::uint32_t maxFramesInFlight,
                           std::uint32_t subpass = 0,
                           VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT);

        void setDynamicRenderingFormats(VkFormat colorFormat,
                                        std::uint32_t maxFramesInFlight,
                                        VkFormat depthFormat = VK_FORMAT_UNDEFINED,
                                        VkFormat stencilFormat = VK_FORMAT_UNDEFINED,
                                        VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT);

        bool drawGui(const std::shared_ptr<RootContainer>& root, VkCommandBuffer cmdBuffer);

        void drawVertexArray(const RenderStates& states,
                             const Vertex* vertices,
                             std::size_t vertexCount,
                             const unsigned int* indices,
                             std::size_t indexCount,
                             const std::shared_ptr<BackendTexture>& texture) override;

 
    protected:
        void updateClipping(FloatRect clipRect, FloatRect clipViewport) override;

        // Removes the current pipeline. It is only destroyed once the frames that might still be using it have finished.
        void retirePipeline();

        // Changes the amount of frame resources. Waits until the queue is idle when the amount changes.
        void setMaxFramesInFlight(std::uint32_t maxFramesInFlight);

        // Destroys the buffers and retired pipelines of all frames
        void destroyFrameResources();

 
    protected:
        struct DrawCommand
        {
            std::size_t indexCount;
            std::shared_ptr<BackendTextureVulkan::ImageResources> imageResources;
            bool smooth;
            VkRect2D clipRect;
        };
 
        // Resources that can only be reused once the GPU has finished executing the frame
        struct FrameResources
        {
            VkBuffer buffer = VK_NULL_HANDLE;
            VkDeviceMemory memory = VK_NULL_HANDLE;
            VkDeviceSize bufferSize = 0;
            void* mappedMemory = nullptr;
            std::vector<DrawCommand> drawCommands; // Keeps the used images alive until the frame is no longer in flight
            std::vector<VkPipeline> retiredPipelines;
        };
 
        std::shared_ptr<BackendRendererVulkan> m_renderer;
        std::unique_ptr<BackendTextureVulkan> m_emptyTexture;
 
        Transform m_projectionTransform;
 
        VkPipeline m_pipeline = VK_NULL_HANDLE;
        VkRenderPass m_renderPass = VK_NULL_HANDLE;
        std::uint32_t m_subpass = 0;
        VkFormat m_colorFormat = VK_FORMAT_UNDEFINED;
        VkFormat m_depthFormat = VK_FORMAT_UNDEFINED;
        VkFormat m_stencilFormat = VK_FORMAT_UNDEFINED;
        VkSampleCountFlagBits m_samples = VK_SAMPLE_COUNT_1_BIT;
 
        std::vector<FrameResources> m_frames;
        std::size_t m_currentFrame = 0;
 
        // Used while drawGui is being executed
        std::vector<Vertex> m_vertices;
        std::vector<unsigned int> m_indices;
        VkRect2D m_clipRect = {};
    };
} // namespace tgui
 
#endif // TGUI_BACKEND_RENDER_TARGET_VULKAN_HPP