Merge branch 'docking_inter'

generator.lua: fix missing void in Vulkan function generation

README.md

@@ -11,7 +11,7 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.91.6 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.91.9 of Dear ImGui with internal api]
 * only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
 * if you are interested in imgui backends you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
 * All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
@@ -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_dx11/main.c

@@ -24,6 +24,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;
 
 // Data

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_glfw_opengl3/main.c

@@ -17,6 +17,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;
 
 int main(int argc, char *argv[])

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)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	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)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
 
-if(SDL2_FOUND)
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
-		include_directories(${SDL2_INCLUDE_DIRS})
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-	else()#use new one SDL2 config
-		include_directories(${SDL_INCLUDE})
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
-	endif()
-else(SDL2_FOUND)
-	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)
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+#FetchContent_MakeAvailable(SDL2)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include})
+
+#if dynamic SDL2 then install
+install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+)
 
 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_opengl3/main.c

@@ -18,6 +18,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 SDL_Window *window = NULL;
 
 int main(int argc, char* argv[])

backend_test/example_sdl_vulkan/CMakeLists.txt

@@ -18,12 +18,12 @@ else()
 	set(TABLES_SOURCE "")
 endif()
 
-include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+include_directories(../../imgui ../../imgui/backends)
+
 
 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)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	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)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
 
-if(SDL2_FOUND)
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
-		include_directories(${SDL2_INCLUDE_DIRS})
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-	else()#use new one SDL2 config
-		include_directories(${SDL_INCLUDE})
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
-	endif()
-else(SDL2_FOUND)
-	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)
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include)
 
-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
-#include <windows.h>
+// Volk headers
+#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"
@@ -20,10 +26,18 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 #define IM_UNUSED(_VAR)  ((void)(_VAR))
 #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 +54,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 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)
+static void check_vk_result_line(VkResult err,int line)
 {
-    (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);
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d in line: (%d)\n", err, line);
+    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;
-
-  // Create Vulkan Instance
-  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);
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+    volkInitialize();
 #endif
 
-  // Select GPU
-  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++)
+    // Create Vulkan Instance
     {
-    VkPhysicalDeviceProperties properties;
-    vkGetPhysicalDeviceProperties(gpus[i], &properties);
-    if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+        VkInstanceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+
+        // 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;
-        break;
+            //instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+            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
     }
-
-  g_PhysicalDevice = gpus[use_gpu];
-  free(gpus);
-
+    // Select Physical Device (GPU)
+    g_PhysicalDevice = ImGui_ImplVulkanH_SelectPhysicalDevice(g_Instance);
+    IM_ASSERT(g_PhysicalDevice != VK_NULL_HANDLE);
     // Select graphics queue family
-  uint32_t count;
-  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);
+    g_QueueFamily = ImGui_ImplVulkanH_SelectQueueFamilyIndex(g_PhysicalDevice);
     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;
+        //device_extensions.push_back("VK_KHR_swapchain");
+        uint32_t device_extensions_count = 1;
+        const char** device_extensions = (const char**)malloc(device_extensions_count * sizeof(char*));
+        device_extensions[0] = "VK_KHR_swapchain";
+
+        // Enumerate physical device extension
+        uint32_t properties_count;
+        //ImVector<VkExtensionProperties> properties;
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, NULL);
+        //properties.resize(properties_count);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, properties);
+#ifdef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)){
+            //device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            device_extensions_count++;
+            device_extensions = realloc(device_extensions, device_extensions_count * sizeof(const char*)); 
+            assert(device_extensions);
+            device_extensions[device_extensions_count-1] = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+        }
+#endif
+
         const float queue_priority[] = { 1.0f };
-  VkDeviceQueueCreateInfo queue_info[1] = {
-    [0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-    [0].queueFamilyIndex = g_QueueFamily,
-    [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,
-  };
+        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(err);
+        check_vk_result_line(err, __LINE__);
         vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
-
+    }
     // Create Descriptor Pool
-  VkDescriptorPoolSize pool_sizes[] = {
-      { VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
-      { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
-      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
-      { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
-      { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
-      { VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
-      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
-      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
-      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
-      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
-      { VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
-  };
-  VkDescriptorPoolCreateInfo pool_info = {
-    .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,
+    // 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(err);
+        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,
-                              int width, int height)
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
 {
     wd->Surface = surface;
 
@@ -219,43 +249,33 @@ static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface
     }
 
     // Select Surface Format
-    const VkFormat requestSurfaceImageFormat[] = {
-        VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM,
-        VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM
-    };
+    const VkFormat requestSurfaceImageFormat[] = { 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(
-      g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat,
-      (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
 
     // Select Present Mode
-#ifdef IMGUI_UNLIMITED_FRAME_RATE
-    VkPresentModeKHR present_modes[] = {
-      VK_PRESENT_MODE_MAILBOX_KHR,VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR
-    };
+#ifdef APP_USE_UNLIMITED_FRAME_RATE
+    VkPresentModeKHR present_modes[] = { 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(
-      g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(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(
-      g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator,
-      width, height, g_MinImageCount);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(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)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
-  vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
-#endif // IMGUI_VULKAN_DEBUG_REPORT
+    PFN_vkDestroyDebugReportCallbackEXT f_vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
+    f_vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
+#endif // APP_USE_VULKAN_DEBUG_REPORT
 
     vkDestroyDevice(g_Device, g_Allocator);
     vkDestroyInstance(g_Instance, g_Allocator);
@@ -268,115 +288,125 @@ static void CleanupVulkanWindow()
 
 static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
 {
-  VkResult err;
-
-  VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores[wd->SemaphoreIndex].ImageAcquiredSemaphore;
-  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);
+    VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores.Data[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkResult 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;
-  }
-  check_vk_result(err);
+    if (err != VK_SUBOPTIMAL_KHR)
+        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);
-  VkCommandBufferBeginInfo info = {
-    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-  };
+        check_vk_result_line(err, __LINE__);
+        VkCommandBufferBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
         err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
-  check_vk_result(err);
-  VkRenderPassBeginInfo rp_info = {
-    .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-    .renderPass = wd->RenderPass,
-    .framebuffer = fd->Framebuffer,
-    .renderArea.extent.width = wd->Width,
-    .renderArea.extent.height = wd->Height,
-    .clearValueCount = 1,
-    .pClearValues = &wd->ClearValue,
-  };
-  vkCmdBeginRenderPass(fd->CommandBuffer, &rp_info, VK_SUBPASS_CONTENTS_INLINE);
+        check_vk_result_line(err, __LINE__);
+    }
+    {
+        VkRenderPassBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+        info.renderPass = wd->RenderPass;
+        info.framebuffer = fd->Framebuffer;
+        info.renderArea.extent.width = wd->Width;
+        info.renderArea.extent.height = wd->Height;
+        info.clearValueCount = 1;
+        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 = {
-    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-    .waitSemaphoreCount = 1,
-    .pWaitSemaphores = &image_acquired_semaphore,
-    .pWaitDstStageMask = &wait_stage,
-    .commandBufferCount = 1,
-    .pCommandBuffers = &fd->CommandBuffer,
-    .signalSemaphoreCount = 1,
-    .pSignalSemaphores = &render_complete_semaphore,
-  };
+        VkSubmitInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        info.waitSemaphoreCount = 1;
+        info.pWaitSemaphores = &image_acquired_semaphore;
+        info.pWaitDstStageMask = &wait_stage;
+        info.commandBufferCount = 1;
+        info.pCommandBuffers = &fd->CommandBuffer;
+        info.signalSemaphoreCount = 1;
+        info.pSignalSemaphores = &render_complete_semaphore;
 
         err = vkEndCommandBuffer(fd->CommandBuffer);
-  check_vk_result(err);
-  err = vkQueueSubmit(g_Queue, 1, &sub_info, fd->Fence);
-  check_vk_result(err);
+        check_vk_result_line(err, __LINE__);
+        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);
+        check_vk_result_line(err, __LINE__);
+    }
 }
 
 static void FramePresent(ImGui_ImplVulkanH_Window* wd)
 {
-  if (g_SwapChainRebuild) return;
-  VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
-  VkPresentInfoKHR info = {
-    .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-    .waitSemaphoreCount = 1,
-    .pWaitSemaphores = &render_complete_semaphore,
-    .swapchainCount = 1,
-    .pSwapchains = &wd->Swapchain,
-    .pImageIndices = &wd->FrameIndex,
-  };
+    if (g_SwapChainRebuild)
+        return;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkPresentInfoKHR info = {};
+    info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    info.waitSemaphoreCount = 1;
+    info.pWaitSemaphores = &render_complete_semaphore;
+    info.swapchainCount = 1;
+    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;
-  }
-  check_vk_result(err);
-  wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->ImageCount; // Now we can use the next set of semaphores
+    if (err != VK_SUBOPTIMAL_KHR)
+        check_vk_result_line(err, __LINE__);
+    wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->SemaphoreCount; // Now we can use the next set of semaphores
 }
 
+// Main code
 int main(int argc, char* argv[])
 {
-
-  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
-    SDL_Log("failed to init: %s", SDL_GetError());
+    //g_MainWindowData.ClearEnable = true;
+	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
+	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
-  SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN |
-    SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
-  SDL_Window* window = SDL_CreateWindow("cImGui SDL2+Vulkan example",
-    SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
-  if (window == NULL) {
-    SDL_Log("Failed to create window: %s", SDL_GetError());
+    // From 2.0.18: Enable native IME.
+#ifdef SDL_HINT_IME_SHOW_UI
+    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
+#endif
+
+    // Create window with Vulkan graphics context
+    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 +422,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
-  ImGuiIO* ioptr = igGetIO();
-  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;       // Enable Keyboard Controls
-  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //ImGui::StyleColorsLight();
+
+    // 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 = {
-    .Instance = g_Instance,
-    .PhysicalDevice = g_PhysicalDevice,
-    .Device = g_Device,
-    .QueueFamily = g_QueueFamily,
-    .Queue = g_Queue,
-    .PipelineCache = g_PipelineCache,
-    .DescriptorPool = g_DescriptorPool,
-    .Subpass = 0,
-    .MinImageCount = g_MinImageCount,
-    .ImageCount = wd->ImageCount,
-    .MSAASamples = VK_SAMPLE_COUNT_1_BIT,
-    .Allocator = g_Allocator,
-    .CheckVkResultFn = check_vk_result
-  };
-  ImGui_ImplVulkan_Init(&init_info, wd->RenderPass);
+    ImGui_ImplVulkan_InitInfo init_info = {};
+    init_info.Instance = g_Instance;
+    init_info.PhysicalDevice = g_PhysicalDevice;
+    init_info.Device = g_Device;
+    init_info.QueueFamily = g_QueueFamily;
+    init_info.Queue = g_Queue;
+    init_info.PipelineCache = g_PipelineCache;
+    init_info.DescriptorPool = g_DescriptorPool;
+    init_info.RenderPass = wd->RenderPass;
+    init_info.Subpass = 0;
+    init_info.MinImageCount = g_MinImageCount;
+    init_info.ImageCount = wd->ImageCount;
+    init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+    init_info.Allocator = g_Allocator;
+    init_info.CheckVkResultFn = check_vk_result;
+    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
-  // Use any command queue
-  VkCommandPool command_pool = wd->Frames[wd->FrameIndex].CommandPool;
-  VkCommandBuffer command_buffer = wd->Frames[wd->FrameIndex].CommandBuffer;
+    // Our state
+    bool show_demo_window = true;
+    bool show_another_window = false;
+    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);
-  check_vk_result(err);
-  VkCommandBufferBeginInfo begin_info = {
-    .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)
+    // Main loop
+    bool done = false;
+    while (!done)
     {
-    SDL_Event e;
-
-    // we need to call SDL_PollEvent to let window rendered, otherwise
-    // no window will be shown
-    while (SDL_PollEvent(&e) != 0)
+        // 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.
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+        // 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);
-      if (e.type == SDL_QUIT)
-        quit = true;
-      if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_CLOSE &&
-          e.window.windowID == SDL_GetWindowID(window))
-        quit = true;
+            ImGui_ImplSDL2_ProcessEvent(&event);
+            if (event.type == SDL_QUIT)
+                done = true;
+            if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
+                done = true;
+        }
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
         }
 
-    // Resize swap chain
-    if (g_SwapChainRebuild)
-    {
-        int width, height;
-        SDL_GetWindowSize(window, &width, &height);
-        if (width > 0 && height > 0)
+        // Resize swap chain?
+        int fb_width, fb_height;
+        SDL_GetWindowSize(window, &fb_width, &fb_height);
+        if (fb_width > 0 && fb_height > 0 && (g_SwapChainRebuild || g_MainWindowData.Width != fb_width || g_MainWindowData.Height != fb_height))
         {
             ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
-            ImGui_ImplVulkanH_CreateOrResizeWindow(
-              g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData,
-              g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, fb_width, fb_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)
-      igShowDemoWindow(&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!).
+        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("Another window", &showAnotherWindow);
+            igCheckbox("Demo window", &show_demo_window);
+            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 +559,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();
-    const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
-    if (!is_minimized)
+        ImDrawData* main_draw_data = igGetDrawData();
+        const bool main_is_minimized = (main_draw_data->DisplaySize.x <= 0.0f || main_draw_data->DisplaySize.y <= 0.0f);
+        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;
-        wd->ClearValue.color.float32[1] = clearColor.y * clearColor.w;
-        wd->ClearValue.color.float32[2] = clearColor.z * clearColor.w;
-        wd->ClearValue.color.float32[3] = clearColor.w;
-        FrameRender(wd, draw_data);
-        FramePresent(wd);
+            igUpdatePlatformWindows();
+            igRenderPlatformWindowsDefault(NULL, NULL);
         }
+
+        // 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.cpp

@@ -1,8 +1,7 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.91.6" 19160 from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.91.9b" 19191 from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
 //with imgui_freetype.h api
-//docking branch
 
 #include "./imgui/imgui.h"
 #ifdef IMGUI_ENABLE_FREETYPE
@@ -53,11 +52,11 @@ CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
 {
     return ImGui::SetCurrentContext(ctx);
 }
-CIMGUI_API ImGuiIO* igGetIO()
+CIMGUI_API ImGuiIO* igGetIO_Nil()
 {
     return &ImGui::GetIO();
 }
-CIMGUI_API ImGuiPlatformIO* igGetPlatformIO()
+CIMGUI_API ImGuiPlatformIO* igGetPlatformIO_Nil()
 {
     return &ImGui::GetPlatformIO();
 }
@@ -173,10 +172,6 @@ CIMGUI_API ImDrawList* igGetWindowDrawList()
 {
     return ImGui::GetWindowDrawList();
 }
-CIMGUI_API float igGetWindowDpiScale()
-{
-    return ImGui::GetWindowDpiScale();
-}
 CIMGUI_API void igGetWindowPos(ImVec2 *pOut)
 {
     *pOut = ImGui::GetWindowPos();
@@ -193,10 +188,6 @@ CIMGUI_API float igGetWindowHeight()
 {
     return ImGui::GetWindowHeight();
 }
-CIMGUI_API ImGuiViewport* igGetWindowViewport()
-{
-    return ImGui::GetWindowViewport();
-}
 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
 {
     return ImGui::SetNextWindowPos(pos,cond,pivot);
@@ -229,10 +220,6 @@ CIMGUI_API void igSetNextWindowBgAlpha(float alpha)
 {
     return ImGui::SetNextWindowBgAlpha(alpha);
 }
-CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id)
-{
-    return ImGui::SetNextWindowViewport(viewport_id);
-}
 CIMGUI_API void igSetWindowPos_Vec2(const ImVec2 pos,ImGuiCond cond)
 {
     return ImGui::SetWindowPos(pos,cond);
@@ -667,9 +654,13 @@ CIMGUI_API void igTextLinkOpenURL(const char* label,const char* url)
 {
     return ImGui::TextLinkOpenURL(label,url);
 }
-CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)
+CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1)
 {
-    return ImGui::Image(user_texture_id,image_size,uv0,uv1,tint_col,border_col);
+    return ImGui::Image(user_texture_id,image_size,uv0,uv1);
+}
+CIMGUI_API void igImageWithBg(ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)
+{
+    return ImGui::ImageWithBg(user_texture_id,image_size,uv0,uv1,bg_col,tint_col);
 }
 CIMGUI_API bool igImageButton(const char* str_id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)
 {
@@ -1281,30 +1272,6 @@ CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
 {
     return ImGui::SetTabItemClosed(tab_or_docked_window_label);
 }
-CIMGUI_API ImGuiID igDockSpace(ImGuiID dockspace_id,const ImVec2 size,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
-{
-    return ImGui::DockSpace(dockspace_id,size,flags,window_class);
-}
-CIMGUI_API ImGuiID igDockSpaceOverViewport(ImGuiID dockspace_id,const ImGuiViewport* viewport,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
-{
-    return ImGui::DockSpaceOverViewport(dockspace_id,viewport,flags,window_class);
-}
-CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id,ImGuiCond cond)
-{
-    return ImGui::SetNextWindowDockID(dock_id,cond);
-}
-CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class)
-{
-    return ImGui::SetNextWindowClass(window_class);
-}
-CIMGUI_API ImGuiID igGetWindowDockID()
-{
-    return ImGui::GetWindowDockID();
-}
-CIMGUI_API bool igIsWindowDocked()
-{
-    return ImGui::IsWindowDocked();
-}
 CIMGUI_API void igLogToTTY(int auto_open_depth)
 {
     return ImGui::LogToTTY(auto_open_depth);
@@ -1461,13 +1428,13 @@ CIMGUI_API ImGuiViewport* igGetMainViewport()
 {
     return ImGui::GetMainViewport();
 }
-CIMGUI_API ImDrawList* igGetBackgroundDrawList(ImGuiViewport* viewport)
+CIMGUI_API ImDrawList* igGetBackgroundDrawList_Nil()
 {
-    return ImGui::GetBackgroundDrawList(viewport);
+    return ImGui::GetBackgroundDrawList();
 }
-CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport)
+CIMGUI_API ImDrawList* igGetForegroundDrawList_Nil()
 {
-    return ImGui::GetForegroundDrawList(viewport);
+    return ImGui::GetForegroundDrawList();
 }
 CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size)
 {
@@ -1577,6 +1544,10 @@ CIMGUI_API bool igIsMouseDoubleClicked_Nil(ImGuiMouseButton button)
 {
     return ImGui::IsMouseDoubleClicked(button);
 }
+CIMGUI_API bool igIsMouseReleasedWithDelay(ImGuiMouseButton button,float delay)
+{
+    return ImGui::IsMouseReleasedWithDelay(button,delay);
+}
 CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button)
 {
     return ImGui::GetMouseClickedCount(button);
@@ -1692,26 +1663,6 @@ CIMGUI_API void igMemFree(void* ptr)
 {
     return ImGui::MemFree(ptr);
 }
-CIMGUI_API void igUpdatePlatformWindows()
-{
-    return ImGui::UpdatePlatformWindows();
-}
-CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_render_arg,void* renderer_render_arg)
-{
-    return ImGui::RenderPlatformWindowsDefault(platform_render_arg,renderer_render_arg);
-}
-CIMGUI_API void igDestroyPlatformWindows()
-{
-    return ImGui::DestroyPlatformWindows();
-}
-CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id)
-{
-    return ImGui::FindViewportByID(id);
-}
-CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle)
-{
-    return ImGui::FindViewportByPlatformHandle(platform_handle);
-}
 CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void)
 {
     return IM_NEW(ImGuiTableSortSpecs)();
@@ -1764,10 +1715,6 @@ CIMGUI_API void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self,ImGuiMouseSource sourc
 {
     return self->AddMouseSourceEvent(source);
 }
-CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self,ImGuiID id)
-{
-    return self->AddMouseViewportEvent(id);
-}
 CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self,bool focused)
 {
     return self->AddFocusEvent(focused);
@@ -1840,14 +1787,6 @@ CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackDa
 {
     return self->HasSelection();
 }
-CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void)
-{
-    return IM_NEW(ImGuiWindowClass)();
-}
-CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self)
-{
-    IM_DELETE(self);
-}
 CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
 {
     return IM_NEW(ImGuiPayload)();
@@ -1956,6 +1895,10 @@ CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self)
 {
     return self->clear();
 }
+CIMGUI_API void ImGuiTextBuffer_resize(ImGuiTextBuffer* self,int size)
+{
+    return self->resize(size);
+}
 CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity)
 {
     return self->reserve(capacity);
@@ -2596,14 +2539,14 @@ CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
 {
     return self->ClearInputData();
 }
-CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
-{
-    return self->ClearTexData();
-}
 CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self)
 {
     return self->ClearFonts();
 }
+CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
+{
+    return self->ClearTexData();
+}
 CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
 {
     return self->Clear();
@@ -2680,10 +2623,6 @@ CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlas
 {
     return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
 }
-CIMGUI_API bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])
-{
-    return self->GetMouseCursorTexData(cursor,out_offset,out_size,out_uv_border,out_uv_fill);
-}
 CIMGUI_API ImFont* ImFont_ImFont(void)
 {
     return IM_NEW(ImFont)();
@@ -2692,11 +2631,11 @@ CIMGUI_API void ImFont_destroy(ImFont* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
+CIMGUI_API ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
 {
     return self->FindGlyph(c);
 }
-CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
+CIMGUI_API ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
 {
     return self->FindGlyphNoFallback(c);
 }
@@ -2748,10 +2687,6 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool ov
 {
     return self->AddRemapChar(dst,src,overwrite_dst);
 }
-CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self,ImWchar c,bool visible)
-{
-    return self->SetGlyphVisible(c,visible);
-}
 CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,unsigned int c_begin,unsigned int c_last)
 {
     return self->IsGlyphRangeUnused(c_begin,c_last);
@@ -2780,14 +2715,6 @@ CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(void)
-{
-    return IM_NEW(ImGuiPlatformMonitor)();
-}
-CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self)
-{
-    IM_DELETE(self);
-}
 CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(void)
 {
     return IM_NEW(ImGuiPlatformImeData)();
@@ -2824,6 +2751,10 @@ CIMGUI_API int igImUpperPowerOfTwo(int v)
 {
     return ImUpperPowerOfTwo(v);
 }
+CIMGUI_API unsigned int igImCountSetBits(unsigned int v)
+{
+    return ImCountSetBits(v);
+}
 CIMGUI_API int igImStricmp(const char* str1,const char* str2)
 {
     return ImStricmp(str1,str2);
@@ -3403,7 +3334,7 @@ CIMGUI_API void ImDrawDataBuilder_destroy(ImDrawDataBuilder* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void* ImGuiDataVarInfo_GetVarPtr(ImGuiDataVarInfo* self,void* parent)
+CIMGUI_API void* ImGuiStyleVarInfo_GetVarPtr(ImGuiStyleVarInfo* self,void* parent)
 {
     return self->GetVarPtr(parent);
 }
@@ -3719,70 +3650,6 @@ CIMGUI_API void ImGuiMultiSelectState_destroy(ImGuiMultiSelectState* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API ImGuiDockNode* ImGuiDockNode_ImGuiDockNode(ImGuiID id)
-{
-    return IM_NEW(ImGuiDockNode)(id);
-}
-CIMGUI_API void ImGuiDockNode_destroy(ImGuiDockNode* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool ImGuiDockNode_IsRootNode(ImGuiDockNode* self)
-{
-    return self->IsRootNode();
-}
-CIMGUI_API bool ImGuiDockNode_IsDockSpace(ImGuiDockNode* self)
-{
-    return self->IsDockSpace();
-}
-CIMGUI_API bool ImGuiDockNode_IsFloatingNode(ImGuiDockNode* self)
-{
-    return self->IsFloatingNode();
-}
-CIMGUI_API bool ImGuiDockNode_IsCentralNode(ImGuiDockNode* self)
-{
-    return self->IsCentralNode();
-}
-CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(ImGuiDockNode* self)
-{
-    return self->IsHiddenTabBar();
-}
-CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self)
-{
-    return self->IsNoTabBar();
-}
-CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self)
-{
-    return self->IsSplitNode();
-}
-CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self)
-{
-    return self->IsLeafNode();
-}
-CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self)
-{
-    return self->IsEmpty();
-}
-CIMGUI_API void ImGuiDockNode_Rect(ImRect *pOut,ImGuiDockNode* self)
-{
-    *pOut = self->Rect();
-}
-CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,ImGuiDockNodeFlags flags)
-{
-    return self->SetLocalFlags(flags);
-}
-CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self)
-{
-    return self->UpdateMergedFlags();
-}
-CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void)
-{
-    return IM_NEW(ImGuiDockContext)();
-}
-CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self)
-{
-    IM_DELETE(self);
-}
 CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void)
 {
     return IM_NEW(ImGuiViewportP)();
@@ -3791,10 +3658,6 @@ CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self)
-{
-    return self->ClearRequestFlags();
-}
 CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min)
 {
     *pOut = self->CalcWorkRectPos(inset_min);
@@ -3991,13 +3854,13 @@ CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiT
 {
     return self->GetColumnSettings();
 }
-CIMGUI_API ImGuiIO* igGetIOEx(ImGuiContext* ctx)
+CIMGUI_API ImGuiIO* igGetIO_ContextPtr(ImGuiContext* ctx)
 {
-    return &ImGui::GetIOEx(ctx);
+    return &ImGui::GetIO(ctx);
 }
-CIMGUI_API ImGuiPlatformIO* igGetPlatformIOEx(ImGuiContext* ctx)
+CIMGUI_API ImGuiPlatformIO* igGetPlatformIO_ContextPtr(ImGuiContext* ctx)
 {
-    return &ImGui::GetPlatformIOEx(ctx);
+    return &ImGui::GetPlatformIO(ctx);
 }
 CIMGUI_API ImGuiWindow* igGetCurrentWindowRead()
 {
@@ -4027,9 +3890,9 @@ CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2 *pOut,ImGuiWindow* window)
 {
     *pOut = ImGui::CalcWindowNextAutoFitSize(window);
 }
-CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy)
+CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy)
 {
-    return ImGui::IsWindowChildOf(window,potential_parent,popup_hierarchy,dock_hierarchy);
+    return ImGui::IsWindowChildOf(window,potential_parent,popup_hierarchy);
 }
 CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,ImGuiWindow* potential_parent)
 {
@@ -4127,10 +3990,22 @@ CIMGUI_API ImFont* igGetDefaultFont()
 {
     return ImGui::GetDefaultFont();
 }
+CIMGUI_API void igPushPasswordFont()
+{
+    return ImGui::PushPasswordFont();
+}
 CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window)
 {
     return ImGui::GetForegroundDrawList(window);
 }
+CIMGUI_API ImDrawList* igGetBackgroundDrawList_ViewportPtr(ImGuiViewport* viewport)
+{
+    return ImGui::GetBackgroundDrawList(viewport);
+}
+CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport)
+{
+    return ImGui::GetForegroundDrawList(viewport);
+}
 CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,ImVector_ImDrawListPtr* out_list,ImDrawList* draw_list)
 {
     return ImGui::AddDrawListToDrawDataEx(draw_data,out_list,draw_list);
@@ -4159,10 +4034,6 @@ CIMGUI_API void igStartMouseMovingWindow(ImGuiWindow* window)
 {
     return ImGui::StartMouseMovingWindow(window);
 }
-CIMGUI_API void igStartMouseMovingWindowOrNode(ImGuiWindow* window,ImGuiDockNode* node,bool undock)
-{
-    return ImGui::StartMouseMovingWindowOrNode(window,node,undock);
-}
 CIMGUI_API void igUpdateMouseMovingWindowNewFrame()
 {
     return ImGui::UpdateMouseMovingWindowNewFrame();
@@ -4183,34 +4054,14 @@ CIMGUI_API void igCallContextHooks(ImGuiContext* context,ImGuiContextHookType ty
 {
     return ImGui::CallContextHooks(context,type);
 }
-CIMGUI_API void igTranslateWindowsInViewport(ImGuiViewportP* viewport,const ImVec2 old_pos,const ImVec2 new_pos,const ImVec2 old_size,const ImVec2 new_size)
-{
-    return ImGui::TranslateWindowsInViewport(viewport,old_pos,new_pos,old_size,new_size);
-}
 CIMGUI_API void igScaleWindowsInViewport(ImGuiViewportP* viewport,float scale)
 {
     return ImGui::ScaleWindowsInViewport(viewport,scale);
 }
-CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport)
-{
-    return ImGui::DestroyPlatformWindow(viewport);
-}
 CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
 {
     return ImGui::SetWindowViewport(window,viewport);
 }
-CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
-{
-    return ImGui::SetCurrentViewport(window,viewport);
-}
-CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(ImGuiViewport* viewport)
-{
-    return ImGui::GetViewportPlatformMonitor(viewport);
-}
-CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(const ImVec2 mouse_platform_pos)
-{
-    return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos);
-}
 CIMGUI_API void igMarkIniSettingsDirty_Nil()
 {
     return ImGui::MarkIniSettingsDirty();
@@ -4371,9 +4222,9 @@ CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID id)
 {
     return ImGui::IsClippedEx(bb,id);
 }
-CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags in_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect)
+CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags item_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect)
 {
-    return ImGui::SetLastItemData(item_id,in_flags,status_flags,item_rect);
+    return ImGui::SetLastItemData(item_id,item_flags,status_flags,item_rect);
 }
 CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h)
 {
@@ -4391,7 +4242,7 @@ CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,int count,float width
 {
     return ImGui::ShrinkWidths(items,count,width_excess);
 }
-CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx)
+CIMGUI_API const ImGuiStyleVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx)
 {
     return ImGui::GetStyleVarInfo(idx);
 }
@@ -4427,6 +4278,10 @@ CIMGUI_API bool igBeginPopupEx(ImGuiID id,ImGuiWindowFlags extra_window_flags)
 {
     return ImGui::BeginPopupEx(id,extra_window_flags);
 }
+CIMGUI_API bool igBeginPopupMenuEx(ImGuiID id,const char* label,ImGuiWindowFlags extra_window_flags)
+{
+    return ImGui::BeginPopupMenuEx(id,label,extra_window_flags);
+}
 CIMGUI_API void igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::OpenPopupEx(id,popup_flags);
@@ -4739,174 +4594,6 @@ CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(ImGuiKeyChord key_chord
 {
     return ImGui::GetShortcutRoutingData(key_chord);
 }
-CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx)
-{
-    return ImGui::DockContextInitialize(ctx);
-}
-CIMGUI_API void igDockContextShutdown(ImGuiContext* ctx)
-{
-    return ImGui::DockContextShutdown(ctx);
-}
-CIMGUI_API void igDockContextClearNodes(ImGuiContext* ctx,ImGuiID root_id,bool clear_settings_refs)
-{
-    return ImGui::DockContextClearNodes(ctx,root_id,clear_settings_refs);
-}
-CIMGUI_API void igDockContextRebuildNodes(ImGuiContext* ctx)
-{
-    return ImGui::DockContextRebuildNodes(ctx);
-}
-CIMGUI_API void igDockContextNewFrameUpdateUndocking(ImGuiContext* ctx)
-{
-    return ImGui::DockContextNewFrameUpdateUndocking(ctx);
-}
-CIMGUI_API void igDockContextNewFrameUpdateDocking(ImGuiContext* ctx)
-{
-    return ImGui::DockContextNewFrameUpdateDocking(ctx);
-}
-CIMGUI_API void igDockContextEndFrame(ImGuiContext* ctx)
-{
-    return ImGui::DockContextEndFrame(ctx);
-}
-CIMGUI_API ImGuiID igDockContextGenNodeID(ImGuiContext* ctx)
-{
-    return ImGui::DockContextGenNodeID(ctx);
-}
-CIMGUI_API void igDockContextQueueDock(ImGuiContext* ctx,ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,float split_ratio,bool split_outer)
-{
-    return ImGui::DockContextQueueDock(ctx,target,target_node,payload,split_dir,split_ratio,split_outer);
-}
-CIMGUI_API void igDockContextQueueUndockWindow(ImGuiContext* ctx,ImGuiWindow* window)
-{
-    return ImGui::DockContextQueueUndockWindow(ctx,window);
-}
-CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,ImGuiDockNode* node)
-{
-    return ImGui::DockContextQueueUndockNode(ctx,node);
-}
-CIMGUI_API void igDockContextProcessUndockWindow(ImGuiContext* ctx,ImGuiWindow* window,bool clear_persistent_docking_ref)
-{
-    return ImGui::DockContextProcessUndockWindow(ctx,window,clear_persistent_docking_ref);
-}
-CIMGUI_API void igDockContextProcessUndockNode(ImGuiContext* ctx,ImGuiDockNode* node)
-{
-    return ImGui::DockContextProcessUndockNode(ctx,node);
-}
-CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)
-{
-    return ImGui::DockContextCalcDropPosForDocking(target,target_node,payload_window,payload_node,split_dir,split_outer,out_pos);
-}
-CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,ImGuiID id)
-{
-    return ImGui::DockContextFindNodeByID(ctx,id);
-}
-CIMGUI_API void igDockNodeWindowMenuHandler_Default(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar)
-{
-    return ImGui::DockNodeWindowMenuHandler_Default(ctx,node,tab_bar);
-}
-CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node)
-{
-    return ImGui::DockNodeBeginAmendTabBar(node);
-}
-CIMGUI_API void igDockNodeEndAmendTabBar()
-{
-    return ImGui::DockNodeEndAmendTabBar();
-}
-CIMGUI_API ImGuiDockNode* igDockNodeGetRootNode(ImGuiDockNode* node)
-{
-    return ImGui::DockNodeGetRootNode(node);
-}
-CIMGUI_API bool igDockNodeIsInHierarchyOf(ImGuiDockNode* node,ImGuiDockNode* parent)
-{
-    return ImGui::DockNodeIsInHierarchyOf(node,parent);
-}
-CIMGUI_API int igDockNodeGetDepth(const ImGuiDockNode* node)
-{
-    return ImGui::DockNodeGetDepth(node);
-}
-CIMGUI_API ImGuiID igDockNodeGetWindowMenuButtonId(const ImGuiDockNode* node)
-{
-    return ImGui::DockNodeGetWindowMenuButtonId(node);
-}
-CIMGUI_API ImGuiDockNode* igGetWindowDockNode()
-{
-    return ImGui::GetWindowDockNode();
-}
-CIMGUI_API bool igGetWindowAlwaysWantOwnTabBar(ImGuiWindow* window)
-{
-    return ImGui::GetWindowAlwaysWantOwnTabBar(window);
-}
-CIMGUI_API void igBeginDocked(ImGuiWindow* window,bool* p_open)
-{
-    return ImGui::BeginDocked(window,p_open);
-}
-CIMGUI_API void igBeginDockableDragDropSource(ImGuiWindow* window)
-{
-    return ImGui::BeginDockableDragDropSource(window);
-}
-CIMGUI_API void igBeginDockableDragDropTarget(ImGuiWindow* window)
-{
-    return ImGui::BeginDockableDragDropTarget(window);
-}
-CIMGUI_API void igSetWindowDock(ImGuiWindow* window,ImGuiID dock_id,ImGuiCond cond)
-{
-    return ImGui::SetWindowDock(window,dock_id,cond);
-}
-CIMGUI_API void igDockBuilderDockWindow(const char* window_name,ImGuiID node_id)
-{
-    return ImGui::DockBuilderDockWindow(window_name,node_id);
-}
-CIMGUI_API ImGuiDockNode* igDockBuilderGetNode(ImGuiID node_id)
-{
-    return ImGui::DockBuilderGetNode(node_id);
-}
-CIMGUI_API ImGuiDockNode* igDockBuilderGetCentralNode(ImGuiID node_id)
-{
-    return ImGui::DockBuilderGetCentralNode(node_id);
-}
-CIMGUI_API ImGuiID igDockBuilderAddNode(ImGuiID node_id,ImGuiDockNodeFlags flags)
-{
-    return ImGui::DockBuilderAddNode(node_id,flags);
-}
-CIMGUI_API void igDockBuilderRemoveNode(ImGuiID node_id)
-{
-    return ImGui::DockBuilderRemoveNode(node_id);
-}
-CIMGUI_API void igDockBuilderRemoveNodeDockedWindows(ImGuiID node_id,bool clear_settings_refs)
-{
-    return ImGui::DockBuilderRemoveNodeDockedWindows(node_id,clear_settings_refs);
-}
-CIMGUI_API void igDockBuilderRemoveNodeChildNodes(ImGuiID node_id)
-{
-    return ImGui::DockBuilderRemoveNodeChildNodes(node_id);
-}
-CIMGUI_API void igDockBuilderSetNodePos(ImGuiID node_id,ImVec2 pos)
-{
-    return ImGui::DockBuilderSetNodePos(node_id,pos);
-}
-CIMGUI_API void igDockBuilderSetNodeSize(ImGuiID node_id,ImVec2 size)
-{
-    return ImGui::DockBuilderSetNodeSize(node_id,size);
-}
-CIMGUI_API ImGuiID igDockBuilderSplitNode(ImGuiID node_id,ImGuiDir split_dir,float size_ratio_for_node_at_dir,ImGuiID* out_id_at_dir,ImGuiID* out_id_at_opposite_dir)
-{
-    return ImGui::DockBuilderSplitNode(node_id,split_dir,size_ratio_for_node_at_dir,out_id_at_dir,out_id_at_opposite_dir);
-}
-CIMGUI_API void igDockBuilderCopyDockSpace(ImGuiID src_dockspace_id,ImGuiID dst_dockspace_id,ImVector_const_charPtr* in_window_remap_pairs)
-{
-    return ImGui::DockBuilderCopyDockSpace(src_dockspace_id,dst_dockspace_id,in_window_remap_pairs);
-}
-CIMGUI_API void igDockBuilderCopyNode(ImGuiID src_node_id,ImGuiID dst_node_id,ImVector_ImGuiID* out_node_remap_pairs)
-{
-    return ImGui::DockBuilderCopyNode(src_node_id,dst_node_id,out_node_remap_pairs);
-}
-CIMGUI_API void igDockBuilderCopyWindowSettings(const char* src_name,const char* dst_name)
-{
-    return ImGui::DockBuilderCopyWindowSettings(src_name,dst_name);
-}
-CIMGUI_API void igDockBuilderFinish(ImGuiID node_id)
-{
-    return ImGui::DockBuilderFinish(node_id);
-}
 CIMGUI_API void igPushFocusScope(ImGuiID id)
 {
     return ImGui::PushFocusScope(id);
@@ -5243,10 +4930,6 @@ CIMGUI_API ImGuiTabItem* igTabBarFindTabByOrder(ImGuiTabBar* tab_bar,int order)
 {
     return ImGui::TabBarFindTabByOrder(tab_bar,order);
 }
-CIMGUI_API ImGuiTabItem* igTabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar)
-{
-    return ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar);
-}
 CIMGUI_API ImGuiTabItem* igTabBarGetCurrentTab(ImGuiTabBar* tab_bar)
 {
     return ImGui::TabBarGetCurrentTab(tab_bar);
@@ -5259,10 +4942,6 @@ CIMGUI_API const char* igTabBarGetTabName(ImGuiTabBar* tab_bar,ImGuiTabItem* tab
 {
     return ImGui::TabBarGetTabName(tab_bar,tab);
 }
-CIMGUI_API void igTabBarAddTab(ImGuiTabBar* tab_bar,ImGuiTabItemFlags tab_flags,ImGuiWindow* window)
-{
-    return ImGui::TabBarAddTab(tab_bar,tab_flags,window);
-}
 CIMGUI_API void igTabBarRemoveTab(ImGuiTabBar* tab_bar,ImGuiID tab_id)
 {
     return ImGui::TabBarRemoveTab(tab_bar,tab_id);
@@ -5295,6 +4974,10 @@ CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,
 {
     return ImGui::TabItemEx(tab_bar,label,p_open,flags,docked_window);
 }
+CIMGUI_API void igTabItemSpacing(const char* str_id,ImGuiTabItemFlags flags,float width)
+{
+    return ImGui::TabItemSpacing(str_id,flags,width);
+}
 CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker)
 {
     *pOut = ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker);
@@ -5371,10 +5054,6 @@ CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,ImVec2 pos,ImVec2
 {
     return ImGui::RenderArrowPointingAt(draw_list,pos,half_sz,direction,col);
 }
-CIMGUI_API void igRenderArrowDockMenu(ImDrawList* draw_list,ImVec2 p_min,float sz,ImU32 col)
-{
-    return ImGui::RenderArrowDockMenu(draw_list,p_min,sz,col);
-}
 CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,const ImRect rect,ImU32 col,float x_start_norm,float x_end_norm,float rounding)
 {
     return ImGui::RenderRectFilledRangeH(draw_list,rect,col,x_start_norm,x_end_norm,rounding);
@@ -5383,10 +5062,6 @@ CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,const ImRect ou
 {
     return ImGui::RenderRectFilledWithHole(draw_list,outer,inner,col,rounding);
 }
-CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,const ImRect r_outer,float threshold)
-{
-    return ImGui::CalcRoundingFlagsForRectInRect(r_in,r_outer,threshold);
-}
 CIMGUI_API void igTextEx(const char* text,const char* text_end,ImGuiTextFlags flags)
 {
     return ImGui::TextEx(text,text_end,flags);
@@ -5423,9 +5098,9 @@ CIMGUI_API bool igCloseButton(ImGuiID id,const ImVec2 pos)
 {
     return ImGui::CloseButton(id,pos);
 }
-CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node)
+CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos)
 {
-    return ImGui::CollapseButton(id,pos,dock_node);
+    return ImGui::CollapseButton(id,pos);
 }
 CIMGUI_API void igScrollbar(ImGuiAxis axis)
 {
@@ -5543,6 +5218,10 @@ CIMGUI_API void igSetNextItemRefVal(ImGuiDataType data_type,void* p_data)
 {
     return ImGui::SetNextItemRefVal(data_type,p_data);
 }
+CIMGUI_API bool igIsItemActiveAsInputText()
+{
+    return ImGui::IsItemActiveAsInputText();
+}
 CIMGUI_API void igColorTooltip(const char* text,const float* col,ImGuiColorEditFlags flags)
 {
     return ImGui::ColorTooltip(text,col,flags);
@@ -5671,10 +5350,6 @@ CIMGUI_API void igDebugNodeColumns(ImGuiOldColumns* columns)
 {
     return ImGui::DebugNodeColumns(columns);
 }
-CIMGUI_API void igDebugNodeDockNode(ImGuiDockNode* node,const char* label)
-{
-    return ImGui::DebugNodeDockNode(node,label);
-}
 CIMGUI_API void igDebugNodeDrawList(ImGuiWindow* window,ImGuiViewportP* viewport,const ImDrawList* draw_list,const char* label)
 {
     return ImGui::DebugNodeDrawList(window,viewport,draw_list,label);
@@ -5739,10 +5414,6 @@ CIMGUI_API void igDebugNodeViewport(ImGuiViewportP* viewport)
 {
     return ImGui::DebugNodeViewport(viewport);
 }
-CIMGUI_API void igDebugNodePlatformMonitor(ImGuiPlatformMonitor* monitor,const char* label,int idx)
-{
-    return ImGui::DebugNodePlatformMonitor(monitor,label,idx);
-}
 CIMGUI_API void igDebugRenderKeyboardPreview(ImDrawList* draw_list)
 {
     return ImGui::DebugRenderKeyboardPreview(draw_list);
@@ -5755,17 +5426,17 @@ CIMGUI_API const ImFontBuilderIO* igImFontAtlasGetBuilderForStbTruetype()
 {
     return ImFontAtlasGetBuilderForStbTruetype();
 }
-CIMGUI_API void igImFontAtlasUpdateConfigDataPointers(ImFontAtlas* atlas)
+CIMGUI_API void igImFontAtlasUpdateSourcesPointers(ImFontAtlas* atlas)
 {
-    return ImFontAtlasUpdateConfigDataPointers(atlas);
+    return ImFontAtlasUpdateSourcesPointers(atlas);
 }
 CIMGUI_API void igImFontAtlasBuildInit(ImFontAtlas* atlas)
 {
     return ImFontAtlasBuildInit(atlas);
 }
-CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,ImFont* font,ImFontConfig* font_config,float ascent,float descent)
+CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,ImFont* font,ImFontConfig* src,float ascent,float descent)
 {
-    return ImFontAtlasBuildSetupFont(atlas,font,font_config,ascent,descent);
+    return ImFontAtlasBuildSetupFont(atlas,font,src,ascent,descent);
 }
 CIMGUI_API void igImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas,void* stbrp_context_opaque)
 {
@@ -5791,6 +5462,14 @@ CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[2
 {
     return ImFontAtlasBuildMultiplyRectAlpha8(table,pixels,x,y,w,h,stride);
 }
+CIMGUI_API void igImFontAtlasBuildGetOversampleFactors(const ImFontConfig* src,int* out_oversample_h,int* out_oversample_v)
+{
+    return ImFontAtlasBuildGetOversampleFactors(src,out_oversample_h,out_oversample_v);
+}
+CIMGUI_API bool igImFontAtlasGetMouseCursorTexData(ImFontAtlas* atlas,ImGuiMouseCursor cursor_type,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])
+{
+    return ImFontAtlasGetMouseCursorTexData(atlas,cursor_type,out_offset,out_size,out_uv_border,out_uv_fill);
+}
 #ifdef IMGUI_ENABLE_FREETYPE
 CIMGUI_API const ImFontBuilderIO* ImGuiFreeType_GetBuilderForFreeType()
 {
@@ -5807,7 +5486,7 @@ CIMGUI_API void ImGuiFreeType_SetAllocatorFunctions(void*(*alloc_func)(size_t sz
 
 
 /////////////////////////////manual written functions
-CIMGUI_API void igLogText(CONST char *fmt, ...)
+CIMGUI_API void igLogText(const char *fmt, ...)
 {
     char buffer[256];
     va_list args;
@@ -5817,11 +5496,11 @@ CIMGUI_API void igLogText(CONST char *fmt, ...)
 
     ImGui::LogText("%s", buffer);
 }
-CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
+CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
-    buffer->appendfv(fmt, args);
+    self->appendfv(fmt, args);
     va_end(args);
 }
 

cimgui_impl.cpp

@@ -0,0 +1,46 @@
+#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_GLFW
+#include "imgui_impl_glfw.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL3
+#include "imgui_impl_opengl3.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL2
+#include "imgui_impl_opengl2.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
+
+#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,199 @@
+#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
+{
+    uint32_t ApiVersion;
+    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;
+    VkPipeline Pipeline;
+    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(uint32_t api_version,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* wnd,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* wnd,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(void);
+
+#endif

generator/cimgui_impl_template.cpp

@@ -0,0 +1,23 @@
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+GENERATED_PLACEHOLDER
+
+#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

generator/cimgui_template.cpp

@@ -12,7 +12,7 @@
 
 
 /////////////////////////////manual written functions
-CIMGUI_API void igLogText(CONST char *fmt, ...)
+CIMGUI_API void igLogText(const char *fmt, ...)
 {
     char buffer[256];
     va_list args;
@@ -22,11 +22,11 @@ CIMGUI_API void igLogText(CONST char *fmt, ...)
 
     ImGui::LogText("%s", buffer);
 }
-CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
+CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
-    buffer->appendfv(fmt, args);
+    self->appendfv(fmt, args);
     va_end(args);
 }
 

generator/cimgui_template.h

@@ -49,7 +49,7 @@ typedef union SDL_Event SDL_Event;
 //no LogTextV
 CIMGUI_API void igLogText(const char *fmt, ...);
 //no appendfV
-CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
+CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...);
 //for getting FLT_MAX in bindings
 CIMGUI_API float igGET_FLT_MAX(void);
 //for getting FLT_MIN in bindings

generator/cpp2ffi.lua

@@ -320,6 +320,9 @@ local function getRE()
 	function_re = "^([^;{}]+%b()[\n%s]*;)%s*",
 	function_re = "^([^;{}=]+%b()[\n%s%w]*;)", --const at the end
 	function_re = "^([^;{}=]+%b()[\n%s%w%(%)_]*;)", --attribute(deprecated)
+	--we need to skip = as function because of "var = f()" initialization in struct fields
+	-- but we don want operator== to appear as a var and as we should skip this kind of function solution is:
+	operator_re = "^([^;{}]+operator[^;{}]+%b()[\n%s%w%(%)_]*;)",
 	struct_re = "^([^;{}]-struct[^;{}]-%b{}[%s%w_%(%)]*;)",
 	enum_re = "^([^;{}]-enum[^;{}]-%b{}[%s%w_%(%)]*;)",
 	union_re = "^([^;{}]-union[^;{}]-%b{}[%s%w_%(%)]*;)",
@@ -344,7 +347,7 @@ local function getRE()
 	}
 	
 	local resN = {"comment2_re","comment_re","emptyline_re",
-	"functypedef_re","functype_re","function_re","functionD_re","typedef_st_re","struct_re","enum_re","union_re","namespace_re","class_re","typedef_re","vardef_re"}
+	"functypedef_re","functype_re","function_re","functionD_re","operator_re","typedef_st_re","struct_re","enum_re","union_re","namespace_re","class_re","typedef_re","vardef_re"}
 	
 	return res,resN
 end
@@ -600,7 +603,7 @@ local function clean_names_from_signature(self,signat)
 	return result
 end
 local function clean_functypedef(line)
-	local first, args = line:match("(typedef .-%(%*[_%w]+%))%s*(%b())")
+	local first, args = line:match("(typedef .-%(%*%s*[_%w]+%))%s*(%b())")
 
 	if not args then
 		print"not getting args in"
@@ -946,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 = {}
@@ -1042,7 +1070,39 @@ local function ADDIMSTR_S(FP)
     end
 	FP.funcdefs = newcdefs
 end
+--this creates defsBystruct in case you need to list by struct container
+local function DefsByStruct(FP)
+    local structs = {}
+    for fun,defs in pairs(FP.defsT) do
+        local stname = defs[1].stname
+        structs[stname] = structs[stname] or {}
+        table.insert(structs[stname],defs)--fun)
+    end
+    return structs
+end  
+local function get_nonPOD(FP)
+	local defbystruct = DefsByStruct(FP)
+	--M.prtable(defbystruct)
+	local nonPOD = {}
+	for k,defs in pairs(defbystruct) do 
+		if k~="" then
+		for i, ww in ipairs(defs) do
+			-- print(k,i,ww)
+			-- M.prtable(ww)
+			if not ww[1].ret then --constructor
+				nonPOD[k] = true
+				break;
+			end
+		end
+		end
+	end
+	FP.structs_and_enums_table.nonPOD = nonPOD
+	return nonPOD
+end
 local function ADDnonUDT(FP)
+	local nonPOD = get_nonPOD(FP)
+	--print"nonPOD"
+	--M.prtable(nonPOD)
     local defsT = FP.defsT
     --local newcdefs = {}
     for numcdef,t in ipairs(FP.funcdefs) do
@@ -1056,10 +1116,17 @@ local function ADDnonUDT(FP)
 		end
         --if UDT return generate nonUDT version
 		local isUDT = false
-		for _,udt_ret in ipairs(FP.UDTs) do
-			if udt_ret == defT.ret then isUDT=true;break end
+		--isUDT = FP.structs_and_enums_table.structs[defT.ret] and true or false
+		isUDT = nonPOD[defT.ret] and true or false
+		--inherited
+		if (not isUDT) and FP.cimgui_inherited and FP.cimgui_inherited.nonPOD[defT.ret] then
+			isUDT = true
 		end
-        --if defT.ret=="ImVec2" or defT.ret=="ImVec4" or defT.ret=="ImColor" then
+		for _,udt_ret in ipairs(FP.UDTs) do
+			if udt_ret == defT.ret then isUDT=true; break end
+		end
+
+
 		if isUDT then
             --passing as a pointer arg
             local defT2 = {}
@@ -1425,6 +1492,7 @@ function M.Parser()
 		--save_data("./preparse"..tostring(self):gsub("table: ","")..".c",txt)
 		--]]
 		self.itemsarr = par:parseItemsR2(txt)
+		--save_data("./itemsarr.lua",ToStr(self.itemsarr))
 		itemsarr = self.itemsarr
 	end
 	
@@ -1471,10 +1539,13 @@ function M.Parser()
 		local predeclare = ""
 		--local iner = strip_end(stru:match("%b{}"):sub(2,-2))
 		local inistruct = clean_spaces(stru:match("(.-)%b{}"))
+		--clean final:
+		inistruct = inistruct:gsub("%s*final%s*:",":")
 		--local stname = stru:match("struct%s*(%S+)%s*%b{}")
 		local stname, derived
 		if inistruct:match":" then
 			stname,derived = inistruct:match"struct%s*([^%s:]+):(.+)"
+			--print(inistruct,stname,derived)
 			derived = derived:match"(%S+)$"
 		else
 			if itst.re_name == "struct_re" then
@@ -1529,12 +1600,14 @@ 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
-						if self.typenames[ttype] ~= template then --rule out T (template typename)
+						--print("not doheader",ttype,template,te, self.typenames[ttype])
+						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
 						end
 						if doheader then
+							
 							local templatetypedef = self:gentemplatetypedef(ttype, template,self.templates[ttype][template])
 							predeclare = predeclare .. templatetypedef
 						end
@@ -1590,7 +1663,7 @@ function M.Parser()
 				end
 			elseif it.re_name == "enum_re" then
 				--nop
-			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" then
+			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" and it.re_name ~= "operator_re" then
 				print(it.re_name,"not processed clean_struct in",stname,it.item:sub(1,24))
 				--M.prtable(it)
 			end
@@ -1657,6 +1730,7 @@ function M.Parser()
 						it2 = clean_functypedef(it2)
 					else
 						assert(it.re_name == "vardef_re")
+						it2 = it2:gsub("constexpr","static const")
 						if it2:match"enum" then
 							print("--skip enum forward declaration:",it2)
 							it2 = ""
@@ -1771,7 +1845,9 @@ function M.Parser()
 					local ttype,fun = it.item:match"^%s*template%s+<%s*typename%s+([^>]+)%s*>%s*(.+)$"
 					if self.ftemplate_list and self.ftemplate_list[ttype] then
 						for iT,vT in ipairs(self.ftemplate_list[ttype]) do
-							local funT = fun:gsub(ttype,vT)
+							local funT = fun:gsub("([< %(])"..ttype,"%1"..vT)
+							--funT = funT:gsub("sizeof%("..ttype.."%)","sizeof("..vT..")")
+							--local funT = fun:gsub(ttype,vT)
 							self:parseFunction(stname,{item=funT},namespace,it.locat)
 						end
 					end
@@ -1779,9 +1855,11 @@ function M.Parser()
 					self:parseFunction(stname,it,namespace,it.locat)
 				end
 			else
+				if it.re_name~="operator_re" then
 				print("not processed gen",it.re_name,it.item:sub(1,20))
 				end
 			end
+		end
 		
 		self:Listing(itemsarr,processer)
 		
@@ -1938,7 +2016,7 @@ function M.Parser()
 					self.typedefs_dict[typedefname] = strip(typedefdef)
 				elseif it.re_name == "functypedef_re" then
 					-- "^\n*%s*(typedef[%w%s%*_]+%([^*]*%*?%s*[%w_]+%s*%)%s*%b()%s*;)"
-					local key = it.item:match("%(%*([%w_]+)%)%([^%(%)]*%)")
+					local key = it.item:match("%(%*%s*([%w_]+)%)%s*%([^%(%)]*%)")
 					if key then
 						local linet = it.item
 						linet = linet:gsub("[\n%s]+typedef ","")
@@ -1989,7 +2067,7 @@ function M.Parser()
 				end
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
-			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" then
+			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" and it.re_name ~= "operator_re" then
 				print("not processed gen table",it.re_name)
 			end
 		end
@@ -2062,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
@@ -2234,6 +2317,7 @@ function M.Parser()
 		return self:gen_template_typedef_auto(ttype,te,newte)
 	end
 	function par:gen_template_typedef_auto(ttype,te,newte)
+		--M.prtable(self.templated_structs)
 		assert(self.templated_structs[ttype],ttype)
 		local defi = self.templated_structs[ttype]
 		local Targ = strsplit(self.typenames[ttype],",")
@@ -2277,7 +2361,111 @@ function M.Parser()
 	end
 	return par
 end
+-- more compact serialization
+local function basicSerialize (o)
+    if type(o) == "number" then
+		return string.format("%.17g", o)
+	elseif type(o)=="boolean" then
+        return tostring(o)
+    elseif type(o) == "string" then
+        return string.format("%q", o)
+	elseif pcall(function() return o.__serialize end) then
+		return o.__serialize(o)
+	elseif type(o)=="cdata" then
+		return cdataSerialize(o)
+	else
+		return tostring(o) --"nil"
+    end
+end
+-- very readable and now suited for cyclic tables
+local kw = {['and'] = true, ['break'] = true, ['do'] = true, ['else'] = true,
+	['elseif'] = true, ['end'] = true, ['false'] = true, ['for'] = true,
+	['function'] = true, ['goto'] = true, ['if'] = true, ['in'] = true,
+	['local'] = true, ['nil'] = true, ['not'] = true, ['or'] = true,
+	['repeat'] = true, ['return'] = true, ['then'] = true, ['true'] = true,
+	['until'] = true, ['while'] = true}
+function tb2st_serialize(t,options)
+	options = options or {}
+	local function sorter(a,b)
+        if type(a)==type(b) then 
+            return a<b 
+        elseif type(a)=="number" then
+            return true
+        else
+            assert(type(b)=="number")
+            return false
+        end
+    end
+	local function serialize_key(val, dodot, pretty)
+		local dot = dodot and "." or ""
+		if type(val)=="string" then
+			if  val:match '^[_%a][_%w]*$' and not kw[val] then
+				return dot..tostring(val)
+			else
+				return "[\""..tostring(val).."\"]"
+			end
+		elseif (not pretty) and (not dodot) and (type(val) == "number") and (math.floor(val)==val) then
+			return  --array index
+		else
+			return "["..tostring(val).."]"
+		end
+	end
+	local function serialize_key_name(val)
+		return serialize_key(val, true)
+	end
+	local insert = table.insert
+	local function _tb2st(t,saved,sref,level,name)
+		saved = saved or {}		-- initial value
+		level = level or 0
+		sref = sref or {}
+		name = name or "t"
+		if type(t)=="table" then
+			if saved[t] then
+				sref[#sref+1] = {saved[t],name}
+				return"nil"
+			else
+				saved[t] = name
 
+				local ordered_keys = {}
+				for k,v in pairs(t) do
+					insert(ordered_keys,k)
+				end
+				table.sort(ordered_keys,sorter)
+				
+				local str2 = {}
+				insert(str2,"{")
+				if options.pretty then insert(str2,"\n") end
+				for _,k in ipairs(ordered_keys) do
+					if options.pretty then insert(str2,("  "):rep(level+1)) end
+					local v = t[k]
+					local kser = serialize_key(k, nil, options.pretty)
+					insert(str2, (kser and (kser .."=") or ""))
+					if type(v)~="table" then
+						insert(str2, basicSerialize(v))
+					else
+						local name2 = name .. serialize_key_name(k)
+						insert(str2,_tb2st(v,saved,sref,level+1,name2))
+					end
+					if options.pretty then insert(str2,",\n") else insert(str2, ",") end
+				end
+				str2[#str2] = "}"
+				if level == 0 then
+					--insert(str2, 1,"local ffi = require'ffi'\nlocal t=")
+					insert(str2, 1,"local t=")
+					for i,v in ipairs(sref) do 
+						insert(str2, "\n"..v[2].."="..v[1])
+					end
+					insert(str2,"\n return t")
+				end
+				return table.concat(str2)
+			end
+		else
+			return basicSerialize(t)
+		end
+	end
+	return(_tb2st(t))
+end
+M.tb2st_serialize = tb2st_serialize
 ------serializeTable("anyname",table) gives a string that recreates the table with dofile(generated_string)
 local function serializeTable(name, value, saved)
     
@@ -2339,10 +2527,11 @@ local function serializeTable(name, value, saved)
     
     return table.concat(string_table)
 end
-M.serializeTable = serializeTable
-M.serializeTableF = function(t)
-	return M.serializeTable("defs",t).."\nreturn defs"
-end
+-- M.serializeTable = serializeTable
+-- M.serializeTableF = function(t)
+	-- return M.serializeTable("defs",t).."\nreturn defs"
+-- end
+M.serializeTableF = function(t) return tb2st_serialize(t,{pretty=true}) end --new serialization more compact
 --iterates lines from a gcc/clang -E in a specific location
 local function location(file,locpathT,defines,COMPILER,keepemptylines)
 	local define_re = "^#define%s+([^%s]+)%s+(.+)$"

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 %*
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -13,6 +13,7 @@ local CONSTRUCTORS_GENERATION = script_args[2]:match("constructors") and true or
 local NOCHAR = script_args[2]:match("nochar") and true or false
 local NOIMSTRV = script_args[2]:match("noimstrv") and true or false
 local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
+local CONFIG_GENERATOR_PATH = os.getenv"CONFIG_GENERATOR_PATH" or "./config_generator.lua"
 local CFLAGS = ""
 local CPRE,CTEST
 --get implementations
@@ -91,6 +92,10 @@ local cimgui_skipped = {
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
+	-- igGetIO = {
+		-- ["()"] = "igGetIO",
+		-- ["(ImGuiContext*)"] = "igGetIOEx",
+	-- },
     --igPushID = {
         --["(const char*)"] =           "igPushIDStr",
         --["(const char*,const char*)"] = "igPushIDRange",
@@ -124,16 +129,18 @@ local function func_header_impl_generate(FP)
             local cimf = FP.defsT[t.cimguiname]
             local def = cimf[t.signature]
 			local addcoment = def.comment or ""
+			local empty = def.args:match("^%(%)") --no args
 			if def.constructor then
-				-- it happens with vulkan impl but constructor ImGui_ImplVulkanH_Window is not needed
-			    --assert(def.stname ~= "","constructor without struct")
-                --table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or --def.args)..";"..addcoment.."\n")
+				-- only vulkan is manually created
+				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
+				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
                 
                 if def.stname == "" then --ImGui namespace or top level
-                    local empty = def.args:match("^%(%)") --no args
                     table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..(empty and "(void)" or def.args)..";"..addcoment.."\n")
                 else
 					cpp2ffi.prtable(def)
@@ -295,8 +302,8 @@ local function cimgui_generation(parser)
 	local num
 	hstrfile, num = hstrfile:gsub("typedef ImWchar16 ImWchar;", wchardefine)
 	assert(num == 1)
-	hstrfile, num = hstrfile:gsub("Used4kPagesMap%[%(0xFFFF", "Used4kPagesMap[(IM_UNICODE_CODEPOINT_MAX")
-	assert(num == 1)
+	hstrfile, num = hstrfile:gsub("kPagesMap%[%(0xFFFF", "kPagesMap[(IM_UNICODE_CODEPOINT_MAX")
+	assert(num == 1, "kPagesMap[(IM_UNICODE_CODEPOINT_MAX not found or found more than once")
     save_data("./output/cimgui.h",cimgui_header,hstrfile)
     
     --merge it in cimgui_template.cpp to cimgui.cpp
@@ -314,8 +321,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"}
---cpp2ffi.prtable(gdefines)
+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)
 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 +342,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 +382,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)
@@ -446,11 +455,18 @@ local parser2
 
 if #implementations > 0 then
 	print("------------------implementations generation with "..COMPILER.."------------------------")
+	--parser2 for function defs
+	--parser3 for separated structs and enums in cimgui_impl.h
     parser2 = cpp2ffi.Parser()
 	
-	local config = require"config_generator"
+	local config = dofile(CONFIG_GENERATOR_PATH) --"./config_generator.lua"
     local impl_str = ""
+	local impl_str_cpp = {}
     for i,impl in ipairs(implementations) do
+		table.insert(impl_str_cpp, "\n#ifdef CIMGUI_USE_" .. string.upper(impl))
+		table.insert(impl_str_cpp, [[#include "imgui_impl_]]..impl..[[.h"]])
+		table.insert(impl_str_cpp, "#endif")
+
         local source = backends_folder .. [[imgui_impl_]].. impl .. ".h "
         local locati = [[imgui_impl_]].. impl
 
@@ -464,27 +480,38 @@ 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()
-
-    -- save ./cimgui_impl.h
-    --local cfuncsstr = func_header_impl_generate(parser2) 
-	--local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
-    --save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
 	save_data("./output/cimgui_impl.h",impl_str)
 
     ----------save fundefs in impl_definitions.lua for using in bindings
     save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
+	--impl cpp
+	impl_str_cpp = table.concat(impl_str_cpp, "\n")
+	local cppstr = read_data"./cimgui_impl_template.cpp"
+	cppstr = cppstr:gsub("GENERATED_PLACEHOLDER", impl_str_cpp)
+	save_data("./output/cimgui_impl.cpp",cppstr)
 
 end -- #implementations > 0 then
 
@@ -516,7 +543,11 @@ end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
+copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
+copyfile("./output/cimgui_impl.cpp", "../cimgui_impl.cpp")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
 os.remove("./output/cimgui.h")
+os.remove("./output/cimgui_impl.h")
+os.remove("./output/cimgui_impl.cpp")
 os.remove("./output/cimgui.cpp")
 print"all done!!"

generator/generator.sh

@@ -25,7 +25,7 @@
 POSITIONAL_ARGS=()
 
 TARGETS="internal noimstrv"
-CFLAGS="glfw opengl3 opengl2 sdl2 sdl3"
+CFLAGS="glfw opengl3 opengl2 sdl2 sdl3 vulkan"
 
 help() {
         cat <<EOF

generator/output/cimgui_impl.h

@@ -1,88 +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_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

@@ -17,7 +17,7 @@
       "cimguiname": "ImGui_ImplGlfw_CharCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CharCallback",
-      "location": "imgui_impl_glfw:61",
+      "location": "imgui_impl_glfw:60",
       "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,unsigned int)",
@@ -42,7 +42,7 @@
       "cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CursorEnterCallback",
-      "location": "imgui_impl_glfw:56",
+      "location": "imgui_impl_glfw:55",
       "ov_cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
@@ -71,7 +71,7 @@
       "cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CursorPosCallback",
-      "location": "imgui_impl_glfw:57",
+      "location": "imgui_impl_glfw:56",
       "ov_cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
@@ -96,7 +96,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOpenGL",
-      "location": "imgui_impl_glfw:32",
+      "location": "imgui_impl_glfw:31",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -121,7 +121,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOther",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOther",
-      "location": "imgui_impl_glfw:34",
+      "location": "imgui_impl_glfw:33",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOther",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -146,7 +146,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForVulkan",
-      "location": "imgui_impl_glfw:33",
+      "location": "imgui_impl_glfw:32",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -167,7 +167,7 @@
       "cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InstallCallbacks",
-      "location": "imgui_impl_glfw:47",
+      "location": "imgui_impl_glfw:46",
       "ov_cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
       "ret": "void",
       "signature": "(GLFWwindow*)",
@@ -204,7 +204,7 @@
       "cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_KeyCallback",
-      "location": "imgui_impl_glfw:60",
+      "location": "imgui_impl_glfw:59",
       "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int,int)",
@@ -229,7 +229,7 @@
       "cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MonitorCallback",
-      "location": "imgui_impl_glfw:62",
+      "location": "imgui_impl_glfw:61",
       "ov_cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "ret": "void",
       "signature": "(GLFWmonitor*,int)",
@@ -262,7 +262,7 @@
       "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "location": "imgui_impl_glfw:58",
+      "location": "imgui_impl_glfw:57",
       "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int)",
@@ -278,7 +278,7 @@
       "cimguiname": "ImGui_ImplGlfw_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_NewFrame",
-      "location": "imgui_impl_glfw:36",
+      "location": "imgui_impl_glfw:35",
       "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -299,7 +299,7 @@
       "cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_RestoreCallbacks",
-      "location": "imgui_impl_glfw:48",
+      "location": "imgui_impl_glfw:47",
       "ov_cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
       "ret": "void",
       "signature": "(GLFWwindow*)",
@@ -328,7 +328,7 @@
       "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_ScrollCallback",
-      "location": "imgui_impl_glfw:59",
+      "location": "imgui_impl_glfw:58",
       "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
@@ -349,7 +349,7 @@
       "cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
-      "location": "imgui_impl_glfw:52",
+      "location": "imgui_impl_glfw:51",
       "ov_cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       "ret": "void",
       "signature": "(bool)",
@@ -365,7 +365,7 @@
       "cimguiname": "ImGui_ImplGlfw_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_Shutdown",
-      "location": "imgui_impl_glfw:35",
+      "location": "imgui_impl_glfw:34",
       "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -386,7 +386,7 @@
       "cimguiname": "ImGui_ImplGlfw_Sleep",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_Sleep",
-      "location": "imgui_impl_glfw:65",
+      "location": "imgui_impl_glfw:64",
       "ov_cimguiname": "ImGui_ImplGlfw_Sleep",
       "ret": "void",
       "signature": "(int)",
@@ -411,7 +411,7 @@
       "cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_WindowFocusCallback",
-      "location": "imgui_impl_glfw:55",
+      "location": "imgui_impl_glfw:54",
       "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
@@ -427,7 +427,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:39",
+      "location": "imgui_impl_opengl2:38",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
@@ -443,7 +443,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "location": "imgui_impl_opengl2:37",
+      "location": "imgui_impl_opengl2:36",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
@@ -459,7 +459,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2:40",
+      "location": "imgui_impl_opengl2:39",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
@@ -475,7 +475,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "location": "imgui_impl_opengl2:38",
+      "location": "imgui_impl_opengl2:37",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
@@ -491,7 +491,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_Init",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Init",
-      "location": "imgui_impl_opengl2:31",
+      "location": "imgui_impl_opengl2:30",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
       "ret": "bool",
       "signature": "()",
@@ -507,7 +507,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_NewFrame",
-      "location": "imgui_impl_opengl2:33",
+      "location": "imgui_impl_opengl2:32",
       "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -528,7 +528,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "location": "imgui_impl_opengl2:34",
+      "location": "imgui_impl_opengl2:33",
       "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -544,7 +544,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Shutdown",
-      "location": "imgui_impl_opengl2:32",
+      "location": "imgui_impl_opengl2:31",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -560,7 +560,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "location": "imgui_impl_opengl3:42",
+      "location": "imgui_impl_opengl3:41",
       "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
@@ -576,7 +576,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "location": "imgui_impl_opengl3:40",
+      "location": "imgui_impl_opengl3:39",
       "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
@@ -592,7 +592,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl3:43",
+      "location": "imgui_impl_opengl3:42",
       "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
@@ -608,7 +608,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "location": "imgui_impl_opengl3:41",
+      "location": "imgui_impl_opengl3:40",
       "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
@@ -631,7 +631,7 @@
         "glsl_version": "nullptr"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
-      "location": "imgui_impl_opengl3:34",
+      "location": "imgui_impl_opengl3:33",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
       "ret": "bool",
       "signature": "(const char*)",
@@ -647,7 +647,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_NewFrame",
-      "location": "imgui_impl_opengl3:36",
+      "location": "imgui_impl_opengl3:35",
       "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -668,7 +668,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "location": "imgui_impl_opengl3:37",
+      "location": "imgui_impl_opengl3:36",
       "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -684,7 +684,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_Shutdown",
-      "location": "imgui_impl_opengl3:35",
+      "location": "imgui_impl_opengl3:34",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -705,7 +705,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForD3D",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForD3D",
-      "location": "imgui_impl_sdl2:37",
+      "location": "imgui_impl_sdl2:33",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -726,7 +726,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForMetal",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForMetal",
-      "location": "imgui_impl_sdl2:38",
+      "location": "imgui_impl_sdl2:34",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -751,7 +751,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForOpenGL",
-      "location": "imgui_impl_sdl2:35",
+      "location": "imgui_impl_sdl2:31",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "ret": "bool",
       "signature": "(SDL_Window*,void*)",
@@ -772,7 +772,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForOther",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForOther",
-      "location": "imgui_impl_sdl2:40",
+      "location": "imgui_impl_sdl2:36",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForOther",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -797,7 +797,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
-      "location": "imgui_impl_sdl2:39",
+      "location": "imgui_impl_sdl2:35",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
       "ret": "bool",
       "signature": "(SDL_Window*,SDL_Renderer*)",
@@ -818,7 +818,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForVulkan",
-      "location": "imgui_impl_sdl2:36",
+      "location": "imgui_impl_sdl2:32",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -834,7 +834,7 @@
       "cimguiname": "ImGui_ImplSDL2_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_NewFrame",
-      "location": "imgui_impl_sdl2:42",
+      "location": "imgui_impl_sdl2:38",
       "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -855,7 +855,7 @@
       "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_ProcessEvent",
-      "location": "imgui_impl_sdl2:43",
+      "location": "imgui_impl_sdl2:39",
       "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
@@ -887,7 +887,7 @@
         "manual_gamepads_count": "-1"
       },
       "funcname": "ImGui_ImplSDL2_SetGamepadMode",
-      "location": "imgui_impl_sdl2:48",
+      "location": "imgui_impl_sdl2:44",
       "ov_cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
       "ret": "void",
       "signature": "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)",
@@ -903,7 +903,7 @@
       "cimguiname": "ImGui_ImplSDL2_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_Shutdown",
-      "location": "imgui_impl_sdl2:41",
+      "location": "imgui_impl_sdl2:37",
       "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -924,7 +924,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForD3D",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForD3D",
-      "location": "imgui_impl_sdl3:38",
+      "location": "imgui_impl_sdl3:33",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForD3D",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -945,7 +945,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForMetal",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForMetal",
-      "location": "imgui_impl_sdl3:39",
+      "location": "imgui_impl_sdl3:34",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForMetal",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -970,7 +970,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForOpenGL",
-      "location": "imgui_impl_sdl3:36",
+      "location": "imgui_impl_sdl3:31",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForOpenGL",
       "ret": "bool",
       "signature": "(SDL_Window*,void*)",
@@ -991,13 +991,34 @@
       "cimguiname": "ImGui_ImplSDL3_InitForOther",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForOther",
-      "location": "imgui_impl_sdl3:41",
+      "location": "imgui_impl_sdl3:37",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForOther",
       "ret": "bool",
       "signature": "(SDL_Window*)",
       "stname": ""
     }
   ],
+  "ImGui_ImplSDL3_InitForSDLGPU": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL3_InitForSDLGPU",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL3_InitForSDLGPU",
+      "location": "imgui_impl_sdl3:36",
+      "ov_cimguiname": "ImGui_ImplSDL3_InitForSDLGPU",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplSDL3_InitForSDLRenderer": [
     {
       "args": "(SDL_Window* window,SDL_Renderer* renderer)",
@@ -1016,7 +1037,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForSDLRenderer",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForSDLRenderer",
-      "location": "imgui_impl_sdl3:40",
+      "location": "imgui_impl_sdl3:35",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForSDLRenderer",
       "ret": "bool",
       "signature": "(SDL_Window*,SDL_Renderer*)",
@@ -1037,7 +1058,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForVulkan",
-      "location": "imgui_impl_sdl3:37",
+      "location": "imgui_impl_sdl3:32",
       "ov_cimguiname": "ImGui_ImplSDL3_InitForVulkan",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -1053,7 +1074,7 @@
       "cimguiname": "ImGui_ImplSDL3_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_NewFrame",
-      "location": "imgui_impl_sdl3:43",
+      "location": "imgui_impl_sdl3:39",
       "ov_cimguiname": "ImGui_ImplSDL3_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -1074,7 +1095,7 @@
       "cimguiname": "ImGui_ImplSDL3_ProcessEvent",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_ProcessEvent",
-      "location": "imgui_impl_sdl3:44",
+      "location": "imgui_impl_sdl3:40",
       "ov_cimguiname": "ImGui_ImplSDL3_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
@@ -1106,7 +1127,7 @@
         "manual_gamepads_count": "-1"
       },
       "funcname": "ImGui_ImplSDL3_SetGamepadMode",
-      "location": "imgui_impl_sdl3:49",
+      "location": "imgui_impl_sdl3:45",
       "ov_cimguiname": "ImGui_ImplSDL3_SetGamepadMode",
       "ret": "void",
       "signature": "(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)",
@@ -1122,11 +1143,484 @@
       "cimguiname": "ImGui_ImplSDL3_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_Shutdown",
-      "location": "imgui_impl_sdl3:42",
+      "location": "imgui_impl_sdl3:38",
       "ov_cimguiname": "ImGui_ImplSDL3_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
+  ],
+  "ImGui_ImplVulkanH_CreateOrResizeWindow": [
+    {
+      "args": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wnd",
+          "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* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "call_args": "(instance,physical_device,device,wnd,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* wnd,const VkAllocationCallbacks* allocator)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wnd",
+          "type": "ImGui_ImplVulkanH_Window*"
+        },
+        {
+          "name": "allocator",
+          "type": "const VkAllocationCallbacks*"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
+      "call_args": "(instance,device,wnd,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:214",
+      "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:214",
+      "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": "(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data)",
+      "argsT": [
+        {
+          "name": "api_version",
+          "type": "uint32_t"
+        },
+        {
+          "name": "user_data)",
+          "type": "PFN_vkVoidFunction(*loader_func)(const char* function_name,void*"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data=nullptr)",
+      "call_args": "(api_version,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": "(uint32_t,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/overloads.txt

@@ -108,13 +108,17 @@ igCombo	3
 1	bool	igCombo_Str_arr (const char*,int*,const char* const[],int,int)
 2	bool	igCombo_Str (const char*,int*,const char*,int)
 3	bool	igCombo_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
+igGetBackgroundDrawList	2
+1	ImDrawList*	igGetBackgroundDrawList_Nil ()
+2	ImDrawList*	igGetBackgroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetColorU32	3
 1	ImU32	igGetColorU32_Col (ImGuiCol,float)
 2	ImU32	igGetColorU32_Vec4 (const ImVec4)
 3	ImU32	igGetColorU32_U32 (ImU32,float)
-igGetForegroundDrawList	2
-1	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
+igGetForegroundDrawList	3
+1	ImDrawList*	igGetForegroundDrawList_Nil ()
 2	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
+3	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetID	4
 1	ImGuiID	igGetID_Str (const char*)
 2	ImGuiID	igGetID_StrStr (const char*,const char*)
@@ -123,9 +127,15 @@ igGetID	4
 igGetIDWithSeed	2
 1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
 2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
+igGetIO	2
+1	ImGuiIO*	igGetIO_Nil ()
+2	ImGuiIO*	igGetIO_ContextPtr (ImGuiContext*)
 igGetKeyData	2
 1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
 2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
+igGetPlatformIO	2
+1	ImGuiPlatformIO*	igGetPlatformIO_Nil ()
+2	ImGuiPlatformIO*	igGetPlatformIO_ContextPtr (ImGuiContext*)
 igImAbs	3
 1	int	igImAbs_Int (int)
 2	float	igImAbs_Float (float)
@@ -293,4 +303,4 @@ igValue	4
 2	void	igValue_Int (const char*,int)
 3	void	igValue_Uint (const char*,unsigned int)
 4	void	igValue_Float (const char*,float,const char*)
-205 overloaded
+212 overloaded

generator/output/typedefs_dict.json

@@ -40,19 +40,13 @@
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiContextHook": "struct ImGuiContextHook",
   "ImGuiContextHookCallback": "void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-  "ImGuiDataAuthority": "int",
   "ImGuiDataType": "int",
   "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
   "ImGuiDataTypeStorage": "struct ImGuiDataTypeStorage",
-  "ImGuiDataVarInfo": "struct ImGuiDataVarInfo",
+  "ImGuiDeactivatedItemData": "struct ImGuiDeactivatedItemData",
   "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
   "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
   "ImGuiDebugLogFlags": "int",
-  "ImGuiDockContext": "struct ImGuiDockContext",
-  "ImGuiDockNode": "struct ImGuiDockNode",
-  "ImGuiDockNodeFlags": "int",
-  "ImGuiDockNodeSettings": "struct ImGuiDockNodeSettings",
-  "ImGuiDockRequest": "struct ImGuiDockRequest",
   "ImGuiDragDropFlags": "int",
   "ImGuiErrorCallback": "void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
   "ImGuiErrorRecoveryState": "struct ImGuiErrorRecoveryState",
@@ -69,7 +63,6 @@
   "ImGuiInputEventKey": "struct ImGuiInputEventKey",
   "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
   "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
-  "ImGuiInputEventMouseViewport": "struct ImGuiInputEventMouseViewport",
   "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
   "ImGuiInputEventText": "struct ImGuiInputEventText",
   "ImGuiInputFlags": "int",
@@ -118,7 +111,6 @@
   "ImGuiPayload": "struct ImGuiPayload",
   "ImGuiPlatformIO": "struct ImGuiPlatformIO",
   "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
-  "ImGuiPlatformMonitor": "struct ImGuiPlatformMonitor",
   "ImGuiPopupData": "struct ImGuiPopupData",
   "ImGuiPopupFlags": "int",
   "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
@@ -140,6 +132,7 @@
   "ImGuiStyle": "struct ImGuiStyle",
   "ImGuiStyleMod": "struct ImGuiStyleMod",
   "ImGuiStyleVar": "int",
+  "ImGuiStyleVarInfo": "struct ImGuiStyleVarInfo",
   "ImGuiTabBar": "struct ImGuiTabBar",
   "ImGuiTabBarFlags": "int",
   "ImGuiTabItem": "struct ImGuiTabItem",
@@ -176,8 +169,6 @@
   "ImGuiViewportFlags": "int",
   "ImGuiViewportP": "struct ImGuiViewportP",
   "ImGuiWindow": "struct ImGuiWindow",
-  "ImGuiWindowClass": "struct ImGuiWindowClass",
-  "ImGuiWindowDockStyle": "struct ImGuiWindowDockStyle",
   "ImGuiWindowFlags": "int",
   "ImGuiWindowRefreshFlags": "int",
   "ImGuiWindowSettings": "struct ImGuiWindowSettings",

generator/output/typedefs_dict.lua

@@ -1,207 +1,197 @@
-local defs = {}
-defs["ImBitArrayForNamedKeys"] = "ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN>"
-defs["ImBitArrayPtr"] = "ImU32*"
-defs["ImBitVector"] = "struct ImBitVector"
-defs["ImColor"] = "struct ImColor"
-defs["ImDrawCallback"] = "void (*)(const ImDrawList* parent_list, const ImDrawCmd* cmd);"
-defs["ImDrawChannel"] = "struct ImDrawChannel"
-defs["ImDrawCmd"] = "struct ImDrawCmd"
-defs["ImDrawCmdHeader"] = "struct ImDrawCmdHeader"
-defs["ImDrawData"] = "struct ImDrawData"
-defs["ImDrawDataBuilder"] = "struct ImDrawDataBuilder"
-defs["ImDrawFlags"] = "int"
-defs["ImDrawIdx"] = "unsigned short"
-defs["ImDrawList"] = "struct ImDrawList"
-defs["ImDrawListFlags"] = "int"
-defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
-defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
-defs["ImDrawVert"] = "struct ImDrawVert"
-defs["ImFileHandle"] = "FILE*"
-defs["ImFont"] = "struct ImFont"
-defs["ImFontAtlas"] = "struct ImFontAtlas"
-defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
-defs["ImFontAtlasFlags"] = "int"
-defs["ImFontBuilderIO"] = "struct ImFontBuilderIO"
-defs["ImFontConfig"] = "struct ImFontConfig"
-defs["ImFontGlyph"] = "struct ImFontGlyph"
-defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
-defs["ImGuiActivateFlags"] = "int"
-defs["ImGuiBackendFlags"] = "int"
-defs["ImGuiBoxSelectState"] = "struct ImGuiBoxSelectState"
-defs["ImGuiButtonFlags"] = "int"
-defs["ImGuiChildFlags"] = "int"
-defs["ImGuiCol"] = "int"
-defs["ImGuiColorEditFlags"] = "int"
-defs["ImGuiColorMod"] = "struct ImGuiColorMod"
-defs["ImGuiComboFlags"] = "int"
-defs["ImGuiComboPreviewData"] = "struct ImGuiComboPreviewData"
-defs["ImGuiCond"] = "int"
-defs["ImGuiConfigFlags"] = "int"
-defs["ImGuiContext"] = "struct ImGuiContext"
-defs["ImGuiContextHook"] = "struct ImGuiContextHook"
-defs["ImGuiContextHookCallback"] = "void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);"
-defs["ImGuiDataAuthority"] = "int"
-defs["ImGuiDataType"] = "int"
-defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
-defs["ImGuiDataTypeStorage"] = "struct ImGuiDataTypeStorage"
-defs["ImGuiDataVarInfo"] = "struct ImGuiDataVarInfo"
-defs["ImGuiDebugAllocEntry"] = "struct ImGuiDebugAllocEntry"
-defs["ImGuiDebugAllocInfo"] = "struct ImGuiDebugAllocInfo"
-defs["ImGuiDebugLogFlags"] = "int"
-defs["ImGuiDockContext"] = "struct ImGuiDockContext"
-defs["ImGuiDockNode"] = "struct ImGuiDockNode"
-defs["ImGuiDockNodeFlags"] = "int"
-defs["ImGuiDockNodeSettings"] = "struct ImGuiDockNodeSettings"
-defs["ImGuiDockRequest"] = "struct ImGuiDockRequest"
-defs["ImGuiDragDropFlags"] = "int"
-defs["ImGuiErrorCallback"] = "void (*)(ImGuiContext* ctx, void* user_data, const char* msg);"
-defs["ImGuiErrorRecoveryState"] = "struct ImGuiErrorRecoveryState"
-defs["ImGuiFocusRequestFlags"] = "int"
-defs["ImGuiFocusScopeData"] = "struct ImGuiFocusScopeData"
-defs["ImGuiFocusedFlags"] = "int"
-defs["ImGuiGroupData"] = "struct ImGuiGroupData"
-defs["ImGuiHoveredFlags"] = "int"
-defs["ImGuiID"] = "unsigned int"
-defs["ImGuiIDStackTool"] = "struct ImGuiIDStackTool"
-defs["ImGuiIO"] = "struct ImGuiIO"
-defs["ImGuiInputEvent"] = "struct ImGuiInputEvent"
-defs["ImGuiInputEventAppFocused"] = "struct ImGuiInputEventAppFocused"
-defs["ImGuiInputEventKey"] = "struct ImGuiInputEventKey"
-defs["ImGuiInputEventMouseButton"] = "struct ImGuiInputEventMouseButton"
-defs["ImGuiInputEventMousePos"] = "struct ImGuiInputEventMousePos"
-defs["ImGuiInputEventMouseViewport"] = "struct ImGuiInputEventMouseViewport"
-defs["ImGuiInputEventMouseWheel"] = "struct ImGuiInputEventMouseWheel"
-defs["ImGuiInputEventText"] = "struct ImGuiInputEventText"
-defs["ImGuiInputFlags"] = "int"
-defs["ImGuiInputTextCallback"] = "int (*)(ImGuiInputTextCallbackData* data);"
-defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
-defs["ImGuiInputTextDeactivateData"] = "struct ImGuiInputTextDeactivateData"
-defs["ImGuiInputTextDeactivatedState"] = "struct ImGuiInputTextDeactivatedState"
-defs["ImGuiInputTextFlags"] = "int"
-defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
-defs["ImGuiItemFlags"] = "int"
-defs["ImGuiItemStatusFlags"] = "int"
-defs["ImGuiKeyChord"] = "int"
-defs["ImGuiKeyData"] = "struct ImGuiKeyData"
-defs["ImGuiKeyOwnerData"] = "struct ImGuiKeyOwnerData"
-defs["ImGuiKeyRoutingData"] = "struct ImGuiKeyRoutingData"
-defs["ImGuiKeyRoutingIndex"] = "ImS16"
-defs["ImGuiKeyRoutingTable"] = "struct ImGuiKeyRoutingTable"
-defs["ImGuiLastItemData"] = "struct ImGuiLastItemData"
-defs["ImGuiLayoutType"] = "int"
-defs["ImGuiListClipper"] = "struct ImGuiListClipper"
-defs["ImGuiListClipperData"] = "struct ImGuiListClipperData"
-defs["ImGuiListClipperRange"] = "struct ImGuiListClipperRange"
-defs["ImGuiLocEntry"] = "struct ImGuiLocEntry"
-defs["ImGuiLogFlags"] = "int"
-defs["ImGuiMemAllocFunc"] = "void* (*)(size_t sz, void* user_data);"
-defs["ImGuiMemFreeFunc"] = "void (*)(void* ptr, void* user_data);"
-defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
-defs["ImGuiMetricsConfig"] = "struct ImGuiMetricsConfig"
-defs["ImGuiMouseButton"] = "int"
-defs["ImGuiMouseCursor"] = "int"
-defs["ImGuiMultiSelectFlags"] = "int"
-defs["ImGuiMultiSelectIO"] = "struct ImGuiMultiSelectIO"
-defs["ImGuiMultiSelectState"] = "struct ImGuiMultiSelectState"
-defs["ImGuiMultiSelectTempData"] = "struct ImGuiMultiSelectTempData"
-defs["ImGuiNavItemData"] = "struct ImGuiNavItemData"
-defs["ImGuiNavMoveFlags"] = "int"
-defs["ImGuiNavRenderCursorFlags"] = "int"
-defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
-defs["ImGuiNextItemDataFlags"] = "int"
-defs["ImGuiNextWindowData"] = "struct ImGuiNextWindowData"
-defs["ImGuiNextWindowDataFlags"] = "int"
-defs["ImGuiOldColumnData"] = "struct ImGuiOldColumnData"
-defs["ImGuiOldColumnFlags"] = "int"
-defs["ImGuiOldColumns"] = "struct ImGuiOldColumns"
-defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
-defs["ImGuiPayload"] = "struct ImGuiPayload"
-defs["ImGuiPlatformIO"] = "struct ImGuiPlatformIO"
-defs["ImGuiPlatformImeData"] = "struct ImGuiPlatformImeData"
-defs["ImGuiPlatformMonitor"] = "struct ImGuiPlatformMonitor"
-defs["ImGuiPopupData"] = "struct ImGuiPopupData"
-defs["ImGuiPopupFlags"] = "int"
-defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
-defs["ImGuiScrollFlags"] = "int"
-defs["ImGuiSelectableFlags"] = "int"
-defs["ImGuiSelectionBasicStorage"] = "struct ImGuiSelectionBasicStorage"
-defs["ImGuiSelectionExternalStorage"] = "struct ImGuiSelectionExternalStorage"
-defs["ImGuiSelectionRequest"] = "struct ImGuiSelectionRequest"
-defs["ImGuiSelectionUserData"] = "ImS64"
-defs["ImGuiSeparatorFlags"] = "int"
-defs["ImGuiSettingsHandler"] = "struct ImGuiSettingsHandler"
-defs["ImGuiShrinkWidthItem"] = "struct ImGuiShrinkWidthItem"
-defs["ImGuiSizeCallback"] = "void (*)(ImGuiSizeCallbackData* data);"
-defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
-defs["ImGuiSliderFlags"] = "int"
-defs["ImGuiStackLevelInfo"] = "struct ImGuiStackLevelInfo"
-defs["ImGuiStorage"] = "struct ImGuiStorage"
-defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
-defs["ImGuiStyle"] = "struct ImGuiStyle"
-defs["ImGuiStyleMod"] = "struct ImGuiStyleMod"
-defs["ImGuiStyleVar"] = "int"
-defs["ImGuiTabBar"] = "struct ImGuiTabBar"
-defs["ImGuiTabBarFlags"] = "int"
-defs["ImGuiTabItem"] = "struct ImGuiTabItem"
-defs["ImGuiTabItemFlags"] = "int"
-defs["ImGuiTable"] = "struct ImGuiTable"
-defs["ImGuiTableBgTarget"] = "int"
-defs["ImGuiTableCellData"] = "struct ImGuiTableCellData"
-defs["ImGuiTableColumn"] = "struct ImGuiTableColumn"
-defs["ImGuiTableColumnFlags"] = "int"
-defs["ImGuiTableColumnIdx"] = "ImS16"
-defs["ImGuiTableColumnSettings"] = "struct ImGuiTableColumnSettings"
-defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
-defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
-defs["ImGuiTableDrawChannelIdx"] = "ImU16"
-defs["ImGuiTableFlags"] = "int"
-defs["ImGuiTableHeaderData"] = "struct ImGuiTableHeaderData"
-defs["ImGuiTableInstanceData"] = "struct ImGuiTableInstanceData"
-defs["ImGuiTableRowFlags"] = "int"
-defs["ImGuiTableSettings"] = "struct ImGuiTableSettings"
-defs["ImGuiTableSortSpecs"] = "struct ImGuiTableSortSpecs"
-defs["ImGuiTableTempData"] = "struct ImGuiTableTempData"
-defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
-defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
-defs["ImGuiTextFlags"] = "int"
-defs["ImGuiTextIndex"] = "struct ImGuiTextIndex"
-defs["ImGuiTextRange"] = "struct ImGuiTextRange"
-defs["ImGuiTooltipFlags"] = "int"
-defs["ImGuiTreeNodeFlags"] = "int"
-defs["ImGuiTreeNodeStackData"] = "struct ImGuiTreeNodeStackData"
-defs["ImGuiTypingSelectFlags"] = "int"
-defs["ImGuiTypingSelectRequest"] = "struct ImGuiTypingSelectRequest"
-defs["ImGuiTypingSelectState"] = "struct ImGuiTypingSelectState"
-defs["ImGuiViewport"] = "struct ImGuiViewport"
-defs["ImGuiViewportFlags"] = "int"
-defs["ImGuiViewportP"] = "struct ImGuiViewportP"
-defs["ImGuiWindow"] = "struct ImGuiWindow"
-defs["ImGuiWindowClass"] = "struct ImGuiWindowClass"
-defs["ImGuiWindowDockStyle"] = "struct ImGuiWindowDockStyle"
-defs["ImGuiWindowFlags"] = "int"
-defs["ImGuiWindowRefreshFlags"] = "int"
-defs["ImGuiWindowSettings"] = "struct ImGuiWindowSettings"
-defs["ImGuiWindowStackData"] = "struct ImGuiWindowStackData"
-defs["ImGuiWindowTempData"] = "struct ImGuiWindowTempData"
-defs["ImPoolIdx"] = "int"
-defs["ImRect"] = "struct ImRect"
-defs["ImS16"] = "signed short"
-defs["ImS32"] = "signed int"
-defs["ImS64"] = "signed long long"
-defs["ImS8"] = "signed char"
-defs["ImStbTexteditState"] = "ImStb::STB_TexteditState"
-defs["ImTextureID"] = "ImU64"
-defs["ImU16"] = "unsigned short"
-defs["ImU32"] = "unsigned int"
-defs["ImU64"] = "unsigned long long"
-defs["ImU8"] = "unsigned char"
-defs["ImVec1"] = "struct ImVec1"
-defs["ImVec2"] = "struct ImVec2"
-defs["ImVec2ih"] = "struct ImVec2ih"
-defs["ImVec4"] = "struct ImVec4"
-defs["ImWchar"] = "ImWchar16"
-defs["ImWchar16"] = "unsigned short"
-defs["ImWchar32"] = "unsigned int"
-defs["STB_TexteditState"] = "struct STB_TexteditState"
-
-return defs
+local t={
+  ImBitArrayForNamedKeys="ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN>",
+  ImBitArrayPtr="ImU32*",
+  ImBitVector="struct ImBitVector",
+  ImColor="struct ImColor",
+  ImDrawCallback="void (*)(const ImDrawList* parent_list, const ImDrawCmd* cmd);",
+  ImDrawChannel="struct ImDrawChannel",
+  ImDrawCmd="struct ImDrawCmd",
+  ImDrawCmdHeader="struct ImDrawCmdHeader",
+  ImDrawData="struct ImDrawData",
+  ImDrawDataBuilder="struct ImDrawDataBuilder",
+  ImDrawFlags="int",
+  ImDrawIdx="unsigned short",
+  ImDrawList="struct ImDrawList",
+  ImDrawListFlags="int",
+  ImDrawListSharedData="struct ImDrawListSharedData",
+  ImDrawListSplitter="struct ImDrawListSplitter",
+  ImDrawVert="struct ImDrawVert",
+  ImFileHandle="FILE*",
+  ImFont="struct ImFont",
+  ImFontAtlas="struct ImFontAtlas",
+  ImFontAtlasCustomRect="struct ImFontAtlasCustomRect",
+  ImFontAtlasFlags="int",
+  ImFontBuilderIO="struct ImFontBuilderIO",
+  ImFontConfig="struct ImFontConfig",
+  ImFontGlyph="struct ImFontGlyph",
+  ImFontGlyphRangesBuilder="struct ImFontGlyphRangesBuilder",
+  ImGuiActivateFlags="int",
+  ImGuiBackendFlags="int",
+  ImGuiBoxSelectState="struct ImGuiBoxSelectState",
+  ImGuiButtonFlags="int",
+  ImGuiChildFlags="int",
+  ImGuiCol="int",
+  ImGuiColorEditFlags="int",
+  ImGuiColorMod="struct ImGuiColorMod",
+  ImGuiComboFlags="int",
+  ImGuiComboPreviewData="struct ImGuiComboPreviewData",
+  ImGuiCond="int",
+  ImGuiConfigFlags="int",
+  ImGuiContext="struct ImGuiContext",
+  ImGuiContextHook="struct ImGuiContextHook",
+  ImGuiContextHookCallback="void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
+  ImGuiDataType="int",
+  ImGuiDataTypeInfo="struct ImGuiDataTypeInfo",
+  ImGuiDataTypeStorage="struct ImGuiDataTypeStorage",
+  ImGuiDeactivatedItemData="struct ImGuiDeactivatedItemData",
+  ImGuiDebugAllocEntry="struct ImGuiDebugAllocEntry",
+  ImGuiDebugAllocInfo="struct ImGuiDebugAllocInfo",
+  ImGuiDebugLogFlags="int",
+  ImGuiDragDropFlags="int",
+  ImGuiErrorCallback="void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
+  ImGuiErrorRecoveryState="struct ImGuiErrorRecoveryState",
+  ImGuiFocusRequestFlags="int",
+  ImGuiFocusScopeData="struct ImGuiFocusScopeData",
+  ImGuiFocusedFlags="int",
+  ImGuiGroupData="struct ImGuiGroupData",
+  ImGuiHoveredFlags="int",
+  ImGuiID="unsigned int",
+  ImGuiIDStackTool="struct ImGuiIDStackTool",
+  ImGuiIO="struct ImGuiIO",
+  ImGuiInputEvent="struct ImGuiInputEvent",
+  ImGuiInputEventAppFocused="struct ImGuiInputEventAppFocused",
+  ImGuiInputEventKey="struct ImGuiInputEventKey",
+  ImGuiInputEventMouseButton="struct ImGuiInputEventMouseButton",
+  ImGuiInputEventMousePos="struct ImGuiInputEventMousePos",
+  ImGuiInputEventMouseWheel="struct ImGuiInputEventMouseWheel",
+  ImGuiInputEventText="struct ImGuiInputEventText",
+  ImGuiInputFlags="int",
+  ImGuiInputTextCallback="int (*)(ImGuiInputTextCallbackData* data);",
+  ImGuiInputTextCallbackData="struct ImGuiInputTextCallbackData",
+  ImGuiInputTextDeactivateData="struct ImGuiInputTextDeactivateData",
+  ImGuiInputTextDeactivatedState="struct ImGuiInputTextDeactivatedState",
+  ImGuiInputTextFlags="int",
+  ImGuiInputTextState="struct ImGuiInputTextState",
+  ImGuiItemFlags="int",
+  ImGuiItemStatusFlags="int",
+  ImGuiKeyChord="int",
+  ImGuiKeyData="struct ImGuiKeyData",
+  ImGuiKeyOwnerData="struct ImGuiKeyOwnerData",
+  ImGuiKeyRoutingData="struct ImGuiKeyRoutingData",
+  ImGuiKeyRoutingIndex="ImS16",
+  ImGuiKeyRoutingTable="struct ImGuiKeyRoutingTable",
+  ImGuiLastItemData="struct ImGuiLastItemData",
+  ImGuiLayoutType="int",
+  ImGuiListClipper="struct ImGuiListClipper",
+  ImGuiListClipperData="struct ImGuiListClipperData",
+  ImGuiListClipperRange="struct ImGuiListClipperRange",
+  ImGuiLocEntry="struct ImGuiLocEntry",
+  ImGuiLogFlags="int",
+  ImGuiMemAllocFunc="void* (*)(size_t sz, void* user_data);",
+  ImGuiMemFreeFunc="void (*)(void* ptr, void* user_data);",
+  ImGuiMenuColumns="struct ImGuiMenuColumns",
+  ImGuiMetricsConfig="struct ImGuiMetricsConfig",
+  ImGuiMouseButton="int",
+  ImGuiMouseCursor="int",
+  ImGuiMultiSelectFlags="int",
+  ImGuiMultiSelectIO="struct ImGuiMultiSelectIO",
+  ImGuiMultiSelectState="struct ImGuiMultiSelectState",
+  ImGuiMultiSelectTempData="struct ImGuiMultiSelectTempData",
+  ImGuiNavItemData="struct ImGuiNavItemData",
+  ImGuiNavMoveFlags="int",
+  ImGuiNavRenderCursorFlags="int",
+  ImGuiNextItemData="struct ImGuiNextItemData",
+  ImGuiNextItemDataFlags="int",
+  ImGuiNextWindowData="struct ImGuiNextWindowData",
+  ImGuiNextWindowDataFlags="int",
+  ImGuiOldColumnData="struct ImGuiOldColumnData",
+  ImGuiOldColumnFlags="int",
+  ImGuiOldColumns="struct ImGuiOldColumns",
+  ImGuiOnceUponAFrame="struct ImGuiOnceUponAFrame",
+  ImGuiPayload="struct ImGuiPayload",
+  ImGuiPlatformIO="struct ImGuiPlatformIO",
+  ImGuiPlatformImeData="struct ImGuiPlatformImeData",
+  ImGuiPopupData="struct ImGuiPopupData",
+  ImGuiPopupFlags="int",
+  ImGuiPtrOrIndex="struct ImGuiPtrOrIndex",
+  ImGuiScrollFlags="int",
+  ImGuiSelectableFlags="int",
+  ImGuiSelectionBasicStorage="struct ImGuiSelectionBasicStorage",
+  ImGuiSelectionExternalStorage="struct ImGuiSelectionExternalStorage",
+  ImGuiSelectionRequest="struct ImGuiSelectionRequest",
+  ImGuiSelectionUserData="ImS64",
+  ImGuiSeparatorFlags="int",
+  ImGuiSettingsHandler="struct ImGuiSettingsHandler",
+  ImGuiShrinkWidthItem="struct ImGuiShrinkWidthItem",
+  ImGuiSizeCallback="void (*)(ImGuiSizeCallbackData* data);",
+  ImGuiSizeCallbackData="struct ImGuiSizeCallbackData",
+  ImGuiSliderFlags="int",
+  ImGuiStackLevelInfo="struct ImGuiStackLevelInfo",
+  ImGuiStorage="struct ImGuiStorage",
+  ImGuiStoragePair="struct ImGuiStoragePair",
+  ImGuiStyle="struct ImGuiStyle",
+  ImGuiStyleMod="struct ImGuiStyleMod",
+  ImGuiStyleVar="int",
+  ImGuiStyleVarInfo="struct ImGuiStyleVarInfo",
+  ImGuiTabBar="struct ImGuiTabBar",
+  ImGuiTabBarFlags="int",
+  ImGuiTabItem="struct ImGuiTabItem",
+  ImGuiTabItemFlags="int",
+  ImGuiTable="struct ImGuiTable",
+  ImGuiTableBgTarget="int",
+  ImGuiTableCellData="struct ImGuiTableCellData",
+  ImGuiTableColumn="struct ImGuiTableColumn",
+  ImGuiTableColumnFlags="int",
+  ImGuiTableColumnIdx="ImS16",
+  ImGuiTableColumnSettings="struct ImGuiTableColumnSettings",
+  ImGuiTableColumnSortSpecs="struct ImGuiTableColumnSortSpecs",
+  ImGuiTableColumnsSettings="struct ImGuiTableColumnsSettings",
+  ImGuiTableDrawChannelIdx="ImU16",
+  ImGuiTableFlags="int",
+  ImGuiTableHeaderData="struct ImGuiTableHeaderData",
+  ImGuiTableInstanceData="struct ImGuiTableInstanceData",
+  ImGuiTableRowFlags="int",
+  ImGuiTableSettings="struct ImGuiTableSettings",
+  ImGuiTableSortSpecs="struct ImGuiTableSortSpecs",
+  ImGuiTableTempData="struct ImGuiTableTempData",
+  ImGuiTextBuffer="struct ImGuiTextBuffer",
+  ImGuiTextFilter="struct ImGuiTextFilter",
+  ImGuiTextFlags="int",
+  ImGuiTextIndex="struct ImGuiTextIndex",
+  ImGuiTextRange="struct ImGuiTextRange",
+  ImGuiTooltipFlags="int",
+  ImGuiTreeNodeFlags="int",
+  ImGuiTreeNodeStackData="struct ImGuiTreeNodeStackData",
+  ImGuiTypingSelectFlags="int",
+  ImGuiTypingSelectRequest="struct ImGuiTypingSelectRequest",
+  ImGuiTypingSelectState="struct ImGuiTypingSelectState",
+  ImGuiViewport="struct ImGuiViewport",
+  ImGuiViewportFlags="int",
+  ImGuiViewportP="struct ImGuiViewportP",
+  ImGuiWindow="struct ImGuiWindow",
+  ImGuiWindowFlags="int",
+  ImGuiWindowRefreshFlags="int",
+  ImGuiWindowSettings="struct ImGuiWindowSettings",
+  ImGuiWindowStackData="struct ImGuiWindowStackData",
+  ImGuiWindowTempData="struct ImGuiWindowTempData",
+  ImPoolIdx="int",
+  ImRect="struct ImRect",
+  ImS16="signed short",
+  ImS32="signed int",
+  ImS64="signed long long",
+  ImS8="signed char",
+  ImStbTexteditState="ImStb::STB_TexteditState",
+  ImTextureID="ImU64",
+  ImU16="unsigned short",
+  ImU32="unsigned int",
+  ImU64="unsigned long long",
+  ImU8="unsigned char",
+  ImVec1="struct ImVec1",
+  ImVec2="struct ImVec2",
+  ImVec2ih="struct ImVec2ih",
+  ImVec4="struct ImVec4",
+  ImWchar="ImWchar16",
+  ImWchar16="unsigned short",
+  ImWchar32="unsigned int",
+  STB_TexteditState="struct STB_TexteditState"}
+ return t

generator/print_defines.cpp

@@ -31,3 +31,7 @@
 #ifdef ImDrawCallback_ResetRenderState
 #pragma message(CIMGUI_DEFSTRING(ImDrawCallback_ResetRenderState))
 #endif
+
+#ifdef IMGUI_HAS_TEXTURES
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_TEXTURES))
+#endif

test/main.c

@@ -11,6 +11,8 @@
 #define igDebugCheckVersionAndDataLayout igDebugCheckVersionAndDataLayout_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 int main(void)
 {
   assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),