text: // dear imgui: Renderer Backend for Vulkan
  // This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
  
  // Implemented features:
  //  [X] Renderer: Support for large meshes (64k+ vertices) with 16-bit indices.
  // Missing features:
  //  [ ] Platform: Multi-viewport / platform windows.
  //  [ ] Renderer: User texture binding. Changes of ImTextureID aren't supported by this backend! See https://github.com/ocornut/imgui/pull/914
  
  // You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
  // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
  // Read online: https://github.com/ocornut/imgui/tree/master/docs
  
  // The aim of imgui_impl_vulkan.h/.cpp is to be usable in your engine without any modification.
  // IF YOU FEEL YOU NEED TO MAKE ANY CHANGE TO THIS CODE, please share them and your feedback at https://github.com/ocornut/imgui/
  
  // Important note to the reader who wish to integrate imgui_impl_vulkan.cpp/.h in their own engine/app.
  // - Common ImGui_ImplVulkan_XXX functions and structures are used to interface with imgui_impl_vulkan.cpp/.h.
  //   You will use those if you want to use this rendering backend in your engine/app.
  // - Helper ImGui_ImplVulkanH_XXX functions and structures are only used by this example (main.cpp) and by
  //   the backend itself (imgui_impl_vulkan.cpp), but should PROBABLY NOT be used by your own engine/app code.
  // Read comments in imgui_impl_vulkan.h.
  
  #pragma once
  #include "imgui.h"      // IMGUI_IMPL_API
  
  // [Configuration] in order to use a custom Vulkan function loader:
  // (1) You'll need to disable default Vulkan function prototypes.
  //     We provide a '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' convenience configuration flag.
  //     In order to make sure this is visible from the imgui_impl_vulkan.cpp compilation unit:
  //     - Add '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' in your imconfig.h file
  //     - Or as a compilation flag in your build system
  //     - Or uncomment here (not recommended because you'd be modifying imgui sources!)
  //     - Do not simply add it in a .cpp file!
  // (2) Call ImGui_ImplVulkan_LoadFunctions() before ImGui_ImplVulkan_Init() with your custom function.
  // If you have no idea what this is, leave it alone!
  //#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES
  
  // Vulkan includes
  #if defined(IMGUI_IMPL_VULKAN_NO_PROTOTYPES) && !defined(VK_NO_PROTOTYPES)
  #define VK_NO_PROTOTYPES
  #endif
  #include "vulkan/vk_mem_alloc.hpp"
  
  // Initialization data, for ImGui_ImplVulkan_Init()
  // [Please zero-clear before use!]
  struct ImGui_ImplVulkan_InitInfo
  {
      VkInstance                      Instance;
      VkPhysicalDevice                PhysicalDevice;
      VkDevice                        Device;
      uint32_t                        QueueFamily;
      VkQueue                         Queue;
      VkPipelineCache                 PipelineCache;
      VkDescriptorPool                DescriptorPool;
      uint32_t                        Subpass;
      uint32_t                        MinImageCount;          // >= 2
      uint32_t                        ImageCount;             // >= MinImageCount
      VkSampleCountFlagBits           MSAASamples;            // >= VK_SAMPLE_COUNT_1_BIT
      const VkAllocationCallbacks*    Allocator;
      void                            (*CheckVkResultFn)(VkResult err);
  };
  
  // Called by user code
  IMGUI_IMPL_API bool     ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info, VkRenderPass render_pass);
  IMGUI_IMPL_API void     ImGui_ImplVulkan_Shutdown();
  IMGUI_IMPL_API void     ImGui_ImplVulkan_NewFrame();
  IMGUI_IMPL_API void     ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer command_buffer, VkPipeline pipeline = VK_NULL_HANDLE);
  IMGUI_IMPL_API bool     ImGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);
  IMGUI_IMPL_API void     ImGui_ImplVulkan_DestroyFontUploadObjects();
  IMGUI_IMPL_API void     ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count); // To override MinImageCount after initialization (e.g. if swap chain is recreated)
  
  // Optional: load Vulkan functions with a custom function loader
  // This is only useful with IMGUI_IMPL_VULKAN_NO_PROTOTYPES / VK_NO_PROTOTYPES
  IMGUI_IMPL_API bool     ImGui_ImplVulkan_LoadFunctions(PFN_vkVoidFunction(*loader_func)(const char* function_name, void* user_data), void* user_data = NULL);
  
  //-------------------------------------------------------------------------
  // Internal / Miscellaneous Vulkan Helpers
  // (Used by example's main.cpp. Used by multi-viewport features. PROBABLY NOT used by your own engine/app.)
  //-------------------------------------------------------------------------
  // You probably do NOT need to use or care about those functions.
  // Those functions only exist because:
  //   1) they facilitate the readability and maintenance of the multiple main.cpp examples files.
  //   2) the multi-viewport / platform window implementation needs them internally.
  // Generally we avoid exposing any kind of superfluous high-level helpers in the bindings,
  // but it is too much code to duplicate everywhere so we exceptionally expose them.
  //
  // Your engine/app will likely _already_ have code to setup all that stuff (swap chain, render pass, frame buffers, etc.).
  // You may read this code to learn about Vulkan, but it is recommended you use you own custom tailored code to do equivalent work.
  // (The ImGui_ImplVulkanH_XXX functions do not interact with any of the state used by the regular ImGui_ImplVulkan_XXX functions)
  //-------------------------------------------------------------------------
  
  struct ImGui_ImplVulkanH_Frame;
  struct ImGui_ImplVulkanH_Window;
  
  // Helpers
  IMGUI_IMPL_API void                 ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wnd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
  IMGUI_IMPL_API void                 ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wnd, const VkAllocationCallbacks* allocator);
  IMGUI_IMPL_API VkSurfaceFormatKHR   ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkFormat* request_formats, int request_formats_count, VkColorSpaceKHR request_color_space);
  IMGUI_IMPL_API VkPresentModeKHR     ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkPresentModeKHR* request_modes, int request_modes_count);
  IMGUI_IMPL_API int                  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
  
  // Helper structure to hold the data needed by one rendering frame
  // (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
  // [Please zero-clear before use!]
  struct ImGui_ImplVulkanH_Frame
  {
      VkCommandPool       CommandPool;
      VkCommandBuffer     CommandBuffer;
      VkFence             Fence;
      VkImage             Backbuffer;
      VkImageView         BackbufferView;
      VkFramebuffer       Framebuffer;
  };
  
  struct ImGui_ImplVulkanH_FrameSemaphores
  {
      VkSemaphore         ImageAcquiredSemaphore;
      VkSemaphore         RenderCompleteSemaphore;
  };
  
  // Helper structure to hold the data needed by one rendering context into one OS window
  // (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
  struct ImGui_ImplVulkanH_Window
  {
      int                 Width;
      int                 Height;
      VkSwapchainKHR      Swapchain;
      VkSurfaceKHR        Surface;
      VkSurfaceFormatKHR  SurfaceFormat;
      VkPresentModeKHR    PresentMode;
      VkRenderPass        RenderPass;
      VkPipeline          Pipeline;               // The window pipeline may uses a different VkRenderPass than the one passed in ImGui_ImplVulkan_InitInfo
      bool                ClearEnable;
      VkClearValue        ClearValue;
      uint32_t            FrameIndex;             // Current frame being rendered to (0 <= FrameIndex < FrameInFlightCount)
      uint32_t            ImageCount;             // Number of simultaneous in-flight frames (returned by vkGetSwapchainImagesKHR, usually derived from min_image_count)
      uint32_t            SemaphoreIndex;         // Current set of swapchain wait semaphores we're using (needs to be distinct from per frame data)
      ImGui_ImplVulkanH_Frame*            Frames;
      ImGui_ImplVulkanH_FrameSemaphores*  FrameSemaphores;
  
      ImGui_ImplVulkanH_Window()
      {
          memset(this, 0, sizeof(*this));
          PresentMode = VK_PRESENT_MODE_MAX_ENUM_KHR;
          ClearEnable = true;
      }
  };
  