IMGUI_HAS_TEXTURES ImTextureID -> ImTextureUserID

README.md

@@ -92,10 +92,10 @@ Notes:
 * methods have the same parameter list and return values (where possible)
 * functions that belong to a struct have an extra first argument with a pointer to the struct.
 * where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
-
+* constructors return pointer to struct and has been named Struct_name_Struct_name
 # usage with backends
 
-* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan
+* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan, glfw and dx11
 * read [How can cimgui backends be used](https://github.com/cimgui/cimgui/issues/157)
 
 # example bindings based on cimgui

backend_test/example_glfw_dx11/CMakeLists.txt

@@ -102,7 +102,6 @@ target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
 
 
 # using library
-include_directories(../../generator/output/)
 add_executable(${PROJECT_NAME} main.c)
 target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_DX11 -DCIMGUI_USE_GLFW)
 target_link_libraries(${PROJECT_NAME} d3d11 d3dcompiler.lib cimgui)

backend_test/example_glfw_opengl3/CMakeLists.txt

@@ -106,7 +106,6 @@ target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
 
 
 # using library
-include_directories(../../generator/output/)
 add_executable(${PROJECT_NAME} main.c)
 target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_GLFW)
 target_link_libraries(${PROJECT_NAME} cimgui)

backend_test/example_sdl_opengl3/CMakeLists.txt

@@ -22,8 +22,6 @@ else()
 endif()
 
 include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
 include_directories(../../)
 set(IMGUI_SOURCES 
@@ -38,11 +36,7 @@ ${TABLES_SOURCE}
 set(IMGUI_SOURCES_sdl)
 set(IMGUI_LIBRARIES )
 
-if (WIN32)
+
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
 
 add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
 
@@ -66,47 +60,46 @@ else(WIN32)#Unix
 endif(WIN32)
 
 
-#sdl2
 list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
+include(FetchContent)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+Set(FETCHCONTENT_QUIET FALSE)
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
 
-if(SDL2_FOUND)
+FetchContent_Declare(
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+        SDL2
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+        GIT_TAG release-2.30.12
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+        #GIT_SHALLOW TRUE
-		include_directories(${SDL2_INCLUDE_DIRS})
+        GIT_PROGRESS TRUE
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+)
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+#FetchContent_MakeAvailable(SDL2)
-	else()#use new one SDL2 config
+FetchContent_GetProperties(SDL2)
-		include_directories(${SDL_INCLUDE})
+if (NOT sdl2_POPULATED)
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+	set(FETCHCONTENT_QUIET NO)
-		set(SDL_MAIN SDL2::SDL2main)
+    FetchContent_Populate(SDL2)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
 endif()
-else(SDL2_FOUND)
+include_directories(${SDL2_SOURCE_DIR}/include})
-	if(DEFINED SDL_PATH)
+
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
+#if dynamic SDL2 then install
-	else(DEFINED SDL_PATH)
+install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
+					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
-	endif(DEFINED SDL_PATH)
+)
-endif(SDL2_FOUND)
 
 add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL2)
 
 #using library
-include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
 target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL2)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+target_link_libraries(test_sdl SDL2 cimgui_sdl)
-

backend_test/example_sdl_opengl3/README.md

@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl_opengl3` and then `make install`

backend_test/example_sdl_vulkan/CMakeLists.txt

@@ -18,12 +18,12 @@ else()
 	set(TABLES_SOURCE "")
 endif()
 
-include_directories(../../imgui)
+include_directories(../../imgui ../../imgui/backends)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
 include_directories(../../)
 set(IMGUI_SOURCES ../../cimgui.cpp
+../../cimgui_impl.cpp
 ../../imgui/imgui.cpp
 ../../imgui/imgui_draw.cpp
 ../../imgui/imgui_demo.cpp
@@ -34,11 +34,6 @@ ${TABLES_SOURCE}
 set(IMGUI_SOURCES_sdl)
 set(IMGUI_LIBRARIES )
 
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
 
 #optional adding freetype
 option(IMGUI_FREETYPE "add Freetype2" OFF)
@@ -54,48 +49,52 @@ endif(IMGUI_FREETYPE)
 find_package(Vulkan REQUIRED FATAL_ERROR)
 list(APPEND IMGUI_LIBRARIES Vulkan::Vulkan)
 list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_vulkan.cpp)
+include_directories(${Vulkan_INCLUDE_DIRS})
 
 #sdl2
 list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
+include(FetchContent)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+Set(FETCHCONTENT_QUIET FALSE)
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
 
-if(SDL2_FOUND)
+FetchContent_Declare(
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+        SDL2
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+        GIT_TAG release-2.30.12
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+        #GIT_SHALLOW TRUE
-		include_directories(${SDL2_INCLUDE_DIRS})
+        GIT_PROGRESS TRUE
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+)
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+FetchContent_GetProperties(SDL2)
-	else()#use new one SDL2 config
+if (NOT sdl2_POPULATED)
-		include_directories(${SDL_INCLUDE})
+	set(FETCHCONTENT_QUIET NO)
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+    FetchContent_Populate(SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
 endif()
-else(SDL2_FOUND)
+include_directories(${SDL2_SOURCE_DIR}/include)
-	if(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
-	else(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
-	endif(DEFINED SDL_PATH)
-endif(SDL2_FOUND)
 
-add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
+
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+#if dynamic SDL2 then install
+# install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					# LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+# )
+
+add_library(cimgui_sdl STATIC ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+target_compile_definitions(cimgui_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2)
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+#target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL2-static)
 
 #using library
-include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
 target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+target_link_libraries(test_sdl SDL2-static cimgui_sdl ${IMGUI_LIBRARIES})
 

backend_test/example_sdl_vulkan/README.md

@@ -0,0 +1,3 @@
+This example needs vulkan generation before compilation: Vulkan SDK should be installed and then add "vulkan" to generator.bat and generate.
+
+To build use `cmake path_to_example_sdl_vulkan` and then `make install`

backend_test/example_sdl_vulkan/main.c

@@ -1,13 +1,19 @@
-#include <stdio.h>
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
 #include <assert.h>
 #define SDL_MAIN_HANDLED
 #include <SDL.h>
 #include <SDL_vulkan.h>
 #include <vulkan/vulkan.h>
-#ifdef _MSC_VER
+// Volk headers
-#include <windows.h>
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+#define VOLK_IMPLEMENTATION
+#include <volk.h>
 #endif
 
+//this must be equal to that in imgui_impl_vulkan.h
+#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
+
 #define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "cimgui.h"
 #include "cimgui_impl.h"
@@ -24,6 +30,12 @@
 #define IM_ASSERT(_EXPR) assert(_EXPR)
 #define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
 
+//#define APP_USE_UNLIMITED_FRAME_RATE
+#ifdef _DEBUG
+#define APP_USE_VULKAN_DEBUG_REPORT
+#endif
+#define APP_USE_VULKAN_DEBUG_REPORT
+// Data
 static VkAllocationCallbacks*   g_Allocator = NULL;
 static VkInstance               g_Instance = VK_NULL_HANDLE;
 static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
@@ -40,172 +52,188 @@ static bool                     g_SwapChainRebuild = false;
 
 static void check_vk_result(VkResult err)
 {
-    if (err == 0)
+    if (err == VK_SUCCESS)
         return;
     fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
     if (err < 0)
         abort();
 }
 
-#ifdef IMGUI_VULKAN_DEBUG_REPORT
+static void check_vk_result_line(VkResult err,int line)
-static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags,
-  VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
-  int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
 {
-    (void)flags; (void)object; (void)location; (void)messageCode;
+    if (err == VK_SUCCESS)
-    (void)pUserData; (void)pLayerPrefix; // Unused arguments
+        return;
-    fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n",
+    fprintf(stderr, "[vulkan] Error: VkResult = %d in line: (%d)\n", err, line);
-      objectType, pMessage);
+    if (err < 0)
+        abort();
+}
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
+{
+    (void)flags; (void)object; (void)location; (void)messageCode; (void)pUserData; (void)pLayerPrefix; // Unused arguments
+    fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n", objectType, pMessage);
     return VK_FALSE;
 }
-#endif // IMGUI_VULKAN_DEBUG_REPORT
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+//*
+static bool IsExtensionAvailable(VkExtensionProperties* properties, uint32_t properties_count, const char* extension)
+{
+    for(uint32_t i = 0 ; i < properties_count; i++){
+        if (strcmp(properties[i].extensionName, extension) == 0)
+            return true;
+    }
+    return false;
+}
 
 static void SetupVulkan(const char** extensions, uint32_t extensions_count)
 {
     VkResult err;
-
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
-  // Create Vulkan Instance
+    volkInitialize();
-  VkInstanceCreateInfo inst_create_info = {
-    .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-    .enabledExtensionCount = extensions_count,
-    .ppEnabledExtensionNames = extensions,
-  };
-#ifdef IMGUI_VULKAN_DEBUG_REPORT
-  // Enabling validation layers
-  const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
-  inst_create_info.enabledLayerCount = 1;
-  inst_create_info.ppEnabledLayerNames = layers;
-
-  // Enable debug report extension (we need additional storage, so we duplicate the user array to add our new extension to it)
-  const char** extensions_ext = (const char**)malloc(
-      sizeof(const char*) * (extensions_count + 1));
-  memcpy(extensions_ext, extensions, extensions_count * sizeof(const char*));
-  extensions_ext[extensions_count] = "VK_EXT_debug_report";
-  inst_create_info.enabledExtensionCount = extensions_count + 1;
-  inst_create_info.ppEnabledExtensionNames = extensions_ext;
-
-  // Create Vulkan Instance
-  err = vkCreateInstance(&inst_create_info, g_Allocator, &g_Instance);
-  check_vk_result(err);
-  free(extensions_ext);
-
-  // Get the function pointer (required for any extensions)
-  PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT =
-    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance,
-      "vkCreateDebugReportCallbackEXT");
-  IM_ASSERT(vkCreateDebugReportCallbackEXT != NULL);
-
-  // Setup the debug report callback
-  VkDebugReportCallbackCreateInfoEXT debug_report_ci = {
-    .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-    .flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
-             VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
-    .pfnCallback = debug_report,
-    .pUserData = NULL,
-  };
-  err = vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator,
-    &g_DebugReport);
-  check_vk_result(err);
-#else
-  // Create Vulkan Instance without any debug feature
-  err = vkCreateInstance(&inst_create_info, g_Allocator, &g_Instance);
-  check_vk_result(err);
-  IM_UNUSED(g_DebugReport);
 #endif
 
-  // Select GPU
+    // Create Vulkan Instance
-  uint32_t gpu_count;
-  err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, NULL);
-  check_vk_result(err);
-  IM_ASSERT(gpu_count > 0);
-
-  VkPhysicalDevice* gpus = (VkPhysicalDevice*)malloc(sizeof(VkPhysicalDevice) * gpu_count);
-  err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, gpus);
-  check_vk_result(err);
-
-  // If a number >1 of GPUs got reported, find discrete GPU if present, or use first one available. This covers
-  // most common cases (multi-gpu/integrated+dedicated graphics). Handling more complicated setups (multiple
-  // dedicated GPUs) is out of scope of this sample.
-  int use_gpu = 0;
-  for (int i = 0; i < (int)gpu_count; i++)
     {
-    VkPhysicalDeviceProperties properties;
+        VkInstanceCreateInfo create_info = {};
-    vkGetPhysicalDeviceProperties(gpus[i], &properties);
+        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-    if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+
+        // Enumerate available extensions
+        uint32_t properties_count;
+        vkEnumerateInstanceExtensionProperties(NULL, &properties_count, NULL);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        err = vkEnumerateInstanceExtensionProperties(NULL, &properties_count, properties);
+        check_vk_result_line(err, __LINE__);
+
+        // Enable required extensions
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)){
+            //instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+        }
+#ifdef VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME))
         {
-        use_gpu = i;
+            //instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
-        break;
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
+            create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
         }
+#endif
+        free(properties);
+        // Enabling validation layers
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
+        create_info.enabledLayerCount = 1;
+        create_info.ppEnabledLayerNames = layers;
+        //instance_extensions.push_back("VK_EXT_debug_report");
+        extensions_count++;
+        extensions = realloc(extensions, extensions_count * sizeof(char*));
+        assert(extensions);
+        extensions[extensions_count-1] = "VK_EXT_debug_report";
+#endif
+
+        // Create Vulkan Instance
+        create_info.enabledExtensionCount = extensions_count;//(uint32_t)instance_extensions.Size;
+        create_info.ppEnabledExtensionNames = extensions;//instance_extensions.Data;
+        err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
+        check_vk_result_line(err, __LINE__);
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+        volkLoadInstance(g_Instance);
+#endif
+
+        // Setup the debug report callback
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        PFN_vkCreateDebugReportCallbackEXT f_vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkCreateDebugReportCallbackEXT");
+        IM_ASSERT(f_vkCreateDebugReportCallbackEXT != NULL);
+        VkDebugReportCallbackCreateInfoEXT debug_report_ci = {};
+        debug_report_ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+        debug_report_ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+        debug_report_ci.pfnCallback = debug_report;
+        debug_report_ci.pUserData = NULL;
+        err = f_vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator, &g_DebugReport);
+        check_vk_result_line(err, __LINE__);
+#endif
     }
-
+    // Select Physical Device (GPU)
-  g_PhysicalDevice = gpus[use_gpu];
+    g_PhysicalDevice = ImGui_ImplVulkanH_SelectPhysicalDevice(g_Instance);
-  free(gpus);
+    IM_ASSERT(g_PhysicalDevice != VK_NULL_HANDLE);
-
     // Select graphics queue family
-  uint32_t count;
+    g_QueueFamily = ImGui_ImplVulkanH_SelectQueueFamilyIndex(g_PhysicalDevice);
-  vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, NULL);
-  VkQueueFamilyProperties* queues = (VkQueueFamilyProperties*)malloc(
-      sizeof(VkQueueFamilyProperties) * count);
-  vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, queues);
-  for (uint32_t i = 0; i < count; i++)
-    if (queues[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
-    {
-      g_QueueFamily = i;
-      break;
-    }
-  free(queues);
     IM_ASSERT(g_QueueFamily != (uint32_t)-1);
 
     // Create Logical Device (with 1 queue)
-  int device_extension_count = 1;
+    {
-  const char* device_extensions[] = { "VK_KHR_swapchain" };
+        //ImVector<const char*> device_extensions;
-  const float queue_priority[] = { 1.0f };
+        //device_extensions.push_back("VK_KHR_swapchain");
-  VkDeviceQueueCreateInfo queue_info[1] = {
+        uint32_t device_extensions_count = 1;
-    [0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+        const char** device_extensions = (const char**)malloc(device_extensions_count * sizeof(char*));
-    [0].queueFamilyIndex = g_QueueFamily,
+        device_extensions[0] = "VK_KHR_swapchain";
-    [0].queueCount = 1,
-    [0].pQueuePriorities = queue_priority,
-  };
-  VkDeviceCreateInfo create_info = {
-    .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-    .queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]),
-    .pQueueCreateInfos = queue_info,
-    .enabledExtensionCount = device_extension_count,
-    .ppEnabledExtensionNames = device_extensions,
-  };
-  err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
-  check_vk_result(err);
-  vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
 
-  // Create Descriptor Pool
+        // Enumerate physical device extension
-  VkDescriptorPoolSize pool_sizes[] = {
+        uint32_t properties_count;
-      { VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
+        //ImVector<VkExtensionProperties> properties;
-      { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, NULL);
-      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
+        //properties.resize(properties_count);
-      { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
-      { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, properties);
-      { VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
+#ifdef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
-      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)){
-      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
+            //device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
-      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
+            device_extensions_count++;
-      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
+            device_extensions = realloc(device_extensions, device_extensions_count * sizeof(const char*)); 
-      { VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
+            assert(device_extensions);
-  };
+            device_extensions[device_extensions_count-1] = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
-  VkDescriptorPoolCreateInfo pool_info = {
-    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-    .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-    .maxSets = 1000 * IM_ARRAYSIZE(pool_sizes),
-    .poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes),
-    .pPoolSizes = pool_sizes,
-  };
-  err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
-  check_vk_result(err);
         }
+#endif
 
+        const float queue_priority[] = { 1.0f };
+        VkDeviceQueueCreateInfo queue_info[1] = {};
+        queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queue_info[0].queueFamilyIndex = g_QueueFamily;
+        queue_info[0].queueCount = 1;
+        queue_info[0].pQueuePriorities = queue_priority;
+        VkDeviceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        create_info.queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]);
+        create_info.pQueueCreateInfos = queue_info;
+        create_info.enabledExtensionCount = device_extensions_count; //(uint32_t)device_extensions.Size;
+        create_info.ppEnabledExtensionNames = device_extensions;//device_extensions.Data;
+        err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
+        check_vk_result_line(err, __LINE__);
+        vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+    }
+    // Create Descriptor Pool
+    // If you wish to load e.g. additional textures you may need to alter pools sizes and maxSets.
+    {
+        VkDescriptorPoolSize pool_sizes[] =
+        {
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+        };
+        VkDescriptorPoolCreateInfo pool_info = {};
+        pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+        pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+        pool_info.maxSets = 0;
+        //for (VkDescriptorPoolSize& pool_size : pool_sizes)
+        //    pool_info.maxSets += pool_size.descriptorCount;
+        for(int i = 0; i < IM_ARRAYSIZE(pool_sizes); i++){
+            VkDescriptorPoolSize pool_size = pool_sizes[i];
+            pool_info.maxSets += pool_size.descriptorCount;
+        }
+        pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
+        pool_info.pPoolSizes = pool_sizes;
+        err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+//*/
 // All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
 // Your real engine/app may not use them.
-static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface,
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
-                              int width, int height)
 {
     wd->Surface = surface;
 
@@ -219,43 +247,33 @@ static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface
     }
 
     // Select Surface Format
-    const VkFormat requestSurfaceImageFormat[] = {
+    const VkFormat requestSurfaceImageFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
-        VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM,
-        VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM
-    };
     const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
-    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
-      g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat,
-      (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
 
     // Select Present Mode
-#ifdef IMGUI_UNLIMITED_FRAME_RATE
+#ifdef APP_USE_UNLIMITED_FRAME_RATE
-    VkPresentModeKHR present_modes[] = {
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
-      VK_PRESENT_MODE_MAILBOX_KHR,VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR
-    };
 #else
     VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
 #endif
-    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
-      g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+    //printf("[vulkan] Selected PresentMode = %d\n", wd->PresentMode);
 
     // Create SwapChain, RenderPass, Framebuffer, etc.
     IM_ASSERT(g_MinImageCount >= 2);
-    ImGui_ImplVulkanH_CreateOrResizeWindow(
+    ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
-      g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator,
-      width, height, g_MinImageCount);
 }
 
 static void CleanupVulkan()
 {
     vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
 
-#ifdef IMGUI_VULKAN_DEBUG_REPORT
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
     // Remove the debug report callback
-  PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT =
+    PFN_vkDestroyDebugReportCallbackEXT f_vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
-    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
+    f_vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
-  vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
+#endif // APP_USE_VULKAN_DEBUG_REPORT
-#endif // IMGUI_VULKAN_DEBUG_REPORT
 
     vkDestroyDevice(g_Device, g_Allocator);
     vkDestroyInstance(g_Instance, g_Allocator);
@@ -268,115 +286,125 @@ static void CleanupVulkanWindow()
 
 static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
 {
-  VkResult err;
+    VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores.Data[wd->SemaphoreIndex].ImageAcquiredSemaphore;
-
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
-  VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+    VkResult err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
-  VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
-  err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
     if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
-  {
         g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
         return;
-  }
+    if (err != VK_SUBOPTIMAL_KHR)
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
 
-  ImGui_ImplVulkanH_Frame* fd = &wd->Frames[wd->FrameIndex];
+    ImGui_ImplVulkanH_Frame* fd = &wd->Frames.Data[wd->FrameIndex];
+    {
         err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);    // wait indefinitely instead of periodically checking
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
 
         err = vkResetFences(g_Device, 1, &fd->Fence);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
-
+    }
+    {
         err = vkResetCommandPool(g_Device, fd->CommandPool, 0);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
-  VkCommandBufferBeginInfo info = {
+        VkCommandBufferBeginInfo info = {};
-    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-  };
         err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
-  VkRenderPassBeginInfo rp_info = {
+    }
-    .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+    {
-    .renderPass = wd->RenderPass,
+        VkRenderPassBeginInfo info = {};
-    .framebuffer = fd->Framebuffer,
+        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-    .renderArea.extent.width = wd->Width,
+        info.renderPass = wd->RenderPass;
-    .renderArea.extent.height = wd->Height,
+        info.framebuffer = fd->Framebuffer;
-    .clearValueCount = 1,
+        info.renderArea.extent.width = wd->Width;
-    .pClearValues = &wd->ClearValue,
+        info.renderArea.extent.height = wd->Height;
-  };
+        info.clearValueCount = 1;
-  vkCmdBeginRenderPass(fd->CommandBuffer, &rp_info, VK_SUBPASS_CONTENTS_INLINE);
+        info.pClearValues = &wd->ClearValue;
+        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
+    }
 
     // Record dear imgui primitives into command buffer
     ImGui_ImplVulkan_RenderDrawData(draw_data, fd->CommandBuffer, VK_NULL_HANDLE);
 
     // Submit command buffer
     vkCmdEndRenderPass(fd->CommandBuffer);
+    {
         VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-  VkSubmitInfo sub_info = {
+        VkSubmitInfo info = {};
-    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-    .waitSemaphoreCount = 1,
+        info.waitSemaphoreCount = 1;
-    .pWaitSemaphores = &image_acquired_semaphore,
+        info.pWaitSemaphores = &image_acquired_semaphore;
-    .pWaitDstStageMask = &wait_stage,
+        info.pWaitDstStageMask = &wait_stage;
-    .commandBufferCount = 1,
+        info.commandBufferCount = 1;
-    .pCommandBuffers = &fd->CommandBuffer,
+        info.pCommandBuffers = &fd->CommandBuffer;
-    .signalSemaphoreCount = 1,
+        info.signalSemaphoreCount = 1;
-    .pSignalSemaphores = &render_complete_semaphore,
+        info.pSignalSemaphores = &render_complete_semaphore;
-  };
 
         err = vkEndCommandBuffer(fd->CommandBuffer);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
-  err = vkQueueSubmit(g_Queue, 1, &sub_info, fd->Fence);
+        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
+    }
 }
 
 static void FramePresent(ImGui_ImplVulkanH_Window* wd)
 {
-  if (g_SwapChainRebuild) return;
+    if (g_SwapChainRebuild)
-  VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
+        return;
-  VkPresentInfoKHR info = {
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
-    .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    VkPresentInfoKHR info = {};
-    .waitSemaphoreCount = 1,
+    info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
-    .pWaitSemaphores = &render_complete_semaphore,
+    info.waitSemaphoreCount = 1;
-    .swapchainCount = 1,
+    info.pWaitSemaphores = &render_complete_semaphore;
-    .pSwapchains = &wd->Swapchain,
+    info.swapchainCount = 1;
-    .pImageIndices = &wd->FrameIndex,
+    info.pSwapchains = &wd->Swapchain;
-  };
+    info.pImageIndices = &wd->FrameIndex;
     VkResult err = vkQueuePresentKHR(g_Queue, &info);
     if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
-  {
         g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
         return;
-  }
+    if (err != VK_SUBOPTIMAL_KHR)
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
-  wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->ImageCount; // Now we can use the next set of semaphores
+    wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->SemaphoreCount; // Now we can use the next set of semaphores
 }
 
+// Main code
 int main(int argc, char* argv[])
 {
-
+    //g_MainWindowData.ClearEnable = true;
-  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
-    SDL_Log("failed to init: %s", SDL_GetError());
+	g_MainWindowData = *ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
+    // Setup SDL
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
+    {
+        printf("Error: %s\n", SDL_GetError());
         return -1;
     }
 
-  /// Setup window
+    // From 2.0.18: Enable native IME.
-  SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN |
+#ifdef SDL_HINT_IME_SHOW_UI
-    SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
-  SDL_Window* window = SDL_CreateWindow("cImGui SDL2+Vulkan example",
+#endif
-    SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+
-  if (window == NULL) {
+    // Create window with Vulkan graphics context
-    SDL_Log("Failed to create window: %s", SDL_GetError());
+    SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Vulkan example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
         return -1;
     }
-
   // Setup Vulkan
   uint32_t extensions_count = 0;
   SDL_Vulkan_GetInstanceExtensions(window, &extensions_count, NULL);
-  const char** extensions = malloc(extensions_count * sizeof(const char*));
+  const char** extensions = (const char**)malloc(extensions_count * sizeof(const char*));
   SDL_Vulkan_GetInstanceExtensions(window, &extensions_count, extensions);
   SetupVulkan(extensions, extensions_count);
-  free(extensions);
+  //leak?? but free crashes
-
+  // free(extensions);
     // Create Window Surface
     VkSurfaceKHR surface;
     VkResult err;
@@ -392,126 +420,129 @@ int main(int argc, char* argv[])
     ImGui_ImplVulkanH_Window* wd = &g_MainWindowData;
     SetupVulkanWindow(wd, surface, w, h);
 
-  // setup imgui
+    // Setup Dear ImGui context
+    //IMGUI_CHECKVERSION();
     igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+    io->ConfigFlags |= ImGuiConfigFlags_DockingEnable;         // Enable Docking
+    io->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;       // Enable Multi-Viewport / Platform Windows
+    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoTaskBarIcons;
+    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoMerge;
 
-  //set docking
+    // Setup Dear ImGui style
-  ImGuiIO* ioptr = igGetIO();
+    igStyleColorsDark(NULL);
-  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;       // Enable Keyboard Controls
+    //ImGui::StyleColorsLight();
-  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+    // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+    ImGuiStyle* style = igGetStyle();
+    if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+    {
+        style->WindowRounding = 0.0f;
+        style->Colors[ImGuiCol_WindowBg].w = 1.0f;
+    }
 
     // Setup Platform/Renderer backends
     ImGui_ImplSDL2_InitForVulkan(window);
-  ImGui_ImplVulkan_InitInfo init_info = {
+    ImGui_ImplVulkan_InitInfo init_info = {};
-    .Instance = g_Instance,
+    init_info.Instance = g_Instance;
-    .PhysicalDevice = g_PhysicalDevice,
+    init_info.PhysicalDevice = g_PhysicalDevice;
-    .Device = g_Device,
+    init_info.Device = g_Device;
-    .QueueFamily = g_QueueFamily,
+    init_info.QueueFamily = g_QueueFamily;
-    .Queue = g_Queue,
+    init_info.Queue = g_Queue;
-    .PipelineCache = g_PipelineCache,
+    init_info.PipelineCache = g_PipelineCache;
-    .DescriptorPool = g_DescriptorPool,
+    init_info.DescriptorPool = g_DescriptorPool;
-    .Subpass = 0,
+    init_info.RenderPass = wd->RenderPass;
-    .MinImageCount = g_MinImageCount,
+    init_info.Subpass = 0;
-    .ImageCount = wd->ImageCount,
+    init_info.MinImageCount = g_MinImageCount;
-    .MSAASamples = VK_SAMPLE_COUNT_1_BIT,
+    init_info.ImageCount = wd->ImageCount;
-    .Allocator = g_Allocator,
+    init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
-    .CheckVkResultFn = check_vk_result
+    init_info.Allocator = g_Allocator;
-  };
+    init_info.CheckVkResultFn = check_vk_result;
-  ImGui_ImplVulkan_Init(&init_info, wd->RenderPass);
+    ImGui_ImplVulkan_Init(&init_info);
 
-  igStyleColorsDark(NULL);
+    // Load Fonts
+    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
+    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
+    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
+    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
+    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
+    // - Read 'docs/FONTS.md' for more instructions and details.
+    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr, io.Fonts->GetGlyphRangesJapanese());
+    //IM_ASSERT(font != nullptr);
 
-  // Upload Fonts
+    // Our state
-  // Use any command queue
+    bool show_demo_window = true;
-  VkCommandPool command_pool = wd->Frames[wd->FrameIndex].CommandPool;
+    bool show_another_window = false;
-  VkCommandBuffer command_buffer = wd->Frames[wd->FrameIndex].CommandBuffer;
+    ImVec4 clear_color;
+    clear_color.x = 0.45f;
+    clear_color.y = 0.55f;
+    clear_color.z = 0.60f;
+    clear_color.w = 1.00f;
 
-  err = vkResetCommandPool(g_Device, command_pool, 0);
+    // Main loop
-  check_vk_result(err);
+    bool done = false;
-  VkCommandBufferBeginInfo begin_info = {
+    while (!done)
-    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-  };
-  err = vkBeginCommandBuffer(command_buffer, &begin_info);
-  check_vk_result(err);
-
-  ImGui_ImplVulkan_CreateFontsTexture(command_buffer);
-
-  VkSubmitInfo end_info = {
-    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-    .commandBufferCount = 1,
-    .pCommandBuffers = &command_buffer,
-  };
-  err = vkEndCommandBuffer(command_buffer);
-  check_vk_result(err);
-  err = vkQueueSubmit(g_Queue, 1, &end_info, VK_NULL_HANDLE);
-  check_vk_result(err);
-
-  err = vkDeviceWaitIdle(g_Device);
-  check_vk_result(err);
-  ImGui_ImplVulkan_DestroyFontUploadObjects();
-
-  bool showDemoWindow = true;
-  bool showAnotherWindow = false;
-  ImVec4 clearColor;
-  clearColor.x = 0.45f;
-  clearColor.y = 0.55f;
-  clearColor.z = 0.60f;
-  clearColor.w = 1.00f;
-
-  bool quit = false;
-  while (!quit)
     {
-    SDL_Event e;
+        // Poll and handle events (inputs, window resize, etc.)
-
+        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
-    // we need to call SDL_PollEvent to let window rendered, otherwise
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
-    // no window will be shown
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
-    while (SDL_PollEvent(&e) != 0)
+        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
         {
-      ImGui_ImplSDL2_ProcessEvent(&e);
+            ImGui_ImplSDL2_ProcessEvent(&event);
-      if (e.type == SDL_QUIT)
+            if (event.type == SDL_QUIT)
-        quit = true;
+                done = true;
-      if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_CLOSE &&
+            if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
-          e.window.windowID == SDL_GetWindowID(window))
+                done = true;
-        quit = true;
+        }
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
         }
 
-    // Resize swap chain
+        // Resize swap chain?
-    if (g_SwapChainRebuild)
+        int fb_width, fb_height;
-    {
+        SDL_GetWindowSize(window, &fb_width, &fb_height);
-        int width, height;
+        if (fb_width > 0 && fb_height > 0 && (g_SwapChainRebuild || g_MainWindowData.Width != fb_width || g_MainWindowData.Height != fb_height))
-        SDL_GetWindowSize(window, &width, &height);
-        if (width > 0 && height > 0)
         {
             ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
-            ImGui_ImplVulkanH_CreateOrResizeWindow(
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, fb_width, fb_height, g_MinImageCount);
-              g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData,
-              g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
             g_MainWindowData.FrameIndex = 0;
             g_SwapChainRebuild = false;
         }
-    }
 
-    // start imgui frame
+        // Start the Dear ImGui frame
         ImGui_ImplVulkan_NewFrame();
         ImGui_ImplSDL2_NewFrame();
         igNewFrame();
 
-    if (showDemoWindow)
+        // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
-      igShowDemoWindow(&showDemoWindow);
+        if (show_demo_window)
+            igShowDemoWindow(&show_demo_window);
 
-    // show a simple window that we created ourselves.
+        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
         {
             static float f = 0.0f;
             static int counter = 0;
 
             igBegin("Hello, world!", NULL, 0);
             igText("This is some useful text");
-      igCheckbox("Demo window", &showDemoWindow);
+            igCheckbox("Demo window", &show_demo_window);
-      igCheckbox("Another window", &showAnotherWindow);
+            igCheckbox("Another window", &show_another_window);
         
             igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
-      igColorEdit3("clear color", (float*)&clearColor, 0);
+            igColorEdit3("clear color", (float*)&clear_color, 0);
         
             ImVec2 buttonSize;
             buttonSize.x = 0;
@@ -526,37 +557,46 @@ int main(int argc, char* argv[])
             igEnd();
         }
 
-    if (showAnotherWindow)
+        // 3. Show another simple window.
+        if (show_another_window)
         {
-      igBegin("imgui Another Window", &showAnotherWindow, 0);
+           igBegin("imgui Another Window", &show_another_window, 0);
            igText("Hello from imgui");
            ImVec2 buttonSize;
            buttonSize.x = 0; buttonSize.y = 0;
            if (igButton("Close me", buttonSize))
            {
-        showAnotherWindow = false;
+               show_another_window = false;
            }
            igEnd();
         }
 
-    // render
+        // Rendering
         igRender();
-    ImDrawData* draw_data = igGetDrawData();
+        ImDrawData* main_draw_data = igGetDrawData();
-    const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+        const bool main_is_minimized = (main_draw_data->DisplaySize.x <= 0.0f || main_draw_data->DisplaySize.y <= 0.0f);
-    if (!is_minimized)
+        wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
+        wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
+        wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
+        wd->ClearValue.color.float32[3] = clear_color.w;
+        if (!main_is_minimized)
+            FrameRender(wd, main_draw_data);
+
+        // Update and Render additional Platform Windows
+        if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
         {
-        wd->ClearValue.color.float32[0] = clearColor.x * clearColor.w;
+            igUpdatePlatformWindows();
-        wd->ClearValue.color.float32[1] = clearColor.y * clearColor.w;
+            igRenderPlatformWindowsDefault(NULL, NULL);
-        wd->ClearValue.color.float32[2] = clearColor.z * clearColor.w;
-        wd->ClearValue.color.float32[3] = clearColor.w;
-        FrameRender(wd, draw_data);
-        FramePresent(wd);
         }
+
+        // Present Main Platform Window
+        if (!main_is_minimized)
+            FramePresent(wd);
     }
 
     // Cleanup
     err = vkDeviceWaitIdle(g_Device);
-  check_vk_result(err);
+    check_vk_result_line(err, __LINE__);
     ImGui_ImplVulkan_Shutdown();
     ImGui_ImplSDL2_Shutdown();
     igDestroyContext(NULL);

cimgui_impl.cpp

@@ -0,0 +1,65 @@
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+#ifdef CIMGUI_USE_DX9
+#include "imgui_impl_dx9.h"
+#endif
+
+#ifdef CIMGUI_USE_DX10
+#include "imgui_impl_dx10.h"
+#endif
+
+#ifdef CIMGUI_USE_DX11
+#include "imgui_impl_dx11.h"
+#endif
+
+#ifdef CIMGUI_USE_DX12
+#include "imgui_impl_dx12.h"
+#endif
+
+#ifdef CIMGUI_USE_GLFW
+#include "imgui_impl_glfw.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL2
+#include "imgui_impl_opengl2.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL3
+#include "imgui_impl_opengl3.h"
+#endif
+
+#ifdef CIMGUI_USE_SDL2
+#include "imgui_impl_sdl2.h"
+#endif
+
+#ifdef CIMGUI_USE_SDL3
+#include "imgui_impl_sdl3.h"
+#endif
+
+#ifdef CIMGUI_USE_VULKAN
+#include "imgui_impl_vulkan.h"
+#endif
+
+#ifdef CIMGUI_USE_WIN32
+#include "imgui_impl_win32.h"
+#endif
+
+#include "cimgui_impl.h"
+
+#ifdef CIMGUI_USE_VULKAN
+
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window()
+{
+	return IM_NEW(ImGui_ImplVulkanH_Window)();
+}
+CIMGUI_API void ImGui_ImplVulkanH_Window_Construct(ImGui_ImplVulkanH_Window* self)
+{
+	IM_PLACEMENT_NEW(self) ImGui_ImplVulkanH_Window();
+}
+
+#endif

cimgui_impl.h

@@ -0,0 +1,197 @@
+#ifdef CIMGUI_USE_GLFW
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct GLFWwindow GLFWwindow;
+typedef struct GLFWmonitor GLFWmonitor;
+struct GLFWwindow;
+struct GLFWmonitor;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
+CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
+CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
+CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL3
+CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
+CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL2
+CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+
+#endif
+#ifdef CIMGUI_USE_SDL2
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct _SDL_GameController _SDL_GameController;
+struct SDL_Window;
+struct SDL_Renderer;
+struct _SDL_GameController;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
+CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
+#ifdef CIMGUI_USE_SDL3
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct SDL_Gamepad SDL_Gamepad;
+struct SDL_Window;
+struct SDL_Renderer;
+struct SDL_Gamepad;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
+CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
+CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
+#ifdef CIMGUI_USE_VULKAN
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct ImGui_ImplVulkanH_Frame ImGui_ImplVulkanH_Frame;
+typedef struct ImGui_ImplVulkanH_Window ImGui_ImplVulkanH_Window;
+typedef struct ImGui_ImplVulkan_InitInfo ImGui_ImplVulkan_InitInfo;
+struct ImGui_ImplVulkan_InitInfo
+{
+    VkInstance Instance;
+    VkPhysicalDevice PhysicalDevice;
+    VkDevice Device;
+    uint32_t QueueFamily;
+    VkQueue Queue;
+    VkDescriptorPool DescriptorPool;
+    VkRenderPass RenderPass;
+    uint32_t MinImageCount;
+    uint32_t ImageCount;
+    VkSampleCountFlagBits MSAASamples;
+    VkPipelineCache PipelineCache;
+    uint32_t Subpass;
+    uint32_t DescriptorPoolSize;
+    bool UseDynamicRendering;
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+    const VkAllocationCallbacks* Allocator;
+    void (*CheckVkResultFn)(VkResult err);
+    VkDeviceSize MinAllocationSize;
+};
+typedef struct ImGui_ImplVulkan_RenderState ImGui_ImplVulkan_RenderState;
+struct ImGui_ImplVulkan_RenderState
+{
+    VkCommandBuffer CommandBuffer;
+    VkPipeline Pipeline;
+    VkPipelineLayout PipelineLayout;
+};
+struct ImGui_ImplVulkanH_Frame;
+struct ImGui_ImplVulkanH_Window;
+struct ImGui_ImplVulkanH_Frame
+{
+    VkCommandPool CommandPool;
+    VkCommandBuffer CommandBuffer;
+    VkFence Fence;
+    VkImage Backbuffer;
+    VkImageView BackbufferView;
+    VkFramebuffer Framebuffer;
+};
+typedef struct ImGui_ImplVulkanH_FrameSemaphores ImGui_ImplVulkanH_FrameSemaphores;
+struct ImGui_ImplVulkanH_FrameSemaphores
+{
+    VkSemaphore ImageAcquiredSemaphore;
+    VkSemaphore RenderCompleteSemaphore;
+};
+typedef struct ImVector_ImGui_ImplVulkanH_Frame {int Size;int Capacity;ImGui_ImplVulkanH_Frame* Data;} ImVector_ImGui_ImplVulkanH_Frame;
+
+typedef struct ImVector_ImGui_ImplVulkanH_FrameSemaphores {int Size;int Capacity;ImGui_ImplVulkanH_FrameSemaphores* Data;} ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+
+struct ImGui_ImplVulkanH_Window
+{
+    int Width;
+    int Height;
+    VkSwapchainKHR Swapchain;
+    VkSurfaceKHR Surface;
+    VkSurfaceFormatKHR SurfaceFormat;
+    VkPresentModeKHR PresentMode;
+    VkRenderPass RenderPass;
+    bool UseDynamicRendering;
+    bool ClearEnable;
+    VkClearValue ClearValue;
+    uint32_t FrameIndex;
+    uint32_t ImageCount;
+    uint32_t SemaphoreCount;
+    uint32_t SemaphoreIndex;
+    ImVector_ImGui_ImplVulkanH_Frame Frames;
+    ImVector_ImGui_ImplVulkanH_FrameSemaphores FrameSemaphores;
+};
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
+typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
+CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
+CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
+CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
+CIMGUI_API bool ImGui_ImplVulkan_CreateFontsTexture(void);
+CIMGUI_API void ImGui_ImplVulkan_DestroyFontsTexture(void);
+CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
+CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
+CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
+CIMGUI_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator);
+CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
+CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
+CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
+CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
+CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
+
+#endif

generator/cpp2ffi.lua

@@ -949,6 +949,31 @@ local function AdjustArguments(FP)
         end
     end
 end
+local function REPLACE_TEXTUREID(FP)
+	local defsT = FP.defsT
+	for numcdef,t in ipairs(FP.funcdefs) do
+		assert(t.cimguiname)
+		local cimf = defsT[t.cimguiname]
+		local defT = cimf[t.signature]
+		local hasTextureID = false
+		for i,arg in ipairs(defT.argsT) do
+			if arg.type == "ImTextureID" then print(t.cimguiname,t.signature);hasTextureID = true; break end
+		end
+		if hasTextureID then
+			for i,v in ipairs(defT.argsT) do
+				v.type = (v.type == "ImTextureID") and "ImTextureUserID" or v.type
+            end
+			--defaults table
+			for k,v in pairs(defT.defaults) do
+				if v:match"ImTextureID" then
+					error"default ImTextureID not implemented"
+				end
+            end
+			defT.args = defT.args:gsub("ImTextureID","ImTextureUserID")
+			defT.signature = defT.signature:gsub("ImTextureID","ImTextureUserID")
+		end
+	end
+end
 local function ADDIMSTR_S(FP)
     local defsT = FP.defsT
     local newcdefs = {}
@@ -1575,8 +1600,8 @@ function M.Parser()
 					--local ttype,template = it.item:match("([^%s,%(%)]+)%s*<(.+)>")
 					local ttype,template,te,code2 =  check_template(it2)  --it.item:match"([^%s,%(%)]+)%s*<(.+)>"
 					if template then
-						--print("not doheader",ttype,template,te)
+						--print("not doheader",ttype,template,te, self.typenames[ttype])
-						if self.typenames[ttype] ~= template then --rule out T (template typename)
+						if self.typenames[ttype] ~= template and self.typenames[ttype].."*" ~= template then --rule out T (template typename)
 							self.templates[ttype] = self.templates[ttype] or {}
 							self.templates[ttype][template] = te
 							it2=code2
@@ -2115,6 +2140,11 @@ function M.Parser()
         for k,v in pairs(self.alltypes) do print(k, typetoStr(k) ) end
     end
     function par:compute_overloads()
+		if self.IMGUI_HAS_TEXTURES then
+			print"----------replacing ImTextureID with ImTextureUserID"
+			REPLACE_TEXTUREID(self)
+			print"----------end replacing ImTextureID with ImTextureUserID"
+		end
 		ADDIMSTR_S(self)
         local strt = {}
         local numoverloaded = 0

generator/generator.bat

@@ -20,7 +20,7 @@ set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\min
 :: examples: "" "internal" "internal comments"
 :: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG) 
 ::-DIMGUI_USE_WCHAR32 should not be used (is discarded)
-luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 -DIMGUI_USE_WCHAR32 %*
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 vulkan -DIMGUI_USE_WCHAR32 %*
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -91,6 +91,10 @@ local cimgui_skipped = {
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
+	igGetIO = {
+		["()"] = "igGetIO",
+		["(ImGuiContext*)"] = "igGetIOEx",
+	},
     --igPushID = {
         --["(const char*)"] =           "igPushIDStr",
         --["(const char*,const char*)"] = "igPushIDRange",
@@ -125,9 +129,11 @@ local function func_header_impl_generate(FP)
             local def = cimf[t.signature]
 			local addcoment = def.comment or ""
 			if def.constructor then
-				-- it happens with vulkan impl but constructor ImGui_ImplVulkanH_Window is not needed
+				-- only vulkan is manually created
-			    --assert(def.stname ~= "","constructor without struct")
+				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
-                --table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or --def.args)..";"..addcoment.."\n")
+				def.ov_cimguiname=="ImGui_ImplVulkanH_Window_Construct", "not cpp for "..def.ov_cimguiname)
+			    assert(def.stname ~= "","constructor without struct")
+                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
             elseif def.destructor then
                 --table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
 			else
@@ -314,8 +320,8 @@ end
 --------------------------------------------------------
 --get imgui.h version and IMGUI_HAS_DOCK--------------------------
 --defines for the cl compiler must be present in the print_defines.cpp file
-gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState"}
+gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState","IMGUI_HAS_TEXTURES"}
---cpp2ffi.prtable(gdefines)
+cpp2ffi.prtable(gdefines)
 if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
 if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end
 
@@ -335,6 +341,7 @@ if gdefines.IMGUI_HAS_DOCK then
 end
 assert(not NOCHAR or not NOIMSTRV,"nochar and noimstrv cant be set at the same time")
 print("IMGUI_HAS_IMSTR",gdefines.IMGUI_HAS_IMSTR)
+print("IMGUI_HAS_TEXTURES",gdefines.IMGUI_HAS_TEXTURES and true)
 print("NOCHAR",NOCHAR)
 print("NOIMSTRV",NOIMSTRV)
 print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
@@ -374,6 +381,7 @@ local function parseImGuiHeader(header,names)
 	parser.CONSTRUCTORS_GENERATION = CONSTRUCTORS_GENERATION
 	parser.NOCHAR = NOCHAR
 	parser.NOIMSTRV = NOIMSTRV
+	parser.IMGUI_HAS_TEXTURES = gdefines.IMGUI_HAS_TEXTURES
 	parser.custom_function_post = custom_function_post
 	parser.header_text_insert = header_text_insert
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
@@ -464,15 +472,26 @@ if #implementations > 0 then
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
-		
+		parser2.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		
 		local parser3 = cpp2ffi.Parser()
+		parser3.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
 		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		parser3:do_parse()
 		local cfuncsstr = func_header_impl_generate(parser3) 
 		local cstructstr1,cstructstr2 = parser3.structs_and_enums[1], parser3.structs_and_enums[2]
-		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n" .. cstructstr1 .. cstructstr2 .. cfuncsstr .. "\n#endif\n"
+		local cstru = cstructstr1 .. cstructstr2
+		if cstru ~="" then
+			cstru = "#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"..cstru .."\n#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"
+		end
+		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n".. cstru
+		local outtab = cpp2ffi.func_header_generate_structs(parser3)
+		if #outtab > 0 then
+			table.insert(outtab, 1, "#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+			table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+		end
+		impl_str = impl_str.. table.concat(outtab)..cfuncsstr .. "\n#endif\n"
     end
 	
     parser2:do_parse()
@@ -516,7 +535,9 @@ end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
+copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
 os.remove("./output/cimgui.h")
+os.remove("./output/cimgui_impl.h")
 os.remove("./output/cimgui.cpp")
 print"all done!!"

generator/output/cimgui_impl.h

@@ -1,89 +0,0 @@
-#ifdef CIMGUI_USE_GLFW
-
-typedef struct GLFWwindow GLFWwindow;
-typedef struct GLFWmonitor GLFWmonitor;
-struct GLFWwindow;
-struct GLFWmonitor;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
-CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
-CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
-CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
-CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
-CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
-CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
-CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
-CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
-
-#endif
-#ifdef CIMGUI_USE_OPENGL3
-CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
-CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
-CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
-
-#endif
-#ifdef CIMGUI_USE_OPENGL2
-CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
-CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
-
-#endif
-#ifdef CIMGUI_USE_SDL2
-
-typedef struct SDL_Window SDL_Window;
-typedef struct SDL_Renderer SDL_Renderer;
-typedef struct _SDL_GameController _SDL_GameController;
-struct SDL_Window;
-struct SDL_Renderer;
-struct _SDL_GameController;
-typedef union SDL_Event SDL_Event;
-typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
-CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
-CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
-CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
-
-#endif
-#ifdef CIMGUI_USE_SDL3
-
-typedef struct SDL_Window SDL_Window;
-typedef struct SDL_Renderer SDL_Renderer;
-typedef struct SDL_Gamepad SDL_Gamepad;
-struct SDL_Window;
-struct SDL_Renderer;
-struct SDL_Gamepad;
-typedef union SDL_Event SDL_Event;
-typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
-CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
-CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
-CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
-
-#endif

generator/output/impl_definitions.json

@@ -1149,5 +1149,474 @@
       "signature": "()",
       "stname": ""
     }
+  ],
+  "ImGui_ImplVulkanH_CreateOrResizeWindow": [
+    {
+      "args": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wd",
+          "type": "ImGui_ImplVulkanH_Window*"
+        },
+        {
+          "name": "queue_family",
+          "type": "uint32_t"
+        },
+        {
+          "name": "allocator",
+          "type": "const VkAllocationCallbacks*"
+        },
+        {
+          "name": "w",
+          "type": "int"
+        },
+        {
+          "name": "h",
+          "type": "int"
+        },
+        {
+          "name": "min_image_count",
+          "type": "uint32_t"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "call_args": "(instance,physical_device,device,wd,queue_family,allocator,w,h,min_image_count)",
+      "cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
+      "location": "imgui_impl_vulkan:165",
+      "ov_cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
+      "ret": "void",
+      "signature": "(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_DestroyWindow": [
+    {
+      "args": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wd",
+          "type": "ImGui_ImplVulkanH_Window*"
+        },
+        {
+          "name": "allocator",
+          "type": "const VkAllocationCallbacks*"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
+      "call_args": "(instance,device,wd,allocator)",
+      "cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_DestroyWindow",
+      "location": "imgui_impl_vulkan:166",
+      "ov_cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
+      "ret": "void",
+      "signature": "(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode": [
+    {
+      "args": "(VkPresentModeKHR present_mode)",
+      "argsT": [
+        {
+          "name": "present_mode",
+          "type": "VkPresentModeKHR"
+        }
+      ],
+      "argsoriginal": "(VkPresentModeKHR present_mode)",
+      "call_args": "(present_mode)",
+      "cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "location": "imgui_impl_vulkan:171",
+      "ov_cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "ret": "int",
+      "signature": "(VkPresentModeKHR)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectPhysicalDevice": [
+    {
+      "args": "(VkInstance instance)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance)",
+      "call_args": "(instance)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "location": "imgui_impl_vulkan:169",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "ret": "VkPhysicalDevice",
+      "signature": "(VkInstance)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectPresentMode": [
+    {
+      "args": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "surface",
+          "type": "VkSurfaceKHR"
+        },
+        {
+          "name": "request_modes",
+          "type": "const VkPresentModeKHR*"
+        },
+        {
+          "name": "request_modes_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      "call_args": "(physical_device,surface,request_modes,request_modes_count)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "location": "imgui_impl_vulkan:168",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "ret": "VkPresentModeKHR",
+      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectQueueFamilyIndex": [
+    {
+      "args": "(VkPhysicalDevice physical_device)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device)",
+      "call_args": "(physical_device)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "location": "imgui_impl_vulkan:170",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "ret": "uint32_t",
+      "signature": "(VkPhysicalDevice)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectSurfaceFormat": [
+    {
+      "args": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "surface",
+          "type": "VkSurfaceKHR"
+        },
+        {
+          "name": "request_formats",
+          "type": "const VkFormat*"
+        },
+        {
+          "name": "request_formats_count",
+          "type": "int"
+        },
+        {
+          "name": "request_color_space",
+          "type": "VkColorSpaceKHR"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      "call_args": "(physical_device,surface,request_formats,request_formats_count,request_color_space)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "location": "imgui_impl_vulkan:167",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "ret": "VkSurfaceFormatKHR",
+      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_Window",
+      "location": "imgui_impl_vulkan:213",
+      "ov_cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      "signature": "()",
+      "stname": "ImGui_ImplVulkanH_Window"
+    }
+  ],
+  "ImGui_ImplVulkanH_Window_destroy": [
+    {
+      "args": "(ImGui_ImplVulkanH_Window* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGui_ImplVulkanH_Window*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGui_ImplVulkanH_Window_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_impl_vulkan:213",
+      "ov_cimguiname": "ImGui_ImplVulkanH_Window_destroy",
+      "ret": "void",
+      "signature": "(ImGui_ImplVulkanH_Window*)",
+      "stname": "ImGui_ImplVulkanH_Window"
+    }
+  ],
+  "ImGui_ImplVulkan_AddTexture": [
+    {
+      "args": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "argsT": [
+        {
+          "name": "sampler",
+          "type": "VkSampler"
+        },
+        {
+          "name": "image_view",
+          "type": "VkImageView"
+        },
+        {
+          "name": "image_layout",
+          "type": "VkImageLayout"
+        }
+      ],
+      "argsoriginal": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "call_args": "(sampler,image_view,image_layout)",
+      "cimguiname": "ImGui_ImplVulkan_AddTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_AddTexture",
+      "location": "imgui_impl_vulkan:122",
+      "ov_cimguiname": "ImGui_ImplVulkan_AddTexture",
+      "ret": "VkDescriptorSet",
+      "signature": "(VkSampler,VkImageView,VkImageLayout)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_CreateFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_CreateFontsTexture",
+      "location": "imgui_impl_vulkan:115",
+      "ov_cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_DestroyFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_DestroyFontsTexture",
+      "location": "imgui_impl_vulkan:116",
+      "ov_cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_Init": [
+    {
+      "args": "(ImGui_ImplVulkan_InitInfo* info)",
+      "argsT": [
+        {
+          "name": "info",
+          "type": "ImGui_ImplVulkan_InitInfo*"
+        }
+      ],
+      "argsoriginal": "(ImGui_ImplVulkan_InitInfo* info)",
+      "call_args": "(info)",
+      "cimguiname": "ImGui_ImplVulkan_Init",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_Init",
+      "location": "imgui_impl_vulkan:111",
+      "ov_cimguiname": "ImGui_ImplVulkan_Init",
+      "ret": "bool",
+      "signature": "(ImGui_ImplVulkan_InitInfo*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_LoadFunctions": [
+    {
+      "args": "(PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data)",
+      "argsT": [
+        {
+          "name": "user_data)",
+          "type": "PFN_vkVoidFunction(*loader_func)(const char* function_name,void*"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data=nullptr)",
+      "call_args": "(user_data),user_data)",
+      "cimguiname": "ImGui_ImplVulkan_LoadFunctions",
+      "defaults": {
+        "user_data": "nullptr"
+      },
+      "funcname": "ImGui_ImplVulkan_LoadFunctions",
+      "location": "imgui_impl_vulkan:127",
+      "ov_cimguiname": "ImGui_ImplVulkan_LoadFunctions",
+      "ret": "bool",
+      "signature": "(PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_NewFrame",
+      "location": "imgui_impl_vulkan:113",
+      "ov_cimguiname": "ImGui_ImplVulkan_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_RemoveTexture": [
+    {
+      "args": "(VkDescriptorSet descriptor_set)",
+      "argsT": [
+        {
+          "name": "descriptor_set",
+          "type": "VkDescriptorSet"
+        }
+      ],
+      "argsoriginal": "(VkDescriptorSet descriptor_set)",
+      "call_args": "(descriptor_set)",
+      "cimguiname": "ImGui_ImplVulkan_RemoveTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_RemoveTexture",
+      "location": "imgui_impl_vulkan:123",
+      "ov_cimguiname": "ImGui_ImplVulkan_RemoveTexture",
+      "ret": "void",
+      "signature": "(VkDescriptorSet)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        },
+        {
+          "name": "command_buffer",
+          "type": "VkCommandBuffer"
+        },
+        {
+          "name": "pipeline",
+          "type": "VkPipeline"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline=0ULL)",
+      "call_args": "(draw_data,command_buffer,pipeline)",
+      "cimguiname": "ImGui_ImplVulkan_RenderDrawData",
+      "defaults": {
+        "pipeline": "0ULL"
+      },
+      "funcname": "ImGui_ImplVulkan_RenderDrawData",
+      "location": "imgui_impl_vulkan:114",
+      "ov_cimguiname": "ImGui_ImplVulkan_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*,VkCommandBuffer,VkPipeline)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_SetMinImageCount": [
+    {
+      "args": "(uint32_t min_image_count)",
+      "argsT": [
+        {
+          "name": "min_image_count",
+          "type": "uint32_t"
+        }
+      ],
+      "argsoriginal": "(uint32_t min_image_count)",
+      "call_args": "(min_image_count)",
+      "cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_SetMinImageCount",
+      "location": "imgui_impl_vulkan:117",
+      "ov_cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
+      "ret": "void",
+      "signature": "(uint32_t)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_Shutdown",
+      "location": "imgui_impl_vulkan:112",
+      "ov_cimguiname": "ImGui_ImplVulkan_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
   ]
 }

generator/output/impl_definitions.lua

@@ -996,6 +996,403 @@ local t={
       ret="void",
       signature="()",
       stname=""},
+    ["()"]=nil},
+  ImGui_ImplVulkanH_CreateOrResizeWindow={
+    [1]={
+      args="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"},
+        [2]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [3]={
+          name="device",
+          type="VkDevice"},
+        [4]={
+          name="wd",
+          type="ImGui_ImplVulkanH_Window*"},
+        [5]={
+          name="queue_family",
+          type="uint32_t"},
+        [6]={
+          name="allocator",
+          type="const VkAllocationCallbacks*"},
+        [7]={
+          name="w",
+          type="int"},
+        [8]={
+          name="h",
+          type="int"},
+        [9]={
+          name="min_image_count",
+          type="uint32_t"}},
+      argsoriginal="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      call_args="(instance,physical_device,device,wd,queue_family,allocator,w,h,min_image_count)",
+      cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_CreateOrResizeWindow",
+      location="imgui_impl_vulkan:165",
+      ov_cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
+      ret="void",
+      signature="(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
+      stname=""},
+    ["(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)"]=nil},
+  ImGui_ImplVulkanH_DestroyWindow={
+    [1]={
+      args="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"},
+        [2]={
+          name="device",
+          type="VkDevice"},
+        [3]={
+          name="wd",
+          type="ImGui_ImplVulkanH_Window*"},
+        [4]={
+          name="allocator",
+          type="const VkAllocationCallbacks*"}},
+      argsoriginal="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
+      call_args="(instance,device,wd,allocator)",
+      cimguiname="ImGui_ImplVulkanH_DestroyWindow",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_DestroyWindow",
+      location="imgui_impl_vulkan:166",
+      ov_cimguiname="ImGui_ImplVulkanH_DestroyWindow",
+      ret="void",
+      signature="(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
+      stname=""},
+    ["(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)"]=nil},
+  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode={
+    [1]={
+      args="(VkPresentModeKHR present_mode)",
+      argsT={
+        [1]={
+          name="present_mode",
+          type="VkPresentModeKHR"}},
+      argsoriginal="(VkPresentModeKHR present_mode)",
+      call_args="(present_mode)",
+      cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      location="imgui_impl_vulkan:171",
+      ov_cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      ret="int",
+      signature="(VkPresentModeKHR)",
+      stname=""},
+    ["(VkPresentModeKHR)"]=nil},
+  ImGui_ImplVulkanH_SelectPhysicalDevice={
+    [1]={
+      args="(VkInstance instance)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"}},
+      argsoriginal="(VkInstance instance)",
+      call_args="(instance)",
+      cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      location="imgui_impl_vulkan:169",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      ret="VkPhysicalDevice",
+      signature="(VkInstance)",
+      stname=""},
+    ["(VkInstance)"]=nil},
+  ImGui_ImplVulkanH_SelectPresentMode={
+    [1]={
+      args="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [2]={
+          name="surface",
+          type="VkSurfaceKHR"},
+        [3]={
+          name="request_modes",
+          type="const VkPresentModeKHR*"},
+        [4]={
+          name="request_modes_count",
+          type="int"}},
+      argsoriginal="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      call_args="(physical_device,surface,request_modes,request_modes_count)",
+      cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectPresentMode",
+      location="imgui_impl_vulkan:168",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
+      ret="VkPresentModeKHR",
+      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
+      stname=""},
+    ["(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)"]=nil},
+  ImGui_ImplVulkanH_SelectQueueFamilyIndex={
+    [1]={
+      args="(VkPhysicalDevice physical_device)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"}},
+      argsoriginal="(VkPhysicalDevice physical_device)",
+      call_args="(physical_device)",
+      cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      location="imgui_impl_vulkan:170",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      ret="uint32_t",
+      signature="(VkPhysicalDevice)",
+      stname=""},
+    ["(VkPhysicalDevice)"]=nil},
+  ImGui_ImplVulkanH_SelectSurfaceFormat={
+    [1]={
+      args="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [2]={
+          name="surface",
+          type="VkSurfaceKHR"},
+        [3]={
+          name="request_formats",
+          type="const VkFormat*"},
+        [4]={
+          name="request_formats_count",
+          type="int"},
+        [5]={
+          name="request_color_space",
+          type="VkColorSpaceKHR"}},
+      argsoriginal="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      call_args="(physical_device,surface,request_formats,request_formats_count,request_color_space)",
+      cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      location="imgui_impl_vulkan:167",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      ret="VkSurfaceFormatKHR",
+      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
+      stname=""},
+    ["(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)"]=nil},
+  ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      constructor=true,
+      defaults={},
+      funcname="ImGui_ImplVulkanH_Window",
+      location="imgui_impl_vulkan:213",
+      ov_cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      signature="()",
+      stname="ImGui_ImplVulkanH_Window"},
+    ["()"]=nil},
+  ImGui_ImplVulkanH_Window_destroy={
+    [1]={
+      args="(ImGui_ImplVulkanH_Window* self)",
+      argsT={
+        [1]={
+          name="self",
+          type="ImGui_ImplVulkanH_Window*"}},
+      call_args="(self)",
+      cimguiname="ImGui_ImplVulkanH_Window_destroy",
+      defaults={},
+      destructor=true,
+      location="imgui_impl_vulkan:213",
+      ov_cimguiname="ImGui_ImplVulkanH_Window_destroy",
+      ret="void",
+      signature="(ImGui_ImplVulkanH_Window*)",
+      stname="ImGui_ImplVulkanH_Window"},
+    ["(ImGui_ImplVulkanH_Window*)"]=nil},
+  ImGui_ImplVulkan_AddTexture={
+    [1]={
+      args="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      argsT={
+        [1]={
+          name="sampler",
+          type="VkSampler"},
+        [2]={
+          name="image_view",
+          type="VkImageView"},
+        [3]={
+          name="image_layout",
+          type="VkImageLayout"}},
+      argsoriginal="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      call_args="(sampler,image_view,image_layout)",
+      cimguiname="ImGui_ImplVulkan_AddTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_AddTexture",
+      location="imgui_impl_vulkan:122",
+      ov_cimguiname="ImGui_ImplVulkan_AddTexture",
+      ret="VkDescriptorSet",
+      signature="(VkSampler,VkImageView,VkImageLayout)",
+      stname=""},
+    ["(VkSampler,VkImageView,VkImageLayout)"]=nil},
+  ImGui_ImplVulkan_CreateFontsTexture={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_CreateFontsTexture",
+      location="imgui_impl_vulkan:115",
+      ov_cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
+      ret="bool",
+      signature="()",
+      stname=""},
+    ["()"]=nil},
+  ImGui_ImplVulkan_DestroyFontsTexture={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_DestroyFontsTexture",
+      location="imgui_impl_vulkan:116",
+      ov_cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
+      ret="void",
+      signature="()",
+      stname=""},
+    ["()"]=nil},
+  ImGui_ImplVulkan_Init={
+    [1]={
+      args="(ImGui_ImplVulkan_InitInfo* info)",
+      argsT={
+        [1]={
+          name="info",
+          type="ImGui_ImplVulkan_InitInfo*"}},
+      argsoriginal="(ImGui_ImplVulkan_InitInfo* info)",
+      call_args="(info)",
+      cimguiname="ImGui_ImplVulkan_Init",
+      defaults={},
+      funcname="ImGui_ImplVulkan_Init",
+      location="imgui_impl_vulkan:111",
+      ov_cimguiname="ImGui_ImplVulkan_Init",
+      ret="bool",
+      signature="(ImGui_ImplVulkan_InitInfo*)",
+      stname=""},
+    ["(ImGui_ImplVulkan_InitInfo*)"]=nil},
+  ImGui_ImplVulkan_LoadFunctions={
+    [1]={
+      args="(PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data)",
+      argsT={
+        [1]={
+          name="user_data)",
+          type="PFN_vkVoidFunction(*loader_func)(const char* function_name,void*"},
+        [2]={
+          name="user_data",
+          type="void*"}},
+      argsoriginal="(PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data=nullptr)",
+      call_args="(user_data),user_data)",
+      cimguiname="ImGui_ImplVulkan_LoadFunctions",
+      defaults={
+        user_data="nullptr"},
+      funcname="ImGui_ImplVulkan_LoadFunctions",
+      location="imgui_impl_vulkan:127",
+      ov_cimguiname="ImGui_ImplVulkan_LoadFunctions",
+      ret="bool",
+      signature="(PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
+      stname=""},
+    ["(PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)"]=nil},
+  ImGui_ImplVulkan_NewFrame={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_NewFrame",
+      defaults={},
+      funcname="ImGui_ImplVulkan_NewFrame",
+      location="imgui_impl_vulkan:113",
+      ov_cimguiname="ImGui_ImplVulkan_NewFrame",
+      ret="void",
+      signature="()",
+      stname=""},
+    ["()"]=nil},
+  ImGui_ImplVulkan_RemoveTexture={
+    [1]={
+      args="(VkDescriptorSet descriptor_set)",
+      argsT={
+        [1]={
+          name="descriptor_set",
+          type="VkDescriptorSet"}},
+      argsoriginal="(VkDescriptorSet descriptor_set)",
+      call_args="(descriptor_set)",
+      cimguiname="ImGui_ImplVulkan_RemoveTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_RemoveTexture",
+      location="imgui_impl_vulkan:123",
+      ov_cimguiname="ImGui_ImplVulkan_RemoveTexture",
+      ret="void",
+      signature="(VkDescriptorSet)",
+      stname=""},
+    ["(VkDescriptorSet)"]=nil},
+  ImGui_ImplVulkan_RenderDrawData={
+    [1]={
+      args="(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline)",
+      argsT={
+        [1]={
+          name="draw_data",
+          type="ImDrawData*"},
+        [2]={
+          name="command_buffer",
+          type="VkCommandBuffer"},
+        [3]={
+          name="pipeline",
+          type="VkPipeline"}},
+      argsoriginal="(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline=0ULL)",
+      call_args="(draw_data,command_buffer,pipeline)",
+      cimguiname="ImGui_ImplVulkan_RenderDrawData",
+      defaults={
+        pipeline="0ULL"},
+      funcname="ImGui_ImplVulkan_RenderDrawData",
+      location="imgui_impl_vulkan:114",
+      ov_cimguiname="ImGui_ImplVulkan_RenderDrawData",
+      ret="void",
+      signature="(ImDrawData*,VkCommandBuffer,VkPipeline)",
+      stname=""},
+    ["(ImDrawData*,VkCommandBuffer,VkPipeline)"]=nil},
+  ImGui_ImplVulkan_SetMinImageCount={
+    [1]={
+      args="(uint32_t min_image_count)",
+      argsT={
+        [1]={
+          name="min_image_count",
+          type="uint32_t"}},
+      argsoriginal="(uint32_t min_image_count)",
+      call_args="(min_image_count)",
+      cimguiname="ImGui_ImplVulkan_SetMinImageCount",
+      defaults={},
+      funcname="ImGui_ImplVulkan_SetMinImageCount",
+      location="imgui_impl_vulkan:117",
+      ov_cimguiname="ImGui_ImplVulkan_SetMinImageCount",
+      ret="void",
+      signature="(uint32_t)",
+      stname=""},
+    ["(uint32_t)"]=nil},
+  ImGui_ImplVulkan_Shutdown={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_Shutdown",
+      defaults={},
+      funcname="ImGui_ImplVulkan_Shutdown",
+      location="imgui_impl_vulkan:112",
+      ov_cimguiname="ImGui_ImplVulkan_Shutdown",
+      ret="void",
+      signature="()",
+      stname=""},
     ["()"]=nil}}
 t.ImGui_ImplGlfw_CharCallback["(GLFWwindow*,unsigned int)"]=t.ImGui_ImplGlfw_CharCallback[1]
 t.ImGui_ImplGlfw_CursorEnterCallback["(GLFWwindow*,int)"]=t.ImGui_ImplGlfw_CursorEnterCallback[1]
@@ -1051,4 +1448,23 @@ t.ImGui_ImplSDL3_NewFrame["()"]=t.ImGui_ImplSDL3_NewFrame[1]
 t.ImGui_ImplSDL3_ProcessEvent["(const SDL_Event*)"]=t.ImGui_ImplSDL3_ProcessEvent[1]
 t.ImGui_ImplSDL3_SetGamepadMode["(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)"]=t.ImGui_ImplSDL3_SetGamepadMode[1]
 t.ImGui_ImplSDL3_Shutdown["()"]=t.ImGui_ImplSDL3_Shutdown[1]
+t.ImGui_ImplVulkanH_CreateOrResizeWindow["(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)"]=t.ImGui_ImplVulkanH_CreateOrResizeWindow[1]
+t.ImGui_ImplVulkanH_DestroyWindow["(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)"]=t.ImGui_ImplVulkanH_DestroyWindow[1]
+t.ImGui_ImplVulkanH_GetMinImageCountFromPresentMode["(VkPresentModeKHR)"]=t.ImGui_ImplVulkanH_GetMinImageCountFromPresentMode[1]
+t.ImGui_ImplVulkanH_SelectPhysicalDevice["(VkInstance)"]=t.ImGui_ImplVulkanH_SelectPhysicalDevice[1]
+t.ImGui_ImplVulkanH_SelectPresentMode["(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)"]=t.ImGui_ImplVulkanH_SelectPresentMode[1]
+t.ImGui_ImplVulkanH_SelectQueueFamilyIndex["(VkPhysicalDevice)"]=t.ImGui_ImplVulkanH_SelectQueueFamilyIndex[1]
+t.ImGui_ImplVulkanH_SelectSurfaceFormat["(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)"]=t.ImGui_ImplVulkanH_SelectSurfaceFormat[1]
+t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window["()"]=t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window[1]
+t.ImGui_ImplVulkanH_Window_destroy["(ImGui_ImplVulkanH_Window*)"]=t.ImGui_ImplVulkanH_Window_destroy[1]
+t.ImGui_ImplVulkan_AddTexture["(VkSampler,VkImageView,VkImageLayout)"]=t.ImGui_ImplVulkan_AddTexture[1]
+t.ImGui_ImplVulkan_CreateFontsTexture["()"]=t.ImGui_ImplVulkan_CreateFontsTexture[1]
+t.ImGui_ImplVulkan_DestroyFontsTexture["()"]=t.ImGui_ImplVulkan_DestroyFontsTexture[1]
+t.ImGui_ImplVulkan_Init["(ImGui_ImplVulkan_InitInfo*)"]=t.ImGui_ImplVulkan_Init[1]
+t.ImGui_ImplVulkan_LoadFunctions["(PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)"]=t.ImGui_ImplVulkan_LoadFunctions[1]
+t.ImGui_ImplVulkan_NewFrame["()"]=t.ImGui_ImplVulkan_NewFrame[1]
+t.ImGui_ImplVulkan_RemoveTexture["(VkDescriptorSet)"]=t.ImGui_ImplVulkan_RemoveTexture[1]
+t.ImGui_ImplVulkan_RenderDrawData["(ImDrawData*,VkCommandBuffer,VkPipeline)"]=t.ImGui_ImplVulkan_RenderDrawData[1]
+t.ImGui_ImplVulkan_SetMinImageCount["(uint32_t)"]=t.ImGui_ImplVulkan_SetMinImageCount[1]
+t.ImGui_ImplVulkan_Shutdown["()"]=t.ImGui_ImplVulkan_Shutdown[1]
  return t

generator/output/structs_and_enums.json

@@ -5139,41 +5139,41 @@
   },
   "locations": {
     "ImBitVector": "imgui_internal:623",
-    "ImColor": "imgui:2883",
+    "ImColor": "imgui:2884",
-    "ImDrawChannel": "imgui:3123",
+    "ImDrawChannel": "imgui:3124",
-    "ImDrawCmd": "imgui:3080",
+    "ImDrawCmd": "imgui:3081",
-    "ImDrawCmdHeader": "imgui:3115",
+    "ImDrawCmdHeader": "imgui:3116",
-    "ImDrawData": "imgui:3339",
+    "ImDrawData": "imgui:3340",
     "ImDrawDataBuilder": "imgui_internal:813",
-    "ImDrawFlags_": "imgui:3148",
+    "ImDrawFlags_": "imgui:3149",
-    "ImDrawList": "imgui:3186",
+    "ImDrawList": "imgui:3187",
-    "ImDrawListFlags_": "imgui:3168",
+    "ImDrawListFlags_": "imgui:3169",
     "ImDrawListSharedData": "imgui_internal:791",
-    "ImDrawListSplitter": "imgui:3131",
+    "ImDrawListSplitter": "imgui:3132",
-    "ImDrawVert": "imgui:3100",
+    "ImDrawVert": "imgui:3101",
-    "ImFont": "imgui:3566",
+    "ImFont": "imgui:3567",
-    "ImFontAtlas": "imgui:3462",
+    "ImFontAtlas": "imgui:3463",
-    "ImFontAtlasCustomRect": "imgui:3421",
+    "ImFontAtlasCustomRect": "imgui:3422",
-    "ImFontAtlasFlags_": "imgui:3437",
+    "ImFontAtlasFlags_": "imgui:3438",
     "ImFontBuilderIO": "imgui_internal:3867",
-    "ImFontConfig": "imgui:3364",
+    "ImFontConfig": "imgui:3365",
-    "ImFontGlyph": "imgui:3394",
+    "ImFontGlyph": "imgui:3395",
-    "ImFontGlyphRangesBuilder": "imgui:3406",
+    "ImFontGlyphRangesBuilder": "imgui:3407",
     "ImGuiActivateFlags_": "imgui_internal:1581",
     "ImGuiAxis": "imgui_internal:1038",
-    "ImGuiBackendFlags_": "imgui:1675",
+    "ImGuiBackendFlags_": "imgui:1676",
     "ImGuiBoxSelectState": "imgui_internal:1770",
     "ImGuiButtonFlagsPrivate_": "imgui_internal:928",
-    "ImGuiButtonFlags_": "imgui:1809",
+    "ImGuiButtonFlags_": "imgui:1810",
-    "ImGuiChildFlags_": "imgui:1158",
+    "ImGuiChildFlags_": "imgui:1159",
-    "ImGuiCol_": "imgui:1690",
+    "ImGuiCol_": "imgui:1691",
-    "ImGuiColorEditFlags_": "imgui:1820",
+    "ImGuiColorEditFlags_": "imgui:1821",
     "ImGuiColorMod": "imgui_internal:1052",
     "ImGuiComboFlagsPrivate_": "imgui_internal:953",
-    "ImGuiComboFlags_": "imgui:1306",
+    "ImGuiComboFlags_": "imgui:1307",
     "ImGuiComboPreviewData": "imgui_internal:1069",
-    "ImGuiCond_": "imgui:1932",
+    "ImGuiCond_": "imgui:1933",
-    "ImGuiConfigFlags_": "imgui:1646",
+    "ImGuiConfigFlags_": "imgui:1647",
     "ImGuiContext": "imgui_internal:2241",
     "ImGuiContextHook": "imgui_internal:2226",
     "ImGuiContextHookType": "imgui_internal:2224",
@@ -5181,29 +5181,29 @@
     "ImGuiDataTypeInfo": "imgui_internal:839",
     "ImGuiDataTypePrivate_": "imgui_internal:848",
     "ImGuiDataTypeStorage": "imgui_internal:833",
-    "ImGuiDataType_": "imgui:1454",
+    "ImGuiDataType_": "imgui:1455",
     "ImGuiDataVarInfo": "imgui_internal:825",
     "ImGuiDeactivatedItemData": "imgui_internal:1346",
     "ImGuiDebugAllocEntry": "imgui_internal:2160",
     "ImGuiDebugAllocInfo": "imgui_internal:2167",
     "ImGuiDebugLogFlags_": "imgui_internal:2138",
-    "ImGuiDir": "imgui:1472",
+    "ImGuiDir": "imgui:1473",
     "ImGuiDockContext": "imgui_internal:1985",
     "ImGuiDockNode": "imgui_internal:1899",
     "ImGuiDockNodeFlagsPrivate_": "imgui_internal:1851",
-    "ImGuiDockNodeFlags_": "imgui:1407",
+    "ImGuiDockNodeFlags_": "imgui:1408",
     "ImGuiDockNodeState": "imgui_internal:1890",
-    "ImGuiDragDropFlags_": "imgui:1426",
+    "ImGuiDragDropFlags_": "imgui:1427",
     "ImGuiErrorRecoveryState": "imgui_internal:1303",
     "ImGuiFocusRequestFlags_": "imgui_internal:998",
     "ImGuiFocusScopeData": "imgui_internal:1667",
-    "ImGuiFocusedFlags_": "imgui:1353",
+    "ImGuiFocusedFlags_": "imgui:1354",
     "ImGuiFreeTypeBuilderFlags": "imgui_freetype:26",
     "ImGuiGroupData": "imgui_internal:1082",
     "ImGuiHoveredFlagsPrivate_": "imgui_internal:911",
-    "ImGuiHoveredFlags_": "imgui:1367",
+    "ImGuiHoveredFlags_": "imgui:1368",
     "ImGuiIDStackTool": "imgui_internal:2207",
-    "ImGuiIO": "imgui:2305",
+    "ImGuiIO": "imgui:2306",
     "ImGuiInputEvent": "imgui_internal:1441",
     "ImGuiInputEventAppFocused": "imgui_internal:1439",
     "ImGuiInputEventKey": "imgui_internal:1437",
@@ -5214,24 +5214,24 @@
     "ImGuiInputEventText": "imgui_internal:1438",
     "ImGuiInputEventType": "imgui_internal:1409",
     "ImGuiInputFlagsPrivate_": "imgui_internal:1508",
-    "ImGuiInputFlags_": "imgui:1623",
+    "ImGuiInputFlags_": "imgui:1624",
     "ImGuiInputSource": "imgui_internal:1422",
-    "ImGuiInputTextCallbackData": "imgui:2560",
+    "ImGuiInputTextCallbackData": "imgui:2561",
     "ImGuiInputTextDeactivatedState": "imgui_internal:1118",
     "ImGuiInputTextFlagsPrivate_": "imgui_internal:919",
-    "ImGuiInputTextFlags_": "imgui:1192",
+    "ImGuiInputTextFlags_": "imgui:1193",
     "ImGuiInputTextState": "imgui_internal:1140",
     "ImGuiItemFlagsPrivate_": "imgui_internal:861",
-    "ImGuiItemFlags_": "imgui:1179",
+    "ImGuiItemFlags_": "imgui:1180",
     "ImGuiItemStatusFlags_": "imgui_internal:885",
-    "ImGuiKey": "imgui:1496",
+    "ImGuiKey": "imgui:1497",
-    "ImGuiKeyData": "imgui:2297",
+    "ImGuiKeyData": "imgui:2298",
     "ImGuiKeyOwnerData": "imgui_internal:1495",
     "ImGuiKeyRoutingData": "imgui_internal:1469",
     "ImGuiKeyRoutingTable": "imgui_internal:1483",
     "ImGuiLastItemData": "imgui_internal:1275",
     "ImGuiLayoutType_": "imgui_internal:1019",
-    "ImGuiListClipper": "imgui:2789",
+    "ImGuiListClipper": "imgui:2790",
     "ImGuiListClipperData": "imgui_internal:1565",
     "ImGuiListClipperRange": "imgui_internal:1552",
     "ImGuiLocEntry": "imgui_internal:2111",
@@ -5239,11 +5239,11 @@
     "ImGuiLogFlags_": "imgui_internal:1026",
     "ImGuiMenuColumns": "imgui_internal:1100",
     "ImGuiMetricsConfig": "imgui_internal:2177",
-    "ImGuiMouseButton_": "imgui:1892",
+    "ImGuiMouseButton_": "imgui:1893",
-    "ImGuiMouseCursor_": "imgui:1902",
+    "ImGuiMouseCursor_": "imgui:1903",
-    "ImGuiMouseSource": "imgui:1921",
+    "ImGuiMouseSource": "imgui:1922",
-    "ImGuiMultiSelectFlags_": "imgui:2941",
+    "ImGuiMultiSelectFlags_": "imgui:2942",
-    "ImGuiMultiSelectIO": "imgui:2968",
+    "ImGuiMultiSelectIO": "imgui:2969",
     "ImGuiMultiSelectState": "imgui_internal:1827",
     "ImGuiMultiSelectTempData": "imgui_internal:1802",
     "ImGuiNavItemData": "imgui_internal:1650",
@@ -5257,85 +5257,85 @@
     "ImGuiOldColumnData": "imgui_internal:1735",
     "ImGuiOldColumnFlags_": "imgui_internal:1715",
     "ImGuiOldColumns": "imgui_internal:1745",
-    "ImGuiOnceUponAFrame": "imgui:2660",
+    "ImGuiOnceUponAFrame": "imgui:2661",
-    "ImGuiPayload": "imgui:2625",
+    "ImGuiPayload": "imgui:2626",
-    "ImGuiPlatformIO": "imgui:3738",
+    "ImGuiPlatformIO": "imgui:3739",
-    "ImGuiPlatformImeData": "imgui:3844",
+    "ImGuiPlatformImeData": "imgui:3845",
-    "ImGuiPlatformMonitor": "imgui:3834",
+    "ImGuiPlatformMonitor": "imgui:3835",
     "ImGuiPlotType": "imgui_internal:1045",
     "ImGuiPopupData": "imgui_internal:1366",
-    "ImGuiPopupFlags_": "imgui:1271",
+    "ImGuiPopupFlags_": "imgui:1272",
     "ImGuiPopupPositionPolicy": "imgui_internal:1358",
     "ImGuiPtrOrIndex": "imgui_internal:1336",
     "ImGuiScrollFlags_": "imgui_internal:1592",
     "ImGuiSelectableFlagsPrivate_": "imgui_internal:966",
-    "ImGuiSelectableFlags_": "imgui:1289",
+    "ImGuiSelectableFlags_": "imgui:1290",
-    "ImGuiSelectionBasicStorage": "imgui:3014",
+    "ImGuiSelectionBasicStorage": "imgui:3015",
-    "ImGuiSelectionExternalStorage": "imgui:3037",
+    "ImGuiSelectionExternalStorage": "imgui:3038",
-    "ImGuiSelectionRequest": "imgui:2988",
+    "ImGuiSelectionRequest": "imgui:2989",
-    "ImGuiSelectionRequestType": "imgui:2980",
+    "ImGuiSelectionRequestType": "imgui:2981",
     "ImGuiSeparatorFlags_": "imgui_internal:987",
     "ImGuiSettingsHandler": "imgui_internal:2073",
     "ImGuiShrinkWidthItem": "imgui_internal:1329",
-    "ImGuiSizeCallbackData": "imgui:2594",
+    "ImGuiSizeCallbackData": "imgui:2595",
     "ImGuiSliderFlagsPrivate_": "imgui_internal:959",
-    "ImGuiSliderFlags_": "imgui:1876",
+    "ImGuiSliderFlags_": "imgui:1877",
-    "ImGuiSortDirection": "imgui:1483",
+    "ImGuiSortDirection": "imgui:1484",
     "ImGuiStackLevelInfo": "imgui_internal:2195",
-    "ImGuiStorage": "imgui:2732",
+    "ImGuiStorage": "imgui:2733",
-    "ImGuiStoragePair": "imgui:2715",
+    "ImGuiStoragePair": "imgui:2716",
-    "ImGuiStyle": "imgui:2219",
+    "ImGuiStyle": "imgui:2220",
     "ImGuiStyleMod": "imgui_internal:1059",
-    "ImGuiStyleVar_": "imgui:1768",
+    "ImGuiStyleVar_": "imgui:1769",
     "ImGuiTabBar": "imgui_internal:2877",
     "ImGuiTabBarFlagsPrivate_": "imgui_internal:2839",
-    "ImGuiTabBarFlags_": "imgui:1321",
+    "ImGuiTabBarFlags_": "imgui:1322",
     "ImGuiTabItem": "imgui_internal:2857",
     "ImGuiTabItemFlagsPrivate_": "imgui_internal:2847",
-    "ImGuiTabItemFlags_": "imgui:1338",
+    "ImGuiTabItemFlags_": "imgui:1339",
     "ImGuiTable": "imgui_internal:3024",
-    "ImGuiTableBgTarget_": "imgui:2073",
+    "ImGuiTableBgTarget_": "imgui:2074",
     "ImGuiTableCellData": "imgui_internal:2992",
     "ImGuiTableColumn": "imgui_internal:2932",
-    "ImGuiTableColumnFlags_": "imgui:2020",
+    "ImGuiTableColumnFlags_": "imgui:2021",
     "ImGuiTableColumnSettings": "imgui_internal:3172",
-    "ImGuiTableColumnSortSpecs": "imgui:2095",
+    "ImGuiTableColumnSortSpecs": "imgui:2096",
-    "ImGuiTableFlags_": "imgui:1967",
+    "ImGuiTableFlags_": "imgui:1968",
     "ImGuiTableHeaderData": "imgui_internal:3001",
     "ImGuiTableInstanceData": "imgui_internal:3011",
-    "ImGuiTableRowFlags_": "imgui:2058",
+    "ImGuiTableRowFlags_": "imgui:2059",
     "ImGuiTableSettings": "imgui_internal:3196",
-    "ImGuiTableSortSpecs": "imgui:2085",
+    "ImGuiTableSortSpecs": "imgui:2086",
     "ImGuiTableTempData": "imgui_internal:3149",
-    "ImGuiTextBuffer": "imgui:2695",
+    "ImGuiTextBuffer": "imgui:2696",
-    "ImGuiTextFilter": "imgui:2668",
+    "ImGuiTextFilter": "imgui:2669",
     "ImGuiTextFlags_": "imgui_internal:1005",
     "ImGuiTextIndex": "imgui_internal:743",
-    "ImGuiTextRange": "imgui:2678",
+    "ImGuiTextRange": "imgui:2679",
     "ImGuiTooltipFlags_": "imgui_internal:1011",
     "ImGuiTreeNodeFlagsPrivate_": "imgui_internal:980",
-    "ImGuiTreeNodeFlags_": "imgui:1234",
+    "ImGuiTreeNodeFlags_": "imgui:1235",
     "ImGuiTreeNodeStackData": "imgui_internal:1294",
     "ImGuiTypingSelectFlags_": "imgui_internal:1678",
     "ImGuiTypingSelectRequest": "imgui_internal:1686",
     "ImGuiTypingSelectState": "imgui_internal:1697",
-    "ImGuiViewport": "imgui:3653",
+    "ImGuiViewport": "imgui:3654",
-    "ImGuiViewportFlags_": "imgui:3625",
+    "ImGuiViewportFlags_": "imgui:3626",
     "ImGuiViewportP": "imgui_internal:2002",
     "ImGuiWindow": "imgui_internal:2687",
-    "ImGuiWindowClass": "imgui:2609",
+    "ImGuiWindowClass": "imgui:2610",
     "ImGuiWindowDockStyle": "imgui_internal:1980",
     "ImGuiWindowDockStyleCol": "imgui_internal:1966",
-    "ImGuiWindowFlags_": "imgui:1107",
+    "ImGuiWindowFlags_": "imgui:1108",
     "ImGuiWindowRefreshFlags_": "imgui_internal:1188",
     "ImGuiWindowSettings": "imgui_internal:2054",
     "ImGuiWindowStackData": "imgui_internal:1321",
     "ImGuiWindowTempData": "imgui_internal:2631",
     "ImRect": "imgui_internal:545",
     "ImVec1": "imgui_internal:527",
-    "ImVec2": "imgui:299",
+    "ImVec2": "imgui:300",
     "ImVec2ih": "imgui_internal:535",
-    "ImVec4": "imgui:312"
+    "ImVec4": "imgui:313"
   },
   "nonPOD": {
     "ImBitArray": true,

generator/output/structs_and_enums.lua

@@ -4062,41 +4062,41 @@ local t={
     ImGuiSortDirection="ImU8"},
   locations={
     ImBitVector="imgui_internal:623",
-    ImColor="imgui:2883",
+    ImColor="imgui:2884",
-    ImDrawChannel="imgui:3123",
+    ImDrawChannel="imgui:3124",
-    ImDrawCmd="imgui:3080",
+    ImDrawCmd="imgui:3081",
-    ImDrawCmdHeader="imgui:3115",
+    ImDrawCmdHeader="imgui:3116",
-    ImDrawData="imgui:3339",
+    ImDrawData="imgui:3340",
     ImDrawDataBuilder="imgui_internal:813",
-    ImDrawFlags_="imgui:3148",
+    ImDrawFlags_="imgui:3149",
-    ImDrawList="imgui:3186",
+    ImDrawList="imgui:3187",
-    ImDrawListFlags_="imgui:3168",
+    ImDrawListFlags_="imgui:3169",
     ImDrawListSharedData="imgui_internal:791",
-    ImDrawListSplitter="imgui:3131",
+    ImDrawListSplitter="imgui:3132",
-    ImDrawVert="imgui:3100",
+    ImDrawVert="imgui:3101",
-    ImFont="imgui:3566",
+    ImFont="imgui:3567",
-    ImFontAtlas="imgui:3462",
+    ImFontAtlas="imgui:3463",
-    ImFontAtlasCustomRect="imgui:3421",
+    ImFontAtlasCustomRect="imgui:3422",
-    ImFontAtlasFlags_="imgui:3437",
+    ImFontAtlasFlags_="imgui:3438",
     ImFontBuilderIO="imgui_internal:3867",
-    ImFontConfig="imgui:3364",
+    ImFontConfig="imgui:3365",
-    ImFontGlyph="imgui:3394",
+    ImFontGlyph="imgui:3395",
-    ImFontGlyphRangesBuilder="imgui:3406",
+    ImFontGlyphRangesBuilder="imgui:3407",
     ImGuiActivateFlags_="imgui_internal:1581",
     ImGuiAxis="imgui_internal:1038",
-    ImGuiBackendFlags_="imgui:1675",
+    ImGuiBackendFlags_="imgui:1676",
     ImGuiBoxSelectState="imgui_internal:1770",
     ImGuiButtonFlagsPrivate_="imgui_internal:928",
-    ImGuiButtonFlags_="imgui:1809",
+    ImGuiButtonFlags_="imgui:1810",
-    ImGuiChildFlags_="imgui:1158",
+    ImGuiChildFlags_="imgui:1159",
-    ImGuiCol_="imgui:1690",
+    ImGuiCol_="imgui:1691",
-    ImGuiColorEditFlags_="imgui:1820",
+    ImGuiColorEditFlags_="imgui:1821",
     ImGuiColorMod="imgui_internal:1052",
     ImGuiComboFlagsPrivate_="imgui_internal:953",
-    ImGuiComboFlags_="imgui:1306",
+    ImGuiComboFlags_="imgui:1307",
     ImGuiComboPreviewData="imgui_internal:1069",
-    ImGuiCond_="imgui:1932",
+    ImGuiCond_="imgui:1933",
-    ImGuiConfigFlags_="imgui:1646",
+    ImGuiConfigFlags_="imgui:1647",
     ImGuiContext="imgui_internal:2241",
     ImGuiContextHook="imgui_internal:2226",
     ImGuiContextHookType="imgui_internal:2224",
@@ -4104,29 +4104,29 @@ local t={
     ImGuiDataTypeInfo="imgui_internal:839",
     ImGuiDataTypePrivate_="imgui_internal:848",
     ImGuiDataTypeStorage="imgui_internal:833",
-    ImGuiDataType_="imgui:1454",
+    ImGuiDataType_="imgui:1455",
     ImGuiDataVarInfo="imgui_internal:825",
     ImGuiDeactivatedItemData="imgui_internal:1346",
     ImGuiDebugAllocEntry="imgui_internal:2160",
     ImGuiDebugAllocInfo="imgui_internal:2167",
     ImGuiDebugLogFlags_="imgui_internal:2138",
-    ImGuiDir="imgui:1472",
+    ImGuiDir="imgui:1473",
     ImGuiDockContext="imgui_internal:1985",
     ImGuiDockNode="imgui_internal:1899",
     ImGuiDockNodeFlagsPrivate_="imgui_internal:1851",
-    ImGuiDockNodeFlags_="imgui:1407",
+    ImGuiDockNodeFlags_="imgui:1408",
     ImGuiDockNodeState="imgui_internal:1890",
-    ImGuiDragDropFlags_="imgui:1426",
+    ImGuiDragDropFlags_="imgui:1427",
     ImGuiErrorRecoveryState="imgui_internal:1303",
     ImGuiFocusRequestFlags_="imgui_internal:998",
     ImGuiFocusScopeData="imgui_internal:1667",
-    ImGuiFocusedFlags_="imgui:1353",
+    ImGuiFocusedFlags_="imgui:1354",
     ImGuiFreeTypeBuilderFlags="imgui_freetype:26",
     ImGuiGroupData="imgui_internal:1082",
     ImGuiHoveredFlagsPrivate_="imgui_internal:911",
-    ImGuiHoveredFlags_="imgui:1367",
+    ImGuiHoveredFlags_="imgui:1368",
     ImGuiIDStackTool="imgui_internal:2207",
-    ImGuiIO="imgui:2305",
+    ImGuiIO="imgui:2306",
     ImGuiInputEvent="imgui_internal:1441",
     ImGuiInputEventAppFocused="imgui_internal:1439",
     ImGuiInputEventKey="imgui_internal:1437",
@@ -4137,24 +4137,24 @@ local t={
     ImGuiInputEventText="imgui_internal:1438",
     ImGuiInputEventType="imgui_internal:1409",
     ImGuiInputFlagsPrivate_="imgui_internal:1508",
-    ImGuiInputFlags_="imgui:1623",
+    ImGuiInputFlags_="imgui:1624",
     ImGuiInputSource="imgui_internal:1422",
-    ImGuiInputTextCallbackData="imgui:2560",
+    ImGuiInputTextCallbackData="imgui:2561",
     ImGuiInputTextDeactivatedState="imgui_internal:1118",
     ImGuiInputTextFlagsPrivate_="imgui_internal:919",
-    ImGuiInputTextFlags_="imgui:1192",
+    ImGuiInputTextFlags_="imgui:1193",
     ImGuiInputTextState="imgui_internal:1140",
     ImGuiItemFlagsPrivate_="imgui_internal:861",
-    ImGuiItemFlags_="imgui:1179",
+    ImGuiItemFlags_="imgui:1180",
     ImGuiItemStatusFlags_="imgui_internal:885",
-    ImGuiKey="imgui:1496",
+    ImGuiKey="imgui:1497",
-    ImGuiKeyData="imgui:2297",
+    ImGuiKeyData="imgui:2298",
     ImGuiKeyOwnerData="imgui_internal:1495",
     ImGuiKeyRoutingData="imgui_internal:1469",
     ImGuiKeyRoutingTable="imgui_internal:1483",
     ImGuiLastItemData="imgui_internal:1275",
     ImGuiLayoutType_="imgui_internal:1019",
-    ImGuiListClipper="imgui:2789",
+    ImGuiListClipper="imgui:2790",
     ImGuiListClipperData="imgui_internal:1565",
     ImGuiListClipperRange="imgui_internal:1552",
     ImGuiLocEntry="imgui_internal:2111",
@@ -4162,11 +4162,11 @@ local t={
     ImGuiLogFlags_="imgui_internal:1026",
     ImGuiMenuColumns="imgui_internal:1100",
     ImGuiMetricsConfig="imgui_internal:2177",
-    ImGuiMouseButton_="imgui:1892",
+    ImGuiMouseButton_="imgui:1893",
-    ImGuiMouseCursor_="imgui:1902",
+    ImGuiMouseCursor_="imgui:1903",
-    ImGuiMouseSource="imgui:1921",
+    ImGuiMouseSource="imgui:1922",
-    ImGuiMultiSelectFlags_="imgui:2941",
+    ImGuiMultiSelectFlags_="imgui:2942",
-    ImGuiMultiSelectIO="imgui:2968",
+    ImGuiMultiSelectIO="imgui:2969",
     ImGuiMultiSelectState="imgui_internal:1827",
     ImGuiMultiSelectTempData="imgui_internal:1802",
     ImGuiNavItemData="imgui_internal:1650",
@@ -4180,85 +4180,85 @@ local t={
     ImGuiOldColumnData="imgui_internal:1735",
     ImGuiOldColumnFlags_="imgui_internal:1715",
     ImGuiOldColumns="imgui_internal:1745",
-    ImGuiOnceUponAFrame="imgui:2660",
+    ImGuiOnceUponAFrame="imgui:2661",
-    ImGuiPayload="imgui:2625",
+    ImGuiPayload="imgui:2626",
-    ImGuiPlatformIO="imgui:3738",
+    ImGuiPlatformIO="imgui:3739",
-    ImGuiPlatformImeData="imgui:3844",
+    ImGuiPlatformImeData="imgui:3845",
-    ImGuiPlatformMonitor="imgui:3834",
+    ImGuiPlatformMonitor="imgui:3835",
     ImGuiPlotType="imgui_internal:1045",
     ImGuiPopupData="imgui_internal:1366",
-    ImGuiPopupFlags_="imgui:1271",
+    ImGuiPopupFlags_="imgui:1272",
     ImGuiPopupPositionPolicy="imgui_internal:1358",
     ImGuiPtrOrIndex="imgui_internal:1336",
     ImGuiScrollFlags_="imgui_internal:1592",
     ImGuiSelectableFlagsPrivate_="imgui_internal:966",
-    ImGuiSelectableFlags_="imgui:1289",
+    ImGuiSelectableFlags_="imgui:1290",
-    ImGuiSelectionBasicStorage="imgui:3014",
+    ImGuiSelectionBasicStorage="imgui:3015",
-    ImGuiSelectionExternalStorage="imgui:3037",
+    ImGuiSelectionExternalStorage="imgui:3038",
-    ImGuiSelectionRequest="imgui:2988",
+    ImGuiSelectionRequest="imgui:2989",
-    ImGuiSelectionRequestType="imgui:2980",
+    ImGuiSelectionRequestType="imgui:2981",
     ImGuiSeparatorFlags_="imgui_internal:987",
     ImGuiSettingsHandler="imgui_internal:2073",
     ImGuiShrinkWidthItem="imgui_internal:1329",
-    ImGuiSizeCallbackData="imgui:2594",
+    ImGuiSizeCallbackData="imgui:2595",
     ImGuiSliderFlagsPrivate_="imgui_internal:959",
-    ImGuiSliderFlags_="imgui:1876",
+    ImGuiSliderFlags_="imgui:1877",
-    ImGuiSortDirection="imgui:1483",
+    ImGuiSortDirection="imgui:1484",
     ImGuiStackLevelInfo="imgui_internal:2195",
-    ImGuiStorage="imgui:2732",
+    ImGuiStorage="imgui:2733",
-    ImGuiStoragePair="imgui:2715",
+    ImGuiStoragePair="imgui:2716",
-    ImGuiStyle="imgui:2219",
+    ImGuiStyle="imgui:2220",
     ImGuiStyleMod="imgui_internal:1059",
-    ImGuiStyleVar_="imgui:1768",
+    ImGuiStyleVar_="imgui:1769",
     ImGuiTabBar="imgui_internal:2877",
     ImGuiTabBarFlagsPrivate_="imgui_internal:2839",
-    ImGuiTabBarFlags_="imgui:1321",
+    ImGuiTabBarFlags_="imgui:1322",
     ImGuiTabItem="imgui_internal:2857",
     ImGuiTabItemFlagsPrivate_="imgui_internal:2847",
-    ImGuiTabItemFlags_="imgui:1338",
+    ImGuiTabItemFlags_="imgui:1339",
     ImGuiTable="imgui_internal:3024",
-    ImGuiTableBgTarget_="imgui:2073",
+    ImGuiTableBgTarget_="imgui:2074",
     ImGuiTableCellData="imgui_internal:2992",
     ImGuiTableColumn="imgui_internal:2932",
-    ImGuiTableColumnFlags_="imgui:2020",
+    ImGuiTableColumnFlags_="imgui:2021",
     ImGuiTableColumnSettings="imgui_internal:3172",
-    ImGuiTableColumnSortSpecs="imgui:2095",
+    ImGuiTableColumnSortSpecs="imgui:2096",
-    ImGuiTableFlags_="imgui:1967",
+    ImGuiTableFlags_="imgui:1968",
     ImGuiTableHeaderData="imgui_internal:3001",
     ImGuiTableInstanceData="imgui_internal:3011",
-    ImGuiTableRowFlags_="imgui:2058",
+    ImGuiTableRowFlags_="imgui:2059",
     ImGuiTableSettings="imgui_internal:3196",
-    ImGuiTableSortSpecs="imgui:2085",
+    ImGuiTableSortSpecs="imgui:2086",
     ImGuiTableTempData="imgui_internal:3149",
-    ImGuiTextBuffer="imgui:2695",
+    ImGuiTextBuffer="imgui:2696",
-    ImGuiTextFilter="imgui:2668",
+    ImGuiTextFilter="imgui:2669",
     ImGuiTextFlags_="imgui_internal:1005",
     ImGuiTextIndex="imgui_internal:743",
-    ImGuiTextRange="imgui:2678",
+    ImGuiTextRange="imgui:2679",
     ImGuiTooltipFlags_="imgui_internal:1011",
     ImGuiTreeNodeFlagsPrivate_="imgui_internal:980",
-    ImGuiTreeNodeFlags_="imgui:1234",
+    ImGuiTreeNodeFlags_="imgui:1235",
     ImGuiTreeNodeStackData="imgui_internal:1294",
     ImGuiTypingSelectFlags_="imgui_internal:1678",
     ImGuiTypingSelectRequest="imgui_internal:1686",
     ImGuiTypingSelectState="imgui_internal:1697",
-    ImGuiViewport="imgui:3653",
+    ImGuiViewport="imgui:3654",
-    ImGuiViewportFlags_="imgui:3625",
+    ImGuiViewportFlags_="imgui:3626",
     ImGuiViewportP="imgui_internal:2002",
     ImGuiWindow="imgui_internal:2687",
-    ImGuiWindowClass="imgui:2609",
+    ImGuiWindowClass="imgui:2610",
     ImGuiWindowDockStyle="imgui_internal:1980",
     ImGuiWindowDockStyleCol="imgui_internal:1966",
-    ImGuiWindowFlags_="imgui:1107",
+    ImGuiWindowFlags_="imgui:1108",
     ImGuiWindowRefreshFlags_="imgui_internal:1188",
     ImGuiWindowSettings="imgui_internal:2054",
     ImGuiWindowStackData="imgui_internal:1321",
     ImGuiWindowTempData="imgui_internal:2631",
     ImRect="imgui_internal:545",
     ImVec1="imgui_internal:527",
-    ImVec2="imgui:299",
+    ImVec2="imgui:300",
     ImVec2ih="imgui_internal:535",
-    ImVec4="imgui:312"},
+    ImVec4="imgui:313"},
   nonPOD={
     ImBitArray=true,
     ImColor=true,