Attempt at synchronizing memory write

3 files changed, 159 insertions, 76 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 5098f5d..4db8f55 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -72,16 +72,16 @@ int main() {
                 case EVENT_TYPES::RESIZE: {
                     width = event.width;
                     height = event.height;
-                    ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->width = width;
-                    ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->height = height;
+                    ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->width = width;
+                    ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->height = height;
 
                     if (event.width == 0 && event.height == 0) {
                         canRender = false;
                     } else {
                         canRender = true;
                         renderer.recreate_swapchain();
-                        ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.set_aspect_ratio((float)event.width / (float)event.height);
-                        ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->sample_index = 0;
+                        ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.set_aspect_ratio((float)event.width / (float)event.height);
+                        ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->sample_index = 0;
                     }
                     break;
                 }
@@ -95,29 +95,29 @@ int main() {
 
                     switch (event.key) {
                         case KEYS::W: {
-                            move_vec = ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.forward.unit() * move_speed;
+                            move_vec = ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.forward.unit() * move_speed;
                             break;
                         }
                         case KEYS::S: {
-                            move_vec = -((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.forward.unit() * move_speed;
+                            move_vec = -((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.forward.unit() * move_speed;
                             break;
                         }
                         case KEYS::D: {
-                            move_vec = ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.right.unit() * move_speed;
+                            move_vec = ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.right.unit() * move_speed;
                             break;
                         }
                         case KEYS::A: {
-                            move_vec = -((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.right.unit() * move_speed;
+                            move_vec = -((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.right.unit() * move_speed;
                             break;
                         }
                         default:
                             break;
                     }
 
-                    ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->cam.move(move_vec);
+                    ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->cam.move(move_vec);
 
                     if (!move_vec.near_zero()) {
-                        ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->sample_index = 0;
+                        ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->sample_index = 0;
                     }
 
                     break;
@@ -139,12 +139,12 @@ int main() {
             renderer.begin_frame();
             renderer.ui();
 
-            if (((input_data*) renderer.compute_shader_buffer.mapped_ptr)->sample_index < samples_per_pixel) {
-                bool clear = ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->sample_index == 0;
-                // renderer.compute(width, height, clear);
+            // if (((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->sample_index < samples_per_pixel) {
+            //     bool clear = ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->sample_index == 0;
+            //     renderer.compute(width, height, clear);
 
-                ((input_data*) renderer.compute_shader_buffer.mapped_ptr)->sample_index++;
-            }
+            //     ((input_data*) renderer.compute_shader_buffer.alloc_info.pMappedData)->sample_index++;
+            // }
 
             renderer.finish_frame();
         }
diff --git a/src/vk-api.cpp b/src/vk-api.cpp
index f051025..3ff6cb8 100644
--- a/src/vk-api.cpp
+++ b/src/vk-api.cpp
@@ -46,24 +46,20 @@ vkapi::~vkapi() {
 }
 
 
-Buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage, void* ptr) {
+Buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage) {
     Buffer buffer = {};
 
-    if (ptr) {
-        buffer.mapped_ptr = ptr;
-    }
-
-    VkBufferCreateInfo buffer_info  = {  };
+    VkBufferCreateInfo buffer_info  = {};
     buffer_info.sType               = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     buffer_info.size                = data_size;
     buffer_info.usage               = buffer_usage;
      
     VmaAllocationCreateInfo alloc_create_info = {};
     alloc_create_info.usage = mem_usage;
+    alloc_create_info.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+    alloc_create_info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      
-    VKRESULT(vmaCreateBuffer(context.allocator, &buffer_info, &alloc_create_info, &buffer.handle, &buffer.alloc, nullptr))
-
-    vmaMapMemory(context.allocator, buffer.alloc, (void**) &buffer.mapped_ptr);
+    VKRESULT(vmaCreateBuffer(context.allocator, &buffer_info, &alloc_create_info, &buffer.handle, &buffer.alloc, &buffer.alloc_info))
 
     return std::move(buffer);
 }
@@ -74,13 +70,9 @@ void vkapi::destroy_buffer(Buffer& buffer) {
 }
 
 
-Image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, void* ptr) {
+Image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages) {
     Image image;
 
-    if (ptr) {
-        image.mapped_ptr = ptr;
-    }
-
     image.size = size;
 
     image.subresource_range.aspectMask      = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -108,8 +100,9 @@ Image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags us
 
     VmaAllocationCreateInfo alloc_create_info = {};
     alloc_create_info.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+    alloc_create_info.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
 
-    VKRESULT(vmaCreateImage(context.allocator, &img_create_info, &alloc_create_info, &image.handle, &image.alloc, nullptr))
+    VKRESULT(vmaCreateImage(context.allocator, &img_create_info, &alloc_create_info, &image.handle, &image.alloc, &image.alloc_info))
 
     VkImageViewCreateInfo image_view_create_info    = {};
     image_view_create_info.sType                    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -139,7 +132,7 @@ std::vector<Image> vkapi::create_images(VkExtent3D size, VkFormat format, VkImag
     std::vector<Image> images { image_count };
 
     for (size_t image_index = 0; image_index < image_count; image_index++) {
-        images[image_index] = create_image(size, format, usages, nullptr);
+        images[image_index] = create_image(size, format, usages);
     }
 
     return std::move(images);
@@ -252,8 +245,8 @@ VkRenderPass vkapi::create_render_pass(std::vector<VkFormat>& color_attachments_
         attachment_description.storeOp                                  = VK_ATTACHMENT_STORE_OP_STORE;
         attachment_description.stencilLoadOp                            = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
         attachment_description.stencilStoreOp                           = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-        attachment_description.initialLayout                            = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // TODO: Change this
-        attachment_description.finalLayout                              = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        attachment_description.initialLayout                            = VK_IMAGE_LAYOUT_UNDEFINED; // TODO: Change this
+        attachment_description.finalLayout                              = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 
         attachments_description.push_back(attachment_description);
 
@@ -480,12 +473,12 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
     input_assembly_state_create_info.topology                               = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 
     VkViewport viewport = {};
-    viewport.x          = 0;
-    viewport.y          = 0;
-    viewport.width      = 1;
-    viewport.height     = 1;
-    viewport.minDepth   = 0;
-    viewport.maxDepth   = 1;
+    viewport.x          = 0.f;
+    viewport.y          = 0.f;
+    viewport.width      = 384.f;
+    viewport.height     = 186.f;
+    viewport.minDepth   = 0.f;
+    viewport.maxDepth   = 1.f;
 
     VkRect2D scissor    = {};
     scissor.offset      = {
@@ -493,8 +486,8 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
         0,
     };
     scissor.extent      = {
-        400,
-        400,
+        384,
+        186,
     };
 
     VkPipelineViewportStateCreateInfo viewport_state_create_info            = {};
@@ -511,10 +504,10 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
     rasterization_state_create_info.pNext                                   = nullptr;
     rasterization_state_create_info.flags                                   = 0;
     rasterization_state_create_info.depthClampEnable                        = VK_FALSE;
-    rasterization_state_create_info.rasterizerDiscardEnable                 = VK_TRUE;
+    rasterization_state_create_info.rasterizerDiscardEnable                 = VK_FALSE;
     rasterization_state_create_info.polygonMode                             = VK_POLYGON_MODE_FILL;
     rasterization_state_create_info.cullMode                                = VK_CULL_MODE_BACK_BIT;
-    rasterization_state_create_info.frontFace                               = VK_FRONT_FACE_CLOCKWISE;
+    rasterization_state_create_info.frontFace                               = VK_FRONT_FACE_COUNTER_CLOCKWISE;
     rasterization_state_create_info.depthBiasEnable                         = VK_FALSE;
     rasterization_state_create_info.lineWidth                               = 1.f;
 
@@ -524,9 +517,17 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
     multisample_state_create_info.flags                                     = 0;
     multisample_state_create_info.rasterizationSamples                      = VK_SAMPLE_COUNT_1_BIT;
     multisample_state_create_info.sampleShadingEnable                       = VK_FALSE;
+    multisample_state_create_info.minSampleShading                          = 1.f;
 
     VkPipelineColorBlendAttachmentState color_attachment_state              = {};
     color_attachment_state.blendEnable                                      = VK_FALSE;
+    color_attachment_state.srcColorBlendFactor                              = VK_BLEND_FACTOR_ONE;
+    color_attachment_state.dstColorBlendFactor                              = VK_BLEND_FACTOR_ZERO;
+    color_attachment_state.colorBlendOp                                     = VK_BLEND_OP_ADD;
+    color_attachment_state.srcAlphaBlendFactor                              = VK_BLEND_FACTOR_ONE;
+    color_attachment_state.dstAlphaBlendFactor                              = VK_BLEND_FACTOR_ZERO;
+    color_attachment_state.alphaBlendOp                                     = VK_BLEND_OP_ADD;
+    color_attachment_state.colorWriteMask                                   = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 
     VkPipelineColorBlendStateCreateInfo color_blend_state_create_info       = {};
     color_blend_state_create_info.sType                                     = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
diff --git a/src/vk-renderer.cpp b/src/vk-renderer.cpp
index 6cd1616..b881fa2 100644
--- a/src/vk-renderer.cpp
+++ b/src/vk-renderer.cpp
@@ -61,8 +61,8 @@ vkrenderer::vkrenderer(window& wnd, const input_data& inputs) {
     execution_semaphores = api.create_semaphores(swapchain.image_count);
     acquire_semaphores = api.create_semaphores(swapchain.image_count);
 
-    compute_shader_buffer = api.create_buffer(sizeof(inputs), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, nullptr);
-    std::memcpy(compute_shader_buffer.mapped_ptr, &inputs, sizeof(inputs));
+    compute_shader_buffer = api.create_buffer(sizeof(inputs), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
+    std::memcpy(compute_shader_buffer.alloc_info.pMappedData, &inputs, sizeof(inputs));
 
     for (size_t index = 0; index < swapchain.image_count; index++) {
         api.update_descriptor_set_buffer(compute_shader_sets[index], compute_sets_bindings[0], compute_shader_buffer);
@@ -102,7 +102,7 @@ vkrenderer::vkrenderer(window& wnd, const input_data& inputs) {
         .height = (uint32_t)atlas_height,
         .depth = 1,
     };
-    ui_texture = api.create_image(atlas_size, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_SAMPLED_BIT, pixels);
+    ui_texture = api.create_image(atlas_size, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_SAMPLED_BIT);
     io.Fonts->SetTexID((void*)&ui_texture);
 
     ui_vertex_buffers.resize(swapchain.image_count);
@@ -170,36 +170,44 @@ void vkrenderer::begin_frame() {
     // Update descriptor with only the part of the buffer we are interested in
     for (size_t cmd_index = 0; cmd_index < draw_data->CmdListsCount; cmd_index++) {
         ImDrawList* draw_list = draw_data->CmdLists[cmd_index];
-        ImVector vertex_buffer = draw_list->VtxBuffer;
-        ImVector index_buffer = draw_list->IdxBuffer;
+        auto vbuf = draw_list->VtxBuffer;
+        auto ibuf = draw_list->IdxBuffer;
 
-        auto vk_vtx_buf = api.create_buffer(vertex_buffer.Size * sizeof(vertex_buffer.Data[0]), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, nullptr);
-        std::memcpy(vk_vtx_buf.mapped_ptr, vertex_buffer.Data, vertex_buffer.Size * sizeof(vertex_buffer.Data[0]));
+        // auto vk_vtx_buf = api.create_buffer(vertex_buffer.Size * sizeof(vertex_buffer.Data[0]), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
+        // std::memcpy(vk_vtx_buf.alloc_info.pMappedData, vertex_buffer.Data, vertex_buffer.Size * sizeof(vertex_buffer.Data[0]));
 
-        auto vk_idx_buf = api.create_buffer(index_buffer.Size * sizeof(index_buffer.Data[0]), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, nullptr);
-        std::memcpy(vk_idx_buf.mapped_ptr, index_buffer.Data, index_buffer.Size * sizeof(index_buffer.Data[0]));
+        // auto vk_idx_buf = api.create_buffer(index_buffer.Size * sizeof(index_buffer.Data[0]), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
+        // std::memcpy(vk_idx_buf.alloc_info.pMappedData, index_buffer.Data, index_buffer.Size * sizeof(index_buffer.Data[0]));
 
-        temp_vertex_buffers.push_back(vk_vtx_buf);
-        temp_index_buffers.push_back(vk_idx_buf);
+        // temp_vertex_buffers.push_back(vk_vtx_buf);
+        // temp_index_buffers.push_back(vk_idx_buf);
+
+        vertex_buffer = api.create_buffer(vbuf.Size * sizeof(vbuf.Data[0]), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
+        std::memcpy(vertex_buffer.alloc_info.pMappedData, vbuf.Data, vbuf.Size * sizeof(vbuf.Data[0]));
+        vmaFlushAllocation(api.context.allocator, vertex_buffer.alloc, 0, VK_WHOLE_SIZE);
+
+        index_buffer = api.create_buffer(ibuf.Size * sizeof(ibuf.Data[0]), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
+        std::memcpy(index_buffer.alloc_info.pMappedData, ibuf.Data, ibuf.Size * sizeof(ibuf.Data[0]));
+        vmaFlushAllocation(api.context.allocator, index_buffer.alloc, 0, VK_WHOLE_SIZE);
     }
 
 
     VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[frame_index], VK_TRUE, UINT64_MAX))
     VKRESULT(vkResetFences(api.context.device, 1, &submission_fences[frame_index]))
 
-    for (auto& vertex_buffer: ui_vertex_buffers[frame_index]) {
-        api.destroy_buffer(vertex_buffer);
-    }
+    // for (auto& vertex_buffer: ui_vertex_buffers[frame_index]) {
+    //     api.destroy_buffer(vertex_buffer);
+    // }
 
-    for (auto& index_buffer: ui_index_buffers[frame_index]) {
-        api.destroy_buffer(index_buffer);
-    }
+    // for (auto& index_buffer: ui_index_buffers[frame_index]) {
+    //     api.destroy_buffer(index_buffer);
+    // }
 
-    ui_vertex_buffers[frame_index].clear();
-    ui_index_buffers[frame_index].clear();
+    // ui_vertex_buffers[frame_index].clear();
+    // ui_index_buffers[frame_index].clear();
 
-    ui_vertex_buffers[frame_index] = std::move(temp_vertex_buffers);
-    ui_index_buffers[frame_index] = std::move(temp_index_buffers);
+    // ui_vertex_buffers[frame_index] = std::move(temp_vertex_buffers);
+    // ui_index_buffers[frame_index] = std::move(temp_index_buffers);
 
     swapchain_image_index = 0;
     auto acquire_result = vkAcquireNextImageKHR(api.context.device, swapchain.handle, UINT64_MAX, acquire_semaphores[frame_index], VK_NULL_HANDLE, &swapchain_image_index);
@@ -239,28 +247,102 @@ void vkrenderer::ui() {
     render_pass_begin_info.clearValueCount          = 1;
     render_pass_begin_info.pClearValues             = &clear_value;
 
-    api.image_barrier(cmd_buf, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, swapchain.images[swapchain_image_index]);
+
+    // std::vector<VkBufferMemoryBarrier> buffers_barrier = {};
+    // VkBufferMemoryBarrier vertex_buffer_barrier  = {};
+    // vertex_buffer_barrier.sType                  = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+    // vertex_buffer_barrier.pNext                  = VK_NULL_HANDLE;
+    // vertex_buffer_barrier.srcAccessMask          = VK_ACCESS_MEMORY_WRITE_BIT;
+    // vertex_buffer_barrier.dstAccessMask          = VK_ACCESS_MEMORY_WRITE_BIT;
+    // vertex_buffer_barrier.srcQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
+    // vertex_buffer_barrier.dstQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
+    // vertex_buffer_barrier.buffer                 = vertex_buffer.handle;
+    // vertex_buffer_barrier.offset                 = 0;
+    // vertex_buffer_barrier.size                   = VK_WHOLE_SIZE;
+    // buffers_barrier.push_back(vertex_buffer_barrier);
+
+    // VkBufferMemoryBarrier index_buffer_barrier  = {};
+    // index_buffer_barrier.sType                  = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+    // index_buffer_barrier.pNext                  = VK_NULL_HANDLE;
+    // index_buffer_barrier.srcAccessMask          = VK_ACCESS_MEMORY_WRITE_BIT;
+    // index_buffer_barrier.dstAccessMask          = VK_ACCESS_MEMORY_WRITE_BIT;
+    // index_buffer_barrier.srcQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
+    // index_buffer_barrier.dstQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
+    // index_buffer_barrier.buffer                 = index_buffer.handle;
+    // index_buffer_barrier.offset                 = 0;
+    // index_buffer_barrier.size                   = VK_WHOLE_SIZE;
+    // buffers_barrier.push_back(index_buffer_barrier);
+
+    // vkCmdPipelineBarrier(
+    //     cmd_buf,
+    //     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+    //     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+    //     0,
+    //     0,
+    //     nullptr,
+    //     2,
+    //     buffers_barrier.data(),
+    //     0,
+    //     nullptr
+    // );
+
+    // VkMemoryBarrier memory_barrier  = {};
+    // memory_barrier.sType            = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+    // memory_barrier.pNext            = VK_NULL_HANDLE;
+    // memory_barrier.srcAccessMask    = VK_ACCESS_MEMORY_WRITE_BIT;
+    // memory_barrier.dstAccessMask    = VK_ACCESS_INDEX_READ_BIT;
+
+    // vkCmdPipelineBarrier(
+    //     cmd_buf,
+    //     VK_PIPELINE_STAGE_HOST_BIT,
+    //     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+    //     0,
+    //     1,
+    //     &memory_barrier,
+    //     0,
+    //     nullptr,
+    //     0,
+    //     nullptr
+    // );
+
+    vkCmdPipelineBarrier(
+        cmd_buf,
+        VK_PIPELINE_STAGE_HOST_BIT,
+        VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+        0,
+        0,
+        nullptr,
+        0,
+        nullptr,
+        0,
+        nullptr
+    );
+
     vkCmdBeginRenderPass(cmd_buf, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
 
     vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, ui_pipeline.layout, 0, 1, &ui_sets[frame_index], 0, nullptr);
 
     vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, ui_pipeline.handle);
 
-    for (size_t cmd_index = 0; cmd_index < draw_data->CmdListsCount; cmd_index++) {
-        ImDrawList* draw_list = draw_data->CmdLists[cmd_index];
+    // for (size_t cmd_index = 0; cmd_index < draw_data->CmdListsCount; cmd_index++) {
+    //     ImDrawList* draw_list = draw_data->CmdLists[cmd_index];
 
-        api.update_descriptor_set_buffer(ui_sets[frame_index], ui_sets_bindings[0], ui_vertex_buffers[frame_index][cmd_index]);
+        // api.update_descriptor_set_buffer(ui_sets[frame_index], ui_sets_bindings[0], ui_vertex_buffers[frame_index][cmd_index]);
 
-        vkCmdBindIndexBuffer(cmd_buf, ui_index_buffers[frame_index][cmd_index].handle, 0, VK_INDEX_TYPE_UINT16);
+        // vkCmdBindIndexBuffer(cmd_buf, ui_index_buffers[frame_index][cmd_index].handle, 0, VK_INDEX_TYPE_UINT16);
 
-        for (auto& draw_cmd: draw_list->CmdBuffer) {
-            vkCmdDrawIndexed(cmd_buf, draw_cmd.ElemCount, 1, draw_cmd.IdxOffset, draw_cmd.VtxOffset, 0);
-        }
-    }
+        api.update_descriptor_set_buffer(ui_sets[frame_index], ui_sets_bindings[0], vertex_buffer);
+        // auto temp_buffer = { 0, 1, 2, 2, 1, 3 };
+        // std::memcpy(ui_index_buffers[frame_index][cmd_index].alloc_info.pMappedData, &temp_buffer, sizeof(temp_buffer));
+        vkCmdBindIndexBuffer(cmd_buf, index_buffer.handle, 0, VK_INDEX_TYPE_UINT16);
+        vkCmdDrawIndexed(cmd_buf, 50, 1, 0, 0, 0);
 
-    vkCmdEndRenderPass(cmd_buf);
+    //     for (auto& draw_cmd: draw_list->CmdBuffer) {
+    //         vkCmdDrawIndexed(cmd_buf, draw_cmd.ElemCount, 1, draw_cmd.IdxOffset, draw_cmd.VtxOffset, 0);
+    //     }
+    // }
 
-    api.image_barrier(cmd_buf, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, 0, swapchain.images[swapchain_image_index]);
+    vkCmdEndRenderPass(cmd_buf);
 }
 
 void vkrenderer::compute(uint32_t width, uint32_t height, bool clear) {
@@ -304,7 +386,7 @@ void vkrenderer::finish_frame() {
     auto present_result = api.present(swapchain, swapchain_image_index, execution_semaphores[frame_index]);
     handle_swapchain_result(present_result);
 
-    std::swap(accumulation_images[0], accumulation_images[1]);
+    // std::swap(accumulation_images[0], accumulation_images[1]);
 
     frame_index = ++frame_index % swapchain.image_count;
 }