bug fixes and perf improvement (#289)

Author: JeanPhilippeKernel

Tetragrama/src/Components/SceneViewportUIComponent.cpp

@@ -24,12 +24,20 @@ namespace Tetragrama::Components
         if ((m_viewport_size.x != m_content_region_available_size.x) || (m_viewport_size.y != m_content_region_available_size.y))
         {
             m_viewport_size = m_content_region_available_size;
+            m_request_renderer_resize = true;
+        }
+        else
+        {
+            if (m_request_renderer_resize)
+            {
+                GraphicRenderer::SetViewportSize(m_viewport_size.x, m_viewport_size.y);
+                m_refresh_texture_handle = true;
 
-            GraphicRenderer::SetViewportSize(m_viewport_size.x, m_viewport_size.y);
-            m_refresh_texture_handle = true;
+                Messengers::IMessenger::SendAsync<ZEngine::Layers::Layer, Messengers::GenericMessage<std::pair<float, float>>>(
+                    EDITOR_RENDER_LAYER_SCENE_REQUEST_RESIZE, Messengers::GenericMessage<std::pair<float, float>>{{m_viewport_size.x, m_viewport_size.y}});
 
-            Messengers::IMessenger::SendAsync<ZEngine::Layers::Layer, Messengers::GenericMessage<std::pair<float, float>>>(
-                EDITOR_RENDER_LAYER_SCENE_REQUEST_RESIZE, Messengers::GenericMessage<std::pair<float, float>>{{m_viewport_size.x, m_viewport_size.y}});
+                m_request_renderer_resize = false;
+            }
         }
 
         if (m_is_window_hovered && m_is_window_focused)
@@ -82,9 +90,11 @@ namespace Tetragrama::Components
 
             if (m_refresh_texture_handle)
             {
-                VkDescriptorSet old_scene_texture = m_scene_texture;
-                m_scene_texture                   = VK_NULL_HANDLE;
+                VkDescriptorSet old_scene_texture = VK_NULL_HANDLE;
+                std::swap(m_scene_texture, old_scene_texture);
                 m_refresh_texture_handle          = false;
+
+                VulkanDevice::EnqueueForDeletion(DeviceResourceType::DESCRIPTORSET, DirtyResource{.Handle = old_scene_texture, .Data1 = ImGUIRenderer::s_descriptor_pool});
             }
             auto texture_buffer = texture->GetImage2DBuffer();
             m_scene_texture     = ImGui_ImplVulkan_AddTexture(texture_buffer->GetSampler(), texture_buffer->GetImageViewHandle(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

Tetragrama/src/Components/SceneViewportUIComponent.h

@@ -33,6 +33,7 @@ namespace Tetragrama::Components
         bool                  m_is_window_hovered{false};
         bool                  m_is_window_clicked{false};
         bool                  m_refresh_texture_handle{false};
+        bool                  m_request_renderer_resize{false};
         ImVec2                m_viewport_size{0.f, 0.f};
         ImVec2                m_content_region_available_size{0.f, 0.f};
         std::array<ImVec2, 2> m_viewport_bounds;

ZEngine/include/ZEngine/Hardwares/VulkanDevice.h

@@ -10,15 +10,28 @@
 #include <GLFW/glfw3.h>
 #include <vk_mem_alloc.h>
 
+#include <chrono>
+#include <thread>
+#include <condition_variable>
+
 namespace ZEngine::Hardwares
 {
+
+    struct DirtyResource
+    {
+        void*                                 Handle = nullptr;
+        void*                                 Data1  = nullptr;
+        std::chrono::steady_clock::time_point MarkedAsDirtyTime;
+        Rendering::DeviceResourceType         Type;
+    };
+
     struct QueueView
     {
         uint32_t FamilyIndex{0xFFFFFFFF};
         VkQueue  Handle{VK_NULL_HANDLE};
     };
 
-    struct BufferView
+    struct BufferView : public DirtyResource
     {
         VkBuffer      Handle{VK_NULL_HANDLE};
         VmaAllocation Allocation{nullptr};
@@ -29,7 +42,7 @@ namespace ZEngine::Hardwares
         }
     };
 
-    struct BufferImage
+    struct BufferImage : public DirtyResource
     {
         VkImage       Handle{VK_NULL_HANDLE};
         VkImageView   ViewHandle{VK_NULL_HANDLE};
@@ -67,12 +80,11 @@ namespace ZEngine::Hardwares
             Rendering::Primitives::Fence* const     fence);
 
         static void EnqueueForDeletion(Rendering::DeviceResourceType resource_type, void* const resource_handle);
+        static void EnqueueForDeletion(Rendering::DeviceResourceType resource_type, DirtyResource resource);
 
         static void EnqueueBufferForDeletion(BufferView& buffer);
         static void EnqueueBufferImageForDeletion(BufferImage& buffer);
 
-        static void CleanupResource();
-        static bool HasPendingCleanupResource();
         static void Present(VkSwapchainKHR swapchain, uint32_t* frame_image_index, const std::vector<Rendering::Primitives::Semaphore*>& wait_semaphore_collection);
 
         static Rendering::Pools::CommandPool*                  CreateCommandPool(Rendering::QueueType queue_type, uint64_t swapchain_id, bool present_on_swapchain);
@@ -87,11 +99,8 @@ namespace ZEngine::Hardwares
         static VkSurfaceFormatKHR GetSurfaceFormat();
         static VkPresentModeKHR   GetPresentMode();
 
-        static void       MapAndCopyToMemory(BufferView& buffer, size_t data_size, const void* data);
-        static BufferView CreateBuffer(
-            VkDeviceSize             byte_size,
-            VkBufferUsageFlags       buffer_usage,
-            VmaAllocationCreateFlags vma_create_flags = 0);
+        static void        MapAndCopyToMemory(BufferView& buffer, size_t data_size, const void* data);
+        static BufferView  CreateBuffer(VkDeviceSize byte_size, VkBufferUsageFlags buffer_usage, VmaAllocationCreateFlags vma_create_flags = 0);
         static void        CopyBuffer(const BufferView& source, const BufferView& destination, VkDeviceSize byte_size);
         static BufferImage CreateImage(
             uint32_t              width,
@@ -144,9 +153,10 @@ namespace ZEngine::Hardwares
         static VkPhysicalDeviceFeatures                        m_physical_device_feature;
         static VkPhysicalDeviceMemoryProperties                m_physical_device_memory_properties;
         static VkDebugUtilsMessengerEXT                        m_debug_messenger;
-        static std::map<uint32_t, std::vector<void*>>          m_deletion_resource_queue;
-        static std::vector<BufferView>                         s_dirty_buffer_queue;
-        static std::vector<BufferImage>                        s_dirty_buffer_image_queue;
+        static std::map<uint32_t, std::vector<DirtyResource>>  m_deletion_resource_queue;
+        static std::queue<DirtyResource>                       s_dirty_resource_collection;
+        static std::queue<BufferView>                          s_dirty_buffer_queue;
+        static std::queue<BufferImage>                         s_dirty_buffer_image_queue;
         static std::vector<Ref<Rendering::Pools::CommandPool>> m_command_pool_collection;
         static PFN_vkCreateDebugUtilsMessengerEXT              __createDebugMessengerPtr;
         static PFN_vkDestroyDebugUtilsMessengerEXT             __destroyDebugMessengerPtr;
@@ -156,6 +166,9 @@ namespace ZEngine::Hardwares
         static VkPresentModeKHR                                m_present_mode;
         static VkDescriptorPool                                m_descriptor_pool;
         static VmaAllocator                                    s_vma_allocator;
+        static void                                            __cleanupDirtyResource(std::chrono::steady_clock::time_point);
+        static void                                            __cleanupBufferDirtyResource(std::chrono::steady_clock::time_point);
+        static void                                            __cleanupBufferImageDirtyResource(std::chrono::steady_clock::time_point);
         static VKAPI_ATTR VkBool32 VKAPI_CALL                  __debugCallback(
                              VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
                              VkDebugUtilsMessageTypeFlagsEXT             messageType,
@@ -170,5 +183,11 @@ namespace ZEngine::Hardwares
         static std::condition_variable                                            m_cond;
         static std::atomic_bool                                                   m_is_executing_instant_command;
         static std::mutex                                                         m_instant_command_mutex;
+
+    private:
+        static std::jthread            s_cleanup_thread;
+        static std::condition_variable s_cleanup_cond;
+        static std::atomic_bool        s_cleanup_thread_shutdown;
+        static std::chrono::seconds    s_cleanup_timeout;
     };
 } // namespace ZEngine::Hardwares

ZEngine/include/ZEngine/Rendering/Renderers/ImGUIRenderer.h

@@ -22,9 +22,6 @@ namespace ZEngine::Rendering::Renderers
 
         static void Initialize(void* window, const Ref<Swapchain>& swapchain);
         static void Deinitialize();
-        static void EnqueueForDeletion(Rendering::DeviceResourceType resource_type, void* const resource_handle);
-        static void CleanupResource();
-        static bool HasPendingCleanupResource();
 
         static void Tick();
         static void BeginFrame();
@@ -38,11 +35,10 @@ namespace ZEngine::Rendering::Renderers
         static void __ImGUICreateOrResizeBuffer(VkBuffer& buffer, VkDeviceMemory& buffer_memory, VkDeviceSize& p_buffer_size, size_t new_size, VkBufferUsageFlagBits usage);
         static void __ImGUIRenderDataChildViewport(void* data, void** user_data, VkCommandBuffer command_buffer, VkPipeline pipeline);
 
-    private:
-        static Rendering::Buffers::CommandBuffer*               s_command_buffer;
-        static Rendering::Pools::CommandPool*                   s_ui_command_pool;
-        static VkDescriptorPool                                 s_descriptor_pool;
-        static std::unordered_map<uint32_t, std::vector<void*>> s_deletion_resource_queue;
+    public:
+        static Rendering::Buffers::CommandBuffer* s_command_buffer;
+        static Rendering::Pools::CommandPool*     s_ui_command_pool;
+        static VkDescriptorPool                   s_descriptor_pool;
     };
 
 } // namespace ZEngine::Rendering::Renderers

ZEngine/include/ZEngine/pch.h

@@ -17,3 +17,4 @@
 #include <unordered_set>
 #include <exception>
 #include <stack>
+#include <chrono>

ZEngine/src/GlfwWindow/VulkanWindow.cpp

@@ -341,11 +341,6 @@ namespace ZEngine::Window::GLFWWindow
         }
 
         m_swapchain->Present();
-
-        if (Hardwares::VulkanDevice::HasPendingCleanupResource())
-        {
-            Hardwares::VulkanDevice::CleanupResource();
-        }
     }
 
     Ref<Rendering::Swapchain> VulkanWindow::GetSwapchain() const

ZEngine/src/ImGUIRenderer.cpp

@@ -15,7 +15,6 @@ namespace ZEngine::Rendering::Renderers
     Pools::CommandPool*                              ImGUIRenderer::s_ui_command_pool         = nullptr;
     Rendering::Buffers::CommandBuffer*               ImGUIRenderer::s_command_buffer          = nullptr;
     VkDescriptorPool                                 ImGUIRenderer::s_descriptor_pool         = VK_NULL_HANDLE;
-    std::unordered_map<uint32_t, std::vector<void*>> ImGUIRenderer::s_deletion_resource_queue = {};
 
     void ImGUIRenderer::Initialize(void* window, const Ref<Swapchain>& swapchain)
     {
@@ -24,11 +23,12 @@ namespace ZEngine::Rendering::Renderers
 
         /*Create DescriptorPool*/
         auto                              device     = Hardwares::VulkanDevice::GetNativeDeviceHandle();
+        const auto&                       device_property = Hardwares::VulkanDevice::GetPhysicalDeviceProperties();
         std::vector<VkDescriptorPoolSize> pool_sizes = {{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1}};
         VkDescriptorPoolCreateInfo        pool_info  = {};
         pool_info.sType                              = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         pool_info.flags                              = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
-        pool_info.maxSets                            = 100 * swapchain->GetImageCount();
+        pool_info.maxSets                            = 2000 * swapchain->GetImageCount();
         pool_info.poolSizeCount                      = pool_sizes.size();
         pool_info.pPoolSizes                         = pool_sizes.data();
         ZENGINE_VALIDATE_ASSERT(vkCreateDescriptorPool(device, &pool_info, nullptr, &s_descriptor_pool) == VK_SUCCESS, "Failed to create DescriptorPool -- ImGuiLayer")
@@ -69,44 +69,6 @@ namespace ZEngine::Rendering::Renderers
         ZENGINE_DESTROY_VULKAN_HANDLE(device, vkDestroyDescriptorPool, s_descriptor_pool, nullptr)
     }
 
-    void ImGUIRenderer::EnqueueForDeletion(Rendering::DeviceResourceType resource_type, void* const resource_handle)
-    {
-        if (resource_handle)
-        {
-            s_deletion_resource_queue[static_cast<uint32_t>(resource_type)].emplace_back(resource_handle);
-        }
-    }
-
-    void ImGUIRenderer::CleanupResource()
-    {
-        auto device = Hardwares::VulkanDevice::GetNativeDeviceHandle();
-        for (auto resource : s_deletion_resource_queue)
-        {
-            Rendering::DeviceResourceType resource_type = static_cast<Rendering::DeviceResourceType>(resource.first);
-            for (void* handle : resource.second)
-            {
-                switch (resource_type)
-                {
-                    case Rendering::DeviceResourceType::DESCRIPTORSET:
-                        auto set = reinterpret_cast<VkDescriptorSet>(handle);
-                        vkFreeDescriptorSets(device, s_descriptor_pool, 1, &set);
-                        break;
-                }
-            }
-        }
-
-        s_deletion_resource_queue.clear();
-    }
-
-    bool ImGUIRenderer::HasPendingCleanupResource()
-    {
-        if (s_deletion_resource_queue.empty())
-        {
-            return false;
-        }
-        return s_deletion_resource_queue.at(static_cast<uint32_t>(Rendering::DeviceResourceType::DESCRIPTORSET)).size() > 5;
-    }
-
     void ImGUIRenderer::Tick()
     {
         s_ui_command_pool->Tick();

ZEngine/src/ImguiLayer.cpp

@@ -111,15 +111,11 @@ namespace ZEngine::Layers
         {
             io.DeltaTime = dt;
         }
+
         for (const auto& component : m_ui_components)
         {
             component->Update(dt);
         }
-
-        if (ImGUIRenderer::HasPendingCleanupResource())
-        {
-            ImGUIRenderer::CleanupResource();
-        }
     }
 
     void ImguiLayer::AddUIComponent(const Ref<Components::UI::UIComponent>& component)
@@ -311,6 +307,7 @@ namespace ZEngine::Layers
         if (viewport->RendererUserData)
         {
             auto window_child = reinterpret_cast<ImguiViewPortWindowChild*>(viewport->RendererUserData);
+            window_child->CommandPool->Tick();
             ImGUIRenderer::DrawChildWindow(viewport->Size.x, viewport->Size.y, &window_child, viewport->DrawData);
         }
     }