Сделал минимальный GC для видеопамяти

UwURenderEngine/RenderEngine/GPU_GarbageCollector.cpp

@@ -0,0 +1,22 @@
+#include "GPU_GarbageCollector.h"
+
+
+GPU_GarbageCollector::GPU_GarbageCollector(VkDevice device) : device_(device)
+{}
+
+void GPU_GarbageCollector::AddGarbage(Garbage garbage)
+{
+    std::scoped_lock lock(m_heap_);
+    heap_.push_back(garbage);
+}
+
+void GPU_GarbageCollector::FreeHeap()
+{
+    std::scoped_lock lock(m_heap_);
+    for (auto& i : heap_)
+    {
+        vkFreeMemory(device_, i.device_memory, nullptr);
+        vkDestroyBuffer(device_, i.buffer, nullptr);
+    }
+    heap_.clear();
+}

UwURenderEngine/RenderEngine/GPU_GarbageCollector.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <list>
+#include <mutex>
+#include <vulkan/vulkan.h>
+
+class GPU_GarbageCollector
+{
+public:
+    struct Garbage
+    {
+        VkBuffer buffer;
+        VkDeviceMemory device_memory;
+    };
+private:
+    VkDevice device_ = VK_NULL_HANDLE;
+    
+    std::list<Garbage> heap_;
+    std::mutex m_heap_;
+public:
+    GPU_GarbageCollector() = default;
+
+    explicit GPU_GarbageCollector(VkDevice device);
+
+    void AddGarbage(Garbage garbage);
+    void FreeHeap();
+};

UwURenderEngine/RenderEngine/UwURenderEngine.cpp

@@ -6,6 +6,7 @@
 #include <fstream>
 #include <chrono>
 
+#include "GPU_GarbageCollector.h"
 #include "Core/CoreInstance.hpp"
 #include "Log/Log.hpp"
 
@@ -872,13 +873,15 @@ void UwURenderEngine::draw_frame()
     vkWaitForFences(device_, 1, &in_flight_fences_[current_frame_], VK_TRUE, UINT64_MAX);
     vkResetFences(device_, 1, &in_flight_fences_[current_frame_]);
     
+    garbage_collector_->FreeHeap();
+    
     uint32_t image_index;
     vkAcquireNextImageKHR(device_, swapchain_, UINT64_MAX, image_available_semaphores_[current_frame_], VK_NULL_HANDLE, &image_index);
     
     vkResetCommandBuffer(command_buffers_[current_frame_], 0);
-    record_command_buffer(command_buffers_[current_frame_], image_index);
+    
-
     update_uniform_buffer(current_frame_);
+    record_command_buffer(command_buffers_[current_frame_], image_index);
     
     VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkSubmitInfo submit_info{};
@@ -937,6 +940,7 @@ core_(core)
     allocate_index_buffer();
     create_sync_objects();
     
+    garbage_collector_.reset(new GPU_GarbageCollector(device_));
     model_manager_.reset(new ModelManager(physical_device_, device_));
 }
 
@@ -945,7 +949,7 @@ UwURenderEngine::~UwURenderEngine()
     vkDeviceWaitIdle(device_);
     
     if (index_buffer_memory_ != VK_NULL_HANDLE)
-            vkFreeMemory(device_, index_buffer_memory_, nullptr);
+        vkFreeMemory(device_, index_buffer_memory_, nullptr);
     
     if (index_buffer_ != VK_NULL_HANDLE)
         vkDestroyBuffer(device_, index_buffer_, nullptr);

UwURenderEngine/RenderEngine/UwURenderEngine.hpp

@@ -12,6 +12,8 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 
+class GPU_GarbageCollector;
+
 class UwURenderEngine : public RenderEngineBase
 {
     struct QueueFamilyIndices
@@ -52,11 +54,13 @@ class UwURenderEngine : public RenderEngineBase
     };
     
     static const std::vector<const char*> deviceExtensions;
-
+    
     int current_frame_ = 0;
+    
 
     CoreInstance& core_;
-    std::unique_ptr<ModelManager> model_manager_;
+    std::shared_ptr<ModelManager> model_manager_;
+    std::shared_ptr<GPU_GarbageCollector> garbage_collector_;
     
     VkInstance instance_ = VK_NULL_HANDLE;
     VkSurfaceKHR surface_ = VK_NULL_HANDLE;
@@ -130,11 +134,11 @@ class UwURenderEngine : public RenderEngineBase
     void draw_frame();
 public:
     // Can throw the exception
-    UwURenderEngine(CoreInstance& core);
+    explicit UwURenderEngine(CoreInstance& core);
     ~UwURenderEngine() override;
 
     void start() override;
     void stop_render() const override;
 
-    ModelManager* GetModelManager() const { return model_manager_.get(); }
+    std::shared_ptr<ModelManager> GetModelManager() const { return model_manager_; }
 };