Api manage resources lifetime

6 files changed, 66 insertions, 52 deletions

diff --git a/include/scene.hpp b/include/scene.hpp
index 2c945d4..0638387 100644
--- a/include/scene.hpp
+++ b/include/scene.hpp
@@ -47,13 +47,13 @@ public:
     std::vector<float>      uvs;

     std::vector<material>   materials;

 

-    Buffer                  scene_buffer;

-    Buffer                  indices_buffer;

-    Buffer                  positions_buffer;

-    Buffer                  normals_buffer;

-    Buffer                  uvs_buffer;

-    Buffer                  bvh_buffer;

-    Buffer                  materials_buffer;

+    buffer                  scene_buffer;

+    buffer                  indices_buffer;

+    buffer                  positions_buffer;

+    buffer                  normals_buffer;

+    buffer                  uvs_buffer;

+    buffer                  bvh_buffer;

+    buffer                  materials_buffer;

 

     std::vector<packed_bvh_node> packed_nodes;

 };

diff --git a/include/vk-api.hpp b/include/vk-api.hpp
index 7953817..1127bd7 100644
--- a/include/vk-api.hpp
+++ b/include/vk-api.hpp
@@ -2,10 +2,11 @@
 #define __VK_API_HPP_
 
 #include <vector>
+#include <map>
 
 #include "vk-context.hpp"
 
-struct Buffer {
+struct buffer {
     VmaAllocation       alloc;
     VmaAllocationInfo   alloc_info;
     VkBuffer            handle;
@@ -31,7 +32,7 @@ struct image {
     uint32_t                bindless_sampled_index;
 };
 
-struct Swapchain {
+struct swapchain {
     size_t                  image_count;
     std::vector<image>      images;
     VkSwapchainKHR          handle;
@@ -88,16 +89,15 @@ struct global_descriptor {
 
 class window;
 
-// TODO: Make the api manage ressources
 class vkapi {
     public:
         vkapi();
         ~vkapi();
 
-        Buffer create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage);
-        void copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Buffer dst, size_t size);
-        void copy_buffer(VkCommandBuffer cmd_buf, Buffer src, image dst);
-        void destroy_buffer(Buffer& buffer);
+        buffer create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage);
+        void copy_buffer(VkCommandBuffer cmd_buf, buffer src, buffer dst, size_t size);
+        void copy_buffer(VkCommandBuffer cmd_buf, buffer src, image dst);
+        void destroy_buffer(buffer& buffer);
 
 
         image create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages);
@@ -149,8 +149,8 @@ class vkapi {
         void destroy_surface(VkSurfaceKHR surface);
 
 
-        Swapchain create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain);
-        void destroy_swapchain(Swapchain& swapchain);
+        swapchain create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain);
+        void destroy_swapchain(swapchain& swapchain);
 
         void update_descriptor_images(std::vector<image> &images, VkDescriptorType type);
         void update_descriptor_samplers(std::vector<sampler> &samplers);
@@ -166,7 +166,7 @@ class vkapi {
         void run_compute_pipeline(VkCommandBuffer command_buffer, Pipeline pipeline, size_t group_count_x, size_t group_count_y, size_t group_count_z);
 
         void draw(VkCommandBuffer command_buffer, Pipeline pipeline, uint32_t vertex_count, uint32_t vertex_offset);
-        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, Buffer index_buffer, uint32_t primitive_count, uint32_t indices_offset, uint32_t vertices_offset);
+        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, buffer index_buffer, uint32_t primitive_count, uint32_t indices_offset, uint32_t vertices_offset);
 
         void blit_full(VkCommandBuffer command_buffer, image src_image, image dst_image);
 
@@ -174,7 +174,7 @@ class vkapi {
 
         VkResult submit(VkCommandBuffer command_buffer, VkSemaphore wait_semaphore, VkSemaphore signal_semaphore, VkFence submission_fence);
 
-        VkResult present(Swapchain& swapchain, uint32_t image_index, VkSemaphore wait_semaphore);
+        VkResult present(swapchain& swapchain, uint32_t image_index, VkSemaphore wait_semaphore);
     // private:
 
         vkcontext           context;
@@ -185,6 +185,10 @@ class vkapi {
 
         const char* shader_stage_extension(VkShaderStageFlags shader_stage);
 
+        std::map<VkBuffer, buffer>  buffers;
+        std::map<VkImage, image>    images;
+        std::map<VkSampler, sampler>samplers;
+
         VkCommandPool               command_pool;
         VkDescriptorPool            descriptor_pool;
 
diff --git a/include/vk-renderer.hpp b/include/vk-renderer.hpp
index dada742..99521a6 100644
--- a/include/vk-renderer.hpp
+++ b/include/vk-renderer.hpp
@@ -56,13 +56,13 @@ class vkrenderer {
 
         Pipeline                        compute_pipeline;
 
-        Buffer                          staging_buffer;
+        buffer                          staging_buffer;
 
 
         Pipeline                        tonemapping_pipeline;
 
-        std::vector<Buffer>             ui_vertex_buffers;
-        std::vector<Buffer>             ui_index_buffers;
+        std::vector<buffer>             ui_vertex_buffers;
+        std::vector<buffer>             ui_index_buffers;
         Pipeline                        ui_pipeline;
         VkRenderPass                    render_pass;
         std::vector<VkFramebuffer>      framebuffers;
@@ -72,7 +72,7 @@ class vkrenderer {
         std::vector<VkSemaphore>        acquire_semaphores;
 
         VkSurfaceKHR                    platform_surface;
-        Swapchain                       swapchain;
+        swapchain                       swapchain;
 
         const uint32_t                  min_swapchain_image_count = 3;
         const uint32_t                  virtual_frames_count = 2;
diff --git a/src/scene.cpp b/src/scene.cpp
index 9caed7b..f538292 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -58,13 +58,13 @@
 scene::scene(camera cam, uint32_t width, uint32_t height, vkrenderer &renderer)

     :meta(cam, width, height){

 

-    auto bistro_interior_path = std::filesystem::path("../models/BistroInterior");

-    auto bistro_interior_filename = std::string("BistroInterior.gltf");

-    auto root_node = gltf::load(bistro_interior_path, bistro_interior_filename, renderer);

+    // auto bistro_interior_path = std::filesystem::path("../models/BistroInterior");

+    // auto bistro_interior_filename = std::string("BistroInterior.gltf");

+    // auto root_node = gltf::load(bistro_interior_path, bistro_interior_filename, renderer);

 

-    // auto sponza_path = std::filesystem::path("../models/sponza");

-    // auto sponza_filename = std::string("Sponza.gltf");

-    // auto root_node = gltf::load(sponza_path, sponza_filename, renderer);

+    auto sponza_path = std::filesystem::path("../models/sponza");

+    auto sponza_filename = std::string("Sponza.gltf");

+    auto root_node = gltf::load(sponza_path, sponza_filename, renderer);

 

     std::vector<triangle> triangles;

     auto triangles_offset = 0;

diff --git a/src/vk-api.cpp b/src/vk-api.cpp
index 3391246..4bfae42 100644
--- a/src/vk-api.cpp
+++ b/src/vk-api.cpp
@@ -135,6 +135,16 @@ vkapi::vkapi() {
 }
 
 vkapi::~vkapi() {
+    // Free resources
+    while (buffers.size())
+        destroy_buffer(buffers.begin()->second);
+
+    while (images.size())
+        destroy_image(images.begin()->second);
+
+    while (samplers.size())
+        destroy_sampler(samplers.begin()->second);
+
     // Free bindless descriptor stuff
     vkDestroyDescriptorSetLayout(context.device, bindless_descriptor.set_layout, nullptr);
     vkDestroyPipelineLayout(context.device, bindless_descriptor.pipeline_layout, nullptr);
@@ -145,8 +155,8 @@ vkapi::~vkapi() {
 }
 
 
-Buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage) {
-    Buffer buffer = {};
+buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage) {
+    buffer buffer = {};
 
     VkBufferCreateInfo buffer_info  = {};
     buffer_info.sType               = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -168,10 +178,12 @@ Buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, V
 
     buffer.device_address = vkGetBufferDeviceAddress(context.device, &buffer_device_address_info);
 
+    buffers.insert({ buffer.handle, buffer });
+
     return std::move(buffer);
 }
 
-void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Buffer dst, size_t size) {
+void vkapi::copy_buffer(VkCommandBuffer cmd_buf, buffer src, buffer dst, size_t size) {
     VkBufferCopy buffer_copy = {};
     buffer_copy.srcOffset = 0;
     buffer_copy.dstOffset = 0;
@@ -180,7 +192,7 @@ void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Buffer dst, size_t
     vkCmdCopyBuffer(cmd_buf, src.handle, dst.handle, 1, &buffer_copy);
 }
 
-void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, image dst) {
+void vkapi::copy_buffer(VkCommandBuffer cmd_buf, buffer src, image dst) {
     VkImageSubresourceLayers image_subresource_layers   = {};
     image_subresource_layers.aspectMask                 = dst.subresource_range.aspectMask;
     image_subresource_layers.mipLevel                   = 0;
@@ -198,8 +210,10 @@ void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, image dst) {
     vkCmdCopyBufferToImage(cmd_buf, src.handle, dst.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_to_image_copy);
 }
 
-void vkapi::destroy_buffer(Buffer& buffer) {
+void vkapi::destroy_buffer(buffer& buffer) {
     vmaDestroyBuffer(context.allocator, buffer.handle, buffer.alloc);
+
+    buffers.erase(buffer.handle);
 }
 
 
@@ -256,6 +270,8 @@ image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags us
     image.bindless_storage_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
     image.bindless_sampled_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
+    images.insert({ image.handle, image });
+
     return std::move(image);
 }
 void vkapi::destroy_image(image &image) {
@@ -264,6 +280,9 @@ void vkapi::destroy_image(image &image) {
 
     vmaDestroyImage(context.allocator, image.handle, image.alloc);
     vkDestroyImageView(context.device, image.view, nullptr);
+
+    images.erase(image.handle);
+
 }
 
 std::vector<image> vkapi::create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count) {
@@ -374,6 +393,8 @@ sampler vkapi::create_sampler(VkFilter filter, VkSamplerAddressMode address_mode
 
     sampler.bindless_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_SAMPLER);
 
+    samplers.insert({ sampler.handle, sampler });
+
     return std::move(sampler);
 }
 
@@ -381,6 +402,8 @@ void vkapi::destroy_sampler(sampler sampler) {
     bindless_descriptor.free(sampler.bindless_index, VK_DESCRIPTOR_TYPE_SAMPLER);
 
     vkDestroySampler(context.device, sampler.handle, VK_NULL_HANDLE);
+
+    samplers.erase(sampler.handle);
 }
 
 
@@ -753,8 +776,8 @@ void vkapi::destroy_surface(VkSurfaceKHR surface) {
 }
 
 
-Swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain) {
-    Swapchain swapchain;
+swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain) {
+    swapchain swapchain;
     VkBool32 queue_support_presentation = VK_FALSE;
     VKRESULT(vkGetPhysicalDeviceSurfaceSupportKHR(context.physical_device, context.queue_index, surface, &queue_support_presentation))
 
@@ -864,7 +887,7 @@ Swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
     return std::move(swapchain);
 }
 
-void vkapi::destroy_swapchain(Swapchain& swapchain) {
+void vkapi::destroy_swapchain(swapchain& swapchain) {
     for(auto &image: swapchain.images) {
         bindless_descriptor.free(image.bindless_storage_index, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
         bindless_descriptor.free(image.bindless_sampled_index, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
@@ -1006,7 +1029,7 @@ void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, uint32_t ver
     vkCmdDraw(command_buffer, vertex_count, 1, vertex_offset, 0);
 }
 
-void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, Buffer index_buffer, uint32_t index_count, uint32_t index_offset, uint32_t vertex_offset) {
+void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, buffer index_buffer, uint32_t index_count, uint32_t index_offset, uint32_t vertex_offset) {
     vkCmdBindIndexBuffer(command_buffer, index_buffer.handle, 0, VK_INDEX_TYPE_UINT16);
     vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless_descriptor.pipeline_layout, 0, 1, &bindless_descriptor.set, 0, nullptr);
 
@@ -1063,7 +1086,7 @@ VkResult vkapi::submit(VkCommandBuffer command_buffer, VkSemaphore wait_semaphor
     return vkQueueSubmit(context.queue, 1, &submit_info, submission_fence);
 }
 
-VkResult vkapi::present(Swapchain& swapchain, uint32_t image_index, VkSemaphore wait_semaphore) {
+VkResult vkapi::present(swapchain& swapchain, uint32_t image_index, VkSemaphore wait_semaphore) {
     VkPresentInfoKHR present_info   = {};
     present_info.sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     present_info.pNext              = nullptr;
diff --git a/src/vk-renderer.cpp b/src/vk-renderer.cpp
index ba5f017..76185d0 100644
--- a/src/vk-renderer.cpp
+++ b/src/vk-renderer.cpp
@@ -143,31 +143,18 @@ vkrenderer::vkrenderer(window& wnd) {
 vkrenderer::~vkrenderer() {
     VKRESULT(vkWaitForFences(api.context.device, submission_fences.size(), submission_fences.data(), VK_TRUE, UINT64_MAX))
 
-    api.destroy_buffer(staging_buffer);
     api.destroy_fences(submission_fences);
     api.destroy_semaphores(execution_semaphores);
     api.destroy_semaphores(acquire_semaphores);
 
-    api.destroy_images(accumulation_images);
-
     api.destroy_render_pass(render_pass);
 
     api.destroy_sampler(ui_texture_sampler);
 
-    api.destroy_image(ui_texture);
-
     for (auto& framebuffer: framebuffers) {
         api.destroy_framebuffer(framebuffer);
     }
 
-    for (auto& vertex_buffer: ui_vertex_buffers) {
-        api.destroy_buffer(vertex_buffer);
-    }
-
-    for (auto& index_buffer: ui_index_buffers) {
-        api.destroy_buffer(index_buffer);
-    }
-
     api.destroy_command_buffers(command_buffers);
 
     api.destroy_pipeline(compute_pipeline);
@@ -340,7 +327,7 @@ void vkrenderer::finish_frame() {
 void vkrenderer::recreate_swapchain() {
     VKRESULT(vkWaitForFences(api.context.device, submission_fences.size(), submission_fences.data(), VK_TRUE, UINT64_MAX))
 
-    Swapchain old_swapchain = swapchain;
+    struct swapchain old_swapchain = swapchain;
     swapchain = api.create_swapchain(
         platform_surface,
         min_swapchain_image_count,