example_sdl_vulkan tries to emulate imgui

IMGUI_USE_FREETYPE and IMGUI_USE_WCHAR32 are build options now.
cmake takes IMGUI_FREETYPE and IMGUI_WCHAR32

CMakeLists.txt

@@ -26,10 +26,10 @@ set(IMGUI_FREETYPE "no" CACHE STRING "Build with freetype library")
 set(IMGUI_LIBRARIES )
 
 if(IMGUI_FREETYPE)
+	message(STATUS "Building with freetype")
 	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
 	list(APPEND IMGUI_LIBRARIES freetype)
 	list(APPEND IMGUI_SOURCES imgui/misc/freetype/imgui_freetype.cpp)
-	add_definitions("-DCIMGUI_FREETYPE=1")
 endif(IMGUI_FREETYPE)
 
 #add library and link
@@ -39,6 +39,16 @@ else (IMGUI_STATIC)
     add_library(cimgui SHARED ${IMGUI_SOURCES})
 endif (IMGUI_STATIC)
 
+if(IMGUI_FREETYPE)
+	target_compile_definitions(cimgui PUBLIC IMGUI_ENABLE_FREETYPE)
+	target_compile_definitions(cimgui PUBLIC IMGUI_ENABLE_STB_TRUETYPE)
+endif(IMGUI_FREETYPE)
+
+if(IMGUI_WCHAR32)
+	target_compile_definitions(cimgui PUBLIC IMGUI_USE_WCHAR32)
+endif(IMGUI_WCHAR32)
+
+add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
 target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
 if (WIN32)
     target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t__declspec\(dllexport\))

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.4 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.91.8 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.
@@ -24,7 +24,7 @@ Notes:
   * `git submodule update --init --recursive` (If already cloned)
 * compile 
   * using makefile on linux/macOS/mingw (Or use CMake to generate project)
-  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location) (only if cimgui is generated with freetype option)
+  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location) and IMGUI_WCHAR32
   * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
   
   For compiling with backends there are now examples with SDL2 and opengl3/vulkan in folder backend_test.
@@ -37,12 +37,12 @@ Notes:
 * you will need LuaJIT (https://github.com/LuaJIT/LuaJIT.git better 2.1 branch) or precompiled for linux/macOS/windows in https://luapower.com/luajit/download
 * you need to use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC). (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired backends and whether imgui_internal is generated or not, Freetype2 is used or not and comments are generated or not and if constructors are generated also with versions performing just initialization of structs provided by yourself (_Construct is added to the constructor names)
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired backends and whether imgui_internal is generated or not, comments are generated or not and if constructors are generated also with versions performing just initialization of structs provided by yourself (_Construct is added to the constructor names)
 * the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, vulkan, opengl2 and opengl3 as backends.
 * edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
 * Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp`, `cimgui.h` and `cimgui_impl.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the backends info. 
-* You can pass compiler flags to generator.sh or generator.bat by editing them at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+* You can pass compiler flags to generator.sh or generator.bat by editing them at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG)
 * You are able to pass any extra argument to generator.sh (.bat) in the command-line.
 * If you are using different options than cimgui repo and if you want to keep them after a cimgui update, you can keep them in a copy of generator.sh (.bat) outside of cimgui folder where `cd cimgui/generator` is used before luajit call. See https://github.com/cimgui/cimgui/issues/232#issuecomment-1497059497
 # generate binding

backend_test/example_glfw_dx11/CMakeLists.txt

@@ -23,6 +23,7 @@ else()
 endif()
 
 include_directories(../../imgui)
+add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
 add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
 include_directories(../../)

backend_test/example_glfw_opengl3/CMakeLists.txt

@@ -23,6 +23,7 @@ else()
 endif()
 
 include_directories(../../imgui)
+add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
 add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
 include_directories(../../)

backend_test/example_sdl_opengl3/CMakeLists.txt

@@ -22,7 +22,6 @@ else()
 endif()
 
 include_directories(../../imgui)
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
 include_directories(../../)
 set(IMGUI_SOURCES 
@@ -37,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")
 
@@ -65,40 +60,41 @@ else(WIN32)#Unix
 endif(WIN32)
 
 
-#sdl2
 list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
+include(FetchContent)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+Set(FETCHCONTENT_QUIET FALSE)
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
 
-if(SDL2_FOUND)
+FetchContent_Declare(
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+        SDL2
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+        GIT_TAG release-2.30.12
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+        #GIT_SHALLOW TRUE
-		include_directories(${SDL2_INCLUDE_DIRS})
+        GIT_PROGRESS TRUE
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+)
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+#FetchContent_MakeAvailable(SDL2)
-	else()#use new one SDL2 config
+FetchContent_GetProperties(SDL2)
-		include_directories(${SDL_INCLUDE})
+if (NOT sdl2_POPULATED)
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+	set(FETCHCONTENT_QUIET NO)
-		set(SDL_MAIN SDL2::SDL2main)
+    FetchContent_Populate(SDL2)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
-	endif()
+	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
-else(SDL2_FOUND)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
-	if(DEFINED SDL_PATH)
+endif()
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
+include_directories(${SDL2_SOURCE_DIR}/include})
-	else(DEFINED SDL_PATH)
+
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
+#if dynamic SDL2 then install
-	endif(DEFINED SDL_PATH)
+install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
-endif(SDL2_FOUND)
+					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/)
@@ -107,5 +103,4 @@ target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+target_link_libraries(test_sdl SDL2 cimgui_sdl)
-

backend_test/example_sdl_opengl3/README.md

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

backend_test/example_sdl_vulkan/CMakeLists.txt

@@ -19,7 +19,7 @@ else()
 endif()
 
 include_directories(../../imgui)
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+
 
 include_directories(../../)
 set(IMGUI_SOURCES ../../cimgui.cpp
@@ -33,11 +33,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)
@@ -53,41 +48,45 @@ endif(IMGUI_FREETYPE)
 find_package(Vulkan REQUIRED FATAL_ERROR)
 list(APPEND IMGUI_LIBRARIES Vulkan::Vulkan)
 list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_vulkan.cpp)
+include_directories(${Vulkan_INCLUDE_DIRS})
 
 #sdl2
 list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
+include(FetchContent)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+Set(FETCHCONTENT_QUIET FALSE)
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
 
-if(SDL2_FOUND)
+FetchContent_Declare(
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+        SDL2
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+        GIT_TAG release-2.30.12
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+        #GIT_SHALLOW TRUE
-		include_directories(${SDL2_INCLUDE_DIRS})
+        GIT_PROGRESS TRUE
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+)
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+FetchContent_GetProperties(SDL2)
-	else()#use new one SDL2 config
+if (NOT sdl2_POPULATED)
-		include_directories(${SDL_INCLUDE})
+	set(FETCHCONTENT_QUIET NO)
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+    FetchContent_Populate(SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-	endif()
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
-else(SDL2_FOUND)
+endif()
-	if(DEFINED SDL_PATH)
+include_directories(${SDL2_SOURCE_DIR}/include)
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
-	else(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
-	endif(DEFINED SDL_PATH)
-endif(SDL2_FOUND)
 
-add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
+
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+#if dynamic SDL2 then install
+# install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					# LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+# )
+
+add_library(cimgui_sdl STATIC ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+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/)
@@ -96,5 +95,5 @@ target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+target_link_libraries(test_sdl SDL2-static cimgui_sdl ${IMGUI_LIBRARIES})
 

backend_test/example_sdl_vulkan/README.md

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

backend_test/example_sdl_vulkan/main.c

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

cimconfig.h

@@ -0,0 +1 @@
+#undef NDEBUG

cimgui.cpp

@@ -1,16 +1,9 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.91.4" 19140 from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.91.8" 19180 from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
+//with imgui_freetype.h api
 //docking branch
-#ifdef IMGUI_ENABLE_FREETYPE
+
-#ifndef CIMGUI_FREETYPE
-#error "IMGUI_FREETYPE should be defined for Freetype linking"
-#endif
-#else
-#ifdef CIMGUI_FREETYPE
-#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
-#endif
-#endif
 #include "./imgui/imgui.h"
 #ifdef IMGUI_ENABLE_FREETYPE
 #include "./imgui/misc/freetype/imgui_freetype.h"
@@ -1584,6 +1577,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);
@@ -2303,7 +2300,7 @@ CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,const ImVec2 pos,ImU32
 {
     return self->AddText(pos,col,text_begin,text_end);
 }
-CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)
+CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)
 {
     return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
 }
@@ -2603,14 +2600,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();
@@ -3998,6 +3995,14 @@ CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiT
 {
     return self->GetColumnSettings();
 }
+CIMGUI_API ImGuiIO* igGetIOEx(ImGuiContext* ctx)
+{
+    return &ImGui::GetIOEx(ctx);
+}
+CIMGUI_API ImGuiPlatformIO* igGetPlatformIOEx(ImGuiContext* ctx)
+{
+    return &ImGui::GetPlatformIOEx(ctx);
+}
 CIMGUI_API ImGuiWindow* igGetCurrentWindowRead()
 {
     return ImGui::GetCurrentWindowRead();
@@ -4126,6 +4131,10 @@ 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);
@@ -4370,9 +4379,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)
 {
@@ -4402,9 +4411,9 @@ CIMGUI_API void igEndDisabledOverrideReenable()
 {
     return ImGui::EndDisabledOverrideReenable();
 }
-CIMGUI_API void igLogBegin(ImGuiLogType type,int auto_open_depth)
+CIMGUI_API void igLogBegin(ImGuiLogFlags flags,int auto_open_depth)
 {
-    return ImGui::LogBegin(type,auto_open_depth);
+    return ImGui::LogBegin(flags,auto_open_depth);
 }
 CIMGUI_API void igLogToBuffer(int auto_open_depth)
 {
@@ -5294,6 +5303,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);
@@ -5398,9 +5411,9 @@ CIMGUI_API bool igArrowButtonEx(const char* str_id,ImGuiDir dir,ImVec2 size_arg,
 {
     return ImGui::ArrowButtonEx(str_id,dir,size_arg,flags);
 }
-CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags)
+CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags)
 {
-    return ImGui::ImageButtonEx(id,texture_id,image_size,uv0,uv1,bg_col,tint_col,flags);
+    return ImGui::ImageButtonEx(id,user_texture_id,image_size,uv0,uv1,bg_col,tint_col,flags);
 }
 CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags,float thickness)
 {
@@ -5430,9 +5443,9 @@ CIMGUI_API void igScrollbar(ImGuiAxis axis)
 {
     return ImGui::Scrollbar(axis);
 }
-CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags flags)
+CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags draw_rounding_flags)
 {
-    return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,flags);
+    return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,draw_rounding_flags);
 }
 CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)
 {
@@ -5790,11 +5803,27 @@ CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[2
 {
     return ImFontAtlasBuildMultiplyRectAlpha8(table,pixels,x,y,w,h,stride);
 }
+CIMGUI_API void igImFontAtlasBuildGetOversampleFactors(const ImFontConfig* cfg,int* out_oversample_h,int* out_oversample_v)
+{
+    return ImFontAtlasBuildGetOversampleFactors(cfg,out_oversample_h,out_oversample_v);
+}
+#ifdef IMGUI_ENABLE_FREETYPE
+CIMGUI_API const ImFontBuilderIO* ImGuiFreeType_GetBuilderForFreeType()
+{
+    return ImGuiFreeType::GetBuilderForFreeType();
+}
+
+CIMGUI_API void ImGuiFreeType_SetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)
+{
+    return ImGuiFreeType::SetAllocatorFunctions(alloc_func,free_func,user_data);
+}
+
+#endif
 
 
 
 /////////////////////////////manual written functions
-CIMGUI_API void igLogText(CONST char *fmt, ...)
+CIMGUI_API void igLogText(const char *fmt, ...)
 {
     char buffer[256];
     va_list args;
@@ -5804,11 +5833,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.h

@@ -1,6 +1,7 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.91.4" 19140 from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.91.8" 19180 from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
+//with imgui_freetype.h api
 //docking branch
 #ifndef CIMGUI_INCLUDED
 #define CIMGUI_INCLUDED
@@ -81,12 +82,14 @@ typedef struct ImGuiViewport ImGuiViewport;
 typedef struct ImGuiWindowClass ImGuiWindowClass;
 typedef struct ImBitVector ImBitVector;
 typedef struct ImRect ImRect;
+typedef struct ImGuiTextIndex ImGuiTextIndex;
 typedef struct ImDrawDataBuilder ImDrawDataBuilder;
 typedef struct ImGuiBoxSelectState ImGuiBoxSelectState;
 typedef struct ImGuiColorMod ImGuiColorMod;
 typedef struct ImGuiContextHook ImGuiContextHook;
 typedef struct ImGuiDataVarInfo ImGuiDataVarInfo;
 typedef struct ImGuiDataTypeInfo ImGuiDataTypeInfo;
+typedef struct ImGuiDeactivatedItemData ImGuiDeactivatedItemData;
 typedef struct ImGuiDockContext ImGuiDockContext;
 typedef struct ImGuiDockRequest ImGuiDockRequest;
 typedef struct ImGuiDockNode ImGuiDockNode;
@@ -215,7 +218,18 @@ typedef ImU64 ImTextureID;
 typedef unsigned short ImDrawIdx;
 typedef unsigned int ImWchar32;
 typedef unsigned short ImWchar16;
+
+#ifdef IMGUI_USE_WCHAR32            
+typedef ImWchar32 ImWchar;
+#else
 typedef ImWchar16 ImWchar;
+#endif
+#ifdef IMGUI_USE_WCHAR32
+#define IM_UNICODE_CODEPOINT_MAX     0x10FFFF   
+#else
+#define IM_UNICODE_CODEPOINT_MAX     0xFFFF  
+#endif
+	
 typedef ImS64 ImGuiSelectionUserData;
 typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData* data);
 typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data);
@@ -256,12 +270,12 @@ typedef enum {
     ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
     ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse,
     ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
+    ImGuiWindowFlags_DockNodeHost = 1 << 23,
     ImGuiWindowFlags_ChildWindow = 1 << 24,
     ImGuiWindowFlags_Tooltip = 1 << 25,
     ImGuiWindowFlags_Popup = 1 << 26,
     ImGuiWindowFlags_Modal = 1 << 27,
     ImGuiWindowFlags_ChildMenu = 1 << 28,
-    ImGuiWindowFlags_DockNodeHost = 1 << 29,
 }ImGuiWindowFlags_;
 typedef enum {
     ImGuiChildFlags_None = 0,
@@ -303,12 +317,13 @@ typedef enum {
     ImGuiInputTextFlags_DisplayEmptyRefVal = 1 << 14,
     ImGuiInputTextFlags_NoHorizontalScroll = 1 << 15,
     ImGuiInputTextFlags_NoUndoRedo = 1 << 16,
-    ImGuiInputTextFlags_CallbackCompletion = 1 << 17,
+    ImGuiInputTextFlags_ElideLeft = 1 << 17,
-    ImGuiInputTextFlags_CallbackHistory = 1 << 18,
+    ImGuiInputTextFlags_CallbackCompletion = 1 << 18,
-    ImGuiInputTextFlags_CallbackAlways = 1 << 19,
+    ImGuiInputTextFlags_CallbackHistory = 1 << 19,
-    ImGuiInputTextFlags_CallbackCharFilter = 1 << 20,
+    ImGuiInputTextFlags_CallbackAlways = 1 << 20,
-    ImGuiInputTextFlags_CallbackResize = 1 << 21,
+    ImGuiInputTextFlags_CallbackCharFilter = 1 << 21,
-    ImGuiInputTextFlags_CallbackEdit = 1 << 22,
+    ImGuiInputTextFlags_CallbackResize = 1 << 22,
+    ImGuiInputTextFlags_CallbackEdit = 1 << 23,
 }ImGuiInputTextFlags_;
 typedef enum {
     ImGuiTreeNodeFlags_None = 0,
@@ -325,9 +340,10 @@ typedef enum {
     ImGuiTreeNodeFlags_FramePadding = 1 << 10,
     ImGuiTreeNodeFlags_SpanAvailWidth = 1 << 11,
     ImGuiTreeNodeFlags_SpanFullWidth = 1 << 12,
-    ImGuiTreeNodeFlags_SpanTextWidth = 1 << 13,
+    ImGuiTreeNodeFlags_SpanLabelWidth = 1 << 13,
     ImGuiTreeNodeFlags_SpanAllColumns = 1 << 14,
-    ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 15,
+    ImGuiTreeNodeFlags_LabelSpanAllColumns = 1 << 15,
+    ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 17,
     ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog,
 }ImGuiTreeNodeFlags_;
 typedef enum {
@@ -460,6 +476,7 @@ typedef enum {
     ImGuiDataType_Float,
     ImGuiDataType_Double,
     ImGuiDataType_Bool,
+    ImGuiDataType_String,
     ImGuiDataType_COUNT
 }ImGuiDataType_;
 typedef enum {
@@ -477,6 +494,7 @@ ImGuiSortDirection_Descending=2,
 }ImGuiSortDirection;
 typedef enum {
 ImGuiKey_None=0,
+ImGuiKey_NamedKey_BEGIN=512,
 ImGuiKey_Tab=512,
 ImGuiKey_LeftArrow=513,
 ImGuiKey_RightArrow=514,
@@ -631,18 +649,14 @@ ImGuiKey_ReservedForModCtrl=662,
 ImGuiKey_ReservedForModShift=663,
 ImGuiKey_ReservedForModAlt=664,
 ImGuiKey_ReservedForModSuper=665,
-ImGuiKey_COUNT=666,
+ImGuiKey_NamedKey_END=666,
 ImGuiMod_None=0,
 ImGuiMod_Ctrl=1 << 12,
 ImGuiMod_Shift=1 << 13,
 ImGuiMod_Alt=1 << 14,
 ImGuiMod_Super=1 << 15,
 ImGuiMod_Mask_=0xF000,
-ImGuiKey_NamedKey_BEGIN=512,
-ImGuiKey_NamedKey_END=ImGuiKey_COUNT,
 ImGuiKey_NamedKey_COUNT=ImGuiKey_NamedKey_END - ImGuiKey_NamedKey_BEGIN,
-ImGuiKey_KeysData_SIZE=ImGuiKey_NamedKey_COUNT,
-ImGuiKey_KeysData_OFFSET=ImGuiKey_NamedKey_BEGIN,
 }ImGuiKey;
 typedef enum {
     ImGuiInputFlags_None = 0,
@@ -799,9 +813,10 @@ typedef enum {
     ImGuiColorEditFlags_NoSidePreview = 1 << 8,
     ImGuiColorEditFlags_NoDragDrop = 1 << 9,
     ImGuiColorEditFlags_NoBorder = 1 << 10,
+    ImGuiColorEditFlags_AlphaOpaque = 1 << 11,
+    ImGuiColorEditFlags_AlphaNoBg = 1 << 12,
+    ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 13,
     ImGuiColorEditFlags_AlphaBar = 1 << 16,
-    ImGuiColorEditFlags_AlphaPreview = 1 << 17,
-    ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18,
     ImGuiColorEditFlags_HDR = 1 << 19,
     ImGuiColorEditFlags_DisplayRGB = 1 << 20,
     ImGuiColorEditFlags_DisplayHSV = 1 << 21,
@@ -813,6 +828,7 @@ typedef enum {
     ImGuiColorEditFlags_InputRGB = 1 << 27,
     ImGuiColorEditFlags_InputHSV = 1 << 28,
     ImGuiColorEditFlags_DefaultOptions_ = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_PickerHueBar,
+    ImGuiColorEditFlags_AlphaMask_ = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaOpaque | ImGuiColorEditFlags_AlphaNoBg | ImGuiColorEditFlags_AlphaPreviewHalf,
     ImGuiColorEditFlags_DisplayMask_ = ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_DisplayHex,
     ImGuiColorEditFlags_DataTypeMask_ = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float,
     ImGuiColorEditFlags_PickerMask_ = ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar,
@@ -826,6 +842,7 @@ typedef enum {
     ImGuiSliderFlags_WrapAround = 1 << 8,
     ImGuiSliderFlags_ClampOnInput = 1 << 9,
     ImGuiSliderFlags_ClampZeroRange = 1 << 10,
+    ImGuiSliderFlags_NoSpeedTweaks = 1 << 11,
     ImGuiSliderFlags_AlwaysClamp = ImGuiSliderFlags_ClampOnInput | ImGuiSliderFlags_ClampZeroRange,
     ImGuiSliderFlags_InvalidMask_ = 0x7000000F,
 }ImGuiSliderFlags_;
@@ -1057,6 +1074,7 @@ struct ImGuiIO
     bool ConfigDragClickToInputText;
     bool ConfigWindowsResizeFromEdges;
     bool ConfigWindowsMoveFromTitleBarOnly;
+    bool ConfigWindowsCopyContentsWithCtrlC;
     bool ConfigScrollbarScrollByPage;
     float ConfigMemoryCompactTimer;
     float MouseDoubleClickTime;
@@ -1104,7 +1122,7 @@ struct ImGuiIO
     bool KeyAlt;
     bool KeySuper;
     ImGuiKeyChord KeyMods;
-    ImGuiKeyData KeysData[ImGuiKey_KeysData_SIZE];
+    ImGuiKeyData KeysData[ImGuiKey_NamedKey_COUNT];
     bool WantCaptureMouseUnlessPopupClose;
     ImVec2 MousePosPrev;
     ImVec2 MouseClickedPos[5];
@@ -1114,6 +1132,7 @@ struct ImGuiIO
     ImU16 MouseClickedCount[5];
     ImU16 MouseClickedLastCount[5];
     bool MouseReleased[5];
+    double MouseReleasedTime[5];
     bool MouseDownOwned[5];
     bool MouseDownOwnedUnlessPopupClose[5];
     bool MouseWheelRequestAxisSwap;
@@ -1125,8 +1144,6 @@ struct ImGuiIO
     float PenPressure;
     bool AppFocusLost;
     bool AppAcceptingEvents;
-    ImS8 BackendUsingLegacyKeyArrays;
-    bool BackendUsingLegacyNavInputArray;
     ImWchar16 InputQueueSurrogate;
     ImVector_ImWchar InputQueueCharacters;
 };
@@ -1399,17 +1416,17 @@ struct ImFontConfig
     void* FontData;
     int FontDataSize;
     bool FontDataOwnedByAtlas;
+    bool MergeMode;
+    bool PixelSnapH;
     int FontNo;
-    float SizePixels;
     int OversampleH;
     int OversampleV;
-    bool PixelSnapH;
+    float SizePixels;
     ImVec2 GlyphExtraSpacing;
     ImVec2 GlyphOffset;
     const ImWchar* GlyphRanges;
     float GlyphMinAdvanceX;
     float GlyphMaxAdvanceX;
-    bool MergeMode;
     unsigned int FontBuilderFlags;
     float RasterizerMultiply;
     float RasterizerDensity;
@@ -1435,9 +1452,10 @@ struct ImFontGlyphRangesBuilder
 typedef struct ImFontAtlasCustomRect ImFontAtlasCustomRect;
 struct ImFontAtlasCustomRect
 {
-    unsigned short Width, Height;
     unsigned short X, Y;
-    unsigned int GlyphID;
+    unsigned short Width, Height;
+    unsigned int GlyphID : 31;
+    unsigned int GlyphColored : 1;
     float GlyphAdvanceX;
     ImVec2 GlyphOffset;
     ImFont* Font;
@@ -1460,8 +1478,8 @@ struct ImFontAtlas
     ImTextureID TexID;
     int TexDesiredWidth;
     int TexGlyphPadding;
-    bool Locked;
     void* UserData;
+    bool Locked;
     bool TexReady;
     bool TexPixelsUseColors;
     unsigned char* TexPixelsAlpha8;
@@ -1473,7 +1491,7 @@ struct ImFontAtlas
     ImVector_ImFontPtr Fonts;
     ImVector_ImFontAtlasCustomRect CustomRects;
     ImVector_ImFontConfig ConfigData;
-    ImVec4 TexUvLines[(63) + 1];
+    ImVec4 TexUvLines[(32) + 1];
     const ImFontBuilderIO* FontBuilderIO;
     unsigned int FontBuilderFlags;
     int PackIdMouseCursors;
@@ -1481,6 +1499,8 @@ struct ImFontAtlas
 };
 typedef struct ImVector_float {int Size;int Capacity;float* Data;} ImVector_float;
 
+typedef struct ImVector_ImU16 {int Size;int Capacity;ImU16* Data;} ImVector_ImU16;
+
 typedef struct ImVector_ImFontGlyph {int Size;int Capacity;ImFontGlyph* Data;} ImVector_ImFontGlyph;
 
 struct ImFont
@@ -1488,22 +1508,22 @@ struct ImFont
     ImVector_float IndexAdvanceX;
     float FallbackAdvanceX;
     float FontSize;
-    ImVector_ImWchar IndexLookup;
+    ImVector_ImU16 IndexLookup;
     ImVector_ImFontGlyph Glyphs;
     const ImFontGlyph* FallbackGlyph;
     ImFontAtlas* ContainerAtlas;
     const ImFontConfig* ConfigData;
     short ConfigDataCount;
-    ImWchar FallbackChar;
-    ImWchar EllipsisChar;
     short EllipsisCharCount;
+    ImWchar EllipsisChar;
+    ImWchar FallbackChar;
     float EllipsisWidth;
     float EllipsisCharStep;
-    bool DirtyLookupTables;
     float Scale;
     float Ascent, Descent;
     int MetricsTotalSurface;
-    ImU8 Used4kPagesMap[(0xFFFF +1)/4096/8];
+    bool DirtyLookupTables;
+    ImU8 Used8kPagesMap[(IM_UNICODE_CODEPOINT_MAX +1)/8192/8];
 };
 typedef enum {
     ImGuiViewportFlags_None = 0,
@@ -1599,6 +1619,7 @@ struct ImGuiPlatformImeData
 };
 struct ImBitVector;
 struct ImRect;
+struct ImGuiTextIndex;
 struct ImDrawDataBuilder;
 struct ImDrawListSharedData;
 struct ImGuiBoxSelectState;
@@ -1607,6 +1628,7 @@ struct ImGuiContext;
 struct ImGuiContextHook;
 struct ImGuiDataVarInfo;
 struct ImGuiDataTypeInfo;
+struct ImGuiDeactivatedItemData;
 struct ImGuiDockContext;
 struct ImGuiDockRequest;
 struct ImGuiDockNode;
@@ -1652,6 +1674,7 @@ typedef int ImGuiDebugLogFlags;
 typedef int ImGuiFocusRequestFlags;
 typedef int ImGuiItemStatusFlags;
 typedef int ImGuiOldColumnFlags;
+typedef int ImGuiLogFlags;
 typedef int ImGuiNavRenderCursorFlags;
 typedef int ImGuiNavMoveFlags;
 typedef int ImGuiNextItemDataFlags;
@@ -1685,7 +1708,6 @@ struct ImBitVector
     ImVector_ImU32 Storage;
 };
 typedef int ImPoolIdx;
-typedef struct ImGuiTextIndex ImGuiTextIndex;
 typedef struct ImVector_int {int Size;int Capacity;int* Data;} ImVector_int;
 
 struct ImGuiTextIndex
@@ -1696,6 +1718,7 @@ struct ImGuiTextIndex
 struct ImDrawListSharedData
 {
     ImVec2 TexUvWhitePixel;
+    const ImVec4* TexUvLines;
     ImFont* Font;
     float FontSize;
     float FontScale;
@@ -1707,7 +1730,6 @@ struct ImDrawListSharedData
     ImVec2 ArcFastVtx[48];
     float ArcFastRadiusCutoff;
     ImU8 CircleSegmentCounts[64];
-    const ImVec4* TexUvLines;
 };
 struct ImDrawDataBuilder
 {
@@ -1733,8 +1755,7 @@ struct ImGuiDataTypeInfo
     const char* ScanFmt;
 };
 typedef enum {
-    ImGuiDataType_String = ImGuiDataType_COUNT + 1,
+    ImGuiDataType_Pointer = ImGuiDataType_COUNT + 1,
-    ImGuiDataType_Pointer,
     ImGuiDataType_ID,
 }ImGuiDataTypePrivate_;
 typedef enum {
@@ -1839,12 +1860,13 @@ typedef enum {
     ImGuiLayoutType_Vertical = 1
 }ImGuiLayoutType_;
 typedef enum {
-    ImGuiLogType_None = 0,
+    ImGuiLogFlags_None = 0,
-    ImGuiLogType_TTY,
+    ImGuiLogFlags_OutputTTY = 1 << 0,
-    ImGuiLogType_File,
+    ImGuiLogFlags_OutputFile = 1 << 1,
-    ImGuiLogType_Buffer,
+    ImGuiLogFlags_OutputBuffer = 1 << 2,
-    ImGuiLogType_Clipboard,
+    ImGuiLogFlags_OutputClipboard = 1 << 3,
-}ImGuiLogType;
+    ImGuiLogFlags_OutputMask_ = ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard,
+}ImGuiLogFlags_;
 typedef enum {
     ImGuiAxis_None = -1,
     ImGuiAxis_X = 0,
@@ -1885,7 +1907,7 @@ struct ImGuiGroupData
     ImVec2 BackupCurrLineSize;
     float BackupCurrLineTextBaseOffset;
     ImGuiID BackupActiveIdIsAlive;
-    bool BackupActiveIdPreviousFrameIsAlive;
+    bool BackupDeactivatedIdIsAlive;
     bool BackupHoveredIdIsAlive;
     bool BackupIsSameLine;
     bool EmitItem;
@@ -1912,19 +1934,20 @@ struct ImGuiInputTextState
 {
     ImGuiContext* Ctx;
     ImStbTexteditState* Stb;
+    ImGuiInputTextFlags Flags;
     ImGuiID ID;
-    int CurLenA;
+    int TextLen;
+    const char* TextSrc;
     ImVector_char TextA;
-    ImVector_char InitialTextA;
+    ImVector_char TextToRevertTo;
     ImVector_char CallbackTextBackup;
-    int BufCapacityA;
+    int BufCapacity;
     ImVec2 Scroll;
     float CursorAnim;
     bool CursorFollow;
     bool SelectedAllMouseLock;
     bool Edited;
-    ImGuiInputTextFlags Flags;
+    bool WantReloadUserBuf;
-    bool ReloadUserBuf;
     int ReloadSelectionStart;
     int ReloadSelectionEnd;
 };
@@ -2050,6 +2073,13 @@ struct ImGuiPtrOrIndex
     void* Ptr;
     int Index;
 };
+struct ImGuiDeactivatedItemData
+{
+    ImGuiID ID;
+    int ElapseFrame;
+    bool HasBeenEditedBefore;
+    bool IsAlive;
+};
 typedef enum {
     ImGuiPopupPositionPolicy_Default,
     ImGuiPopupPositionPolicy_ComboBox,
@@ -2572,10 +2602,11 @@ typedef enum {
     ImGuiDebugLogFlags_EventClipper = 1 << 5,
     ImGuiDebugLogFlags_EventSelection = 1 << 6,
     ImGuiDebugLogFlags_EventIO = 1 << 7,
-    ImGuiDebugLogFlags_EventInputRouting = 1 << 8,
+    ImGuiDebugLogFlags_EventFont = 1 << 8,
-    ImGuiDebugLogFlags_EventDocking = 1 << 9,
+    ImGuiDebugLogFlags_EventInputRouting = 1 << 9,
-    ImGuiDebugLogFlags_EventViewport = 1 << 10,
+    ImGuiDebugLogFlags_EventDocking = 1 << 10,
-    ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,
+    ImGuiDebugLogFlags_EventViewport = 1 << 11,
+    ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventFont | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,
     ImGuiDebugLogFlags_OutputToTTY = 1 << 20,
     ImGuiDebugLogFlags_OutputToTestEngine = 1 << 21,
 }ImGuiDebugLogFlags_;
@@ -2716,9 +2747,9 @@ struct ImGuiContext
     int FrameCountEnded;
     int FrameCountPlatformEnded;
     int FrameCountRendered;
+    ImGuiID WithinEndChildID;
     bool WithinFrameScope;
     bool WithinFrameScopeWithImplicitWindow;
-    bool WithinEndChild;
     bool GcCompactAll;
     bool TestEngineHookItems;
     void* TestEngine;
@@ -2772,9 +2803,8 @@ struct ImGuiContext
     ImGuiWindow* ActiveIdWindow;
     ImGuiInputSource ActiveIdSource;
     ImGuiID ActiveIdPreviousFrame;
-    bool ActiveIdPreviousFrameIsAlive;
+    ImGuiDeactivatedItemData DeactivatedItemData;
-    bool ActiveIdPreviousFrameHasBeenEditedBefore;
+    ImGuiDataTypeStorage ActiveIdValueOnActivation;
-    ImGuiWindow* ActiveIdPreviousFrameWindow;
     ImGuiID LastActiveId;
     float LastActiveIdTimer;
     double LastKeyModsChangeTime;
@@ -2965,7 +2995,8 @@ struct ImGuiContext
     ImGuiID HookIdNext;
     const char* LocalizationTable[ImGuiLocKey_COUNT];
     bool LogEnabled;
-    ImGuiLogType LogType;
+    ImGuiLogFlags LogFlags;
+    ImGuiWindow* LogWindow;
     ImFileHandle LogFile;
     ImGuiTextBuffer LogBuffer;
     const char* LogNextPrefix;
@@ -3047,6 +3078,10 @@ struct ImGuiWindowTempData
     ImGuiLayoutType LayoutType;
     ImGuiLayoutType ParentLayoutType;
     ImU32 ModalDimBgColor;
+    ImGuiItemStatusFlags WindowItemStatusFlags;
+    ImGuiItemStatusFlags ChildItemStatusFlags;
+    ImGuiItemStatusFlags DockTabItemStatusFlags;
+    ImRect DockTabItemRect;
     float ItemWidth;
     float TextWrapPos;
     ImVector_float ItemWidthStack;
@@ -3142,7 +3177,9 @@ struct ImGuiWindow
     ImGuiStorage StateStorage;
     ImVector_ImGuiOldColumns ColumnsStorage;
     float FontWindowScale;
+    float FontWindowScaleParents;
     float FontDpiScale;
+    float FontRefSize;
     int SettingsOffset;
     ImDrawList* DrawList;
     ImDrawList DrawListInst;
@@ -3171,8 +3208,6 @@ struct ImGuiWindow
     ImGuiDockNode* DockNode;
     ImGuiDockNode* DockNodeAsHost;
     ImGuiID DockId;
-    ImGuiItemStatusFlags DockTabItemStatusFlags;
-    ImRect DockTabItemRect;
 };
 typedef enum {
     ImGuiTabBarFlags_DockNode = 1 << 20,
@@ -3183,7 +3218,8 @@ typedef enum {
     ImGuiTabItemFlags_SectionMask_ = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing,
     ImGuiTabItemFlags_NoCloseButton = 1 << 20,
     ImGuiTabItemFlags_Button = 1 << 21,
-    ImGuiTabItemFlags_Unsorted = 1 << 22,
+    ImGuiTabItemFlags_Invisible = 1 << 22,
+    ImGuiTabItemFlags_Unsorted = 1 << 23,
 }ImGuiTabItemFlagsPrivate_;
 struct ImGuiTabItem
 {
@@ -3413,6 +3449,7 @@ struct ImGuiTable
     ImGuiTableDrawChannelIdx DummyDrawChannel;
     ImGuiTableDrawChannelIdx Bg2DrawChannelCurrent;
     ImGuiTableDrawChannelIdx Bg2DrawChannelUnfrozen;
+    ImS8 NavLayer;
     bool IsLayoutLocked;
     bool IsInsideRow;
     bool IsInitializing;
@@ -3478,6 +3515,22 @@ struct ImFontBuilderIO
 {
     bool (*FontBuilder_Build)(ImFontAtlas* atlas);
 };
+#ifdef IMGUI_ENABLE_FREETYPE
+struct ImFontAtlas;
+struct ImFontBuilderIO;
+typedef enum {
+    ImGuiFreeTypeBuilderFlags_NoHinting = 1 << 0,
+    ImGuiFreeTypeBuilderFlags_NoAutoHint = 1 << 1,
+    ImGuiFreeTypeBuilderFlags_ForceAutoHint = 1 << 2,
+    ImGuiFreeTypeBuilderFlags_LightHinting = 1 << 3,
+    ImGuiFreeTypeBuilderFlags_MonoHinting = 1 << 4,
+    ImGuiFreeTypeBuilderFlags_Bold = 1 << 5,
+    ImGuiFreeTypeBuilderFlags_Oblique = 1 << 6,
+    ImGuiFreeTypeBuilderFlags_Monochrome = 1 << 7,
+    ImGuiFreeTypeBuilderFlags_LoadColor = 1 << 8,
+    ImGuiFreeTypeBuilderFlags_Bitmap = 1 << 9
+}ImGuiFreeTypeBuilderFlags;
+#endif
 #define IMGUI_HAS_DOCK       1
 
 #define ImDrawCallback_ResetRenderState       (ImDrawCallback)(-8)
@@ -3544,6 +3597,7 @@ typedef ImVector<ImGuiViewportP*> ImVector_ImGuiViewportPPtr;
 typedef ImVector<ImGuiWindow*> ImVector_ImGuiWindowPtr;
 typedef ImVector<ImGuiWindowStackData> ImVector_ImGuiWindowStackData;
 typedef ImVector<ImTextureID> ImVector_ImTextureID;
+typedef ImVector<ImU16> ImVector_ImU16;
 typedef ImVector<ImU32> ImVector_ImU32;
 typedef ImVector<ImU8> ImVector_ImU8;
 typedef ImVector<ImVec2> ImVector_ImVec2;
@@ -3936,6 +3990,7 @@ CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button);
 CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button,bool repeat);
 CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button);
 CIMGUI_API bool igIsMouseDoubleClicked_Nil(ImGuiMouseButton button);
+CIMGUI_API bool igIsMouseReleasedWithDelay(ImGuiMouseButton button,float delay);
 CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button);
 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip);
 CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos);
@@ -4115,7 +4170,7 @@ CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,fl
 CIMGUI_API void ImDrawList_AddEllipse(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments,float thickness);
 CIMGUI_API void ImDrawList_AddEllipseFilled(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments);
 CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end);
-CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect);
+CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect);
 CIMGUI_API void ImDrawList_AddBezierCubic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments);
 CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness,int num_segments);
 CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness);
@@ -4190,8 +4245,8 @@ CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_data_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges);
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges);
 CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self);
-CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self);
 CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self);
+CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self);
 CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self);
 CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self);
 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel);
@@ -4537,6 +4592,8 @@ CIMGUI_API void ImGuiTableColumnSettings_destroy(ImGuiTableColumnSettings* self)
 CIMGUI_API ImGuiTableSettings* ImGuiTableSettings_ImGuiTableSettings(void);
 CIMGUI_API void ImGuiTableSettings_destroy(ImGuiTableSettings* self);
 CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiTableSettings* self);
+CIMGUI_API ImGuiIO* igGetIOEx(ImGuiContext* ctx);
+CIMGUI_API ImGuiPlatformIO* igGetPlatformIOEx(ImGuiContext* ctx);
 CIMGUI_API ImGuiWindow* igGetCurrentWindowRead(void);
 CIMGUI_API ImGuiWindow* igGetCurrentWindow(void);
 CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id);
@@ -4569,6 +4626,7 @@ CIMGUI_API ImGuiWindow* igFindBottomMostVisibleWindowWithinBeginStack(ImGuiWindo
 CIMGUI_API void igSetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags);
 CIMGUI_API void igSetCurrentFont(ImFont* font);
 CIMGUI_API ImFont* igGetDefaultFont(void);
+CIMGUI_API void igPushPasswordFont(void);
 CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window);
 CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,ImVector_ImDrawListPtr* out_list,ImDrawList* draw_list);
 CIMGUI_API void igInitialize(void);
@@ -4630,7 +4688,7 @@ CIMGUI_API bool igItemAdd(const ImRect bb,ImGuiID id,const ImRect* nav_bb,ImGuiI
 CIMGUI_API bool igItemHoverable(const ImRect bb,ImGuiID id,ImGuiItemFlags item_flags);
 CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,ImGuiHoveredFlags flags);
 CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID 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);
 CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h);
 CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos,float wrap_pos_x);
 CIMGUI_API void igPushMultiItemsWidths(int components,float width_full);
@@ -4638,7 +4696,7 @@ CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,int count,float width
 CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx);
 CIMGUI_API void igBeginDisabledOverrideReenable(void);
 CIMGUI_API void igEndDisabledOverrideReenable(void);
-CIMGUI_API void igLogBegin(ImGuiLogType type,int auto_open_depth);
+CIMGUI_API void igLogBegin(ImGuiLogFlags flags,int auto_open_depth);
 CIMGUI_API void igLogToBuffer(int auto_open_depth);
 CIMGUI_API void igLogRenderedText(const ImVec2* ref_pos,const char* text,const char* text_end);
 CIMGUI_API void igLogSetNextTextDecoration(const char* prefix,const char* suffix);
@@ -4861,6 +4919,7 @@ CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,int
 CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,ImVec2 mouse_pos);
 CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar);
 CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window);
+CIMGUI_API void igTabItemSpacing(const char* str_id,ImGuiTabItemFlags flags,float width);
 CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker);
 CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window);
 CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col);
@@ -4887,7 +4946,7 @@ CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,const
 CIMGUI_API void igTextEx(const char* text,const char* text_end,ImGuiTextFlags flags);
 CIMGUI_API bool igButtonEx(const char* label,const ImVec2 size_arg,ImGuiButtonFlags flags);
 CIMGUI_API bool igArrowButtonEx(const char* str_id,ImGuiDir dir,ImVec2 size_arg,ImGuiButtonFlags flags);
-CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags);
+CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags);
 CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags,float thickness);
 CIMGUI_API void igSeparatorTextEx(ImGuiID id,const char* label,const char* label_end,float extra_width);
 CIMGUI_API bool igCheckboxFlags_S64Ptr(const char* label,ImS64* flags,ImS64 flags_value);
@@ -4895,7 +4954,7 @@ CIMGUI_API bool igCheckboxFlags_U64Ptr(const char* label,ImU64* flags,ImU64 flag
 CIMGUI_API bool igCloseButton(ImGuiID id,const ImVec2 pos);
 CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node);
 CIMGUI_API void igScrollbar(ImGuiAxis axis);
-CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags flags);
+CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags draw_rounding_flags);
 CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis);
 CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window,ImGuiAxis axis);
 CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window,int n);
@@ -4985,13 +5044,18 @@ CIMGUI_API void igImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas,in
 CIMGUI_API void igImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned int in_marker_pixel_value);
 CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256],float in_multiply_factor);
 CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256],unsigned char* pixels,int x,int y,int w,int h,int stride);
+CIMGUI_API void igImFontAtlasBuildGetOversampleFactors(const ImFontConfig* cfg,int* out_oversample_h,int* out_oversample_v);
+#ifdef IMGUI_ENABLE_FREETYPE
+CIMGUI_API const ImFontBuilderIO* ImGuiFreeType_GetBuilderForFreeType(void);
+CIMGUI_API void ImGuiFreeType_SetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data);
+#endif
 
 
 /////////////////////////hand written functions
 //no LogTextV
-CIMGUI_API void igLogText(CONST char *fmt, ...);
+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/cimgui_template.cpp

@@ -1,12 +1,4 @@
-#ifdef IMGUI_ENABLE_FREETYPE
+
-#ifndef CIMGUI_FREETYPE
-#error "IMGUI_FREETYPE should be defined for Freetype linking"
-#endif
-#else
-#ifdef CIMGUI_FREETYPE
-#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
-#endif
-#endif
 #include "./imgui/imgui.h"
 #ifdef IMGUI_ENABLE_FREETYPE
 #include "./imgui/misc/freetype/imgui_freetype.h"
@@ -20,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;
@@ -30,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

@@ -47,9 +47,9 @@ typedef union SDL_Event SDL_Event;
 
 /////////////////////////hand written functions
 //no LogTextV
-CIMGUI_API void igLogText(CONST char *fmt, ...);
+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
@@ -432,20 +435,15 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 							loca = table.remove(loca,1)
 						end
 						if not loca then
-							print("not loca",string.format("%q , %q ",itemold,itemfirstline),#itemfirstline)
-							-- for k,v in pairs(linenumdict) do
-								-- if k:match(itemfirstline) then
-									-- print(string.format("%q",k),#k)
-								-- end
-							-- end
-							--error"no entry in linenumdict"
 							--take locat from parent
 							if itparent and itparent.locat then
 								loca = itparent.locat
+								print("parent loca",string.format("%q , %q ",itemold,itemfirstline),#itemfirstline,loca)
 							else
 								loca = 0
-								--error"no entry in linenumdict"
+								print("not loca",string.format("%q , %q ",itemold,itemfirstline),#itemfirstline,loca)
 							end
+							
 						end
 					else
 						error"no linenumdict"
@@ -481,7 +479,7 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 	end
 	return itemarr,items
 end
-M.parseItems = parseItems
+--M.parseItems = parseItems
 local function name_overloadsAlgo(v)
 
     local aa = {} -- args
@@ -605,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"
@@ -673,14 +671,18 @@ local function CleanImU32(def)
 	for i=1,#bb do res = res + bb[i] end 
 	return res
 end
+local function moveptr(line)
+	line = line:gsub("%s*%*","%*")
+	line = line:gsub("%*([%w_])","%* %1")
+	line = line:gsub("(%(%*)%s","%1")
+	return line
+end
 local function parseFunction(self,stname,itt,namespace,locat)
 
 	local lineorig,comment = split_comment(itt.item)
 	line = clean_spaces(lineorig)
 	--move *
-	line = line:gsub("%s*%*","%*")
+	line = moveptr(line)
-	line = line:gsub("%*([%w_])","%* %1")
-	line = line:gsub("(%(%*)%s","%1")
 
 	--print(line)
     --clean implemetation
@@ -719,6 +721,21 @@ local function parseFunction(self,stname,itt,namespace,locat)
 		error"parseFunction not getting args"
     end
 	
+	--get manuals args and ret
+	local cname = self.getCname(stname,funcname, namespace) --cimguiname
+	local manpars = self.manuals[cname]
+	local ismanual
+    if manpars then
+		if type(manpars) == "boolean" then
+			print("warning: unable to get args and ret from "..cname)
+			print("did you forgot to use set_manuals? ")
+		else
+			ismanual = true
+			args, ret = manpars.args, manpars.ret
+			args = moveptr(args)
+			ret = moveptr(ret)
+		end
+	end
 	
 	local argsp = args:sub(2,-2)..","
 	local argsTa = {}
@@ -734,6 +751,8 @@ local function parseFunction(self,stname,itt,namespace,locat)
 			argsTa[#argsTa+1] = tynam
 		end
 	end
+	
+	
 	--- templates in args
 	for i,ar in ipairs(argsTa) do
 		--TODO several diferent templates
@@ -807,6 +826,7 @@ local function parseFunction(self,stname,itt,namespace,locat)
         end
 	end
 	
+
 	local argsArr = argsTa2
 
 	--recreate argscsinpars, call_args and signature from argsArr
@@ -838,7 +858,7 @@ local function parseFunction(self,stname,itt,namespace,locat)
 		caar = "()"
 		signat = "()" .. (extraconst or "")
 	end
-
+	--if ismanual then print("manual",asp, caar, signat) end
     ------------------------------
     
     if not ret and stname then --must be constructors
@@ -871,6 +891,9 @@ local function parseFunction(self,stname,itt,namespace,locat)
 			ar.default = nil
 		end
 	end
+	
+	--if ismanual then M.prtable(argsArr) end
+	
 	defT.templated = self.typenames[stname] and true
 	defT.namespace = namespace
     defT.cimguiname = cimguiname
@@ -901,6 +924,7 @@ local function parseFunction(self,stname,itt,namespace,locat)
         -- end
     end
 	defsT[cimguiname][signat] = defT
+	
 end
 local function itemsCount(items)
 	print"------------items"
@@ -913,8 +937,8 @@ end
 
 local function AdjustArguments(FP)
     for fun,defs in pairs(FP.defsT) do
-        --struct function but no constructors or static functions
+        --struct function but no constructors or static functions or manuals
-        if defs[1].stname~="" and defs[1].ret and not defs[1].is_static_function then
+        if defs[1].stname~="" and defs[1].ret and not defs[1].is_static_function and not defs[1].manual then
             --print("adjusting",fun)
             for i,def in ipairs(defs) do
                 local empty = def.args:match("^%(%)") --no args
@@ -1021,7 +1045,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
@@ -1035,10 +1091,17 @@ local function ADDnonUDT(FP)
 		end
         --if UDT return generate nonUDT version
 		local isUDT = false
-		for _,udt_ret in ipairs(FP.UDTs) do
+		--isUDT = FP.structs_and_enums_table.structs[defT.ret] and true or false
-			if udt_ret == defT.ret then isUDT=true;break end
+		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 = {}
@@ -1111,14 +1174,15 @@ local function ADDdestructors(FP)
 					error"names should be equal"
 				end
 				local def = {}
+				local isrealdestructor = keep_dest_locat[defT[1].stname] and true
 				def.stname = defT[1].stname
 				def.templated = defT[1].templated
-				def.location = keep_dest_locat[defT[1].stname]
+				def.location = keep_dest_locat[defT[1].stname] or defT[1].location
 				def.ret = "void"
 				def.ov_cimguiname = def.stname.."_destroy"
 				def.cimguiname = def.ov_cimguiname
 				def.destructor = true
-				def.realdestructor = def.location and true
+				def.realdestructor = isrealdestructor
 				def.args = "("..def.stname.."* self)"
 				def.call_args = "(self)"
 				def.signature = "("..def.stname.."*)"
@@ -1270,7 +1334,7 @@ function M.Parser()
 							self.typedefs_dict[key] = linet
 						elseif not line:match"typedef%s*struct" then --discard typedef struct
 							print("typedef not found")
-							print(key,value,line)
+							print(key,value,line,cdef[1],cdef[2])
 						end
 					end
 				end
@@ -1295,6 +1359,7 @@ function M.Parser()
 				it.name = it.item:match("class%s+(%S+)")
 				print("cleaning class",it.name)
 				it.item = it.item:gsub("private:.+};$","};")
+				--it.item = it.item:gsub("private:","")
 				it.item = it.item:gsub("public:","")
 				it.item = it.item:gsub("enum%s*class","enum")
 			end
@@ -1343,7 +1408,7 @@ function M.Parser()
 		return table.concat(txtclean)
 	end
 	function par:parseItems()
-		self:initTypedefsDict()
+		--self:initTypedefsDict()
 		
 		self.linenumdict = {}
 		local cdefs2 = {}
@@ -1402,12 +1467,27 @@ 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
 	
 	function par:printItems()
 		printItems(items)
 	end
+	function par:set_manuals(manuals, modulen, erase)
+		erase = erase or {"CIMGUI_API"}
+		local moddata = read_data("./"..modulen.."_template.h")
+		for k,v in pairs(manuals) do
+			local ret = moddata:match("([^%(%):,\n;]+[%*%s])%s?~?"..k.."%b()")
+			for i,ww in ipairs(erase) do
+				ret = ret:gsub(ww,"")
+			end
+			local args = moddata:match(k.."%s*(%b())")
+			manuals[k] = {args = args, ret = ret}
+			--print(k,args,ret)
+		end
+		self.manuals = manuals
+	end
 	par.parseFunction = parseFunction
 	local uniques = {}
 	local function check_unique_typedefs(l,uniques)
@@ -1434,10 +1514,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
@@ -1492,12 +1575,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
+						--print("not doheader",ttype,template,te)
 						if 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
@@ -1553,7 +1638,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
@@ -1582,8 +1667,9 @@ function M.Parser()
 		if parnam~="" then parnam = parnam:sub(1,-3) end
 		return parnam
 	end
-	
+	function par:header_text_insert(tab,txt,it)
-
+		table.insert(tab, txt)
+	end
 	function par:gen_structs_and_enums()
 		print"--------------gen_structs_and_enums"
 		--M.prtable(self.typenames)
@@ -1619,20 +1705,23 @@ 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 = ""
 						end
 					end
 					--table.insert(outtabpre,it2)
-					table.insert(outtab,it2)
+					--table.insert(outtab,it2)
+					self:header_text_insert(outtab, it2, it)
 					-- add typedef after struct name
 					if it.re_name == "vardef_re" and it.item:match"^%s*struct" then
 						local stname = it.item:match("struct%s*(%S+)%s*;")
 						--table.insert(typedefs_table,"typedef struct "..stname.." "..stname..";\n")
 						local tst = "\ntypedef struct "..stname.." "..stname..";"
 						if check_unique_typedefs(tst,uniques) then
-							table.insert(outtabpre,tst)
+							--table.insert(outtabpre,tst)
+							self:header_text_insert(outtabpre ,tst, it)
 						end
 						self.typedefs_dict[stname]="struct "..stname
 						if it.parent then --must be struct name; inside namespace
@@ -1658,11 +1747,15 @@ function M.Parser()
 							end
 						end
 						enumbody = "{"..enumbody.."\n}"
-						table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";"..extraenums)
+						--table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";"..extraenums)
+						local it2 = "\ntypedef enum ".. enumbody..enumname..";"..extraenums
+						self:header_text_insert(outtab, it2, it)
 					else
 						local enumbody = it.item:match"(%b{})"
 						enumbody = clean_comments(enumbody)
-						table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";")
+						--table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";")
+						local it2 = "\ntypedef enum ".. enumbody..enumname..";"
+						self:header_text_insert(outtab, it2, it)
 					end
 					if it.parent then
 						if it.parent.re_name == "namespace_re" then
@@ -1674,7 +1767,8 @@ function M.Parser()
 					end
 				else --unamed enum just repeat declaration
 					local cl_item = clean_comments(it.item)
-					table.insert(outtab,cl_item)
+					--table.insert(outtab,cl_item)
+					self:header_text_insert(outtab, cl_item, it)
 					print("unnamed enum",cl_item)
 				end
 			elseif it.re_name == "struct_re" or it.re_name == "typedef_st_re" or it.re_name == "class_re" then
@@ -1686,12 +1780,14 @@ function M.Parser()
 					--table.insert(typedefs_table,"typedef struct "..structname.." "..structname..";\n")
 					local tst = "\ntypedef struct "..structname.." "..structname..";"
 						if check_unique_typedefs(tst,uniques) then
-							table.insert(outtab,tst)
+							--table.insert(outtab,tst)
+							self:header_text_insert(outtab, tst, it)
 						end
 					self.typedefs_dict[structname]="struct "..structname
 					--dont insert child structs as they are inserted before parent struct
 					if not (it.parent and it.parent.re_name == "struct_re") then
-						table.insert(outtab,predec .. cleanst)
+						--table.insert(outtab,predec .. cleanst)
+						self:header_text_insert(outtab, predec .. cleanst, it)
 					end
 				end
 				if it.parent  then --and (it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" then
@@ -1724,7 +1820,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
@@ -1732,9 +1830,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)
 		
@@ -1864,7 +1964,7 @@ function M.Parser()
 	function par:gen_structs_and_enums_table()
 		print"--------------gen_structs_and_enums_table"
 		local outtab = {enums={},structs={},locations={},enumtypes={},struct_comments={},enum_comments={}}
-		self.typedefs_table = {}
+		--self.typedefs_table = {}
 		local enumsordered = {}
 		unnamed_enum_counter = 0
 		self.templated_structs = {}
@@ -1887,7 +1987,31 @@ function M.Parser()
 				if it.re_name == "typedef_re" and not it.parent then
 					local typedefdef,typedefname = it.item:match"typedef(.+)%s([^%s;]+);$"
 					typedefname = strip(typedefname)
-					self.typedefs_table[typedefname] = strip(typedefdef)
+					--self.typedefs_table[typedefname] = strip(typedefdef)
+					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("%(%*%s*([%w_]+)%)%s*%([^%(%)]*%)")
+					if key then
+						local linet = it.item
+						linet = linet:gsub("[\n%s]+typedef ","")
+						linet = linet:gsub("%(%*("..key..")%)","(*)")
+						self.typedefs_dict[key] = linet
+						--print("functypedef_re",1,linet)--,clean_functypedef(line))
+					else
+						--try function typedef
+						key = it.item:match("%(([%w_]+)%)%([^%(%)]*%)")
+						if key then
+							local linet = it.item
+							linet = linet:gsub("typedef ","")
+							linet = linet:gsub("%(("..key..")%)","()")
+							self.typedefs_dict[key] = linet
+							print("functypedef_re",2, it.item)
+						else
+							print("func typedef not found")
+							print(it.item)
+						end
+					end
 				end
 			elseif it.re_name == "enum_re" then
 				enums_for_table(it, outtab, enumsordered)
@@ -1918,7 +2042,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
@@ -2163,6 +2287,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],",")
@@ -2206,7 +2331,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)
     
@@ -2268,10 +2497,11 @@ local function serializeTable(name, value, saved)
     
     return table.concat(string_table)
 end
-M.serializeTable = serializeTable
+-- M.serializeTable = serializeTable
-M.serializeTableF = function(t)
+-- M.serializeTableF = function(t)
-	return M.serializeTable("defs",t).."\nreturn defs"
+	-- return M.serializeTable("defs",t).."\nreturn defs"
-end
+-- 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+(.+)$"
@@ -2358,7 +2588,8 @@ local function location(file,locpathT,defines,COMPILER,keepemptylines)
 end
 M.location = location
 ---------------------- C writing functions
-local function ImGui_f_implementation(outtab,def)
+local function ImGui_f_implementation(def)
+	local outtab = {}
     local ptret = def.retref and "&" or ""
     table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args.."\n")
     table.insert(outtab,"{\n")
@@ -2385,8 +2616,10 @@ local function ImGui_f_implementation(outtab,def)
         table.insert(outtab,"    return "..ptret..namespace..def.funcname..def.call_args..";\n")
     end
     table.insert(outtab,"}\n")
+	return table.concat(outtab, "")
 end
-local function struct_f_implementation(outtab,def)
+local function struct_f_implementation(def)
+	local outtab = {}
     local empty = def.args:match("^%(%)") --no args
     local ptret = def.retref and "&" or ""
 
@@ -2415,6 +2648,7 @@ local function struct_f_implementation(outtab,def)
         table.insert(outtab,"    return "..ptret.."self->"..def.funcname..def.call_args..";\n")
     end
     table.insert(outtab,"}\n")
+	return table.concat(outtab, "")
 end
 local function func_implementation(FP)
 
@@ -2432,31 +2666,38 @@ local function func_implementation(FP)
         local manual = FP.get_manuals(def)
         if not custom and not manual and not def.templated and not FP.get_skipped(def) then 
             if def.constructor then
+				local tab = {}
                 assert(def.stname ~= "","constructor without struct")
                 local empty = def.args:match("^%(%)") --no args
-                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname..(empty and "(void)" or def.args).."\n")
+                table.insert(tab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname..(empty and "(void)" or def.args).."\n")
-                table.insert(outtab,"{\n")
+                table.insert(tab,"{\n")
-                table.insert(outtab,"    return IM_NEW("..def.stname..")"..def.call_args..";\n")
+                table.insert(tab,"    return IM_NEW("..def.stname..")"..def.call_args..";\n")
-                table.insert(outtab,"}\n")
+                table.insert(tab,"}\n")
 				if FP.CONSTRUCTORS_GENERATION then
-					table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname.."_Construct("..def.stname.."* self"..(empty and "" or ","..def.args:sub(2,-2))..")\n")
+					table.insert(tab,"CIMGUI_API void "..def.ov_cimguiname.."_Construct("..def.stname.."* self"..(empty and "" or ","..def.args:sub(2,-2))..")\n")
-					table.insert(outtab,"{\n")
+					table.insert(tab,"{\n")
-					table.insert(outtab,"    IM_PLACEMENT_NEW(self)"..def.stname..def.call_args..";\n")
+					table.insert(tab,"    IM_PLACEMENT_NEW(self)"..def.stname..def.call_args..";\n")
-					table.insert(outtab,"}\n")
+					table.insert(tab,"}\n")
 				end
+				table.insert(outtab, table.concat(tab, ""))
             elseif def.destructor then
+				local tab = {}
                 local args = "("..def.stname.."* self)"
                 local fname = def.stname.."_destroy" 
-                table.insert(outtab,"CIMGUI_API void "..fname..args.."\n")
+                table.insert(tab,"CIMGUI_API void "..fname..args.."\n")
-                table.insert(outtab,"{\n")
+                table.insert(tab,"{\n")
-                table.insert(outtab,"    IM_DELETE(self);\n")
+                table.insert(tab,"    IM_DELETE(self);\n")
-                table.insert(outtab,"}\n")
+                table.insert(tab,"}\n")
+				table.insert(outtab, table.concat(tab, ""))
             elseif def.stname == "" or def.is_static_function then
-                ImGui_f_implementation(outtab,def)
+                table.insert(outtab, ImGui_f_implementation(def))
             else -- stname
-                struct_f_implementation(outtab,def)
+                table.insert(outtab, struct_f_implementation(def))
             end
         end
+		if FP.custom_function_post then
+			FP:custom_function_post(outtab, def)
+		end
         until true
     end
     return table.concat(outtab)
@@ -2479,7 +2720,9 @@ local function func_header_generate_structs(FP)
 
     local outtab = {}
 
-	table_do_sorted(FP.embeded_structs,function(k,v) table.insert(outtab,"typedef "..v.." "..k..";\n") end)
+	table_do_sorted(FP.embeded_structs,function(k,v) 
+		table.insert(outtab,"typedef "..v.." "..k..";\n") 
+	end)
 	
 	table_do_sorted(FP.embeded_enums,function(k,v) table.insert(outtab,"typedef "..v.." "..k..";\n") end)
 	
@@ -2516,7 +2759,7 @@ local function func_header_generate_funcs(FP)
                 assert(def.stname ~= "","constructor without struct")
                 table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
 				if FP.CONSTRUCTORS_GENERATION then
-					table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname.."_Construct("..def.stname.."* self"..(empty and "" or ","..def.args:sub(2,-2))..");\n")
+					outtab[#outtab] = outtab[#outtab].."\nCIMGUI_API void "..def.ov_cimguiname.."_Construct("..def.stname.."* self"..(empty and "" or ","..def.args:sub(2,-2))..");\n"
 				end
             elseif def.destructor then
                 table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
@@ -2529,9 +2772,13 @@ local function func_header_generate_funcs(FP)
                 end
             end 
         end
+		if FP.custom_function_post then
+			FP:custom_function_post(outtab, def)
+		end
         else --not cimguiname
             table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
         end
+		
     end
 
     return outtab

generator/generator.bat

@@ -15,11 +15,12 @@ set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\min
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
 :: arg[1] compiler name gcc, clang or cl
-:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+:: arg[2] options as words in one string: internal for imgui_internal generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
 :: "constructors" adds the _Construct version of constructors
-:: examples: "" "internal" "internal freetype comments"
+:: examples: "" "internal" "internal comments"
-:: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+:: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG) 
-luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 %*
+::-DIMGUI_USE_WCHAR32 should not be used (is discarded)
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 -DIMGUI_USE_WCHAR32 %*
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -7,7 +7,7 @@ assert(bit,"Must use LuaJIT")
 local script_args = {...}
 local COMPILER = script_args[1]
 local INTERNAL_GENERATION = script_args[2]:match("internal") and true or false
-local FREETYPE_GENERATION = script_args[2]:match("freetype") and true or false
+local FREETYPE_GENERATION = true --script_args[2]:match("freetype") and true or false
 local COMMENTS_GENERATION = script_args[2]:match("comments") and true or false
 local CONSTRUCTORS_GENERATION = script_args[2]:match("constructors") and true or false
 local NOCHAR = script_args[2]:match("nochar") and true or false
@@ -19,6 +19,9 @@ local CPRE,CTEST
 local implementations = {}
 for i=3,#script_args do
     if script_args[i]:match(COMPILER == "cl" and "^/" or "^%-") then
+		if script_args[i]:match("IMGUI_USE_WCHAR32") then
+			script_args[i] = "" --dont use this define
+		end
         local key, value = script_args[i]:match("^(.+)=(.+)$")
         if key and value then
             CFLAGS = CFLAGS .. " " .. key .. "=\"" .. value:gsub("\"", "\\\"") .. "\"";
@@ -31,7 +34,7 @@ for i=3,#script_args do
 end
 
 if FREETYPE_GENERATION then
-	CFLAGS = CFLAGS .. " -DIMGUI_ENABLE_FREETYPE "
+	CFLAGS = CFLAGS .. " -DIMGUI_ENABLE_FREETYPE -DIMGUI_ENABLE_STB_TRUETYPE" --both builders
 end
 
 if COMPILER == "gcc" or COMPILER == "clang" or COMPILER == "zig cc" then
@@ -214,6 +217,27 @@ local function DefsByStruct(FP)
     FP.defsBystruct = structs
 end  
 
+local function colapse_defines(str, define)
+	local num = 1
+	while num > 0 do
+		str,num = str:gsub("(#ifdef "..define..".+)".."(#endif\n+#ifdef "..define.."\n)", "%1")
+	end
+	return str
+end
+local wchardefine =
+[[
+
+#ifdef IMGUI_USE_WCHAR32            
+typedef ImWchar32 ImWchar;
+#else
+typedef ImWchar16 ImWchar;
+#endif
+#ifdef IMGUI_USE_WCHAR32
+#define IM_UNICODE_CODEPOINT_MAX     0x10FFFF   
+#else
+#define IM_UNICODE_CODEPOINT_MAX     0xFFFF  
+#endif
+	]]
 
 --generate cimgui.cpp cimgui.h 
 local function cimgui_generation(parser)
@@ -261,18 +285,27 @@ local function cimgui_generation(parser)
 		end
 	end
 	
+	cstructsstr = colapse_defines(cstructsstr, "IMGUI_ENABLE_FREETYPE")
+	
     hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
     local cfuncsstr = func_header_generate(parser)
+	cfuncsstr = colapse_defines(cfuncsstr, "IMGUI_ENABLE_FREETYPE")
     hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
+	--patch hstrfile for ImWchar
+	local num
+	hstrfile, num = hstrfile:gsub("typedef ImWchar16 ImWchar;", wchardefine)
+	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
     local cimplem = func_implementation(parser)
-
+	cimplem = colapse_defines(cimplem, "IMGUI_ENABLE_FREETYPE")
     local hstrfile = read_data"./cimgui_template.cpp"
 
     hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
-	local ftdef = FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
+	local ftdef = "" --FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
     save_data("./output/cimgui.cpp",cimgui_header, ftdef, hstrfile)
 
 end
@@ -307,6 +340,20 @@ print("NOIMSTRV",NOIMSTRV)
 print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
 print("IMGUI_VERSION",gdefines.IMGUI_VERSION)
 
+local function custom_function_post(self, outtab, def)
+	assert(def.location)
+	if def.location:match("imgui_freetype") then 
+		outtab[#outtab] = "#ifdef IMGUI_ENABLE_FREETYPE\n"..outtab[#outtab].."\n#endif\n"
+	end
+end
+local function header_text_insert(self, outtab, txt, it)
+	assert(it.locat)
+	if it.locat:match("imgui_freetype") then 
+		table.insert(outtab, "\n#ifdef IMGUI_ENABLE_FREETYPE"..txt.."\n#endif")
+	else
+		table.insert(outtab, txt)
+	end
+end
 
 --funtion for parsing imgui headers
 local function parseImGuiHeader(header,names)
@@ -318,7 +365,8 @@ local function parseImGuiHeader(header,names)
 		return pre..funcname
 	end
 	parser.cname_overloads = cimgui_overloads
-	parser.manuals = cimgui_manuals
+	--parser.manuals = cimgui_manuals
+	parser:set_manuals(cimgui_manuals, "cimgui")
 	parser.skipped = cimgui_skipped
 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
 	--parser.gen_template_typedef = gen_template_typedef --use auto
@@ -326,6 +374,8 @@ local function parseImGuiHeader(header,names)
 	parser.CONSTRUCTORS_GENERATION = CONSTRUCTORS_GENERATION
 	parser.NOCHAR = NOCHAR
 	parser.NOIMSTRV = NOIMSTRV
+	parser.custom_function_post = custom_function_post
+	parser.header_text_insert = header_text_insert
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
 	
 	return parser
@@ -414,10 +464,11 @@ 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) 

generator/generator.sh

@@ -13,10 +13,11 @@
 
 #process  files
 # arg[1] compiler name gcc, clang, or cl
-# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+# arg[2] options as words in one string: internal for imgui_internal generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
 # "constructors" adds the _Construct version of constructors
-# examples: "" "internal" "internal freetype" "comments internal"
+# examples: "" "internal" "comments internal"
-# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG)
+# -DIMGUI_USE_WCHAR32 should not be used as it is generated for both ImWchar
 #
 
 # parse command line arguments
@@ -24,7 +25,7 @@
 POSITIONAL_ARGS=()
 
 TARGETS="internal noimstrv"
-CFLAGS="glfw opengl3 opengl2 sdl2"
+CFLAGS="glfw opengl3 opengl2 sdl2 sdl3"
 
 help() {
         cat <<EOF

generator/output/cimgui_impl.h

@@ -79,6 +79,7 @@ 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);

generator/output/impl_definitions.json

@@ -427,7 +427,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:37",
+      "location": "imgui_impl_opengl2:39",
       "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:35",
+      "location": "imgui_impl_opengl2:37",
       "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:38",
+      "location": "imgui_impl_opengl2:40",
       "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:36",
+      "location": "imgui_impl_opengl2:38",
       "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:29",
+      "location": "imgui_impl_opengl2:31",
       "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:31",
+      "location": "imgui_impl_opengl2:33",
       "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:32",
+      "location": "imgui_impl_opengl2:34",
       "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:30",
+      "location": "imgui_impl_opengl2:32",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -879,11 +879,11 @@
           "type": "int"
         }
       ],
-      "argsoriginal": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)",
+      "argsoriginal": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=nullptr,int manual_gamepads_count=-1)",
       "call_args": "(mode,manual_gamepads_array,manual_gamepads_count)",
       "cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
       "defaults": {
-        "manual_gamepads_array": "NULL",
+        "manual_gamepads_array": "nullptr",
         "manual_gamepads_count": "-1"
       },
       "funcname": "ImGui_ImplSDL2_SetGamepadMode",
@@ -924,7 +924,7 @@
       "cimguiname": "ImGui_ImplSDL3_InitForD3D",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_InitForD3D",
-      "location": "imgui_impl_sdl3:38",
+      "location": "imgui_impl_sdl3:36",
       "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:37",
       "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:34",
       "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:40",
       "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:39",
+      "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:38",
       "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:35",
       "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:42",
       "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:43",
       "ov_cimguiname": "ImGui_ImplSDL3_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
@@ -1098,15 +1119,15 @@
           "type": "int"
         }
       ],
-      "argsoriginal": "(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)",
+      "argsoriginal": "(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array=nullptr,int manual_gamepads_count=-1)",
       "call_args": "(mode,manual_gamepads_array,manual_gamepads_count)",
       "cimguiname": "ImGui_ImplSDL3_SetGamepadMode",
       "defaults": {
-        "manual_gamepads_array": "NULL",
+        "manual_gamepads_array": "nullptr",
         "manual_gamepads_count": "-1"
       },
       "funcname": "ImGui_ImplSDL3_SetGamepadMode",
-      "location": "imgui_impl_sdl3:49",
+      "location": "imgui_impl_sdl3:48",
       "ov_cimguiname": "ImGui_ImplSDL3_SetGamepadMode",
       "ret": "void",
       "signature": "(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)",
@@ -1122,7 +1143,7 @@
       "cimguiname": "ImGui_ImplSDL3_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplSDL3_Shutdown",
-      "location": "imgui_impl_sdl3:42",
+      "location": "imgui_impl_sdl3:41",
       "ov_cimguiname": "ImGui_ImplSDL3_Shutdown",
       "ret": "void",
       "signature": "()",

generator/output/overloads.txt

@@ -7,7 +7,7 @@ ImColor_ImColor	5
 5	nil	ImColor_ImColor_U32 (ImU32)
 ImDrawList_AddText	2
 1	void	ImDrawList_AddText_Vec2 (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddText_FontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+2	void	ImDrawList_AddText_FontPtr (ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
 ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
 1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr (void*)
 2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int (int)

generator/output/typedefs_dict.json

@@ -1,9 +1,9 @@
 {
-  "ImBitArrayForNamedKeys": "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>",
+  "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);",
+  "ImDrawCallback": "void (*)(const ImDrawList* parent_list, const ImDrawCmd* cmd);",
   "ImDrawChannel": "struct ImDrawChannel",
   "ImDrawCmd": "struct ImDrawCmd",
   "ImDrawCmdHeader": "struct ImDrawCmdHeader",
@@ -39,12 +39,13 @@
   "ImGuiConfigFlags": "int",
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiContextHook": "struct ImGuiContextHook",
-  "ImGuiContextHookCallback": "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);",
+  "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",
@@ -54,7 +55,7 @@
   "ImGuiDockNodeSettings": "struct ImGuiDockNodeSettings",
   "ImGuiDockRequest": "struct ImGuiDockRequest",
   "ImGuiDragDropFlags": "int",
-  "ImGuiErrorCallback": "void(*)(ImGuiContext* ctx,void* user_data,const char* msg);",
+  "ImGuiErrorCallback": "void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
   "ImGuiErrorRecoveryState": "struct ImGuiErrorRecoveryState",
   "ImGuiFocusRequestFlags": "int",
   "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
@@ -73,7 +74,7 @@
   "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
   "ImGuiInputEventText": "struct ImGuiInputEventText",
   "ImGuiInputFlags": "int",
-  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
+  "ImGuiInputTextCallback": "int (*)(ImGuiInputTextCallbackData* data);",
   "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
   "ImGuiInputTextDeactivateData": "struct ImGuiInputTextDeactivateData",
   "ImGuiInputTextDeactivatedState": "struct ImGuiInputTextDeactivatedState",
@@ -93,8 +94,9 @@
   "ImGuiListClipperData": "struct ImGuiListClipperData",
   "ImGuiListClipperRange": "struct ImGuiListClipperRange",
   "ImGuiLocEntry": "struct ImGuiLocEntry",
-  "ImGuiMemAllocFunc": "void*(*)(size_t sz,void* user_data);",
+  "ImGuiLogFlags": "int",
-  "ImGuiMemFreeFunc": "void(*)(void* ptr,void* user_data);",
+  "ImGuiMemAllocFunc": "void* (*)(size_t sz, void* user_data);",
+  "ImGuiMemFreeFunc": "void (*)(void* ptr, void* user_data);",
   "ImGuiMenuColumns": "struct ImGuiMenuColumns",
   "ImGuiMetricsConfig": "struct ImGuiMetricsConfig",
   "ImGuiMouseButton": "int",
@@ -130,7 +132,7 @@
   "ImGuiSeparatorFlags": "int",
   "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
   "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
-  "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
+  "ImGuiSizeCallback": "void (*)(ImGuiSizeCallbackData* data);",
   "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
   "ImGuiSliderFlags": "int",
   "ImGuiStackLevelInfo": "struct ImGuiStackLevelInfo",
@@ -201,8 +203,5 @@
   "ImWchar": "ImWchar16",
   "ImWchar16": "unsigned short",
   "ImWchar32": "unsigned int",
-  "STB_TexteditState": "struct STB_TexteditState",
+  "STB_TexteditState": "struct STB_TexteditState"
-  "const_iterator": "const value_type*",
-  "iterator": "value_type*",
-  "value_type": "T"
 }

generator/output/typedefs_dict.lua

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