Examples: Vulkan: Coding style tweaks.

examples/README.txt

@@ -79,4 +79,8 @@ allegro5_example/
 	 
 marmalade_example/
     Marmalade example using IwGx
-	 
+    
+vulkan_example/
+	Vulkan example.
+	This is quite long and tedious, because: Vulkan.
+

examples/vulkan_example/build_win32.bat

@@ -0,0 +1,4 @@
+@REM Build for Visual Studio compiler. Run your copy of vcvars32.bat or vcvarsall.bat to setup command-line compiler.
+mkdir Debug
+cl /nologo /Zi /MD /I ..\.. /I ..\libs\glfw\include /I %VULKAN_SDK%\include *.cpp ..\..\*.cpp /FeDebug/vulkan_example.exe /FoDebug/ /link /LIBPATH:..\libs\glfw\lib-vc2010-32 /libpath:%VULKAN_SDK%\bin32 glfw3.lib opengl32.lib gdi32.lib shell32.lib vulkan-1.lib
+

examples/vulkan_example/imgui_impl_glfw_vulkan.cpp

@@ -59,7 +59,8 @@ static VkBuffer               g_IndexBuffer[IMGUI_VK_QUEUED_FRAMES] = {};
 static VkDeviceMemory         g_UploadBufferMemory = VK_NULL_HANDLE;
 static VkBuffer               g_UploadBuffer = VK_NULL_HANDLE;
 
-static unsigned char __glsl_shader_vert_spv[] = {
+static unsigned char __glsl_shader_vert_spv[] = 
+{
   0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
   0x6c, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
   0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00,
@@ -161,7 +162,8 @@ static unsigned char __glsl_shader_vert_spv[] = {
 };
 static unsigned int __glsl_shader_vert_spv_len = 1172;
 
-static unsigned char __glsl_shader_frag_spv[] = {
+static unsigned char __glsl_shader_frag_spv[] = 
+{
   0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
   0x6c, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
   0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -224,15 +226,15 @@ static uint32_t ImGui_ImplGlfwVulkan_MemoryType(VkMemoryPropertyFlags properties
 {
     VkPhysicalDeviceMemoryProperties prop;
     vkGetPhysicalDeviceMemoryProperties(g_Gpu, &prop);
-    for(uint32_t i=0; i < prop.memoryTypeCount; ++i)
-        if((prop.memoryTypes[i].propertyFlags & properties) == properties &&
-           type_bits & (1<<i))
+    for (uint32_t i = 0; i < prop.memoryTypeCount; i++)
+        if ((prop.memoryTypes[i].propertyFlags & properties) == properties && type_bits & (1<<i))
             return i;
     return 0xffffffff; // Unable to find memoryType
 }
+
 static void ImGui_ImplGlfwVulkan_VkResult(VkResult err)
 {
-    if(g_CheckVkResult)
+    if (g_CheckVkResult)
         g_CheckVkResult(err);
 }
 
@@ -244,22 +246,19 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
 
     // Create the Vertex Buffer:
     size_t vertex_size = draw_data->TotalVtxCount * sizeof(ImDrawVert);
-    if(!g_VertexBuffer[g_FrameIndex] ||
-       g_VertexBufferSize[g_FrameIndex] < vertex_size){
-        if(g_VertexBuffer[g_FrameIndex])
+    if (!g_VertexBuffer[g_FrameIndex] || g_VertexBufferSize[g_FrameIndex] < vertex_size)
+    {
+        if (g_VertexBuffer[g_FrameIndex])
             vkDestroyBuffer(g_Device, g_VertexBuffer[g_FrameIndex], g_Allocator);
-        if(g_VertexBufferMemory[g_FrameIndex])
+        if (g_VertexBufferMemory[g_FrameIndex])
             vkFreeMemory(g_Device, g_VertexBufferMemory[g_FrameIndex], g_Allocator);
-        size_t vertex_buffer_size = ((vertex_size-1)/g_BufferMemoryAlignment+1)*g_BufferMemoryAlignment;
+        size_t vertex_buffer_size = ((vertex_size-1) / g_BufferMemoryAlignment+1) * g_BufferMemoryAlignment;
         VkBufferCreateInfo buffer_info = {};
         buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
         buffer_info.size = vertex_buffer_size;
         buffer_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
         buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        err = vkCreateBuffer(g_Device,
-                             &buffer_info,
-                             g_Allocator,
-                             &g_VertexBuffer[g_FrameIndex]);
+        err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_VertexBuffer[g_FrameIndex]);
         ImGui_ImplGlfwVulkan_VkResult(err);
         VkMemoryRequirements req;
         vkGetBufferMemoryRequirements(g_Device, g_VertexBuffer[g_FrameIndex], &req);
@@ -267,38 +266,29 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
         VkMemoryAllocateInfo alloc_info = {};
         alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
         alloc_info.allocationSize = req.size;
-        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
-            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-            req.memoryTypeBits);
-        err = vkAllocateMemory(g_Device,
-                               &alloc_info,
-                               g_Allocator,
-                               &g_VertexBufferMemory[g_FrameIndex]);
+        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
+        err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_VertexBufferMemory[g_FrameIndex]);
         ImGui_ImplGlfwVulkan_VkResult(err);
-        err = vkBindBufferMemory(g_Device,
-                                 g_VertexBuffer[g_FrameIndex],
-                                 g_VertexBufferMemory[g_FrameIndex], 0);
+        err = vkBindBufferMemory(g_Device, g_VertexBuffer[g_FrameIndex], g_VertexBufferMemory[g_FrameIndex], 0);
         ImGui_ImplGlfwVulkan_VkResult(err);
         g_VertexBufferSize[g_FrameIndex] = vertex_buffer_size;
     }
+
     // Create the Index Buffer:
     size_t index_size = draw_data->TotalIdxCount * sizeof(ImDrawIdx);
-    if(!g_IndexBuffer[g_FrameIndex] ||
-       g_IndexBufferSize[g_FrameIndex] < index_size){
-        if(g_IndexBuffer[g_FrameIndex])
+    if (!g_IndexBuffer[g_FrameIndex] || g_IndexBufferSize[g_FrameIndex] < index_size)
+    {
+        if (g_IndexBuffer[g_FrameIndex])
             vkDestroyBuffer(g_Device, g_IndexBuffer[g_FrameIndex], g_Allocator);
-        if(g_IndexBufferMemory[g_FrameIndex])
+        if (g_IndexBufferMemory[g_FrameIndex])
             vkFreeMemory(g_Device, g_IndexBufferMemory[g_FrameIndex], g_Allocator);
-        size_t index_buffer_size = ((index_size-1)/g_BufferMemoryAlignment+1)*g_BufferMemoryAlignment;
+        size_t index_buffer_size = ((index_size-1) / g_BufferMemoryAlignment+1) * g_BufferMemoryAlignment;
         VkBufferCreateInfo buffer_info = {};
         buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
         buffer_info.size = index_buffer_size;
         buffer_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
         buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        err = vkCreateBuffer(g_Device,
-                             &buffer_info,
-                             g_Allocator,
-                             &g_IndexBuffer[g_FrameIndex]);
+        err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_IndexBuffer[g_FrameIndex]);
         ImGui_ImplGlfwVulkan_VkResult(err);
         VkMemoryRequirements req;
         vkGetBufferMemoryRequirements(g_Device, g_IndexBuffer[g_FrameIndex], &req);
@@ -306,38 +296,27 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
         VkMemoryAllocateInfo alloc_info = {};
         alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
         alloc_info.allocationSize = req.size;
-        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
-            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-            req.memoryTypeBits);
-        err = vkAllocateMemory(g_Device,
-                               &alloc_info,
-                               g_Allocator,
-                               &g_IndexBufferMemory[g_FrameIndex]);
+        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
+        err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_IndexBufferMemory[g_FrameIndex]);
         ImGui_ImplGlfwVulkan_VkResult(err);
-        err = vkBindBufferMemory(g_Device,
-                                 g_IndexBuffer[g_FrameIndex],
-                                 g_IndexBufferMemory[g_FrameIndex], 0);
+        err = vkBindBufferMemory(g_Device, g_IndexBuffer[g_FrameIndex], g_IndexBufferMemory[g_FrameIndex], 0);
         ImGui_ImplGlfwVulkan_VkResult(err);
         g_IndexBufferSize[g_FrameIndex] = index_buffer_size;
     }
+
     // Upload Vertex and index Data:
     {
         ImDrawVert* vtx_dst;
         ImDrawIdx* idx_dst;
-        err = vkMapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex],
-                          0, vertex_size, 0,
-                          reinterpret_cast<void**>(&vtx_dst));
+        err = vkMapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex], 0, vertex_size, 0, (void**)(&vtx_dst));
         ImGui_ImplGlfwVulkan_VkResult(err);
-        err = vkMapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex],
-                          0, index_size, 0,
-                          reinterpret_cast<void**>(&idx_dst));
+        err = vkMapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex], 0, index_size, 0, (void**)(&idx_dst));
         ImGui_ImplGlfwVulkan_VkResult(err);
-        for(int n = 0; n < draw_data->CmdListsCount; n++){
+        for (int n = 0; n < draw_data->CmdListsCount; n++)
+        {
             const ImDrawList* cmd_list = draw_data->CmdLists[n];
-            memcpy(vtx_dst, &cmd_list->VtxBuffer[0],
-                   cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
-            memcpy(idx_dst, &cmd_list->IdxBuffer[0],
-                   cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
+            memcpy(vtx_dst, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
+            memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
             vtx_dst += cmd_list->VtxBuffer.size();
             idx_dst += cmd_list->IdxBuffer.size();
         }
@@ -353,29 +332,22 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
         vkUnmapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex]);
         vkUnmapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex]);
     }
+
     // Bind pipeline and descriptor sets:
     {
-        vkCmdBindPipeline(g_CommandBuffer,
-                          VK_PIPELINE_BIND_POINT_GRAPHICS,
-                          g_Pipeline);
+        vkCmdBindPipeline(g_CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, g_Pipeline);
         VkDescriptorSet desc_set[1] = {g_DescriptorSet};
-        vkCmdBindDescriptorSets(g_CommandBuffer,
-                                VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                g_PipelineLayout,
-                                0, 1, desc_set,
-                                0, NULL);
+        vkCmdBindDescriptorSets(g_CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, g_PipelineLayout, 0, 1, desc_set, 0, NULL);
     }
+
     // Bind Vertex And Index Buffer:
     {
         VkBuffer vertex_buffers[1] = {g_VertexBuffer[g_FrameIndex]};
         VkDeviceSize vertex_offset[1] = {0};
-        vkCmdBindVertexBuffers(g_CommandBuffer,
-                               0, 1,
-                               vertex_buffers, vertex_offset);
-        vkCmdBindIndexBuffer(g_CommandBuffer,
-                             g_IndexBuffer[g_FrameIndex],
-                             0, VK_INDEX_TYPE_UINT16);
+        vkCmdBindVertexBuffers(g_CommandBuffer, 0, 1, vertex_buffers, vertex_offset);
+        vkCmdBindIndexBuffer(g_CommandBuffer, g_IndexBuffer[g_FrameIndex], 0, VK_INDEX_TYPE_UINT16);
     }
+
     // Setup viewport:
     {
         VkViewport viewport;
@@ -387,6 +359,7 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
         viewport.maxDepth = 1.0f;
         vkCmdSetViewport(g_CommandBuffer, 0, 1, &viewport);
     }
+
     // Setup scale and translation:
     {
         float scale[2];
@@ -395,39 +368,32 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
         float translate[2];
         translate[0] = -1.0f;
         translate[1] = -1.0f;
-        vkCmdPushConstants(g_CommandBuffer,
-                           g_PipelineLayout,
-                           VK_SHADER_STAGE_VERTEX_BIT,
-                           sizeof(float) * 0,
-                           sizeof(float) * 2,
-                           scale);
-        vkCmdPushConstants(g_CommandBuffer,
-                           g_PipelineLayout,
-                           VK_SHADER_STAGE_VERTEX_BIT,
-                           sizeof(float) * 2,
-                           sizeof(float) * 2,
-                           translate);
+        vkCmdPushConstants(g_CommandBuffer, g_PipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, sizeof(float) * 0, sizeof(float) * 2, scale);
+        vkCmdPushConstants(g_CommandBuffer, g_PipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, sizeof(float) * 2, sizeof(float) * 2, translate);
     }
+
     // Render the command lists:
     int vtx_offset = 0;
     int idx_offset = 0;
-    for(int n = 0; n < draw_data->CmdListsCount; n++){
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
         const ImDrawList* cmd_list = draw_data->CmdLists[n];
-        for(int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++){
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
+        {
             const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
-            if(pcmd->UserCallback){
+            if (pcmd->UserCallback)
+            {
                 pcmd->UserCallback(cmd_list, pcmd);
             }
-            else{
+            else
+            {
                 VkRect2D scissor;
                 scissor.offset.x = static_cast<int32_t>(pcmd->ClipRect.x);
                 scissor.offset.y = static_cast<int32_t>(pcmd->ClipRect.y);
                 scissor.extent.width = static_cast<uint32_t>(pcmd->ClipRect.z - pcmd->ClipRect.x);
                 scissor.extent.height = static_cast<uint32_t>(pcmd->ClipRect.w - pcmd->ClipRect.y + 1); // TODO: + 1??????
                 vkCmdSetScissor(g_CommandBuffer, 0, 1, &scissor);
-                vkCmdDrawIndexed(g_CommandBuffer,
-                                 pcmd->ElemCount, 1,
-                                 idx_offset, vtx_offset, 0);
+                vkCmdDrawIndexed(g_CommandBuffer, pcmd->ElemCount, 1, idx_offset, vtx_offset, 0);
             }
             idx_offset += pcmd->ElemCount;
         }
@@ -468,6 +434,7 @@ void ImGui_ImplGlfwVulkan_KeyCallback(GLFWwindow*, int key, int, int action, int
     io.KeyCtrl = io.KeysDown[GLFW_KEY_LEFT_CONTROL] || io.KeysDown[GLFW_KEY_RIGHT_CONTROL];
     io.KeyShift = io.KeysDown[GLFW_KEY_LEFT_SHIFT] || io.KeysDown[GLFW_KEY_RIGHT_SHIFT];
     io.KeyAlt = io.KeysDown[GLFW_KEY_LEFT_ALT] || io.KeysDown[GLFW_KEY_RIGHT_ALT];
+    io.KeySuper = io.KeysDown[GLFW_KEY_LEFT_SUPER] || io.KeysDown[GLFW_KEY_RIGHT_SUPER];
 }
 
 void ImGui_ImplGlfwVulkan_CharCallback(GLFWwindow*, unsigned int c)
@@ -487,6 +454,7 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
     size_t upload_size = width*height*4*sizeof(char);
 
     VkResult err;
+
     // Create the Image:
     {
         VkImageCreateInfo info = {};
@@ -500,32 +468,23 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         info.arrayLayers = 1;
         info.samples = VK_SAMPLE_COUNT_1_BIT;
         info.tiling = VK_IMAGE_TILING_OPTIMAL;
-        info.usage =
-            VK_IMAGE_USAGE_SAMPLED_BIT |
-            VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+        info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
         info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
         info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        err = vkCreateImage(g_Device,
-                            &info,
-                            g_Allocator,
-                            &g_FontImage);
+        err = vkCreateImage(g_Device, &info, g_Allocator, &g_FontImage);
         ImGui_ImplGlfwVulkan_VkResult(err);
         VkMemoryRequirements req;
         vkGetImageMemoryRequirements(g_Device, g_FontImage, &req);
         VkMemoryAllocateInfo alloc_info = {};
         alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
         alloc_info.allocationSize = req.size;
-        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
-            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-            req.memoryTypeBits);
-        err = vkAllocateMemory(g_Device,
-                               &alloc_info,
-                               g_Allocator,
-                               &g_FontMemory);
+        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, req.memoryTypeBits);
+        err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_FontMemory);
         ImGui_ImplGlfwVulkan_VkResult(err);
         err = vkBindImageMemory(g_Device, g_FontImage, g_FontMemory, 0);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
+
     // Create the Image View:
     {
         VkResult err;
@@ -537,12 +496,10 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         info.subresourceRange.levelCount = 1;
         info.subresourceRange.layerCount = 1;
-        err = vkCreateImageView(g_Device,
-                                &info,
-                                g_Allocator,
-                                &g_FontView);
+        err = vkCreateImageView(g_Device, &info, g_Allocator, &g_FontView);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
+
     // Update the Descriptor Set:
     {
         VkDescriptorImageInfo desc_image[1] = {};
@@ -555,10 +512,9 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         write_desc[0].descriptorCount = 1;
         write_desc[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
         write_desc[0].pImageInfo = desc_image;
-        vkUpdateDescriptorSets(g_Device,
-                               1, write_desc,
-                               0, NULL);
+        vkUpdateDescriptorSets(g_Device, 1, write_desc, 0, NULL);
     }
+
     // Create the Upload Buffer:
     {
         VkBufferCreateInfo buffer_info = {};
@@ -566,10 +522,7 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         buffer_info.size = upload_size;
         buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
         buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        err = vkCreateBuffer(g_Device,
-                             &buffer_info,
-                             g_Allocator,
-                             &g_UploadBuffer);
+        err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_UploadBuffer);
         ImGui_ImplGlfwVulkan_VkResult(err);
         VkMemoryRequirements req;
         vkGetBufferMemoryRequirements(g_Device, g_UploadBuffer, &req);
@@ -577,22 +530,17 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         VkMemoryAllocateInfo alloc_info = {};
         alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
         alloc_info.allocationSize = req.size;
-        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
-            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-            req.memoryTypeBits);
-        err = vkAllocateMemory(g_Device,
-                               &alloc_info,
-                               g_Allocator,
-                               &g_UploadBufferMemory);
+        alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
+        err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_UploadBufferMemory);
         ImGui_ImplGlfwVulkan_VkResult(err);
         err = vkBindBufferMemory(g_Device, g_UploadBuffer, g_UploadBufferMemory, 0);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
+
     // Upload to Buffer:
     {
-        char *map;
-        err = vkMapMemory(g_Device, g_UploadBufferMemory, 0, upload_size, 0,
-                          reinterpret_cast<void**>(&map));
+        char* map = NULL;
+        err = vkMapMemory(g_Device, g_UploadBufferMemory, 0, upload_size, 0, (void**)(&map));
         ImGui_ImplGlfwVulkan_VkResult(err);
         memcpy(map, pixels, upload_size);
         VkMappedMemoryRange range[1] = {};
@@ -616,21 +564,15 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         copy_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         copy_barrier[0].subresourceRange.levelCount = 1;
         copy_barrier[0].subresourceRange.layerCount = 1;
-        vkCmdPipelineBarrier(command_buffer,
-                             VK_PIPELINE_STAGE_HOST_BIT,
-                             VK_PIPELINE_STAGE_TRANSFER_BIT,
-                             0,
-                             0, NULL, 0, NULL, 1, copy_barrier);
+        vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, copy_barrier);
+
         VkBufferImageCopy region = {};
         region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         region.imageSubresource.layerCount = 1;
         region.imageExtent.width = width;
         region.imageExtent.height = height;
-        vkCmdCopyBufferToImage(command_buffer,
-                               g_UploadBuffer,
-                               g_FontImage,
-                               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                               1, &region);
+        vkCmdCopyBufferToImage(command_buffer, g_UploadBuffer, g_FontImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
+
         VkImageMemoryBarrier use_barrier[1] = {};
         use_barrier[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
         use_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
@@ -643,16 +585,11 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
         use_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         use_barrier[0].subresourceRange.levelCount = 1;
         use_barrier[0].subresourceRange.layerCount = 1;
-        vkCmdPipelineBarrier(command_buffer,
-                             VK_PIPELINE_STAGE_TRANSFER_BIT,
-                             VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                             0,
-                             0, NULL, 0, NULL, 1, use_barrier);
+        vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1, use_barrier);
     }
-    io.Fonts->TexID = (void *)(intptr_t)g_FontImage;
 
-    io.Fonts->ClearInputData();
-    io.Fonts->ClearTexData();
+    // Store our identifier
+    io.Fonts->TexID = (void *)(intptr_t)g_FontImage;
 
     return true;
 }
@@ -660,7 +597,6 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
 bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
 {
     VkResult err;
-
     VkShaderModule vert_module;
     VkShaderModule frag_module;
 
@@ -679,7 +615,9 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
         err = vkCreateShaderModule(g_Device, &frag_info, g_Allocator, &frag_module);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
-    if(!g_FontSampler){
+
+    if (!g_FontSampler)
+    {
         VkSamplerCreateInfo info = {};
         info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
         info.magFilter = VK_FILTER_LINEAR;
@@ -690,13 +628,12 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
         info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
         info.minLod = -1000;
         info.maxLod = 1000;
-        err = vkCreateSampler(g_Device,
-                              &info,
-                              g_Allocator,
-                              &g_FontSampler);
+        err = vkCreateSampler(g_Device, &info, g_Allocator, &g_FontSampler);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
-    if(!g_DescriptorSetLayout){
+
+    if (!g_DescriptorSetLayout)
+    {
         VkSampler sampler[1] = {g_FontSampler};
         VkDescriptorSetLayoutBinding binding[1] = {};
         binding[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
@@ -707,12 +644,10 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
         info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
         info.bindingCount = 1;
         info.pBindings = binding;
-        err = vkCreateDescriptorSetLayout(g_Device,
-                                          &info,
-                                          g_Allocator,
-                                          &g_DescriptorSetLayout);
+        err = vkCreateDescriptorSetLayout(g_Device, &info, g_Allocator, &g_DescriptorSetLayout);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
+
     // Create Descriptor Set:
     {
         VkDescriptorSetAllocateInfo alloc_info = {};
@@ -723,7 +658,9 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
         err = vkAllocateDescriptorSets(g_Device, &alloc_info, &g_DescriptorSet);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
-    if(!g_PipelineLayout){
+
+    if (!g_PipelineLayout)
+    {
         VkPushConstantRange push_constants[2] = {};
         push_constants[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
         push_constants[0].offset = sizeof(float) * 0;
@@ -738,8 +675,7 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
         layout_info.pSetLayouts = set_layout;
         layout_info.pushConstantRangeCount = 2;
         layout_info.pPushConstantRanges = push_constants;
-        err = vkCreatePipelineLayout(g_Device, &layout_info,
-                                     g_Allocator, &g_PipelineLayout);
+        err = vkCreatePipelineLayout(g_Device, &layout_info, g_Allocator, &g_PipelineLayout);
         ImGui_ImplGlfwVulkan_VkResult(err);
     }
 
@@ -805,17 +741,14 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
     color_attachment[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
     color_attachment[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
     color_attachment[0].alphaBlendOp = VK_BLEND_OP_ADD;
-    color_attachment[0].colorWriteMask =
-        VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+    color_attachment[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 
     VkPipelineColorBlendStateCreateInfo blend_info = {};
     blend_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
     blend_info.attachmentCount = 1;
     blend_info.pAttachments = color_attachment;
 
-    VkDynamicState dynamic_states[2] = {VK_DYNAMIC_STATE_VIEWPORT,
-                                       VK_DYNAMIC_STATE_SCISSOR};
+    VkDynamicState dynamic_states[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
     VkPipelineDynamicStateCreateInfo dynamic_state = {};
     dynamic_state.dynamicStateCount = 2;
     dynamic_state.pDynamicStates = dynamic_states;
@@ -834,11 +767,7 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
     info.pDynamicState = &dynamic_state;
     info.layout = g_PipelineLayout;
     info.renderPass = g_RenderPass;
-    err = vkCreateGraphicsPipelines(g_Device,
-                                    g_PipelineCache,
-                                    1, &info,
-                                    g_Allocator,
-                                    &g_Pipeline);
+    err = vkCreateGraphicsPipelines(g_Device, g_PipelineCache, 1, &info, g_Allocator, &g_Pipeline);
     ImGui_ImplGlfwVulkan_VkResult(err);
 
     vkDestroyShaderModule(g_Device, vert_module, g_Allocator);
@@ -849,43 +778,47 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
 
 void    ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects()
 {
-    if(g_UploadBuffer){
+    if (g_UploadBuffer)
+    {
         vkDestroyBuffer(g_Device, g_UploadBuffer, g_Allocator);
         g_UploadBuffer = VK_NULL_HANDLE;
     }
-    if(g_UploadBufferMemory){
+    if (g_UploadBufferMemory)
+    {
         vkFreeMemory(g_Device, g_UploadBufferMemory, g_Allocator);
         g_UploadBufferMemory = VK_NULL_HANDLE;
     }
 }
+
 void    ImGui_ImplGlfwVulkan_InvalidateDeviceObjects()
 {
     ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects();
-    for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
-        if(g_VertexBuffer[i])
+    for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++)
+    {
+        if (g_VertexBuffer[i])
             vkDestroyBuffer(g_Device, g_VertexBuffer[i], g_Allocator);
-        if(g_VertexBufferMemory[i])
+        if (g_VertexBufferMemory[i])
             vkFreeMemory(g_Device, g_VertexBufferMemory[i], g_Allocator);
-        if(g_IndexBuffer[i])
+        if (g_IndexBuffer[i])
             vkDestroyBuffer(g_Device, g_IndexBuffer[i], g_Allocator);
-        if(g_IndexBufferMemory[i])
+        if (g_IndexBufferMemory[i])
             vkFreeMemory(g_Device, g_IndexBufferMemory[i], g_Allocator);
     }
 
-    if(g_FontView)
+    if (g_FontView)
         vkDestroyImageView(g_Device, g_FontView, g_Allocator);
-    if(g_FontImage)
+    if (g_FontImage)
         vkDestroyImage(g_Device, g_FontImage, g_Allocator);
-    if(g_FontMemory)
+    if (g_FontMemory)
         vkFreeMemory(g_Device, g_FontMemory, g_Allocator);
-    if(g_FontSampler)
+    if (g_FontSampler)
         vkDestroySampler(g_Device, g_FontSampler, g_Allocator);
 
-    if(g_DescriptorSetLayout)
+    if (g_DescriptorSetLayout)
         vkDestroyDescriptorSetLayout(g_Device, g_DescriptorSetLayout, g_Allocator);
-    if(g_PipelineLayout)
+    if (g_PipelineLayout)
         vkDestroyPipelineLayout(g_Device, g_PipelineLayout, g_Allocator);
-    if(g_Pipeline)
+    if (g_Pipeline)
         vkDestroyPipeline(g_Device, g_Pipeline, g_Allocator);
 }
 
@@ -998,5 +931,5 @@ void ImGui_ImplGlfwVulkan_Render(VkCommandBuffer command_buffer)
     g_CommandBuffer = command_buffer;
     ImGui::Render();
     g_CommandBuffer = VK_NULL_HANDLE;
-    g_FrameIndex = (g_FrameIndex+1)%IMGUI_VK_QUEUED_FRAMES;
+    g_FrameIndex = (g_FrameIndex + 1) % IMGUI_VK_QUEUED_FRAMES;
 }

examples/vulkan_example/imgui_impl_glfw_vulkan.h

@@ -4,11 +4,12 @@
 // If you are new to ImGui, see examples/README.txt and documentation at the top of imgui.cpp.
 // https://github.com/ocornut/imgui
 
-#define IMGUI_VK_QUEUED_FRAMES 2
-
 struct GLFWwindow;
 
-struct ImGui_ImplGlfwVulkan_Init_Data{
+#define IMGUI_VK_QUEUED_FRAMES 2
+
+struct ImGui_ImplGlfwVulkan_Init_Data
+{
     VkAllocationCallbacks* allocator;
     VkPhysicalDevice       gpu;
     VkDevice               device;
@@ -29,7 +30,6 @@ IMGUI_API void        ImGui_ImplGlfwVulkan_InvalidateDeviceObjects();
 IMGUI_API bool        ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);
 IMGUI_API bool        ImGui_ImplGlfwVulkan_CreateDeviceObjects();
 
-
 // GLFW callbacks (installed by default if you enable 'install_callbacks' during initialization)
 // Provided here if you want to chain callbacks.
 // You can also handle inputs yourself and use those as a reference.
@@ -38,4 +38,3 @@ IMGUI_API void        ImGui_ImplGlfwVulkan_ScrollCallback(GLFWwindow* window, do
 IMGUI_API void        ImGui_ImplGlfwVulkan_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
 IMGUI_API void        ImGui_ImplGlfwVulkan_CharCallback(GLFWwindow* window, unsigned int c);
 
-

examples/vulkan_example/main.cpp

@@ -3,8 +3,8 @@
 
 #include <imgui.h>
 
-#include <stdio.h>
-#include <stdlib.h>
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
 #define GLFW_INCLUDE_NONE
 #define GLFW_INCLUDE_VULKAN
 #include <GLFW/glfw3.h>
@@ -47,9 +47,10 @@ static VkClearValue             g_ClearValue = {};
 
 static void check_vk_result(VkResult err)
 {
-    if(err == 0) return;
+    if (err == 0) return;
     printf("VkResult %d\n", err);
-    if(err < 0) abort();
+    if (err < 0) 
+        abort();
 }
 
 static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
@@ -58,15 +59,17 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
     VkSwapchainKHR old_swapchain = g_Swapchain;
     err = vkDeviceWaitIdle(g_Device);
     check_vk_result(err);
+
     // Destroy old Framebuffer:
-    for(uint32_t i=0; i<g_BackBufferCount; i++)
-        if(g_BackBufferView[i])
+    for (uint32_t i=0; i<g_BackBufferCount; i++)
+        if (g_BackBufferView[i])
             vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
-    for(uint32_t i=0; i<g_BackBufferCount; i++)
-        if(g_Framebuffer[i])
+     for(uint32_t i=0; i<g_BackBufferCount; i++)
+        if (g_Framebuffer[i])
             vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
-    if(g_RenderPass)
+    if (g_RenderPass)
         vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
+
     // Create Swapchain:
     {
         VkSwapchainCreateInfoKHR info = {};
@@ -86,13 +89,15 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
         err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(g_Gpu, g_Surface, &cap);
         check_vk_result(err);
         info.minImageCount = (cap.minImageCount + 2 < cap.maxImageCount) ? (cap.minImageCount + 2) : cap.maxImageCount;
-        if(cap.currentExtent.width == 0xffffffff){
+        if (cap.currentExtent.width == 0xffffffff)
+        {
             fb_width = w;
             fb_height = h;
             info.imageExtent.width = fb_width;
             info.imageExtent.height = fb_height;
         }
-        else{
+        else
+        {
             fb_width = cap.currentExtent.width;
             fb_height = cap.currentExtent.height;
             info.imageExtent.width = fb_width;
@@ -105,8 +110,9 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
         err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, g_BackBuffer);
         check_vk_result(err);
     }
-    if(old_swapchain)
+    if (old_swapchain)
         vkDestroySwapchainKHR(g_Device, old_swapchain, g_Allocator);
+
     // Create the Render Pass:
     {
         VkAttachmentDescription attachment = {};
@@ -134,6 +140,7 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
         err = vkCreateRenderPass(g_Device, &info, g_Allocator, &g_RenderPass);
         check_vk_result(err);
     }
+
     // Create The Image Views
     {
         VkImageViewCreateInfo info = {};
@@ -145,12 +152,14 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
         info.components.b = VK_COMPONENT_SWIZZLE_B;
         info.components.a = VK_COMPONENT_SWIZZLE_A;
         info.subresourceRange = g_ImageRange;
-        for(uint32_t i=0; i<g_BackBufferCount; i++){
+        for (uint32_t i = 0; i<g_BackBufferCount; i++)
+        {
             info.image = g_BackBuffer[i];
             err = vkCreateImageView(g_Device, &info, g_Allocator, &g_BackBufferView[i]);
             check_vk_result(err);
         }
     }
+
     // Create Framebuffer:
     {
         VkImageView attachment[1];
@@ -162,7 +171,8 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
         info.width = fb_width;
         info.height = fb_height;
         info.layers = 1;
-        for(uint32_t i=0; i<g_BackBufferCount; i++){
+        for (uint32_t i = 0; i<g_BackBufferCount; i++)
+        {
             attachment[0] = g_BackBufferView[i];
             err = vkCreateFramebuffer(g_Device, &info, g_Allocator, &g_Framebuffer[i]);
             check_vk_result(err);
@@ -173,9 +183,10 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
 static void setup_vulkan(GLFWwindow* window)
 {
     VkResult err;
+
     // Create Vulkan Instance
     {
-        int glfw_extensions_count;
+        uint32_t glfw_extensions_count;
         const char** glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extensions_count);
         VkInstanceCreateInfo create_info = {};
         create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
@@ -184,17 +195,20 @@ static void setup_vulkan(GLFWwindow* window)
         err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
         check_vk_result(err);
     }
+
     // Create Window Surface
     {
         err = glfwCreateWindowSurface(g_Instance, window, g_Allocator, &g_Surface);
         check_vk_result(err);
     }
-    // Get Gpu
+    
+    // Get GPU
     {
         uint32_t count = 1;
         err = vkEnumeratePhysicalDevices(g_Instance, &count, &g_Gpu);
         check_vk_result(err);
     }
+
     // Create Logical Device
     {
         int device_extension_count = 1;
@@ -217,6 +231,7 @@ static void setup_vulkan(GLFWwindow* window)
         check_vk_result(err);
         vkGetDeviceQueue(g_Device, g_QueueFamily, queue_index, &g_Queue);
     }
+
     // Create Framebuffers
     {
         int w, h;
@@ -224,8 +239,10 @@ static void setup_vulkan(GLFWwindow* window)
         resize_vulkan(window, w, h);
         glfwSetFramebufferSizeCallback(window, resize_vulkan);
     }
+
     // Create Command Buffers
-    for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
+    for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++)
+    {
         {
             VkCommandPoolCreateInfo info = {};
             info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
@@ -257,20 +274,23 @@ static void setup_vulkan(GLFWwindow* window)
             check_vk_result(err);
         }
     }
+
     // Create Descriptor Pool
     {
-        VkDescriptorPoolSize pool_size[11] = {
-            {VK_DESCRIPTOR_TYPE_SAMPLER, 1000},
-            {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000},
-            {VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000},
-            {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000},
-            {VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000},
-            {VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000},
-            {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000},
-            {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000},
-            {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000},
-            {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000},
-            {VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000}};
+        VkDescriptorPoolSize pool_size[11] = 
+        {
+            { VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
+            { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
+            { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
+            { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
+            { VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
+            { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
+            { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
+            { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
+            { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
+            { VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
+        };
         VkDescriptorPoolCreateInfo pool_info = {};
         pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
@@ -285,13 +305,15 @@ static void setup_vulkan(GLFWwindow* window)
 static void cleanup_vulkan()
 {
     vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
-    for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
+    for (int i = 0; i < IMGUI_VK_QUEUED_FRAMES; i++)
+    {
         vkDestroyFence(g_Device, g_Fence[i], g_Allocator);
         vkFreeCommandBuffers(g_Device, g_CommandPool[i], 1, &g_CommandBuffer[i]);
         vkDestroyCommandPool(g_Device, g_CommandPool[i], g_Allocator);
         vkDestroySemaphore(g_Device, g_Semaphore[i], g_Allocator);
     }
-    for(uint32_t i=0; i<g_BackBufferCount; i++){
+    for (uint32_t i = 0; i < g_BackBufferCount; i++)
+    {
         vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
         vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
     }
@@ -305,18 +327,15 @@ static void cleanup_vulkan()
 static void frame_begin()
 {
     VkResult err;
-    while(true){
+    while (true)
+    {
         err = vkWaitForFences(g_Device, 1, &g_Fence[g_FrameIndex], VK_TRUE, 100);
-        if(err == VK_SUCCESS) break;
-        if(err == VK_TIMEOUT) continue;
+        if (err == VK_SUCCESS) break;
+        if (err == VK_TIMEOUT) continue;
         check_vk_result(err);
     }
     {
-        err = vkAcquireNextImageKHR(
-            g_Device, g_Swapchain,
-            UINT64_MAX,
-            g_Semaphore[g_FrameIndex], VK_NULL_HANDLE,
-            &g_BackBufferIndex);
+        err = vkAcquireNextImageKHR(g_Device, g_Swapchain, UINT64_MAX, g_Semaphore[g_FrameIndex], VK_NULL_HANDLE, &g_BackBufferIndex);
         check_vk_result(err);
     }
     {
@@ -356,11 +375,7 @@ static void frame_end()
         barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
         barrier.image = g_BackBuffer[g_BackBufferIndex];
         barrier.subresourceRange = g_ImageRange;
-        vkCmdPipelineBarrier(g_CommandBuffer[g_FrameIndex],
-                             VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-                             VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-                             0,
-                             0, NULL, 0, NULL, 1, &barrier);
+        vkCmdPipelineBarrier(g_CommandBuffer[g_FrameIndex], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &barrier);
     }
     {
         VkSubmitInfo info = {};
@@ -391,7 +406,7 @@ static void frame_end()
         check_vk_result(err);
         check_vk_result(res);
     }
-    g_FrameIndex = (g_FrameIndex)%IMGUI_VK_QUEUED_FRAMES;
+    g_FrameIndex = (g_FrameIndex) % IMGUI_VK_QUEUED_FRAMES;
 }
 
 static void error_callback(int error, const char* description)
@@ -410,7 +425,8 @@ int main(int, char**)
     GLFWwindow* window = glfwCreateWindow(1280, 720, "ImGui Vulkan example", NULL, NULL);
 
     // Setup Vulkan
-    if(!glfwVulkanSupported()){
+    if (!glfwVulkanSupported())
+    {
         printf("GLFW: Vulkan Not Supported\n");
         return 1;
     }
@@ -508,9 +524,7 @@ int main(int, char**)
         g_ClearValue.color.float32[3] = clear_color.w;
 
         frame_begin();
-
         ImGui_ImplGlfwVulkan_Render(g_CommandBuffer[g_FrameIndex]);
-
         frame_end();
     }