pull imgui 1.89.1 docking and generate

Adding an example for GLFW + OpenGL

CMakeLists.txt

@@ -2,6 +2,8 @@ cmake_minimum_required(VERSION 3.1)
 
 project(cimgui)
 
+set (CMAKE_CXX_STANDARD 11)
+
 if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/imgui/imgui_tables.cpp)
 	set(TABLES_SOURCE "imgui/imgui_tables.cpp")
 else()

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.86 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.89 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,10 +24,11 @@ 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)
+  * 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)
   * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
   
-  For compiling with backends there is now an example with SDL2 and opengl3 in folder backend_test. It will generate a cimgui_sdl module and a test_sdl executable. You only need to provide SDL_PATH telling cmake where to look for SDL2 cmake installation.
+  For compiling with backends there are now examples with SDL2 and opengl3/vulkan in folder backend_test.
+  They'll generate a cimgui_sdl module and a test_sdl executable.
 
 # using generator
 
@@ -36,8 +37,8 @@ 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 and Freetype2 is used or not. 
+* 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
-* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, opengl2 and opengl3 as backends.
+* 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. 

backend_test/cimgui_extras.cpp

@@ -1,10 +0,0 @@
-#include "../imgui/imgui.h"
-
-#include "../imgui/backends/imgui_impl_opengl3_loader.h"
-
-//making it accesible for luajit
-#ifdef _WIN32
-extern "C" __declspec( dllexport ) int Do_gl3wInit(void){ return imgl3wInit();};
-#else
-extern "C"	int Do_gl3wInit(void){ return imgl3wInit();};
-#endif

backend_test/cimgui_extras.h

@@ -1,8 +0,0 @@
-
-
-//making it accesible for main
-#ifdef _WIN32
-__declspec( dllexport ) int Do_gl3wInit(void);
-#else
-int Do_gl3wInit(void);
-#endif

backend_test/example_glfw_opengl3/CMakeLists.txt

@@ -0,0 +1,103 @@
+Project(cimgui_glfw)
+cmake_minimum_required(VERSION 3.11)
+if(WIN32) # to mingw work as all the others
+	set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+
+set (CMAKE_CXX_STANDARD 11)
+
+# general settings
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
+	set(BAKENDS_FOLDER "../../imgui/backends/")
+else()
+	set(BAKENDS_FOLDER "../../imgui/examples/")
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+include_directories(../../imgui)
+add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+
+include_directories(../../)
+set(IMGUI_SOURCES 
+../../cimgui.cpp 
+../../imgui/imgui.cpp 
+../../imgui/imgui_draw.cpp 
+../../imgui/imgui_demo.cpp 
+../../imgui/imgui_widgets.cpp
+${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")
+
+# optional adding freetype
+option(IMGUI_FREETYPE "add Freetype2" OFF)
+
+if(IMGUI_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)
+
+# opengl3
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp)
+include_directories(../../imgui/examples/libs/gl3w)
+if(WIN32)
+       list(APPEND IMGUI_LIBRARIES opengl32)
+else(WIN32) # Unix
+       list(APPEND IMGUI_LIBRARIES GL)
+endif(WIN32)
+
+# GLFW
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_glfw.cpp)
+
+set(GLFW_VERSION 3.3.8)
+include(FetchContent)
+	FetchContent_Declare(
+    glfw
+    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz)
+
+FetchContent_GetProperties(glfw)
+if (NOT glfw_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(glfw)
+	set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+	set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${glfw_SOURCE_DIR} ${glfw_BINARY_DIR})
+endif()
+
+
+# glfw/imgui gets confused if it is not statically built.
+IF (WIN32)
+  add_library(cimgui STATIC ${IMGUI_SOURCES})
+ELSE()
+  add_library(cimgui SHARED ${IMGUI_SOURCES})
+ENDIF()
+
+target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
+
+
+# using library
+include_directories(../../generator/output/)
+add_executable(${PROJECT_NAME} main.c)
+target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_GLFW)
+if (MINGW)
+	target_link_options(${PROJECT_NAME} PRIVATE "-mconsole")
+endif()
+target_link_libraries(${PROJECT_NAME} ${IMGUI_SDL_LIBRARY} cimgui)
+
+

backend_test/example_glfw_opengl3/main.c

@@ -0,0 +1,169 @@
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_impl.h"
+#include <GLFW/glfw3.h>
+#include <stdio.h>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+#include <GL/gl.h>
+
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+GLFWwindow *window;
+
+int main(int argc, char *argv[])
+{
+
+  if (!glfwInit())
+    return -1;
+
+  // Decide GL+GLSL versions
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+
+#if __APPLE__
+  // GL 3.2 Core + GLSL 150
+  const char *glsl_version = "#version 150";
+#else
+  // GL 3.2 + GLSL 130
+  const char *glsl_version = "#version 130";
+#endif
+
+  // just an extra window hint for resize
+  glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+
+  window = glfwCreateWindow(1024, 768, "Hello World!", NULL, NULL);
+  if (!window) 
+  {
+    printf("Failed to create window! Terminating!\n");
+    glfwTerminate();
+    return -1;
+  }
+
+  glfwMakeContextCurrent(window);
+
+  // enable vsync
+  glfwSwapInterval(1);
+
+  // check opengl version sdl uses
+  printf("opengl version: %s\n", (char *)glGetString(GL_VERSION));
+
+  // setup imgui
+  igCreateContext(NULL);
+
+  // set docking
+  ImGuiIO *ioptr = igGetIO();
+  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;   // Enable Keyboard Controls
+  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
+#ifdef IMGUI_HAS_DOCK
+  ioptr->ConfigFlags |= ImGuiConfigFlags_DockingEnable;       // Enable Docking
+  ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;     // Enable Multi-Viewport / Platform Windows
+#endif
+
+  ImGui_ImplGlfw_InitForOpenGL(window, true);
+  ImGui_ImplOpenGL3_Init(glsl_version);
+
+  igStyleColorsDark(NULL);
+  // ImFontAtlas_AddFontDefault(io.Fonts, NULL);
+
+  bool showDemoWindow = true;
+  bool showAnotherWindow = false;
+  ImVec4 clearColor;
+  clearColor.x = 0.45f;
+  clearColor.y = 0.55f;
+  clearColor.z = 0.60f;
+  clearColor.w = 1.00f;
+
+  // main event loop
+  bool quit = false;
+  while (!glfwWindowShouldClose(window))
+  {
+
+    glfwPollEvents();
+
+    // start imgui frame
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    igNewFrame();
+
+    if (showDemoWindow)
+      igShowDemoWindow(&showDemoWindow);
+
+    // show a simple window that we created ourselves.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      igBegin("Hello, world!", NULL, 0);
+      igText("This is some useful text");
+      igCheckbox("Demo window", &showDemoWindow);
+      igCheckbox("Another window", &showAnotherWindow);
+
+      igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+      igColorEdit3("clear color", (float *)&clearColor, 0);
+
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Button", buttonSize))
+        counter++;
+      igSameLine(0.0f, -1.0f);
+      igText("counter = %d", counter);
+
+      igText("Application average %.3f ms/frame (%.1f FPS)",
+             1000.0f / igGetIO()->Framerate, igGetIO()->Framerate);
+      igEnd();
+    }
+
+    if (showAnotherWindow) 
+    {
+      igBegin("imgui Another Window", &showAnotherWindow, 0);
+      igText("Hello from imgui");
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Close me", buttonSize)) {
+        showAnotherWindow = false;
+      }
+      igEnd();
+    }
+
+    // render
+    igRender();
+    glfwMakeContextCurrent(window);
+    glViewport(0, 0, (int)ioptr->DisplaySize.x, (int)ioptr->DisplaySize.y);
+    glClearColor(clearColor.x, clearColor.y, clearColor.z, clearColor.w);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(igGetDrawData());
+#ifdef IMGUI_HAS_DOCK
+    if (ioptr->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) 
+    {
+      GLFWwindow *backup_current_window = glfwGetCurrentContext();
+      igUpdatePlatformWindows();
+      igRenderPlatformWindowsDefault(NULL, NULL);
+      glfwMakeContextCurrent(backup_current_window);
+    }
+#endif
+    glfwSwapBuffers(window);
+  }
+
+  // clean up
+  ImGui_ImplOpenGL3_Shutdown();
+  ImGui_ImplGlfw_Shutdown();
+  igDestroyContext(NULL);
+
+  glfwDestroyWindow(window);
+  glfwTerminate();
+
+  return 0;
+}

backend_test/example_sdl_opengl3/CMakeLists.txt

@@ -3,30 +3,34 @@ cmake_minimum_required(VERSION 2.8)
 if(WIN32) #to mingw work as all the others
 set(CMAKE_SHARED_LIBRARY_PREFIX "")
 endif(WIN32)
+
+set (CMAKE_CXX_STANDARD 11)
+
 #general settings
 
 
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../imgui/backends)
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
-	set(BAKENDS_FOLDER "../imgui/backends/")
+	set(BAKENDS_FOLDER "../../imgui/backends/")
 else()
-	set(BAKENDS_FOLDER "../imgui/examples/")
+	set(BAKENDS_FOLDER "../../imgui/examples/")
 endif()
 
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../imgui/imgui_tables.cpp)
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
-	set(TABLES_SOURCE "../imgui/imgui_tables.cpp")
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
 else()
 	set(TABLES_SOURCE "")
 endif()
 
-include_directories(../imgui)
+include_directories(../../imgui)
 add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
 
-include_directories(../)
+include_directories(../../)
-set(IMGUI_SOURCES ../cimgui.cpp 
+set(IMGUI_SOURCES 
-../imgui/imgui.cpp 
+../../cimgui.cpp 
-../imgui/imgui_draw.cpp 
+../../imgui/imgui.cpp 
-../imgui/imgui_demo.cpp 
+../../imgui/imgui_draw.cpp 
-../imgui/imgui_widgets.cpp
+../../imgui/imgui_demo.cpp 
+../../imgui/imgui_widgets.cpp
 ${TABLES_SOURCE} 
 )
 
@@ -47,14 +51,13 @@ option(IMGUI_FREETYPE "add Freetype2" OFF)
 if(IMGUI_FREETYPE)
 	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
 	list(APPEND IMGUI_LIBRARIES freetype)
-	list(APPEND IMGUI_SOURCES ../imgui/misc/freetype/imgui_freetype.cpp)
+	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
 	add_definitions("-DCIMGUI_FREETYPE=1")
 endif(IMGUI_FREETYPE)
 
 #opengl3
 list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp)
-list(APPEND IMGUI_SOURCES ./cimgui_extras.cpp)
+include_directories(../../imgui/examples/libs/gl3w)
-include_directories(../imgui/examples/libs/gl3w)
 if(WIN32)
        list(APPEND IMGUI_LIBRARIES opengl32)
 else(WIN32)#Unix
@@ -66,7 +69,13 @@ endif(WIN32)
 list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl.cpp)
 if(DEFINED SDL_PATH)
 	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	FIND_PACKAGE(SDL2 REQUIRED PATHS ${SDL_PATH})
+	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
+else(DEFINED SDL_PATH)
+	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
+	find_package(SDL2)
+endif(DEFINED SDL_PATH)
+
+if(SDL2_FOUND)
 	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
 	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
 	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
@@ -80,17 +89,21 @@ if(DEFINED SDL_PATH)
 		set(SDL_MAIN SDL2::SDL2main)
 		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
 	endif()
-else(DEFINED SDL_PATH)
+else(SDL2_FOUND)
-	message(STATUS "SDL_PATH not defined")
+	if(DEFINED SDL_PATH)
-	set(IMGUI_SDL_LIBRARY SDL2)
+		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
-endif(DEFINED 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})
 
 #using library
-include_directories(../generator/output/)
+include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()

backend_test/example_sdl_opengl3/main.c

@@ -1,6 +1,5 @@
 #define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "cimgui.h"
-#include "cimgui_extras.h"
 #include "cimgui_impl.h"
 #include <stdio.h>
 #define SDL_MAIN_HANDLED
@@ -66,13 +65,6 @@ int main(int argc, char* argv[])
   SDL_GLContext gl_context = SDL_GL_CreateContext(window);
   SDL_GL_SetSwapInterval(1);  // enable vsync
 
-  // Initialize OpenGL loader for cimgui_sdl
-  bool err = Do_gl3wInit() != 0;
-  if (err)
-  {
-    SDL_Log("Failed to initialize OpenGL loader for cimgui_sdl!");
-    return 1;
-  }
 
   // check opengl version sdl uses
   SDL_Log("opengl version: %s", (char*)glGetString(GL_VERSION));
@@ -122,7 +114,7 @@ int main(int argc, char* argv[])
     
     // start imgui frame
     ImGui_ImplOpenGL3_NewFrame();
-    ImGui_ImplSDL2_NewFrame(window);
+    ImGui_ImplSDL2_NewFrame();
     igNewFrame();
 
     if (showDemoWindow)

backend_test/example_sdl_vulkan/CMakeLists.txt

@@ -0,0 +1,100 @@
+Project(cimgui_sdl_vk)
+cmake_minimum_required(VERSION 2.8)
+if(WIN32) # to make mingw work as all the others
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+# general settings
+
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
+	set(BACKENDS_FOLDER "../../imgui/backends/")
+else()
+	set(BACKENDS_FOLDER "../../imgui/examples/")
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+include_directories(../../imgui)
+add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+
+include_directories(../../)
+set(IMGUI_SOURCES ../../cimgui.cpp
+../../imgui/imgui.cpp
+../../imgui/imgui_draw.cpp
+../../imgui/imgui_demo.cpp
+../../imgui/imgui_widgets.cpp
+${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)
+
+if(IMGUI_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)
+
+# vulkan
+find_package(Vulkan REQUIRED FATAL_ERROR)
+list(APPEND IMGUI_LIBRARIES Vulkan::Vulkan)
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_vulkan.cpp)
+
+#sdl2
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl.cpp)
+if(DEFINED SDL_PATH)
+	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
+else(DEFINED SDL_PATH)
+	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
+	find_package(SDL2)
+endif(DEFINED SDL_PATH)
+
+if(SDL2_FOUND)
+	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+		include_directories(${SDL2_INCLUDE_DIRS})
+		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+	else()#use new one SDL2 config
+		include_directories(${SDL_INCLUDE})
+		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+		set(SDL_MAIN SDL2::SDL2main)
+		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	endif()
+else(SDL2_FOUND)
+	if(DEFINED SDL_PATH)
+		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
+	else(DEFINED SDL_PATH)
+		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
+	endif(DEFINED SDL_PATH)
+endif(SDL2_FOUND)
+
+add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
+target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+
+#using library
+include_directories(../../generator/output/)
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+

backend_test/example_sdl_vulkan/main.c

@@ -0,0 +1,571 @@
+#include <stdio.h>
+#include <assert.h>
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+#include <SDL_vulkan.h>
+#include <vulkan/vulkan.h>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_impl.h"
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+#define IM_UNUSED(_VAR)  ((void)(_VAR))
+#define IM_ASSERT(_EXPR) assert(_EXPR)
+#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
+
+static VkAllocationCallbacks*   g_Allocator = NULL;
+static VkInstance               g_Instance = VK_NULL_HANDLE;
+static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
+static VkDevice                 g_Device = VK_NULL_HANDLE;
+static uint32_t                 g_QueueFamily = (uint32_t)-1;
+static VkQueue                  g_Queue = VK_NULL_HANDLE;
+static VkDebugReportCallbackEXT g_DebugReport = VK_NULL_HANDLE;
+static VkPipelineCache          g_PipelineCache = VK_NULL_HANDLE;
+static VkDescriptorPool         g_DescriptorPool = VK_NULL_HANDLE;
+
+static ImGui_ImplVulkanH_Window g_MainWindowData;
+static uint32_t                 g_MinImageCount = 2;
+static bool                     g_SwapChainRebuild = false;
+
+static void check_vk_result(VkResult err)
+{
+    if (err == 0)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
+    if (err < 0)
+        abort();
+}
+
+#ifdef IMGUI_VULKAN_DEBUG_REPORT
+static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags,
+  VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
+  int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
+{
+    (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
+
+static void SetupVulkan(const char** extensions, uint32_t extensions_count)
+{
+  VkResult err;
+
+  // Create Vulkan Instance
+  VkInstanceCreateInfo inst_create_info = {
+    .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    .enabledExtensionCount = extensions_count,
+    .ppEnabledExtensionNames = extensions,
+  };
+#ifdef IMGUI_VULKAN_DEBUG_REPORT
+  // Enabling validation layers
+  const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
+  inst_create_info.enabledLayerCount = 1;
+  inst_create_info.ppEnabledLayerNames = layers;
+
+  // Enable debug report extension (we need additional storage, so we duplicate the user array to add our new extension to it)
+  const char** extensions_ext = (const char**)malloc(
+      sizeof(const char*) * (extensions_count + 1));
+  memcpy(extensions_ext, extensions, extensions_count * sizeof(const char*));
+  extensions_ext[extensions_count] = "VK_EXT_debug_report";
+  inst_create_info.enabledExtensionCount = extensions_count + 1;
+  inst_create_info.ppEnabledExtensionNames = extensions_ext;
+
+  // Create Vulkan Instance
+  err = vkCreateInstance(&inst_create_info, g_Allocator, &g_Instance);
+  check_vk_result(err);
+  free(extensions_ext);
+
+  // Get the function pointer (required for any extensions)
+  PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT =
+    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance,
+      "vkCreateDebugReportCallbackEXT");
+  IM_ASSERT(vkCreateDebugReportCallbackEXT != NULL);
+
+  // Setup the debug report callback
+  VkDebugReportCallbackCreateInfoEXT debug_report_ci = {
+    .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+    .flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
+             VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
+    .pfnCallback = debug_report,
+    .pUserData = NULL,
+  };
+  err = vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator,
+    &g_DebugReport);
+  check_vk_result(err);
+#else
+  // Create Vulkan Instance without any debug feature
+  err = vkCreateInstance(&inst_create_info, g_Allocator, &g_Instance);
+  check_vk_result(err);
+  IM_UNUSED(g_DebugReport);
+#endif
+
+  // Select GPU
+  uint32_t gpu_count;
+  err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, NULL);
+  check_vk_result(err);
+  IM_ASSERT(gpu_count > 0);
+
+  VkPhysicalDevice* gpus = (VkPhysicalDevice*)malloc(sizeof(VkPhysicalDevice) * gpu_count);
+  err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, gpus);
+  check_vk_result(err);
+
+  // If a number >1 of GPUs got reported, find discrete GPU if present, or use first one available. This covers
+  // most common cases (multi-gpu/integrated+dedicated graphics). Handling more complicated setups (multiple
+  // dedicated GPUs) is out of scope of this sample.
+  int use_gpu = 0;
+  for (int i = 0; i < (int)gpu_count; i++)
+  {
+    VkPhysicalDeviceProperties properties;
+    vkGetPhysicalDeviceProperties(gpus[i], &properties);
+    if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+    {
+        use_gpu = i;
+        break;
+    }
+  }
+
+  g_PhysicalDevice = gpus[use_gpu];
+  free(gpus);
+
+  // Select graphics queue family
+  uint32_t count;
+  vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, NULL);
+  VkQueueFamilyProperties* queues = (VkQueueFamilyProperties*)malloc(
+      sizeof(VkQueueFamilyProperties) * count);
+  vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, queues);
+  for (uint32_t i = 0; i < count; i++)
+    if (queues[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+    {
+      g_QueueFamily = i;
+      break;
+    }
+  free(queues);
+  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" };
+  const float queue_priority[] = { 1.0f };
+  VkDeviceQueueCreateInfo queue_info[1] = {
+    [0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+    [0].queueFamilyIndex = g_QueueFamily,
+    [0].queueCount = 1,
+    [0].pQueuePriorities = queue_priority,
+  };
+  VkDeviceCreateInfo create_info = {
+    .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+    .queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]),
+    .pQueueCreateInfos = queue_info,
+    .enabledExtensionCount = device_extension_count,
+    .ppEnabledExtensionNames = device_extensions,
+  };
+  err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
+  check_vk_result(err);
+  vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+
+  // Create Descriptor Pool
+  VkDescriptorPoolSize pool_sizes[] = {
+      { VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
+      { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
+      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
+      { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
+      { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
+      { VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
+      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
+      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
+      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
+      { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
+      { VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
+  };
+  VkDescriptorPoolCreateInfo pool_info = {
+    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+    .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+    .maxSets = 1000 * IM_ARRAYSIZE(pool_sizes),
+    .poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes),
+    .pPoolSizes = pool_sizes,
+  };
+  err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+  check_vk_result(err);
+}
+
+// All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
+// Your real engine/app may not use them.
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface,
+                              int width, int height)
+{
+    wd->Surface = surface;
+
+    // Check for WSI support
+    VkBool32 res;
+    vkGetPhysicalDeviceSurfaceSupportKHR(g_PhysicalDevice, g_QueueFamily, wd->Surface, &res);
+    if (res != VK_TRUE)
+    {
+        fprintf(stderr, "Error no WSI support on physical device 0\n");
+        exit(-1);
+    }
+
+    // Select Surface Format
+    const VkFormat requestSurfaceImageFormat[] = {
+        VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM,
+        VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM
+    };
+    const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(
+      g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat,
+      (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+
+    // Select Present Mode
+#ifdef IMGUI_UNLIMITED_FRAME_RATE
+    VkPresentModeKHR present_modes[] = {
+      VK_PRESENT_MODE_MAILBOX_KHR,VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR
+    };
+#else
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
+#endif
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(
+      g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+
+    // Create SwapChain, RenderPass, Framebuffer, etc.
+    IM_ASSERT(g_MinImageCount >= 2);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(
+      g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator,
+      width, height, g_MinImageCount);
+}
+
+static void CleanupVulkan()
+{
+  vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
+
+#ifdef IMGUI_VULKAN_DEBUG_REPORT
+  // Remove the debug report callback
+  PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT =
+    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
+  vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
+#endif // IMGUI_VULKAN_DEBUG_REPORT
+
+  vkDestroyDevice(g_Device, g_Allocator);
+  vkDestroyInstance(g_Instance, g_Allocator);
+}
+
+static void CleanupVulkanWindow()
+{
+  ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+}
+
+static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
+{
+  VkResult err;
+
+  VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+  VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
+  err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
+  if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+  {
+    g_SwapChainRebuild = true;
+    return;
+  }
+  check_vk_result(err);
+
+  ImGui_ImplVulkanH_Frame* fd = &wd->Frames[wd->FrameIndex];
+  err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);    // wait indefinitely instead of periodically checking
+  check_vk_result(err);
+
+  err = vkResetFences(g_Device, 1, &fd->Fence);
+  check_vk_result(err);
+
+  err = vkResetCommandPool(g_Device, fd->CommandPool, 0);
+  check_vk_result(err);
+  VkCommandBufferBeginInfo info = {
+    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+  };
+  err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
+  check_vk_result(err);
+  VkRenderPassBeginInfo rp_info = {
+    .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+    .renderPass = wd->RenderPass,
+    .framebuffer = fd->Framebuffer,
+    .renderArea.extent.width = wd->Width,
+    .renderArea.extent.height = wd->Height,
+    .clearValueCount = 1,
+    .pClearValues = &wd->ClearValue,
+  };
+  vkCmdBeginRenderPass(fd->CommandBuffer, &rp_info, VK_SUBPASS_CONTENTS_INLINE);
+
+  // Record dear imgui primitives into command buffer
+  ImGui_ImplVulkan_RenderDrawData(draw_data, fd->CommandBuffer, VK_NULL_HANDLE);
+
+  // Submit command buffer
+  vkCmdEndRenderPass(fd->CommandBuffer);
+  VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+  VkSubmitInfo sub_info = {
+    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    .waitSemaphoreCount = 1,
+    .pWaitSemaphores = &image_acquired_semaphore,
+    .pWaitDstStageMask = &wait_stage,
+    .commandBufferCount = 1,
+    .pCommandBuffers = &fd->CommandBuffer,
+    .signalSemaphoreCount = 1,
+    .pSignalSemaphores = &render_complete_semaphore,
+  };
+
+  err = vkEndCommandBuffer(fd->CommandBuffer);
+  check_vk_result(err);
+  err = vkQueueSubmit(g_Queue, 1, &sub_info, fd->Fence);
+  check_vk_result(err);
+}
+
+static void FramePresent(ImGui_ImplVulkanH_Window* wd)
+{
+  if (g_SwapChainRebuild) return;
+  VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
+  VkPresentInfoKHR info = {
+    .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    .waitSemaphoreCount = 1,
+    .pWaitSemaphores = &render_complete_semaphore,
+    .swapchainCount = 1,
+    .pSwapchains = &wd->Swapchain,
+    .pImageIndices = &wd->FrameIndex,
+  };
+  VkResult err = vkQueuePresentKHR(g_Queue, &info);
+  if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+  {
+    g_SwapChainRebuild = true;
+    return;
+  }
+  check_vk_result(err);
+  wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->ImageCount; // Now we can use the next set of semaphores
+}
+
+int main(int argc, char* argv[])
+{
+
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    SDL_Log("failed to init: %s", SDL_GetError());
+    return -1;
+  }
+
+  /// Setup window
+  SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN |
+    SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+  SDL_Window* window = SDL_CreateWindow("cImGui SDL2+Vulkan example",
+    SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+  if (window == NULL) {
+    SDL_Log("Failed to create window: %s", SDL_GetError());
+    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*));
+  SDL_Vulkan_GetInstanceExtensions(window, &extensions_count, extensions);
+  SetupVulkan(extensions, extensions_count);
+  free(extensions);
+
+  // Create Window Surface
+  VkSurfaceKHR surface;
+  VkResult err;
+  if (SDL_Vulkan_CreateSurface(window, g_Instance, &surface) == 0)
+  {
+      printf("Failed to create Vulkan surface.\n");
+      return 1;
+  }
+
+  // Create Framebuffers
+  int w, h;
+  SDL_GetWindowSize(window, &w, &h);
+  ImGui_ImplVulkanH_Window* wd = &g_MainWindowData;
+  SetupVulkanWindow(wd, surface, w, h);
+
+  // setup imgui
+  igCreateContext(NULL);
+
+  //set docking
+  ImGuiIO* ioptr = igGetIO();
+  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;       // Enable Keyboard Controls
+  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+  // Setup Platform/Renderer backends
+  ImGui_ImplSDL2_InitForVulkan(window);
+  ImGui_ImplVulkan_InitInfo init_info = {
+    .Instance = g_Instance,
+    .PhysicalDevice = g_PhysicalDevice,
+    .Device = g_Device,
+    .QueueFamily = g_QueueFamily,
+    .Queue = g_Queue,
+    .PipelineCache = g_PipelineCache,
+    .DescriptorPool = g_DescriptorPool,
+    .Subpass = 0,
+    .MinImageCount = g_MinImageCount,
+    .ImageCount = wd->ImageCount,
+    .MSAASamples = VK_SAMPLE_COUNT_1_BIT,
+    .Allocator = g_Allocator,
+    .CheckVkResultFn = check_vk_result
+  };
+  ImGui_ImplVulkan_Init(&init_info, wd->RenderPass);
+
+  igStyleColorsDark(NULL);
+
+  // Upload Fonts
+  // Use any command queue
+  VkCommandPool command_pool = wd->Frames[wd->FrameIndex].CommandPool;
+  VkCommandBuffer command_buffer = wd->Frames[wd->FrameIndex].CommandBuffer;
+
+  err = vkResetCommandPool(g_Device, command_pool, 0);
+  check_vk_result(err);
+  VkCommandBufferBeginInfo begin_info = {
+    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+  };
+  err = vkBeginCommandBuffer(command_buffer, &begin_info);
+  check_vk_result(err);
+
+  ImGui_ImplVulkan_CreateFontsTexture(command_buffer);
+
+  VkSubmitInfo end_info = {
+    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    .commandBufferCount = 1,
+    .pCommandBuffers = &command_buffer,
+  };
+  err = vkEndCommandBuffer(command_buffer);
+  check_vk_result(err);
+  err = vkQueueSubmit(g_Queue, 1, &end_info, VK_NULL_HANDLE);
+  check_vk_result(err);
+
+  err = vkDeviceWaitIdle(g_Device);
+  check_vk_result(err);
+  ImGui_ImplVulkan_DestroyFontUploadObjects();
+
+  bool showDemoWindow = true;
+  bool showAnotherWindow = false;
+  ImVec4 clearColor;
+  clearColor.x = 0.45f;
+  clearColor.y = 0.55f;
+  clearColor.z = 0.60f;
+  clearColor.w = 1.00f;
+
+  bool quit = false;
+  while (!quit)
+  {
+    SDL_Event e;
+
+    // we need to call SDL_PollEvent to let window rendered, otherwise
+    // no window will be shown
+    while (SDL_PollEvent(&e) != 0)
+    {
+      ImGui_ImplSDL2_ProcessEvent(&e);
+      if (e.type == SDL_QUIT)
+        quit = true;
+      if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_CLOSE &&
+          e.window.windowID == SDL_GetWindowID(window))
+        quit = true;
+    }
+
+    // Resize swap chain
+    if (g_SwapChainRebuild)
+    {
+        int width, height;
+        SDL_GetWindowSize(window, &width, &height);
+        if (width > 0 && height > 0)
+        {
+            ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(
+              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
+    ImGui_ImplVulkan_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    igNewFrame();
+
+    if (showDemoWindow)
+      igShowDemoWindow(&showDemoWindow);
+
+    // show a simple window that we created ourselves.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      igBegin("Hello, world!", NULL, 0);
+      igText("This is some useful text");
+      igCheckbox("Demo window", &showDemoWindow);
+      igCheckbox("Another window", &showAnotherWindow);
+
+      igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+      igColorEdit3("clear color", (float*)&clearColor, 0);
+
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Button", buttonSize))
+        counter++;
+      igSameLine(0.0f, -1.0f);
+      igText("counter = %d", counter);
+
+      igText("Application average %.3f ms/frame (%.1f FPS)",
+             1000.0f / igGetIO()->Framerate, igGetIO()->Framerate);
+      igEnd();
+    }
+
+    if (showAnotherWindow)
+    {
+      igBegin("imgui Another Window", &showAnotherWindow, 0);
+      igText("Hello from imgui");
+      ImVec2 buttonSize;
+      buttonSize.x = 0; buttonSize.y = 0;
+      if (igButton("Close me", buttonSize))
+      {
+        showAnotherWindow = false;
+      }
+      igEnd();
+    }
+
+    // render
+    igRender();
+    ImDrawData* draw_data = igGetDrawData();
+    const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+    if (!is_minimized)
+    {
+        wd->ClearValue.color.float32[0] = clearColor.x * clearColor.w;
+        wd->ClearValue.color.float32[1] = clearColor.y * clearColor.w;
+        wd->ClearValue.color.float32[2] = clearColor.z * clearColor.w;
+        wd->ClearValue.color.float32[3] = clearColor.w;
+        FrameRender(wd, draw_data);
+        FramePresent(wd);
+    }
+  }
+
+  // Cleanup
+  err = vkDeviceWaitIdle(g_Device);
+  check_vk_result(err);
+  ImGui_ImplVulkan_Shutdown();
+  ImGui_ImplSDL2_Shutdown();
+  igDestroyContext(NULL);
+
+  CleanupVulkanWindow();
+  CleanupVulkan();
+
+  SDL_DestroyWindow(window);
+  SDL_Quit();
+
+  return 0;
+}

cimgui.cpp

@@ -1,10 +1,18 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.86" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.89.1 WIP" 18910 from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
 //docking branch
-
+#ifdef IMGUI_ENABLE_FREETYPE
-#include "./imgui/imgui.h"
+#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"
 #endif
 #include "./imgui/imgui_internal.h"
@@ -84,6 +92,10 @@ CIMGUI_API void igShowMetricsWindow(bool* p_open)
 {
     return ImGui::ShowMetricsWindow(p_open);
 }
+CIMGUI_API void igShowDebugLogWindow(bool* p_open)
+{
+    return ImGui::ShowDebugLogWindow(p_open);
+}
 CIMGUI_API void igShowStackToolWindow(bool* p_open)
 {
     return ImGui::ShowStackToolWindow(p_open);
@@ -212,6 +224,10 @@ CIMGUI_API void igSetNextWindowFocus()
 {
     return ImGui::SetNextWindowFocus();
 }
+CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll)
+{
+    return ImGui::SetNextWindowScroll(scroll);
+}
 CIMGUI_API void igSetNextWindowBgAlpha(float alpha)
 {
     return ImGui::SetNextWindowBgAlpha(alpha);
@@ -622,14 +638,6 @@ CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir)
 {
     return ImGui::ArrowButton(str_id,dir);
 }
-CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)
-{
-    return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
-}
-CIMGUI_API bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col)
-{
-    return ImGui::ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col);
-}
 CIMGUI_API bool igCheckbox(const char* label,bool* v)
 {
     return ImGui::Checkbox(label,v);
@@ -658,6 +666,14 @@ CIMGUI_API void igBullet()
 {
     return ImGui::Bullet();
 }
+CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)
+{
+    return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
+}
+CIMGUI_API bool igImageButton(const char* str_id,ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)
+{
+    return ImGui::ImageButton(str_id,user_texture_id,size,uv0,uv1,bg_col,tint_col);
+}
 CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags)
 {
     return ImGui::BeginCombo(label,preview_value,flags);
@@ -854,7 +870,7 @@ CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlag
 {
     return ImGui::ColorPicker4(label,col,flags,ref_col);
 }
-CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size)
+CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,const ImVec2 size)
 {
     return ImGui::ColorButton(desc_id,col,flags,size);
 }
@@ -1393,22 +1409,6 @@ CIMGUI_API ImGuiViewport* igGetMainViewport()
 {
     return ImGui::GetMainViewport();
 }
-CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size)
-{
-    return ImGui::IsRectVisible(size);
-}
-CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,const ImVec2 rect_max)
-{
-    return ImGui::IsRectVisible(rect_min,rect_max);
-}
-CIMGUI_API double igGetTime()
-{
-    return ImGui::GetTime();
-}
-CIMGUI_API int igGetFrameCount()
-{
-    return ImGui::GetFrameCount();
-}
 CIMGUI_API ImDrawList* igGetBackgroundDrawList_Nil()
 {
     return ImGui::GetBackgroundDrawList();
@@ -1425,6 +1425,22 @@ CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewpo
 {
     return ImGui::GetForegroundDrawList(viewport);
 }
+CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size)
+{
+    return ImGui::IsRectVisible(size);
+}
+CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,const ImVec2 rect_max)
+{
+    return ImGui::IsRectVisible(rect_min,rect_max);
+}
+CIMGUI_API double igGetTime()
+{
+    return ImGui::GetTime();
+}
+CIMGUI_API int igGetFrameCount()
+{
+    return ImGui::GetFrameCount();
+}
 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
 {
     return ImGui::GetDrawListSharedData();
@@ -1469,39 +1485,39 @@ CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,floa
 {
     return ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
 }
-CIMGUI_API int igGetKeyIndex(ImGuiKey imgui_key)
+CIMGUI_API bool igIsKeyDown_Nil(ImGuiKey key)
 {
-    return ImGui::GetKeyIndex(imgui_key);
+    return ImGui::IsKeyDown(key);
 }
-CIMGUI_API bool igIsKeyDown(int user_key_index)
+CIMGUI_API bool igIsKeyPressed_Bool(ImGuiKey key,bool repeat)
 {
-    return ImGui::IsKeyDown(user_key_index);
+    return ImGui::IsKeyPressed(key,repeat);
 }
-CIMGUI_API bool igIsKeyPressed(int user_key_index,bool repeat)
+CIMGUI_API bool igIsKeyReleased_Nil(ImGuiKey key)
 {
-    return ImGui::IsKeyPressed(user_key_index,repeat);
+    return ImGui::IsKeyReleased(key);
 }
-CIMGUI_API bool igIsKeyReleased(int user_key_index)
+CIMGUI_API int igGetKeyPressedAmount(ImGuiKey key,float repeat_delay,float rate)
 {
-    return ImGui::IsKeyReleased(user_key_index);
+    return ImGui::GetKeyPressedAmount(key,repeat_delay,rate);
 }
-CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate)
+CIMGUI_API const char* igGetKeyName(ImGuiKey key)
 {
-    return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate);
+    return ImGui::GetKeyName(key);
 }
-CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
+CIMGUI_API void igSetNextFrameWantCaptureKeyboard(bool want_capture_keyboard)
 {
-    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
+    return ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard);
 }
-CIMGUI_API bool igIsMouseDown(ImGuiMouseButton button)
+CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button)
 {
     return ImGui::IsMouseDown(button);
 }
-CIMGUI_API bool igIsMouseClicked(ImGuiMouseButton button,bool repeat)
+CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button,bool repeat)
 {
     return ImGui::IsMouseClicked(button,repeat);
 }
-CIMGUI_API bool igIsMouseReleased(ImGuiMouseButton button)
+CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button)
 {
     return ImGui::IsMouseReleased(button);
 }
@@ -1553,9 +1569,9 @@ CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type)
 {
     return ImGui::SetMouseCursor(cursor_type);
 }
-CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
+CIMGUI_API void igSetNextFrameWantCaptureMouse(bool want_capture_mouse)
 {
-    return ImGui::CaptureMouseFromApp(want_capture_mouse_value);
+    return ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse);
 }
 CIMGUI_API const char* igGetClipboardText()
 {
@@ -1581,6 +1597,10 @@ CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size)
 {
     return ImGui::SaveIniSettingsToMemory(out_ini_size);
 }
+CIMGUI_API void igDebugTextEncoding(const char* text)
+{
+    return ImGui::DebugTextEncoding(text);
+}
 CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
 {
     return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
@@ -1637,6 +1657,34 @@ CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
 {
     return self->ScaleAllSizes(scale_factor);
 }
+CIMGUI_API void ImGuiIO_AddKeyEvent(ImGuiIO* self,ImGuiKey key,bool down)
+{
+    return self->AddKeyEvent(key,down);
+}
+CIMGUI_API void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self,ImGuiKey key,bool down,float v)
+{
+    return self->AddKeyAnalogEvent(key,down,v);
+}
+CIMGUI_API void ImGuiIO_AddMousePosEvent(ImGuiIO* self,float x,float y)
+{
+    return self->AddMousePosEvent(x,y);
+}
+CIMGUI_API void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self,int button,bool down)
+{
+    return self->AddMouseButtonEvent(button,down);
+}
+CIMGUI_API void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self,float wh_x,float wh_y)
+{
+    return self->AddMouseWheelEvent(wh_x,wh_y);
+}
+CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self,ImGuiID id)
+{
+    return self->AddMouseViewportEvent(id);
+}
+CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self,bool focused)
+{
+    return self->AddFocusEvent(focused);
+}
 CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
 {
     return self->AddInputCharacter(c);
@@ -1649,9 +1697,13 @@ CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
 {
     return self->AddInputCharactersUTF8(str);
 }
-CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self,bool focused)
+CIMGUI_API void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self,ImGuiKey key,int native_keycode,int native_scancode,int native_legacy_index)
 {
-    return self->AddFocusEvent(focused);
+    return self->SetKeyEventNativeData(key,native_keycode,native_scancode,native_legacy_index);
+}
+CIMGUI_API void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self,bool accepting_events)
+{
+    return self->SetAppAcceptingEvents(accepting_events);
 }
 CIMGUI_API void ImGuiIO_ClearInputCharacters(ImGuiIO* self)
 {
@@ -1953,14 +2005,6 @@ CIMGUI_API void ImColor_destroy(ImColor* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API ImColor* ImColor_ImColor_Int(int r,int g,int b,int a)
-{
-    return IM_NEW(ImColor)(r,g,b,a);
-}
-CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba)
-{
-    return IM_NEW(ImColor)(rgba);
-}
 CIMGUI_API ImColor* ImColor_ImColor_Float(float r,float g,float b,float a)
 {
     return IM_NEW(ImColor)(r,g,b,a);
@@ -1969,6 +2013,14 @@ CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col)
 {
     return IM_NEW(ImColor)(col);
 }
+CIMGUI_API ImColor* ImColor_ImColor_Int(int r,int g,int b,int a)
+{
+    return IM_NEW(ImColor)(r,g,b,a);
+}
+CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba)
+{
+    return IM_NEW(ImColor)(rgba);
+}
 CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
 {
     return self->SetHSV(h,s,v,a);
@@ -2017,7 +2069,7 @@ CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,Im
 {
     return self->SetCurrentChannel(draw_list,channel_idx);
 }
-CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
+CIMGUI_API ImDrawList* ImDrawList_ImDrawList(ImDrawListSharedData* shared_data)
 {
     return IM_NEW(ImDrawList)(shared_data);
 }
@@ -2025,7 +2077,7 @@ CIMGUI_API void ImDrawList_destroy(ImDrawList* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
+CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
 {
     return self->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
 }
@@ -2421,6 +2473,10 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self)
 {
     return self->GetGlyphRangesDefault();
 }
+CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self)
+{
+    return self->GetGlyphRangesGreek();
+}
 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self)
 {
     return self->GetGlyphRangesKorean();
@@ -2505,11 +2561,11 @@ CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,con
 {
     return self->CalcWordWrapPositionA(scale,text,text_end,wrap_width);
 }
-CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c)
+CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,ImWchar c)
 {
     return self->RenderChar(draw_list,size,pos,col,c);
 }
-CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)
+CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)
 {
     return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
 }
@@ -2573,6 +2629,18 @@ CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(void)
+{
+    return IM_NEW(ImGuiPlatformImeData)();
+}
+CIMGUI_API void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API ImGuiKey igGetKeyIndex(ImGuiKey key)
+{
+    return ImGui::GetKeyIndex(key);
+}
 CIMGUI_API ImGuiID igImHashData(const void* data,size_t data_size,ImU32 seed)
 {
     return ImHashData(data,data_size,seed);
@@ -2649,6 +2717,18 @@ CIMGUI_API const char* igImStrSkipBlank(const char* str)
 {
     return ImStrSkipBlank(str);
 }
+CIMGUI_API char igImToUpper(char c)
+{
+    return ImToUpper(c);
+}
+CIMGUI_API bool igImCharIsBlankA(char c)
+{
+    return ImCharIsBlankA(c);
+}
+CIMGUI_API bool igImCharIsBlankW(unsigned int c)
+{
+    return ImCharIsBlankW(c);
+}
 CIMGUI_API int igImFormatString(char* buf,size_t buf_size,const char* fmt,...)
 {
     va_list args;
@@ -2661,6 +2741,17 @@ CIMGUI_API int igImFormatStringV(char* buf,size_t buf_size,const char* fmt,va_li
 {
     return ImFormatStringV(buf,buf_size,fmt,args);
 }
+CIMGUI_API void igImFormatStringToTempBuffer(const char** out_buf,const char** out_buf_end,const char* fmt,...)
+{
+    va_list args;
+    va_start(args, fmt);
+    ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args);
+    va_end(args);
+}
+CIMGUI_API void igImFormatStringToTempBufferV(const char** out_buf,const char** out_buf_end,const char* fmt,va_list args)
+{
+    return ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args);
+}
 CIMGUI_API const char* igImParseFormatFindStart(const char* format)
 {
     return ImParseFormatFindStart(format);
@@ -2673,18 +2764,18 @@ CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,char* b
 {
     return ImParseFormatTrimDecorations(format,buf,buf_size);
 }
+CIMGUI_API void igImParseFormatSanitizeForPrinting(const char* fmt_in,char* fmt_out,size_t fmt_out_size)
+{
+    return ImParseFormatSanitizeForPrinting(fmt_in,fmt_out,fmt_out_size);
+}
+CIMGUI_API const char* igImParseFormatSanitizeForScanning(const char* fmt_in,char* fmt_out,size_t fmt_out_size)
+{
+    return ImParseFormatSanitizeForScanning(fmt_in,fmt_out,fmt_out_size);
+}
 CIMGUI_API int igImParseFormatPrecision(const char* format,int default_value)
 {
     return ImParseFormatPrecision(format,default_value);
 }
-CIMGUI_API bool igImCharIsBlankA(char c)
-{
-    return ImCharIsBlankA(c);
-}
-CIMGUI_API bool igImCharIsBlankW(unsigned int c)
-{
-    return ImCharIsBlankW(c);
-}
 CIMGUI_API const char* igImTextCharToUtf8(char out_buf[5],unsigned int c)
 {
     return ImTextCharToUtf8(out_buf,c);
@@ -2825,7 +2916,7 @@ CIMGUI_API float igImFloor_Float(float f)
 {
     return ImFloor(f);
 }
-CIMGUI_API float igImFloorSigned(float f)
+CIMGUI_API float igImFloorSigned_Float(float f)
 {
     return ImFloorSigned(f);
 }
@@ -2833,6 +2924,10 @@ CIMGUI_API void igImFloor_Vec2(ImVec2 *pOut,const ImVec2 v)
 {
     *pOut = ImFloor(v);
 }
+CIMGUI_API void igImFloorSigned_Vec2(ImVec2 *pOut,const ImVec2 v)
+{
+    *pOut = ImFloorSigned(v);
+}
 CIMGUI_API int igImModPositive(int a,int b)
 {
     return ImModPositive(a,b);
@@ -3077,6 +3172,26 @@ CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self,int n)
 {
     return self->ClearBit(n);
 }
+CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self)
+{
+    return self->clear();
+}
+CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self)
+{
+    return self->size();
+}
+CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self,const char* base,int n)
+{
+    return self->get_line_begin(base,n);
+}
+CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self,const char* base,int n)
+{
+    return self->get_line_end(base,n);
+}
+CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,const char* base,int old_size,int new_size)
+{
+    return self->append(base,old_size,new_size);
+}
 CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(void)
 {
     return IM_NEW(ImDrawListSharedData)();
@@ -3277,6 +3392,42 @@ CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(int index)
 {
     return IM_NEW(ImGuiPtrOrIndex)(index);
 }
+CIMGUI_API ImGuiInputEvent* ImGuiInputEvent_ImGuiInputEvent(void)
+{
+    return IM_NEW(ImGuiInputEvent)();
+}
+CIMGUI_API void ImGuiInputEvent_destroy(ImGuiInputEvent* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API ImGuiKeyRoutingData* ImGuiKeyRoutingData_ImGuiKeyRoutingData(void)
+{
+    return IM_NEW(ImGuiKeyRoutingData)();
+}
+CIMGUI_API void ImGuiKeyRoutingData_destroy(ImGuiKeyRoutingData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API ImGuiKeyRoutingTable* ImGuiKeyRoutingTable_ImGuiKeyRoutingTable(void)
+{
+    return IM_NEW(ImGuiKeyRoutingTable)();
+}
+CIMGUI_API void ImGuiKeyRoutingTable_destroy(ImGuiKeyRoutingTable* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self)
+{
+    return self->Clear();
+}
+CIMGUI_API ImGuiKeyOwnerData* ImGuiKeyOwnerData_ImGuiKeyOwnerData(void)
+{
+    return IM_NEW(ImGuiKeyOwnerData)();
+}
+CIMGUI_API void ImGuiKeyOwnerData_destroy(ImGuiKeyOwnerData* self)
+{
+    IM_DELETE(self);
+}
 CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min,int max)
 {
     return ImGuiListClipperRange::FromIndices(min,max);
@@ -3505,18 +3656,6 @@ CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self,int n)
 {
     return self->GetID(n);
 }
-CIMGUI_API ImGuiID ImGuiWindow_GetIDNoKeepAlive_Str(ImGuiWindow* self,const char* str,const char* str_end)
-{
-    return self->GetIDNoKeepAlive(str,str_end);
-}
-CIMGUI_API ImGuiID ImGuiWindow_GetIDNoKeepAlive_Ptr(ImGuiWindow* self,const void* ptr)
-{
-    return self->GetIDNoKeepAlive(ptr);
-}
-CIMGUI_API ImGuiID ImGuiWindow_GetIDNoKeepAlive_Int(ImGuiWindow* self,int n)
-{
-    return self->GetIDNoKeepAlive(n);
-}
 CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,const ImRect r_abs)
 {
     return self->GetIDFromRectangle(r_abs);
@@ -3577,6 +3716,14 @@ CIMGUI_API void ImGuiTableColumn_destroy(ImGuiTableColumn* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API ImGuiTableInstanceData* ImGuiTableInstanceData_ImGuiTableInstanceData(void)
+{
+    return IM_NEW(ImGuiTableInstanceData)();
+}
+CIMGUI_API void ImGuiTableInstanceData_destroy(ImGuiTableInstanceData* self)
+{
+    IM_DELETE(self);
+}
 CIMGUI_API ImGuiTable* ImGuiTable_ImGuiTable(void)
 {
     return IM_NEW(ImGuiTable)();
@@ -3721,13 +3868,17 @@ CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window)
 {
     return ImGui::GetForegroundDrawList(window);
 }
-CIMGUI_API void igInitialize(ImGuiContext* context)
+CIMGUI_API void igInitialize()
 {
-    return ImGui::Initialize(context);
+    return ImGui::Initialize();
 }
-CIMGUI_API void igShutdown(ImGuiContext* context)
+CIMGUI_API void igShutdown()
 {
-    return ImGui::Shutdown(context);
+    return ImGui::Shutdown();
+}
+CIMGUI_API void igUpdateInputEvents(bool trickle_fast_inputs)
+{
+    return ImGui::UpdateInputEvents(trickle_fast_inputs);
 }
 CIMGUI_API void igUpdateHoveredWindowAndCaptureFlags()
 {
@@ -3773,6 +3924,10 @@ CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport)
 {
     return ImGui::DestroyPlatformWindow(viewport);
 }
+CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
+{
+    return ImGui::SetWindowViewport(window,viewport);
+}
 CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,ImGuiViewportP* viewport)
 {
     return ImGui::SetCurrentViewport(window,viewport);
@@ -3781,6 +3936,10 @@ CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(ImGuiViewpor
 {
     return ImGui::GetViewportPlatformMonitor(viewport);
 }
+CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(const ImVec2 mouse_platform_pos)
+{
+    return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos);
+}
 CIMGUI_API void igMarkIniSettingsDirty_Nil()
 {
     return ImGui::MarkIniSettingsDirty();
@@ -3805,13 +3964,25 @@ CIMGUI_API ImGuiWindowSettings* igFindOrCreateWindowSettings(const char* name)
 {
     return ImGui::FindOrCreateWindowSettings(name);
 }
+CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler)
+{
+    return ImGui::AddSettingsHandler(handler);
+}
+CIMGUI_API void igRemoveSettingsHandler(const char* type_name)
+{
+    return ImGui::RemoveSettingsHandler(type_name);
+}
 CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name)
 {
     return ImGui::FindSettingsHandler(type_name);
 }
-CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll)
+CIMGUI_API void igLocalizeRegisterEntries(const ImGuiLocEntry* entries,int count)
 {
-    return ImGui::SetNextWindowScroll(scroll);
+    return ImGui::LocalizeRegisterEntries(entries,count);
+}
+CIMGUI_API const char* igLocalizeGetMsg(ImGuiLocKey key)
+{
+    return ImGui::LocalizeGetMsg(key);
 }
 CIMGUI_API void igSetScrollX_WindowPtr(ImGuiWindow* window,float scroll_x)
 {
@@ -4085,81 +4256,149 @@ CIMGUI_API void igNavMoveRequestTryWrapping(ImGuiWindow* window,ImGuiNavMoveFlag
 {
     return ImGui::NavMoveRequestTryWrapping(window,move_flags);
 }
-CIMGUI_API float igGetNavInputAmount(ImGuiNavInput n,ImGuiInputReadMode mode)
-{
-    return ImGui::GetNavInputAmount(n,mode);
-}
-CIMGUI_API void igGetNavInputAmount2d(ImVec2 *pOut,ImGuiNavDirSourceFlags dir_sources,ImGuiInputReadMode mode,float slow_factor,float fast_factor)
-{
-    *pOut = ImGui::GetNavInputAmount2d(dir_sources,mode,slow_factor,fast_factor);
-}
-CIMGUI_API int igCalcTypematicRepeatAmount(float t0,float t1,float repeat_delay,float repeat_rate)
-{
-    return ImGui::CalcTypematicRepeatAmount(t0,t1,repeat_delay,repeat_rate);
-}
 CIMGUI_API void igActivateItem(ImGuiID id)
 {
     return ImGui::ActivateItem(id);
 }
+CIMGUI_API void igSetNavWindow(ImGuiWindow* window)
+{
+    return ImGui::SetNavWindow(window);
+}
 CIMGUI_API void igSetNavID(ImGuiID id,ImGuiNavLayer nav_layer,ImGuiID focus_scope_id,const ImRect rect_rel)
 {
     return ImGui::SetNavID(id,nav_layer,focus_scope_id,rect_rel);
 }
-CIMGUI_API void igPushFocusScope(ImGuiID id)
+CIMGUI_API bool igIsNamedKey(ImGuiKey key)
 {
-    return ImGui::PushFocusScope(id);
+    return ImGui::IsNamedKey(key);
 }
-CIMGUI_API void igPopFocusScope()
+CIMGUI_API bool igIsNamedKeyOrModKey(ImGuiKey key)
 {
-    return ImGui::PopFocusScope();
+    return ImGui::IsNamedKeyOrModKey(key);
 }
-CIMGUI_API ImGuiID igGetFocusedFocusScope()
+CIMGUI_API bool igIsLegacyKey(ImGuiKey key)
 {
-    return ImGui::GetFocusedFocusScope();
+    return ImGui::IsLegacyKey(key);
 }
-CIMGUI_API ImGuiID igGetFocusScope()
+CIMGUI_API bool igIsKeyboardKey(ImGuiKey key)
 {
-    return ImGui::GetFocusScope();
+    return ImGui::IsKeyboardKey(key);
 }
-CIMGUI_API void igSetItemUsingMouseWheel()
+CIMGUI_API bool igIsGamepadKey(ImGuiKey key)
 {
-    return ImGui::SetItemUsingMouseWheel();
+    return ImGui::IsGamepadKey(key);
 }
-CIMGUI_API void igSetActiveIdUsingNavAndKeys()
+CIMGUI_API bool igIsMouseKey(ImGuiKey key)
 {
-    return ImGui::SetActiveIdUsingNavAndKeys();
+    return ImGui::IsMouseKey(key);
 }
-CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir)
+CIMGUI_API bool igIsAliasKey(ImGuiKey key)
 {
-    return ImGui::IsActiveIdUsingNavDir(dir);
+    return ImGui::IsAliasKey(key);
 }
-CIMGUI_API bool igIsActiveIdUsingNavInput(ImGuiNavInput input)
+CIMGUI_API ImGuiKey igConvertSingleModFlagToKey(ImGuiKey key)
 {
-    return ImGui::IsActiveIdUsingNavInput(input);
+    return ImGui::ConvertSingleModFlagToKey(key);
 }
-CIMGUI_API bool igIsActiveIdUsingKey(ImGuiKey key)
+CIMGUI_API ImGuiKeyData* igGetKeyData(ImGuiKey key)
 {
-    return ImGui::IsActiveIdUsingKey(key);
+    return ImGui::GetKeyData(key);
+}
+CIMGUI_API void igGetKeyChordName(ImGuiKeyChord key_chord,char* out_buf,int out_buf_size)
+{
+    return ImGui::GetKeyChordName(key_chord,out_buf,out_buf_size);
+}
+CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button)
+{
+    return ImGui::MouseButtonToKey(button);
 }
 CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,float lock_threshold)
 {
     return ImGui::IsMouseDragPastThreshold(button,lock_threshold);
 }
-CIMGUI_API bool igIsKeyPressedMap(ImGuiKey key,bool repeat)
+CIMGUI_API void igGetKeyVector2d(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)
 {
-    return ImGui::IsKeyPressedMap(key,repeat);
+    *pOut = ImGui::GetKeyVector2d(key_left,key_right,key_up,key_down);
 }
-CIMGUI_API bool igIsNavInputDown(ImGuiNavInput n)
+CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis)
 {
-    return ImGui::IsNavInputDown(n);
+    return ImGui::GetNavTweakPressedAmount(axis);
 }
-CIMGUI_API bool igIsNavInputTest(ImGuiNavInput n,ImGuiInputReadMode rm)
+CIMGUI_API int igCalcTypematicRepeatAmount(float t0,float t1,float repeat_delay,float repeat_rate)
 {
-    return ImGui::IsNavInputTest(n,rm);
+    return ImGui::CalcTypematicRepeatAmount(t0,t1,repeat_delay,repeat_rate);
 }
-CIMGUI_API ImGuiKeyModFlags igGetMergedKeyModFlags()
+CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate)
 {
-    return ImGui::GetMergedKeyModFlags();
+    return ImGui::GetTypematicRepeatRate(flags,repeat_delay,repeat_rate);
+}
+CIMGUI_API void igSetActiveIdUsingAllKeyboardKeys()
+{
+    return ImGui::SetActiveIdUsingAllKeyboardKeys();
+}
+CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir)
+{
+    return ImGui::IsActiveIdUsingNavDir(dir);
+}
+CIMGUI_API ImGuiID igGetKeyOwner(ImGuiKey key)
+{
+    return ImGui::GetKeyOwner(key);
+}
+CIMGUI_API void igSetKeyOwner(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags)
+{
+    return ImGui::SetKeyOwner(key,owner_id,flags);
+}
+CIMGUI_API void igSetItemKeyOwner(ImGuiKey key,ImGuiInputFlags flags)
+{
+    return ImGui::SetItemKeyOwner(key,flags);
+}
+CIMGUI_API bool igTestKeyOwner(ImGuiKey key,ImGuiID owner_id)
+{
+    return ImGui::TestKeyOwner(key,owner_id);
+}
+CIMGUI_API ImGuiKeyOwnerData* igGetKeyOwnerData(ImGuiKey key)
+{
+    return ImGui::GetKeyOwnerData(key);
+}
+CIMGUI_API bool igIsKeyDown_ID(ImGuiKey key,ImGuiID owner_id)
+{
+    return ImGui::IsKeyDown(key,owner_id);
+}
+CIMGUI_API bool igIsKeyPressed_ID(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags)
+{
+    return ImGui::IsKeyPressed(key,owner_id,flags);
+}
+CIMGUI_API bool igIsKeyReleased_ID(ImGuiKey key,ImGuiID owner_id)
+{
+    return ImGui::IsKeyReleased(key,owner_id);
+}
+CIMGUI_API bool igIsMouseDown_ID(ImGuiMouseButton button,ImGuiID owner_id)
+{
+    return ImGui::IsMouseDown(button,owner_id);
+}
+CIMGUI_API bool igIsMouseClicked_ID(ImGuiMouseButton button,ImGuiID owner_id,ImGuiInputFlags flags)
+{
+    return ImGui::IsMouseClicked(button,owner_id,flags);
+}
+CIMGUI_API bool igIsMouseReleased_ID(ImGuiMouseButton button,ImGuiID owner_id)
+{
+    return ImGui::IsMouseReleased(button,owner_id);
+}
+CIMGUI_API bool igShortcut(ImGuiKeyChord key_chord,ImGuiID owner_id,ImGuiInputFlags flags)
+{
+    return ImGui::Shortcut(key_chord,owner_id,flags);
+}
+CIMGUI_API bool igSetShortcutRouting(ImGuiKeyChord key_chord,ImGuiID owner_id,ImGuiInputFlags flags)
+{
+    return ImGui::SetShortcutRouting(key_chord,owner_id,flags);
+}
+CIMGUI_API bool igTestShortcutRouting(ImGuiKeyChord key_chord,ImGuiID owner_id)
+{
+    return ImGui::TestShortcutRouting(key_chord,owner_id);
+}
+CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(ImGuiKeyChord key_chord)
+{
+    return ImGui::GetShortcutRoutingData(key_chord);
 }
 CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx)
 {
@@ -4205,9 +4444,13 @@ CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,ImGuiDockNode* no
 {
     return ImGui::DockContextQueueUndockNode(ctx,node);
 }
-CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)
+CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)
 {
-    return ImGui::DockContextCalcDropPosForDocking(target,target_node,payload,split_dir,split_outer,out_pos);
+    return ImGui::DockContextCalcDropPosForDocking(target,target_node,payload_window,payload_node,split_dir,split_outer,out_pos);
+}
+CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,ImGuiID id)
+{
+    return ImGui::DockContextFindNodeByID(ctx,id);
 }
 CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node)
 {
@@ -4313,6 +4556,22 @@ CIMGUI_API void igDockBuilderFinish(ImGuiID node_id)
 {
     return ImGui::DockBuilderFinish(node_id);
 }
+CIMGUI_API void igPushFocusScope(ImGuiID id)
+{
+    return ImGui::PushFocusScope(id);
+}
+CIMGUI_API void igPopFocusScope()
+{
+    return ImGui::PopFocusScope();
+}
+CIMGUI_API ImGuiID igGetCurrentFocusScope()
+{
+    return ImGui::GetCurrentFocusScope();
+}
+CIMGUI_API bool igIsDragDropActive()
+{
+    return ImGui::IsDragDropActive();
+}
 CIMGUI_API bool igBeginDragDropTargetCustom(const ImRect bb,ImGuiID id)
 {
     return ImGui::BeginDragDropTargetCustom(bb,id);
@@ -4325,6 +4584,10 @@ CIMGUI_API bool igIsDragDropPayloadBeingAccepted()
 {
     return ImGui::IsDragDropPayloadBeingAccepted();
 }
+CIMGUI_API void igRenderDragDropTargetRect(const ImRect bb)
+{
+    return ImGui::RenderDragDropTargetRect(bb);
+}
 CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect clip_rect)
 {
     return ImGui::SetWindowClipRectBeforeSetChannel(window,clip_rect);
@@ -4437,10 +4700,18 @@ CIMGUI_API void igTableDrawContextMenu(ImGuiTable* table)
 {
     return ImGui::TableDrawContextMenu(table);
 }
+CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table)
+{
+    return ImGui::TableBeginContextMenuPopup(table);
+}
 CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table)
 {
     return ImGui::TableMergeDrawChannels(table);
 }
+CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,int instance_no)
+{
+    return ImGui::TableGetInstanceData(table,instance_no);
+}
 CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table)
 {
     return ImGui::TableSortSpecsSanitize(table);
@@ -4533,9 +4804,9 @@ CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table)
 {
     return ImGui::TableGetBoundSettings(table);
 }
-CIMGUI_API void igTableSettingsInstallHandler(ImGuiContext* context)
+CIMGUI_API void igTableSettingsAddSettingsHandler()
 {
-    return ImGui::TableSettingsInstallHandler(context);
+    return ImGui::TableSettingsAddSettingsHandler();
 }
 CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,int columns_count)
 {
@@ -4585,9 +4856,13 @@ 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 igTabItemCalcSize(ImVec2 *pOut,const char* label,bool has_close_button)
+CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker)
 {
-    *pOut = ImGui::TabItemCalcSize(label,has_close_button);
+    *pOut = ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker);
+}
+CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window)
+{
+    *pOut = ImGui::TabItemCalcSize(window);
 }
 CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col)
 {
@@ -4637,6 +4912,10 @@ CIMGUI_API const char* igFindRenderedTextEnd(const char* text,const char* text_e
 {
     return ImGui::FindRenderedTextEnd(text,text_end);
 }
+CIMGUI_API void igRenderMouseCursor(ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow)
+{
+    return ImGui::RenderMouseCursor(pos,scale,mouse_cursor,col_fill,col_border,col_shadow);
+}
 CIMGUI_API void igRenderArrow(ImDrawList* draw_list,ImVec2 pos,ImU32 col,ImGuiDir dir,float scale)
 {
     return ImGui::RenderArrow(draw_list,pos,col,dir,scale);
@@ -4649,10 +4928,6 @@ CIMGUI_API void igRenderCheckMark(ImDrawList* draw_list,ImVec2 pos,ImU32 col,flo
 {
     return ImGui::RenderCheckMark(draw_list,pos,col,sz);
 }
-CIMGUI_API void igRenderMouseCursor(ImDrawList* draw_list,ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow)
-{
-    return ImGui::RenderMouseCursor(draw_list,pos,scale,mouse_cursor,col_fill,col_border,col_shadow);
-}
 CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,ImVec2 pos,ImVec2 half_sz,ImGuiDir direction,ImU32 col)
 {
     return ImGui::RenderArrowPointingAt(draw_list,pos,half_sz,direction,col);
@@ -4665,7 +4940,7 @@ CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,const ImRect rect
 {
     return ImGui::RenderRectFilledRangeH(draw_list,rect,col,x_start_norm,x_end_norm,rounding);
 }
-CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,ImRect outer,ImRect inner,ImU32 col,float rounding)
+CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,const ImRect outer,const ImRect inner,ImU32 col,float rounding)
 {
     return ImGui::RenderRectFilledWithHole(draw_list,outer,inner,col,rounding);
 }
@@ -4701,9 +4976,9 @@ CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p
 {
     return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,flags);
 }
-CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec2 padding,const ImVec4 bg_col,const ImVec4 tint_col)
+CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)
 {
-    return ImGui::ImageButtonEx(id,texture_id,size,uv0,uv1,padding,bg_col,tint_col);
+    return ImGui::ImageButtonEx(id,texture_id,size,uv0,uv1,bg_col,tint_col);
 }
 CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)
 {
@@ -4753,14 +5028,18 @@ CIMGUI_API bool igTreeNodeBehavior(ImGuiID id,ImGuiTreeNodeFlags flags,const cha
 {
     return ImGui::TreeNodeBehavior(id,flags,label,label_end);
 }
-CIMGUI_API bool igTreeNodeBehaviorIsOpen(ImGuiID id,ImGuiTreeNodeFlags flags)
-{
-    return ImGui::TreeNodeBehaviorIsOpen(id,flags);
-}
 CIMGUI_API void igTreePushOverrideID(ImGuiID id)
 {
     return ImGui::TreePushOverrideID(id);
 }
+CIMGUI_API void igTreeNodeSetOpen(ImGuiID id,bool open)
+{
+    return ImGui::TreeNodeSetOpen(id,open);
+}
+CIMGUI_API bool igTreeNodeUpdateNextOpen(ImGuiID id,ImGuiTreeNodeFlags flags)
+{
+    return ImGui::TreeNodeUpdateNextOpen(id,flags);
+}
 CIMGUI_API const ImGuiDataTypeInfo* igDataTypeGetInfo(ImGuiDataType data_type)
 {
     return ImGui::DataTypeGetInfo(data_type);
@@ -4773,9 +5052,9 @@ CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,int op,void* output,co
 {
     return ImGui::DataTypeApplyOp(data_type,op,output,arg_1,arg_2);
 }
-CIMGUI_API bool igDataTypeApplyOpFromText(const char* buf,const char* initial_value_buf,ImGuiDataType data_type,void* p_data,const char* format)
+CIMGUI_API bool igDataTypeApplyFromText(const char* buf,ImGuiDataType data_type,void* p_data,const char* format)
 {
-    return ImGui::DataTypeApplyOpFromText(buf,initial_value_buf,data_type,p_data,format);
+    return ImGui::DataTypeApplyFromText(buf,data_type,p_data,format);
 }
 CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,const void* arg_1,const void* arg_2)
 {
@@ -4841,6 +5120,17 @@ CIMGUI_API void igGcAwakeTransientWindowBuffers(ImGuiWindow* window)
 {
     return ImGui::GcAwakeTransientWindowBuffers(window);
 }
+CIMGUI_API void igDebugLog(const char* fmt,...)
+{
+    va_list args;
+    va_start(args, fmt);
+    ImGui::DebugLogV(fmt,args);
+    va_end(args);
+}
+CIMGUI_API void igDebugLogV(const char* fmt,va_list args)
+{
+    return ImGui::DebugLogV(fmt,args);
+}
 CIMGUI_API void igErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,void* user_data)
 {
     return ImGui::ErrorCheckEndFrameRecover(log_callback,user_data);
@@ -4849,6 +5139,22 @@ CIMGUI_API void igErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,
 {
     return ImGui::ErrorCheckEndWindowRecover(log_callback,user_data);
 }
+CIMGUI_API void igErrorCheckUsingSetCursorPosToExtendParentBoundaries()
+{
+    return ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
+}
+CIMGUI_API void igDebugLocateItem(ImGuiID target_id)
+{
+    return ImGui::DebugLocateItem(target_id);
+}
+CIMGUI_API void igDebugLocateItemOnHover(ImGuiID target_id)
+{
+    return ImGui::DebugLocateItemOnHover(target_id);
+}
+CIMGUI_API void igDebugLocateItemResolveWithLastItem()
+{
+    return ImGui::DebugLocateItemResolveWithLastItem();
+}
 CIMGUI_API void igDebugDrawItemRect(ImU32 col)
 {
     return ImGui::DebugDrawItemRect(col);
@@ -4885,6 +5191,10 @@ CIMGUI_API void igDebugNodeFont(ImFont* font)
 {
     return ImGui::DebugNodeFont(font);
 }
+CIMGUI_API void igDebugNodeFontGlyph(ImFont* font,const ImFontGlyph* glyph)
+{
+    return ImGui::DebugNodeFontGlyph(font,glyph);
+}
 CIMGUI_API void igDebugNodeStorage(ImGuiStorage* storage,const char* label)
 {
     return ImGui::DebugNodeStorage(storage,label);
@@ -4901,6 +5211,10 @@ CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings)
 {
     return ImGui::DebugNodeTableSettings(settings);
 }
+CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state)
+{
+    return ImGui::DebugNodeInputTextState(state);
+}
 CIMGUI_API void igDebugNodeWindow(ImGuiWindow* window,const char* label)
 {
     return ImGui::DebugNodeWindow(window,label);
@@ -4925,6 +5239,10 @@ CIMGUI_API void igDebugRenderViewportThumbnail(ImDrawList* draw_list,ImGuiViewpo
 {
     return ImGui::DebugRenderViewportThumbnail(draw_list,viewport,bb);
 }
+CIMGUI_API bool igIsKeyPressedMap(ImGuiKey key,bool repeat)
+{
+    return ImGui::IsKeyPressedMap(key,repeat);
+}
 CIMGUI_API const ImFontBuilderIO* igImFontAtlasGetBuilderForStbTruetype()
 {
     return ImFontAtlasGetBuilderForStbTruetype();

generator/cimgui_template.cpp

@@ -1,6 +1,14 @@
-
+#ifdef IMGUI_ENABLE_FREETYPE
-#include "./imgui/imgui.h"
+#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"
 #endif
 #include "./imgui/imgui_internal.h"

generator/cimgui_template.h

@@ -51,12 +51,12 @@ CIMGUI_API void igLogText(CONST char *fmt, ...);
 //no appendfV
 CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
 //for getting FLT_MAX in bindings
-CIMGUI_API float igGET_FLT_MAX();
+CIMGUI_API float igGET_FLT_MAX(void);
 //for getting FLT_MIN in bindings
-CIMGUI_API float igGET_FLT_MIN();
+CIMGUI_API float igGET_FLT_MIN(void);
 
 
-CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
+CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create(void);
 CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);

generator/config_generator.lua

@@ -1,3 +1,3 @@
 return {
-	vulkan = {[[C:\VulkanSDK\1.1.130.0\Include]]}
+	vulkan = {(os.getenv("VULKAN_SDK") or "vulkan_SDK_not_found").."/Include"}, --{[[C:\VulkanSDK\1.3.216.0\Include]]}
-}
+} 

generator/cpp2ffi.lua

@@ -116,7 +116,7 @@ end
 M.strsplit = strsplit
 local function split_comment(line)
     local comment = line:match("(%s*//.*)") --or ""
-    line = line:gsub("%s*//.*","")
+    line = line:gsub("%s*//[^\n]*","")
     line = line:gsub("%s*$","")
     return line,comment
 end
@@ -129,6 +129,23 @@ local function clean_comments(txt)
 	txt = txt:gsub("%s*//[^\n]*","")
 	return txt,comms
 end
+--dont keep commens above empty line
+local function clean_outercomms(oc)
+	local oc2 = {}
+	for i,v in ipairs(oc) do
+		--print(string.format("%d\n%q",i,v))
+		if v:match"\n%s*\n" then
+			--print(string.format("match:\n%q",v))--,v:match"\n%s*\n"))
+			v=v:gsub("\n%s*\n","")
+			--print("clean",v)
+			oc2 = {}
+		else
+			--print"dont clean"
+		end
+		table.insert(oc2,v)
+	end
+	return table.concat(oc2)--,"\n")
+end
 local function strip(cad)
     return cad:gsub("^%s*(.-)%s*$","%1") --remove initial and final spaces
 end
@@ -139,6 +156,7 @@ local function clean_spaces(cad)
     cad = strip(cad)
     cad = cad:gsub("%s+"," ") --not more than one space
     cad = cad:gsub("%s*([%(%),=:%+])%s*","%1") --not spaces with ( , ) or ( = ) or ( : ) or + 
+	cad = cad:gsub("%s*(>>)%s*","%1")
 	--name [] to name[]
 	cad = cad:gsub("(%S)%s(%[)","%1%2")
 	--clean %d * %d (could be done above but type*name should be treated different in other places)
@@ -147,6 +165,22 @@ local function clean_spaces(cad)
 end
 
 ------------------------------------
+local function check_template(code)
+	local ttype,template = code:match("([^%s,%(%)]+)%s*<(.-)>")
+	local code2,te
+	if template then
+		te = template:gsub("%s*,%s*",",")
+		te = te:gsub(",","__")
+		te = te:gsub("%-","less")
+		te = te:gsub("%s","_")
+		te = te:gsub("%*","Ptr")
+	
+		code2 = code:gsub("(<[%w_%*%s]+>)([^%s%*])","%1 %2")
+		code2 = code2:gsub("<([^<>]-)>","_"..te)
+	end
+	return ttype,template,te,code2
+end
+----------------------------------------
 local function parse_enum_value(value, allenums,dontpost)
 	local function clean(val)
 		if type(val)=="string" then
@@ -159,6 +193,7 @@ local function parse_enum_value(value, allenums,dontpost)
 	if type(value)=="number" then
 		return value
 	elseif type(value)=="string" then 
+		--print(value)
 		--numbers
 		local numval = tonumber(value)
 		if numval then return numval end 
@@ -170,13 +205,13 @@ local function parse_enum_value(value, allenums,dontpost)
 		value = value:gsub("^(%()",""):gsub("(%))$","")
 		assert(not value:match("[%(%)]"),value)
 		
-		local several,seps = strsplit(value,"([<>&|~%+]+)") 
+		local several,seps = strsplit(value,"([<>&|~%+%-]+)") 
 		--M.prtable(value,several,seps)
 		assert(#seps+1==#several)
 		
 		local i = 1
 		local ik = 1
-		local sepk = {"~","<<",">>","&","^","|","+"}
+		local sepk = {"~","<<",">>","&","^","|","+","-"}
 		while(#seps>0) do
 			local sep = sepk[ik]
 			local v = seps[i]
@@ -206,6 +241,8 @@ local function parse_enum_value(value, allenums,dontpost)
 					several[i] = bit.bor(val1,val2)
 				elseif v=="+" then
 					several[i] = val1 + val2
+				elseif v=="-" then
+					several[i] = val1 - val2
 				else
 					error("unknown operator "..v)
 				end
@@ -223,7 +260,7 @@ local function parse_enum_value(value, allenums,dontpost)
 		end
 		if #seps>0 or type(several[1])~="number" and not dontpost then
 			--M.prtable("enline",enline)
-			print("parse_enum_value WARNING",value,several[1])
+			print("parse_enum_value WARNING:",value,several[1])
 			--M.prtable(several,seps)
 			--M.prtable("allenums",allenums)
 		end
@@ -278,6 +315,7 @@ local function getRE()
 	local res = {
 	function_re = "^([^;{}]+%b()[\n%s]*;)%s*",
 	function_re = "^([^;{}=]+%b()[\n%s%w]*;)", --const at the end
+	function_re = "^([^;{}=]+%b()[\n%s%w%(%)_]*;)", --attribute(deprecated)
 	struct_re = "^([^;{}]-struct[^;{}]-%b{}[%s%w_%(%)]*;)",
 	enum_re = "^([^;{}]-enum[^;{}]-%b{}[%s%w_%(%)]*;)",
 	union_re = "^([^;{}]-union[^;{}]-%b{}[%s%w_%(%)]*;)",
@@ -291,15 +329,18 @@ local function getRE()
 	--vardef_re = "^\n*([^;{}%(%)]+;)",
 	--change for things as
 	--[[ImU8 Used4kPagesMap[((sizeof(ImWchar16) == 2 ? 0xFFFF : 0x10FFFF)+1)/4096/8];]]
-	vardef_re = "^\n*([^;{}]+;)",
+	--vardef_re = "^\n*([^;{}]+;)",
+	vardef_re = "^\n*([^;]+;)",
 	functionD_re = "^([^;{}]-%b()[\n%s%w]*%b{}%s-;*)",
 	--functionD_re = "^([^;{}]-%b()[^{}%(%)]*%b{})",
 	functype_re = "^%s*[%w%s%*]+%(%*[%w_]+%)%([^%(%)]*%)%s*;",
-	comment_re = "^%s*//[^\n]*",
+	comment_re = "^\n*%s*//[^\n]*",
-	comment2_re = "^%s*/%*.-%*/"
+	comment2_re = "^%s*/%*.-%*/",
+	emptyline_re = "^\n%s*\n"
 	}
 	
-	local resN = {"comment2_re","comment_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"}
+	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"}
 	
 	return res,resN
 end
@@ -324,7 +365,9 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 			local re = res[re_name]
 			local i,e = txt:find(re,ini)
 			if i then
+				
 				item = txt:sub(i,e)
+				--print("re_name:",re_name,string.format("%q",item))
 				------------------
 				--[[
 				--if re~=functionD_re then --skip defined functions
@@ -335,7 +378,8 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 				table.insert(items[re_name],item)
 				--]]
 				--------------------
-				if re_name=="comment_re" or re_name=="comment2_re" then
+				if re_name=="comment_re" or re_name=="comment2_re" or re_name=="emptyline_re" then
+					--print("parit",item)
 					--[[
 					table.insert(outercomms,item)
 					-- comments to previous item
@@ -344,6 +388,13 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 						itemarr[#itemarr].comments = prev .. item 
 					end
 					--]]
+					--clean initial spaces
+					--item = item:gsub("^%s*(//.-)$","%1")
+					--if item:match"^[^\n%S]*" then
+						--print("commspace1",string.format("%q",item))
+						item = item:gsub("^[^\n%S]*(//.-)$","%1")
+						--print("commspace2",string.format("%q",item))
+					--end
 					--comments begining with \n will go to next item
 					if item:match("^%s*\n") then
 						table.insert(outercomms,item)
@@ -358,7 +409,8 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 					--item,inercoms = clean_comments(item)
 					local itemold = item
 					item = item:gsub("extern __attribute__%(%(dllexport%)%) ","")
-					local comments = table.concat(outercomms,"\n") --..inercoms
+					local comments = clean_outercomms(outercomms) 
+					--local comments = table.concat(outercomms,"\n") --..inercoms
 					if comments=="" then comments=nil end
 					outercomms = {}
 					local loca
@@ -377,17 +429,23 @@ local function parseItems(txt,linenumdict, itparent, dumpit)
 						end
 						if not loca then
 							print("not loca",string.format("%q , %q ",itemold,itemfirstline),#itemfirstline)
-							for k,v in pairs(linenumdict) do
+							-- for k,v in pairs(linenumdict) do
-								if k:match(itemfirstline) then
+								-- if k:match(itemfirstline) then
-									print(string.format("%q",k),#k)
+									-- print(string.format("%q",k),#k)
-								end
+								-- end
+							-- end
+							--error"no entry in linenumdict"
+							--take locat from parent
+							if itparent.locat then
+								loca = itparent.locat
+							else
+								error"no entry in linenumdict"
 							end
-							error"no entry in linenumdict"
 						end
 					else
 						error"no linenumdict"
 					end
-					table.insert(itemarr,{re_name=re_name,item=item,locat=loca})--,comments=comments})
+					table.insert(itemarr,{re_name=re_name,item=item,locat=loca,prevcomments=comments})
 					items[re_name] = items[re_name] or {}
 					table.insert(items[re_name],item)
 				end
@@ -540,7 +598,77 @@ local function clean_names_from_signature(self,signat)
 	result = result:sub(1,-2) .. ")"
 	return result
 end
+local function clean_functypedef(line)
+	local first, args = line:match("(typedef .-%(%*[_%w]+%))%s*(%b())")
+
+	if not args then
+		print"not getting args in"
+		print(line)
+		print(first,"args",args)
+		error"clean_functypedef not getting args"
+    end
+	
+	local argsp = args:sub(2,-2)..","
+	local argsTa = {}
+	for tynam in argsp:gmatch("([^,]+),") do
+		if tynam:match("%)") and not tynam:match("%b()") then
+			--patenthesis not closed are merged in previous (happens in some defaults)
+			argsTa[#argsTa] = argsTa[#argsTa]..","..tynam
+			while argsTa[#argsTa]:match("%)") and not argsTa[#argsTa]:match("%b()") do
+				argsTa[#argsTa-1] = argsTa[#argsTa-1] .. "," .. argsTa[#argsTa]
+				argsTa[#argsTa] = nil
+			end
+		else
+			argsTa[#argsTa+1] = tynam
+		end
+	end
+
+	local result = "\n"..first.."("
+	for i,ar in ipairs(argsTa) do
+		if ar:match("&") then
+			if ar:match("const") then
+				argsTa[i] = ar:gsub("&","")
+			else
+				argsTa[i] = ar:gsub("&","*")
+			end
+        end
+		result = result..argsTa[i]..(i==#argsTa and ");" or ",")
+	end
+	--M.prtable(argsTa)
+	--print(result)
+	return result
+end
+
+local function CleanImU32(def)
+	local function deleteOuterPars(def)
+		local w = def:match("^%b()$")
+		if w then
+			w = w:gsub("^%((.+)%)$","%1")
+			return w
+		else 
+			return def 
+		end
+	end
+	def = def:gsub("%(ImU32%)","")
+	--quitar () de numeros
+	def = def:gsub("%((%d+)%)","%1")
+	def = deleteOuterPars(def)
+	local bb=strsplit(def,"|")
+	for i=1,#bb do
+		local val = deleteOuterPars(bb[i])
+		if val:match"<<" then
+			local v1,v2 = val:match("(%d+)%s*<<%s*(%d+)")
+			val = v1*2^v2
+			bb[i] = val
+		end
+		assert(type(bb[i])=="number",bb[i])
+	end
+	local res = 0 
+	for i=1,#bb do res = res + bb[i] end 
+	return res
+end
 local function parseFunction(self,stname,itt,namespace,locat)
+
 	local lineorig,comment = split_comment(itt.item)
 	line = clean_spaces(lineorig)
 	--move *
@@ -563,6 +691,8 @@ local function parseFunction(self,stname,itt,namespace,locat)
 	line = line:gsub("inline","")
 	line = line:gsub("mutable","")
 	line = line:gsub("explicit","")
+	line = line:gsub("constexpr","")
+	line = clean_spaces(line)
 	--skip operator
 	if line:match("operator") then return end
 	--skip template
@@ -601,20 +731,15 @@ local function parseFunction(self,stname,itt,namespace,locat)
 	--- templates in args
 	for i,ar in ipairs(argsTa) do
 		--TODO several diferent templates
-		local ttype,template = ar:match("([^%s,%(%)]+)%s*<(.-)>")
+		local ttype,template,te,code2 = check_template(ar) --ar:match("([^%s,%(%)]+)%s*<(.-)>")
 
-		local te=""
 		if template then
 			if self.typenames[stname] ~= template then --rule out template typename
-			te = template:gsub("%s","_")
+				self.templates[ttype] = self.templates[ttype] or {}
-			te = te:gsub("%*","Ptr")
+				self.templates[ttype][template] = te
-	
-			self.templates[ttype] = self.templates[ttype] or {}
-			self.templates[ttype][template] = te
-			te = "_"..te
 			end
 		end
-	    argsTa[i] = ar:gsub("<([%w_%*%s]+)>",te) --ImVector
+	    argsTa[i] = te and code2 or ar --ar:gsub("<([%w_%*%s]+)>",te) --ImVector
 	end
 	
 	--get typ, name and defaults
@@ -725,6 +850,15 @@ local function parseFunction(self,stname,itt,namespace,locat)
     defT.defaults = {}
 	for i,ar in ipairs(argsArr) do
 		if ar.default then
+			--clean defaults
+			--do only if not a c string
+				local is_cstring = ar.default:sub(1,1)=='"' and ar.default:sub(-1,-1) =='"'
+				if not is_cstring then
+					ar.default = ar.default:gsub("%(%(void%s*%*%)0%)","NULL")
+					if ar.default:match"%(ImU32%)" and not ar.default:match"sizeof" then
+						ar.default = tostring(CleanImU32(ar.default))
+					end
+				end
 			defT.defaults[ar.name] = ar.default
 			ar.default = nil
 		end
@@ -1063,14 +1197,20 @@ function M.Parser()
 		return par.skipped[def.ov_cimguiname] or par.skipped[def.cimguiname]
 	end
 	function par:take_lines(cmd_line,names,compiler)
+		if self.COMMENTS_GENERATION then
+			cmd_line = cmd_line .. (compiler=="cl" and " /C " or " -C ")
+		end
 		local pipe,err = io.popen(cmd_line,"r")
 		if not pipe then
 			error("could not execute COMPILER "..err)
 		end
 		local defines = {}
-		for line,loca,loca2 in M.location(pipe,names,defines,compiler) do
+		local preprocessed = {}--
+		for line,loca,loca2 in M.location(pipe,names,defines,compiler,self.COMMENTS_GENERATION) do
 			self:insert(line, tostring(loca)..":"..tostring(loca2))
+			table.insert(preprocessed,line)--
 		end
+		save_data("preprocesed.h",table.concat(preprocessed,"\n"))
 		pipe:close()
 		return defines
 	end
@@ -1140,7 +1280,8 @@ function M.Parser()
 					local stname = it.item:match("struct%s+(%S+)")
 					it.name = stname
 					
-					local templa1,templa2 = it.item:match("^%s*template%s*<%s*(%S+)%s*(%S+)%s*>")
+					--local templa1,templa2 = it.item:match("^%s*template%s*<%s*(%S+)%s*(%S+)%s*>")
+					local templa2 = it.item:match("^%s*template%s*<%s*([^<>]+)%s*>")
 					if templa1 or templa2 then print("template found",stname,templa1,templa2,"typename",typename) end
 					
 					if typename or templa2 then -- it is a struct template
@@ -1160,21 +1301,49 @@ function M.Parser()
 		self.linenumdict = {}
 		local cdefs2 = {}
 		for i,cdef in ipairs(cdefs) do
-			if self.linenumdict[cdef[1]] then
+			local cdef1 = clean_comments(cdef[1])
+			if self.linenumdict[cdef1] then
 				--print("linenumdict already defined for", cdef[1],type(self.linenumdict[cdef[1]]))
-				if type(self.linenumdict[cdef[1]])=="string" then
+				if type(self.linenumdict[cdef1])=="string" then
-					self.linenumdict[cdef[1]] = {self.linenumdict[cdef[1]], cdef[2]}
+					self.linenumdict[cdef1] = {self.linenumdict[cdef1], cdef[2]}
 				else -- must be table already
-					table.insert(self.linenumdict[cdef[1]],cdef[2])
+					table.insert(self.linenumdict[cdef1],cdef[2])
 				end
 			else
 				--print("nuevo linenumdict es",cdef[1],cdef[2])
-				self.linenumdict[cdef[1]]=cdef[2]
+				self.linenumdict[cdef1]=cdef[2]
 			end
 			table.insert(cdefs2,cdef[1])
 		end
 		local txt = table.concat(cdefs2,"\n")
-		
+		--clean bad positioned comments inside functionD_re
+		if self.COMMENTS_GENERATION then
+		print"cleaning comments inside functionD_re--------------"
+		---[[
+		local nn = 0
+		local txtclean = {}
+		local reg = "(\n[%w%s]-[%w]+%s*%b())(%s*//[^\n]*)([\n%s%w]*%b{}%s-;*)"
+		--reg = "^([^;{}]-%b()[\n%s%w]*%b{}%s-;*)"
+		local ini = 1
+		local i,e,a,b,c = txt:find(reg,ini)
+		while i do
+			print(i,e,#txt)
+			table.insert(txtclean,txt:sub(ini,i-1))
+			table.insert(txtclean,a)
+			print("a:",a)
+			print("b:",b)
+			print("c:",c)
+			c = c:gsub("(%s*//[^\n]*)","")
+			table.insert(txtclean,c)
+			nn = nn + 1
+			ini = e + 1
+			i,e,a,b,c = txt:find(reg,ini)
+		end
+		table.insert(txtclean,txt:sub(ini))
+		print("end cleaning ------------------------------",nn)
+		txt = table.concat(txtclean)
+		end
+		--]]
 		self.itemsarr = par:parseItemsR2(txt)
 		itemsarr = self.itemsarr
 	end
@@ -1183,8 +1352,25 @@ function M.Parser()
 		printItems(items)
 	end
 	par.parseFunction = parseFunction
-	
+	local uniques = {}
-	function par:clean_structR1(itst)
+	local function check_unique_typedefs(l,uniques)
+		if not uniques[l] then
+			uniques[l] = true
+			return true
+		end
+		return false
+	end
+	function par:generate_templates()
+		local ttd = {}
+		M.table_do_sorted(self.templates , function (ttype, v)
+			--print("generate_templates",ttype,v)
+			M.table_do_sorted(v, function(te,newte) 
+				table.insert(ttd,self:gentemplatetypedef(ttype,te,newte))
+			end)
+		end)
+		return table.concat(ttd,"")
+	end
+	function par:clean_structR1(itst,doheader)
 		local stru = itst.item
 		local outtab = {}
 		local commtab = {}
@@ -1215,11 +1401,11 @@ function M.Parser()
 		--table.insert(outtab,stru:match("(.-)%b{}"))
 		table.insert(outtab,"\nstruct "..stname.."\n")
 		table.insert(outtab,"{")
-		table.insert(commtab,nil)--"")
+		table.insert(commtab,"")
-		table.insert(commtab,nil)--"")
+		table.insert(commtab,"")
 		if derived then
 			table.insert(outtab,"\n    "..derived.." _"..derived..";")
-			table.insert(commtab,nil)--"")
+			table.insert(commtab,"")
 		end
 		--local itlist,itemsin = parseItems(iner, false,locat)
 		local itlist = itst.childs
@@ -1234,15 +1420,16 @@ function M.Parser()
 			if  not (it.re_name == "vardef_re" and it.item:match"static") then --skip static variables
 				local it2 = it.item --:gsub("<([%w_]+)>","_%1") --templates
 				--local ttype,template = it.item:match("([^%s,%(%)]+)%s*<(.+)>")
-				local ttype,template =    it.item:match"([^%s,%(%)]+)%s*<(.+)>"
+				local ttype,template,te,code2 =  check_template(it2)  --it.item:match"([^%s,%(%)]+)%s*<(.+)>"
 				if template then
 					if self.typenames[ttype] ~= template then --rule out T (template typename)
-					local te = template:gsub("%s","_")
+						self.templates[ttype] = self.templates[ttype] or {}
-					te = te:gsub("%*","Ptr")
+						self.templates[ttype][template] = te
-					self.templates[ttype] = self.templates[ttype] or {}
+						it2=code2
-					self.templates[ttype][template] = te
+					end
-					it2 = it2:gsub("(<[%w_%*%s]+>)([^%s])","%1 %2") --add if not present space after <>
+					if doheader then
-					it2 = it2:gsub("<([%w_%*%s]+)>","_"..te)
+						local templatetypedef = self:gentemplatetypedef(ttype, template,self.templates[ttype][template])
+						predeclare = predeclare .. templatetypedef
 					end
 				end
 				--clean mutable
@@ -1254,16 +1441,24 @@ function M.Parser()
 					it2 = it2:gsub("%s*=.+;",";")
 				end
 				table.insert(outtab,it2)
-				table.insert(commtab,it.comments )--or "")
+				table.insert(commtab,{above=it.prevcomments,sameline=it.comments})--it.comments or "")
 				end
 			elseif it.re_name == "struct_re" then
 				--check if has declaration
 				local decl = it.item:match"%b{}%s*([^%s}{]+)%s*;"
 				if decl then
 					table.insert(outtab,"\n    "..it.name.." "..decl..";")
-					table.insert(commtab,it.comments )--or "")
+					table.insert(commtab,{above=it.prevcomments,sameline=it.comments})--it.comments or "")
+				end
+				local cleanst,structname,strtab,comstab,predec = self:clean_structR1(it,doheader)
+				if doheader then
+				local tst = "\ntypedef struct "..structname.." "..structname..";\n"
+						if check_unique_typedefs(tst,uniques) then
+							--table.insert(outtab,tst)
+							--print("xxxxxxxxxxxxxxxinsert typedef",structname)
+							cleanst = cleanst .. tst
+						end
 				end
-				local cleanst,structname,strtab,comstab,predec = self:clean_structR1(it)
 				predeclare = predeclare .. predec .. cleanst
 			elseif it.re_name == "enum_re" then
 				--nop
@@ -1293,20 +1488,55 @@ function M.Parser()
 		if parnam~="" then parnam = parnam:sub(1,-3) end
 		return parnam
 	end
+	
+
 	function par:gen_structs_and_enums()
+		print"--------------gen_structs_and_enums"
+		--M.prtable(self.typenames)
 		local outtab = {} 
 		local outtabpre = {}
 		local typedefs_table = {}
 		self.embeded_enums = {}
+		--local uniques = {}
 		
 		local processer = function(it)
 			if it.re_name == "typedef_re" or it.re_name == "functypedef_re" or it.re_name == "vardef_re" then
 				if not it.parent or it.parent.re_name=="namespace_re" then
-					table.insert(outtabpre,it.item)
+					local it2 = it.item
+					if it.re_name == "typedef_re" then
+						--check if it is templated
+						local ttype,template,te,code2 = check_template(it2)   --it.item:match"([^%s,%(%)]+)%s*<(.+)>"
+						if template then
+							--if self.typenames[ttype] ~= template then --rule out T (template typename)
+							--self.templates[ttype] = self.templates[ttype] or {}
+							--self.templates[ttype][template] = te
+							--end
+							
+							--local templatetypedef = self:gentemplatetypedef(ttype, template,self.templates[ttype][template])
+								--predeclare = predeclare .. templatetypedef
+
+							local tdt = self:gentemplatetypedef(ttype,template,te)
+							it2 = tdt..code2
+						end
+					elseif it.re_name == "functypedef_re" then
+						it2 = clean_functypedef(it2)
+					else
+						assert(it.re_name == "vardef_re")
+						if it2:match"enum" then
+							print("--skip enum forward declaration:",it2)
+							it2 = ""
+						end
+					end
+					--table.insert(outtabpre,it2)
+					table.insert(outtab,it2)
 					-- 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")
+						--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)
+						end
 						self.typedefs_dict[stname]="struct "..stname
 						if it.parent then --must be struct name; inside namespace
 							local parname = get_parents_name(it)
@@ -1349,16 +1579,21 @@ function M.Parser()
 					print("unnamed enum",cl_item)
 				end
 			elseif it.re_name == "struct_re" or it.re_name == "typedef_st_re" then
-				local cleanst,structname,strtab,comstab,predec = self:clean_structR1(it)
+				local cleanst,structname,strtab,comstab,predec = self:clean_structR1(it,true)
 				if not structname then print("NO NAME",cleanst,it.item) end
 				--if not void stname or templated
 				if structname and not self.typenames[structname] then
+					
+					--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)
+						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)
 					end
-					table.insert(typedefs_table,"typedef struct "..structname.." "..structname..";\n")
-					self.typedefs_dict[structname]="struct "..structname
 				end
 				if it.parent  then --and (it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" then
 					local embededst = (it.re_name == "struct_re" and it.item:match("struct%s+(%S+)")) 
@@ -1402,13 +1637,13 @@ function M.Parser()
 		
 		self:Listing(itemsarr,processer)
 		
-		local uniques = {}
+		-- local uniques = {}
-		for i,l in ipairs(typedefs_table) do
+		-- for i,l in ipairs(typedefs_table) do
-			if not uniques[l] then
+			-- if not uniques[l] then
-				uniques[l] = true
+				-- uniques[l] = true
-				table.insert(outtabpre,1,l)
+				-- table.insert(outtabpre,1,l)
-			end
+			-- end
-		end
+		-- end
 		--check arg detection failure if no name in function declaration
 		check_arg_detection(self.defsT,self.typedefs_dict)
 		local outtabprest, outtabst = table.concat(outtabpre,""),table.concat(outtab,"")
@@ -1417,6 +1652,11 @@ function M.Parser()
 	end
 	-----------
 	function par:parse_struct_line(line,outtab,comment)
+		if type(comment)=="string" then
+			comment = comment ~= "" and comment or nil
+		else
+			comment = next(comment) and comment or nil
+		end
 		local functype_re = "^%s*[%w%s%*]+%(%*[%w_]+%)%([^%(%)]*%)"
 		local functype_reex = "^(%s*[%w%s%*]+%(%*)([%w_]+)(%)%([^%(%)]*%))"
 		line = clean_spaces(line)
@@ -1426,6 +1666,7 @@ function M.Parser()
 		else
 			--split type name1,name2; in several lines
 			local typen,rest = line:match("%s*([^,]+)%s(%S+[,;])")
+			--print(typen,"rest:",rest)
             if not typen then -- Lets try Type*name
                 typen,rest = line:match("([^,]+%*)(%S+[,;])")
             end
@@ -1468,6 +1709,8 @@ function M.Parser()
 			print("enumtype",enumtype) 
 			outtab.enumtypes[enumname] = enumtype
 		end
+		outtab.enum_comments[enumname] = {sameline=it.comments, above=it.prevcomments}
+		outtab.enum_comments[enumname] = next(outtab.enum_comments[enumname]) and outtab.enum_comments[enumname] or nil
 		outtab.enums[enumname] = {}
 		table.insert(enumsordered,enumname)
 		local inner = strip_end(it.item:match("%b{}"):sub(2,-2))
@@ -1489,6 +1732,7 @@ function M.Parser()
 		for j,line in ipairs(enumarr) do
 			local comment
 			line, comment = split_comment(line)
+			comment = comment and comment:gsub("^[^\n%S]*(//.-)$","%1") or nil
 			assert(line~="")
 			local name,value = line:match("%s*([%w_]+)%s*=%s*([^,]+)")
 			if value then
@@ -1515,10 +1759,25 @@ function M.Parser()
 	end
 	par.enums_for_table = enums_for_table
 	function par:gen_structs_and_enums_table()
-		local outtab = {enums={},structs={},locations={},enumtypes={}}
+		print"--------------gen_structs_and_enums_table"
+		local outtab = {enums={},structs={},locations={},enumtypes={},struct_comments={},enum_comments={}}
 		self.typedefs_table = {}
 		local enumsordered = {}
 		unnamed_enum_counter = 0
+		self.templated_structs = {}
+		--take cimgui templated_structs if given
+		if self.cimgui_inherited then
+			self.templated_structs = self.cimgui_inherited.templated_structs
+			self.templates_done = self.cimgui_inherited.templates_done
+			--M.prtable(self.typenames)
+			for k,v in pairs(self.cimgui_inherited.typenames) do
+				assert(not self.typenames[k])
+				if self.typenames[k] then
+					print("typenames repeated",k,self.typenames[k],v)
+				end
+				self.typenames[k] = v
+			end
+		end
 		
 		local processer = function(it)
 			if it.re_name == "typedef_re" or it.re_name == "functypedef_re" or it.re_name == "vardef_re" then
@@ -1535,12 +1794,24 @@ function M.Parser()
 				if not structname then print("NO NAME",cleanst,it.item) end
 				if structname and not self.typenames[structname] then
 					outtab.structs[structname] = {}
+					outtab.struct_comments[structname] = {sameline=it.comments,above=it.prevcomments}
+					outtab.struct_comments[structname] = next(outtab.struct_comments[structname]) and outtab.struct_comments[structname] or nil
 					outtab.locations[structname] = it.locat
 					for j=3,#strtab-1 do
 						self:parse_struct_line(strtab[j],outtab.structs[structname],comstab[j])
 					end
 				else
-					print("skipped unnamed or templated struct",structname)
+					--templated struct
+					if structname then
+						print("saving templated struct",structname)
+						self.templated_structs[structname] = {}
+						for j=3,#strtab-1 do
+							self:parse_struct_line(strtab[j],self.templated_structs[structname],comstab[j])
+						end
+						--M.prtable(self.templated_structs[structname])
+					else
+						print("skipped unnamed struct",structname)
+					end
 				end
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
@@ -1552,7 +1823,16 @@ function M.Parser()
 		self:Listing(itemsarr,processer)
 		
 		--calcule size of name[16+1] [xxx_COUNT]
-		local allenums = {}
+		local allenums = {} 
+		--take cimgui struct_and_enums if given
+		if self.cimgui_inherited then
+			for k,v in pairs(self.cimgui_inherited.enums) do
+				for j,v2 in ipairs(v) do
+					allenums[v2.name] = v2.calc_value
+					--print(k,v.calc_value)
+				end
+			end
+		end
 		--first calc_value in enums
 		for i,enumname in ipairs(enumsordered) do
 		--for enumname,enum in pairs(outtab.enums) do
@@ -1586,6 +1866,11 @@ function M.Parser()
 				end
 			end
 		end
+		--delete comments tables if not desired
+		if not self.COMMENTS_GENERATION then
+			outtab.enum_comments = nil
+			outtab.struct_comments = nil
+		end
 		self.structs_and_enums_table = outtab
 		return outtab
 	end
@@ -1616,6 +1901,7 @@ function M.Parser()
                 --print(k,#v)
                 table.insert(strt,string.format("%s\t%d",k,#v))
                 local typesc,post = name_overloadsAlgo(v)
+				--M.prtable(v)
                 for i,t in ipairs(v) do
                     --take overloaded name from manual table or algorythm
                     t.ov_cimguiname = self.getCname_overload(t.stname,t.funcname,t.signature,t.namespace) or k..typetoStr(post[i])
@@ -1756,6 +2042,58 @@ function M.Parser()
 			table.insert(self.funcdefs,v)
 		end
 	end
+	function par:gentemplatetypedef(ttype,te,newte)
+		--print("gentemplatetypedef",ttype,te,newte)
+		if not newte then return "" end
+		self.templates_done = self.templates_done or {}
+		self.templates_done[ttype] = self.templates_done[ttype] or {}
+		if self.templates_done[ttype][te] then return "" end
+		self.templates_done[ttype][te] = true
+		--return self:gen_template_typedef(ttype,te,newte) --given by user
+		return self:gen_template_typedef_auto(ttype,te,newte)
+	end
+	function par:gen_template_typedef_auto(ttype,te,newte)
+		assert(self.templated_structs[ttype],ttype)
+		local defi = self.templated_structs[ttype]
+		local Targ = strsplit(self.typenames[ttype],",")
+		local defa = {}
+		local tes = strsplit(te,",")
+		--get the only name of template arg
+		for i,arg in ipairs(Targ) do
+			Targ[i] = strip(arg)
+			defa[i] = Targ[i]:match"=(.+)" --get default
+			if defa[i] then defa[i] = strip(defa[i]) end
+			Targ[i] = Targ[i]:gsub("%s*=.+","")
+			Targ[i] = Targ[i]:match"%S+$"
+		end
+
+		--assert(not Targ:match",") --still not several
+		local code = {}
+		local precode = {}
+		for i,v in ipairs(defi) do
+			local typ = v.type  --:gsub(Targ,te)
+			local nam = v.name  --:gsub(Targ,te)
+			for j,w in ipairs(Targ) do
+				local subs = tes[j] or defa[j]
+				typ = typ:gsub(w,subs)
+				nam = nam:gsub(w,subs)
+			end
+			--if typ still has template
+			local ttypet,templatet,tet,code2t =  check_template(typ)
+			if templatet then
+				typ = code2t
+				table.insert(precode, self:gentemplatetypedef(ttypet,templatet,tet))
+			end
+			--if name still has template
+			local ttypet,templatet,tet,code2t =  check_template(nam)
+			if templatet then
+				nam = code2t
+				table.insert(precode, self:gentemplatetypedef(ttypet,templatet,tet))
+			end
+			table.insert(code, typ.." "..nam..";")
+		end
+		return table.concat(precode).."\ntypedef struct "..ttype.."_"..newte.." {"..table.concat(code).."} "..ttype.."_"..newte..";\n"
+	end
 	return par
 end
 
@@ -1825,7 +2163,7 @@ M.serializeTableF = function(t)
 	return M.serializeTable("defs",t).."\nreturn defs"
 end
 --iterates lines from a gcc/clang -E in a specific location
-local function location(file,locpathT,defines,COMPILER)
+local function location(file,locpathT,defines,COMPILER,keepemptylines)
 	local define_re = "^#define%s+([^%s]+)%s+(.+)$"
 	local number_re = "^-?[0-9]+u*$"
 	local hex_re = "0x[0-9a-fA-F]+u*$"
@@ -1890,7 +2228,7 @@ local function location(file,locpathT,defines,COMPILER)
                 local loc_num_real = loc_num + loc_num_incr
                 loc_num_incr = loc_num_incr + 1
 				--if doprint then print(which_locationold,which_location) end
-				if line:match("%S") then --nothing on emptyline
+				if keepemptylines or line:match("%S") then --nothing on emptyline
                 if (which_locationold~=which_location) or (loc_num_realold and loc_num_realold < loc_num_real) then
                     --old line complete
 					--doprint = false
@@ -1977,8 +2315,12 @@ local function func_implementation(FP)
         local cimf = FP.defsT[t.cimguiname]
         local def = cimf[t.signature]
         assert(def)
+		local custom
+		if FP.custom_implementation then
+			custom = FP.custom_implementation(outtab, def)
+		end
         local manual = FP.get_manuals(def)
-        if not manual and not def.templated and not FP.get_skipped(def) then 
+        if not custom and not manual and not def.templated and not FP.get_skipped(def) then 
             if def.constructor then
                 assert(def.stname ~= "","constructor without struct")
                 local empty = def.args:match("^%(%)") --no args
@@ -2044,8 +2386,12 @@ local function func_header_generate_funcs(FP)
         local cimf = FP.defsT[t.cimguiname]
         local def = cimf[t.signature]
         assert(def,t.signature..t.cimguiname)
+		local custom
+		if FP.custom_header then
+			custom = FP.custom_header(outtab, def)
+		end
         local manual = FP.get_manuals(def)
-        if not manual and not def.templated and not FP.get_skipped(def) then
+        if not custom and not manual and not def.templated and not FP.get_skipped(def) then
 
             local addcoment = "" --def.comment or ""
             local empty = def.args:match("^%(%)") --no args
@@ -2088,31 +2434,46 @@ end
 M.func_header_generate = func_header_generate
 --[=[
 -- tests
-local code = [[struct ImDrawListSharedData
+
+local code = [[
+
+int pedro;
+//linea1
+
+
+
+//linea2
+enum coco
 {
-    ImVec2 TexUvWhitePixel;
+uno,
-    ImFont* Font;
+dos
-    float FontSize;
+};
-    float CurveTessellationTol;
+
-    float CircleSegmentMaxError;
+]]																		  
-    ImVec4 ClipRectFullscreen;
-    ImDrawListFlags InitialFlags;
-    ImVec2 ArcFastVtx[12 * 1];
-    ImU8 CircleSegmentCounts[64];
-    ImDrawListSharedData();
-    void SetCircleSegmentMaxError(float max_error);
-};]]
-local code = [[static inline void      ImQsort(void* base, size_t count, size_t size_of_element, int(__cdecl *compare_func)(void const*, void const*)) { if (count > 1) qsort(base, count, size_of_element, compare_func); }
-]]
 local parser = M.Parser()
-for line in code:gmatch("[^\n]+") do
+--for line in code:gmatch("[^\n]+") do
-	print("inserting",line)
+for line in code:gmatch'(.-)\r?\n' do
+	--print("inserting",line)
 	parser:insert(line,"11")
 end
 parser:do_parse()
 M.prtable(parser)
---M.prtable(parser:gen_structs_and_enums_table())
+M.prtable(parser:gen_structs_and_enums_table())
 --]=]
 --print(clean_spaces[[ImVec2 ArcFastVtx[12 * 1];]])
+--[=[
+local code = [[ImU32 Storage[(BITCOUNT + 31) >> 5];]]
+--local code = [[ImU32 Storage[37 + 2];]]
+local parser = M.Parser()
+parser:insert(code,"11")
+--parser:do_parse()
+--M.prtable(parser)
+local tab={}
+print(type(code),code)
+print(clean_spaces(code))
+parser:parse_struct_line(code,tab)
+M.prtable(tab)
+--]=]
+
 
 return M

generator/generator.bat

@@ -15,8 +15,8 @@ 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
+:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation
-:: examples: "" "internal" "internal freetype"
+:: examples: "" "internal" "internal freetype comments"
 :: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
 luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl
 

generator/generator.lua

@@ -8,6 +8,7 @@ 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 COMMENTS_GENERATION = script_args[2]:match("comments") and true or false
 local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
 local CFLAGS = ""
 local CPRE,CTEST
@@ -26,6 +27,10 @@ for i=3,#script_args do
     end
 end
 
+if FREETYPE_GENERATION then
+	CFLAGS = CFLAGS .. " -DIMGUI_ENABLE_FREETYPE "
+end
+
 if COMPILER == "gcc" or COMPILER == "clang" then
     CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]] .. CFLAGS
     CTEST = COMPILER.." --version"
@@ -59,6 +64,8 @@ assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
 print("HAVE_COMPILER",HAVE_COMPILER)
 print("INTERNAL_GENERATION",INTERNAL_GENERATION)
 print("FREETYPE_GENERATION",FREETYPE_GENERATION)
+print("COMMENTS_GENERATION",COMMENTS_GENERATION)
+print("CPRE",CPRE)
 --------------------------------------------------------------------------
 --this table has the functions to be skipped in generation
 --------------------------------------------------------------------------
@@ -116,7 +123,8 @@ local function func_header_impl_generate(FP)
 			else
                 
                 if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
+                    local empty = def.args:match("^%(%)") --no args
+                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..(empty and "(void)" or def.args)..";"..addcoment.."\n")
                 else
 					cpp2ffi.prtable(def)
                     error("class function in implementations")
@@ -137,16 +145,18 @@ local func_implementation = cpp2ffi.func_implementation
 -------------------functions for getting and setting defines
 local function get_defines(t)
     local compiler_cmd = COMPILER == "cl"
-                         and COMPILER..[[ /TP /nologo /c /Fo"NUL" /I "]]..IMGUI_PATH..[[" print_defines.cpp]]..CFLAGS
+                         and COMPILER..[[ /TP /nologo /c /Fo"NUL" /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS ]]..CFLAGS..[[ /I"]]..IMGUI_PATH..[[" print_defines.cpp]]
                          or COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]..IMGUI_PATH..[[/imgui.h]]..CFLAGS
     print(compiler_cmd)
     local pipe,err = io.popen(compiler_cmd,"r")
     local defines = {}
+    local compiler_output = {"There were fails in compilation."}
     while true do
         local line = pipe:read"*l"
         if not line then break end
         local key,value = line:match([[^#define%s+(%S+)%s*(.*)]])
         if not key then --or not value then 
+			table.insert(compiler_output, line)
             --print(line)
         else
             defines[key]=value or ""
@@ -155,7 +165,7 @@ local function get_defines(t)
     pipe:close()
     --require"anima.utils"
     --prtable(defines)
-    --FLT_MAX
+	assert(next(defines), table.concat(compiler_output, "\n"))
     local ret = {}
     for i,v in ipairs(t) do
         local aa = defines[v]
@@ -197,82 +207,7 @@ local function DefsByStruct(FP)
     FP.defsBystruct = structs
 end  
 
--- function for repairing funcdefs default values
-local function repair_defaults(defsT,str_and_enu)
-	local function deleteOuterPars(def)
-		local w = def:match("^%b()$")
-		if w then
-			w = w:gsub("^%((.+)%)$","%1")
-			return w
-		else 
-			return def 
-		end
-	end
-	local function CleanImU32(def)
-		def = def:gsub("%(ImU32%)","")
-		--quitar () de numeros
-		def = def:gsub("%((%d+)%)","%1")
-		def = deleteOuterPars(def)
-		local bb=cpp2ffi.strsplit(def,"|")
-		for i=1,#bb do
-			local val = deleteOuterPars(bb[i])
-			if val:match"<<" then
-				local v1,v2 = val:match("(%d+)%s*<<%s*(%d+)")
-				val = v1*2^v2
-				bb[i] = val
-			end
-			assert(type(bb[i])=="number")
-		end
-		local res = 0 
-		for i=1,#bb do res = res + bb[i] end 
-		return res
-	end
-	for k,defT in pairs(defsT) do
-		for i,def in ipairs(defT) do
-			for k,v in pairs(def.defaults) do
-				--do only if not a c string
-				local is_cstring = v:sub(1,1)=='"' and v:sub(-1,-1) =='"'
-				if not is_cstring then
-					def.defaults[k] = def.defaults[k]:gsub("%(%(void%s*%*%)0%)","NULL")
-					if def.defaults[k]:match"%(ImU32%)" then
-						def.defaults[k] = tostring(CleanImU32(def.defaults[k]))
-					end
-				end
-			end
-		end
-	end
-end
 
-----------custom ImVector templates
-local table_do_sorted = cpp2ffi.table_do_sorted
-local function generate_templates(code,codeimpool,templates)
-    table.insert(code,"\n"..[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
-	table_do_sorted(templates , function (ttype, v)
-		if ttype == "ImVector" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-			end)
-		elseif ttype == "ImPool" then
-			--declare ImGuiStorage
-			table_do_sorted(v, function(te, newte)
-				table.insert(codeimpool,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(codeimpool,"typedef struct ImPool_"..newte.." {ImVector_"..te.." Buf;ImGuiStorage Map;ImPoolIdx FreeIdx;} ImPool_"..newte..";\n")
-			end)
-		elseif ttype == "ImChunkStream" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(code,"typedef struct ImChunkStream_"..newte.." {ImVector_"..te.." Buf;} ImChunkStream_"..newte..";\n")
-			end)
-		elseif ttype == "ImSpan" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImSpan_"..newte.." {"..te.."* Data;" ..te.."* DataEnd;} ImSpan_"..newte..";\n")
-			end)
-		else
-			print("generate_templates ttype not done",ttype)
-			error"generate templates"
-		end
-	end)
-end
 --generate cimgui.cpp cimgui.h 
 local function cimgui_generation(parser)
 
@@ -303,15 +238,9 @@ local function cimgui_generation(parser)
 	cpp2ffi.prtable(parser.templates)
 	cpp2ffi.prtable(parser.typenames)
 	
-	local outtab = {}
-	local outtabpool = {}
-    generate_templates(outtab, outtabpool, parser.templates)
-	
-	--move outtabpool after ImGuiStorage definition
-	local outpost1, outpost2 = outpost:match("^(.+struct ImGuiStorage%s*\n%b{};\n)(.+)$")
-	outpost = outpost1..table.concat(outtabpool)..outpost2
 
-	local cstructsstr = outpre..table.concat(outtab,"")..outpost --..(extra or "")
+	local  tdt = parser:generate_templates()
+	local cstructsstr = outpre..tdt..outpost 
     
 	if gdefines.IMGUI_HAS_DOCK then
 		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_DOCK       1\n"
@@ -331,7 +260,8 @@ local function cimgui_generation(parser)
     local hstrfile = read_data"./cimgui_template.cpp"
 
     hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
-    save_data("./output/cimgui.cpp",cimgui_header,hstrfile)
+	local ftdef = FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
+    save_data("./output/cimgui.cpp",cimgui_header, ftdef, hstrfile)
 
 end
 --------------------------------------------------------
@@ -339,12 +269,12 @@ end
 --------------------------------------------------------
 --get imgui.h version and IMGUI_HAS_DOCK--------------------------
 --defines for the cl compiler must be present in the print_defines.cpp file
-gdefines = get_defines{"IMGUI_VERSION","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR"}
+gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR"}
 
 if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
 if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end
 
-cimgui_header = cimgui_header:gsub("XXX",gdefines.IMGUI_VERSION)
+cimgui_header = cimgui_header:gsub("XXX",gdefines.IMGUI_VERSION .. " "..(gdefines.IMGUI_VERSION_NUM or ""))
 if INTERNAL_GENERATION then
 	cimgui_header = cimgui_header..[[//with imgui_internal.h api
 ]]
@@ -375,7 +305,8 @@ local function parseImGuiHeader(header,names)
 	parser.cname_overloads = cimgui_overloads
 	parser.manuals = cimgui_manuals
 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
-	
+	--parser.gen_template_typedef = gen_template_typedef --use auto
+	parser.COMMENTS_GENERATION = COMMENTS_GENERATION
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
 	
 	return parser
@@ -411,13 +342,16 @@ cimgui_generation(parser1)
 ----------save struct and enums lua table in structs_and_enums.lua for using in bindings
 
 local structs_and_enums_table = parser1.structs_and_enums_table
+structs_and_enums_table.templated_structs = parser1.templated_structs
+structs_and_enums_table.typenames = parser1.typenames
+structs_and_enums_table.templates_done = parser1.templates_done
+
 save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
 save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
 
 ----------save fundefs in definitions.lua for using in bindings
 --DefsByStruct(pFP)
 set_defines(parser1.defsT) 
-repair_defaults(parser1.defsT, structs_and_enums_table)
 save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
 
 --check every function has ov_cimguiname
@@ -444,7 +378,7 @@ if #implementations > 0 then
     parser2 = cpp2ffi.Parser()
 	
 	local config = require"config_generator"
-    
+    local impl_str = ""
     for i,impl in ipairs(implementations) do
         local source = backends_folder .. [[imgui_impl_]].. impl .. ".h "
         local locati = [[imgui_impl_]].. impl
@@ -461,15 +395,22 @@ if #implementations > 0 then
 		end
 		
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
-
+		
+		local parser3 = cpp2ffi.Parser()
+		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
+		parser3:do_parse()
+		local cfuncsstr = func_header_impl_generate(parser3) 
+		local cstructstr1,cstructstr2 = parser3.structs_and_enums[1], parser3.structs_and_enums[2]
+		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n" .. cstructstr1 .. cstructstr2 .. cfuncsstr .. "\n#endif\n"
     end
 	
     parser2:do_parse()
 
     -- save ./cimgui_impl.h
-    local cfuncsstr = func_header_impl_generate(parser2) 
+    --local cfuncsstr = func_header_impl_generate(parser2) 
-	local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
+	--local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
-    save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
+    --save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
+	save_data("./output/cimgui_impl.h",impl_str)
 
     ----------save fundefs in impl_definitions.lua for using in bindings
     save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
@@ -492,6 +433,10 @@ end
 ---[[
 local json = require"json"
 save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),{dict_on_empty={defaults=true}}))
+--delete extra info for json
+structs_and_enums_table.templated_structs = nil
+structs_and_enums_table.typenames = nil
+structs_and_enums_table.templates_done = nil
 save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
 save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
 if parser2 then

generator/generator.sh

@@ -13,7 +13,7 @@
 
 #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
+# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation
-# examples: "" "internal" "internal freetype"
+# examples: "" "internal" "internal freetype" "comments internal"
 # arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
 luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl

generator/output/cimgui_impl.h

@@ -1,44 +1,60 @@
-typedef struct SDL_Window SDL_Window;
+#ifdef CIMGUI_USE_GLFW
-typedef struct GLFWmonitor GLFWmonitor;
+
 typedef struct GLFWwindow GLFWwindow;
-
+typedef struct GLFWmonitor GLFWmonitor;
 struct GLFWwindow;
-struct GLFWmonitor;
+struct GLFWmonitor;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
-
-struct SDL_Window;
-typedef union SDL_Event SDL_Event;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown();
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
-CIMGUI_API void ImGui_ImplGlfw_NewFrame();
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
 CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
 CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
 CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
 CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
 CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
 CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL3
 CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
-CIMGUI_API void ImGui_ImplOpenGL3_Shutdown();
+CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL3_NewFrame();
+CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture();
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture();
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects();
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects();
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
-CIMGUI_API bool ImGui_ImplOpenGL2_Init();
+
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown();
+#endif
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame();
+#ifdef CIMGUI_USE_OPENGL2
+CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture();
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture();
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+
+#endif
+#ifdef CIMGUI_USE_SDL
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+struct SDL_Window;
+struct SDL_Renderer;
+typedef union SDL_Event SDL_Event;CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown();
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
-CIMGUI_API void ImGui_ImplSDL2_NewFrame();
+CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+
+#endif

generator/output/impl_definitions.json

@@ -17,7 +17,7 @@
       "cimguiname": "ImGui_ImplGlfw_CharCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CharCallback",
-      "location": "imgui_impl_glfw:44",
+      "location": "imgui_impl_glfw:46",
       "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,unsigned int)",
@@ -42,13 +42,42 @@
       "cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CursorEnterCallback",
-      "location": "imgui_impl_glfw:40",
+      "location": "imgui_impl_glfw:41",
       "ov_cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
       "stname": ""
     }
   ],
+  "ImGui_ImplGlfw_CursorPosCallback": [
+    {
+      "args": "(GLFWwindow* window,double x,double y)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,double x,double y)",
+      "call_args": "(window,x,y)",
+      "cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_CursorPosCallback",
+      "location": "imgui_impl_glfw:42",
+      "ov_cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,double,double)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplGlfw_InitForOpenGL": [
     {
       "args": "(GLFWwindow* window,bool install_callbacks)",
@@ -67,7 +96,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOpenGL",
-      "location": "imgui_impl_glfw:30",
+      "location": "imgui_impl_glfw:27",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -92,7 +121,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOther",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOther",
-      "location": "imgui_impl_glfw:32",
+      "location": "imgui_impl_glfw:29",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOther",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -117,13 +146,34 @@
       "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForVulkan",
-      "location": "imgui_impl_glfw:31",
+      "location": "imgui_impl_glfw:28",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
       "stname": ""
     }
   ],
+  "ImGui_ImplGlfw_InstallCallbacks": [
+    {
+      "args": "(GLFWwindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InstallCallbacks",
+      "location": "imgui_impl_glfw:36",
+      "ov_cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
+      "ret": "void",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplGlfw_KeyCallback": [
     {
       "args": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
@@ -154,7 +204,7 @@
       "cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_KeyCallback",
-      "location": "imgui_impl_glfw:43",
+      "location": "imgui_impl_glfw:45",
       "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int,int)",
@@ -179,7 +229,7 @@
       "cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MonitorCallback",
-      "location": "imgui_impl_glfw:45",
+      "location": "imgui_impl_glfw:47",
       "ov_cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "ret": "void",
       "signature": "(GLFWmonitor*,int)",
@@ -212,7 +262,7 @@
       "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "location": "imgui_impl_glfw:41",
+      "location": "imgui_impl_glfw:43",
       "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int)",
@@ -228,13 +278,34 @@
       "cimguiname": "ImGui_ImplGlfw_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_NewFrame",
-      "location": "imgui_impl_glfw:34",
+      "location": "imgui_impl_glfw:31",
       "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
+  "ImGui_ImplGlfw_RestoreCallbacks": [
+    {
+      "args": "(GLFWwindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "location": "imgui_impl_glfw:37",
+      "ov_cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "ret": "void",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplGlfw_ScrollCallback": [
     {
       "args": "(GLFWwindow* window,double xoffset,double yoffset)",
@@ -257,7 +328,7 @@
       "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_ScrollCallback",
-      "location": "imgui_impl_glfw:42",
+      "location": "imgui_impl_glfw:44",
       "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
@@ -273,7 +344,7 @@
       "cimguiname": "ImGui_ImplGlfw_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_Shutdown",
-      "location": "imgui_impl_glfw:33",
+      "location": "imgui_impl_glfw:30",
       "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -298,7 +369,7 @@
       "cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_WindowFocusCallback",
-      "location": "imgui_impl_glfw:39",
+      "location": "imgui_impl_glfw:40",
       "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
@@ -511,11 +582,11 @@
           "type": "const char*"
         }
       ],
-      "argsoriginal": "(const char* glsl_version=((void*)0))",
+      "argsoriginal": "(const char* glsl_version=nullptr)",
       "call_args": "(glsl_version)",
       "cimguiname": "ImGui_ImplOpenGL3_Init",
       "defaults": {
-        "glsl_version": "((void*)0)"
+        "glsl_version": "nullptr"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
       "location": "imgui_impl_opengl3:25",
@@ -592,7 +663,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForD3D",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForD3D",
-      "location": "imgui_impl_sdl:28",
+      "location": "imgui_impl_sdl:29",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -613,7 +684,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForMetal",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForMetal",
-      "location": "imgui_impl_sdl:29",
+      "location": "imgui_impl_sdl:30",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -638,7 +709,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForOpenGL",
-      "location": "imgui_impl_sdl:26",
+      "location": "imgui_impl_sdl:27",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "ret": "bool",
       "signature": "(SDL_Window*,void*)",
@@ -647,22 +718,26 @@
   ],
   "ImGui_ImplSDL2_InitForSDLRenderer": [
     {
-      "args": "(SDL_Window* window)",
+      "args": "(SDL_Window* window,SDL_Renderer* renderer)",
       "argsT": [
         {
           "name": "window",
           "type": "SDL_Window*"
+        },
+        {
+          "name": "renderer",
+          "type": "SDL_Renderer*"
         }
       ],
-      "argsoriginal": "(SDL_Window* window)",
+      "argsoriginal": "(SDL_Window* window,SDL_Renderer* renderer)",
-      "call_args": "(window)",
+      "call_args": "(window,renderer)",
       "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
-      "location": "imgui_impl_sdl:30",
+      "location": "imgui_impl_sdl:31",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
       "ret": "bool",
-      "signature": "(SDL_Window*)",
+      "signature": "(SDL_Window*,SDL_Renderer*)",
       "stname": ""
     }
   ],
@@ -680,7 +755,7 @@
       "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForVulkan",
-      "location": "imgui_impl_sdl:27",
+      "location": "imgui_impl_sdl:28",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -696,7 +771,7 @@
       "cimguiname": "ImGui_ImplSDL2_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_NewFrame",
-      "location": "imgui_impl_sdl:32",
+      "location": "imgui_impl_sdl:33",
       "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -717,7 +792,7 @@
       "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_ProcessEvent",
-      "location": "imgui_impl_sdl:33",
+      "location": "imgui_impl_sdl:34",
       "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
@@ -733,7 +808,7 @@
       "cimguiname": "ImGui_ImplSDL2_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplSDL2_Shutdown",
-      "location": "imgui_impl_sdl:31",
+      "location": "imgui_impl_sdl:32",
       "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
       "ret": "void",
       "signature": "()",

generator/output/impl_definitions.lua

@@ -14,7 +14,7 @@ defs["ImGui_ImplGlfw_CharCallback"][1]["call_args"] = "(window,c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CharCallback"
 defs["ImGui_ImplGlfw_CharCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw:44"
+defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw:46"
 defs["ImGui_ImplGlfw_CharCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CharCallback"
 defs["ImGui_ImplGlfw_CharCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_CharCallback"][1]["signature"] = "(GLFWwindow*,unsigned int)"
@@ -35,12 +35,36 @@ defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["call_args"] = "(window,entered)"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CursorEnterCallback"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["funcname"] = "ImGui_ImplGlfw_CursorEnterCallback"
-defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["location"] = "imgui_impl_glfw:40"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["location"] = "imgui_impl_glfw:41"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CursorEnterCallback"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["signature"] = "(GLFWwindow*,int)"
 defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["stname"] = ""
 defs["ImGui_ImplGlfw_CursorEnterCallback"]["(GLFWwindow*,int)"] = defs["ImGui_ImplGlfw_CursorEnterCallback"][1]
+defs["ImGui_ImplGlfw_CursorPosCallback"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["args"] = "(GLFWwindow* window,double x,double y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2]["name"] = "x"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2]["type"] = "double"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3]["name"] = "y"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3]["type"] = "double"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsoriginal"] = "(GLFWwindow* window,double x,double y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["call_args"] = "(window,x,y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["funcname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["location"] = "imgui_impl_glfw:42"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_CursorPosCallback"]["(GLFWwindow*,double,double)"] = defs["ImGui_ImplGlfw_CursorPosCallback"][1]
 defs["ImGui_ImplGlfw_InitForOpenGL"] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
@@ -56,7 +80,7 @@ defs["ImGui_ImplGlfw_InitForOpenGL"][1]["call_args"] = "(window,install_callback
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw:30"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw:27"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ret"] = "bool"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["signature"] = "(GLFWwindow*,bool)"
@@ -77,7 +101,7 @@ defs["ImGui_ImplGlfw_InitForOther"][1]["call_args"] = "(window,install_callbacks
 defs["ImGui_ImplGlfw_InitForOther"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOther"
 defs["ImGui_ImplGlfw_InitForOther"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForOther"][1]["funcname"] = "ImGui_ImplGlfw_InitForOther"
-defs["ImGui_ImplGlfw_InitForOther"][1]["location"] = "imgui_impl_glfw:32"
+defs["ImGui_ImplGlfw_InitForOther"][1]["location"] = "imgui_impl_glfw:29"
 defs["ImGui_ImplGlfw_InitForOther"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForOther"
 defs["ImGui_ImplGlfw_InitForOther"][1]["ret"] = "bool"
 defs["ImGui_ImplGlfw_InitForOther"][1]["signature"] = "(GLFWwindow*,bool)"
@@ -98,12 +122,30 @@ defs["ImGui_ImplGlfw_InitForVulkan"][1]["call_args"] = "(window,install_callback
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw:31"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw:28"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["ret"] = "bool"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["signature"] = "(GLFWwindow*,bool)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["stname"] = ""
 defs["ImGui_ImplGlfw_InitForVulkan"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForVulkan"][1]
+defs["ImGui_ImplGlfw_InstallCallbacks"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["args"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsoriginal"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["call_args"] = "(window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["cimguiname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["funcname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["location"] = "imgui_impl_glfw:36"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["signature"] = "(GLFWwindow*)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_InstallCallbacks"]["(GLFWwindow*)"] = defs["ImGui_ImplGlfw_InstallCallbacks"][1]
 defs["ImGui_ImplGlfw_KeyCallback"] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1]["args"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
@@ -128,7 +170,7 @@ defs["ImGui_ImplGlfw_KeyCallback"][1]["call_args"] = "(window,key,scancode,actio
 defs["ImGui_ImplGlfw_KeyCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw:43"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw:45"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["signature"] = "(GLFWwindow*,int,int,int,int)"
@@ -149,7 +191,7 @@ defs["ImGui_ImplGlfw_MonitorCallback"][1]["call_args"] = "(monitor,event)"
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MonitorCallback"
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["funcname"] = "ImGui_ImplGlfw_MonitorCallback"
-defs["ImGui_ImplGlfw_MonitorCallback"][1]["location"] = "imgui_impl_glfw:45"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["location"] = "imgui_impl_glfw:47"
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_MonitorCallback"
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_MonitorCallback"][1]["signature"] = "(GLFWmonitor*,int)"
@@ -176,7 +218,7 @@ defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["call_args"] = "(window,button,act
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw:41"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw:43"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["signature"] = "(GLFWwindow*,int,int,int)"
@@ -191,12 +233,30 @@ defs["ImGui_ImplGlfw_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["cimguiname"] = "ImGui_ImplGlfw_NewFrame"
 defs["ImGui_ImplGlfw_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw:34"
+defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw:31"
 defs["ImGui_ImplGlfw_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_NewFrame"
 defs["ImGui_ImplGlfw_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["stname"] = ""
 defs["ImGui_ImplGlfw_NewFrame"]["()"] = defs["ImGui_ImplGlfw_NewFrame"][1]
+defs["ImGui_ImplGlfw_RestoreCallbacks"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["args"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsoriginal"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["call_args"] = "(window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["cimguiname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["funcname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["location"] = "imgui_impl_glfw:37"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["signature"] = "(GLFWwindow*)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_RestoreCallbacks"]["(GLFWwindow*)"] = defs["ImGui_ImplGlfw_RestoreCallbacks"][1]
 defs["ImGui_ImplGlfw_ScrollCallback"] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["args"] = "(GLFWwindow* window,double xoffset,double yoffset)"
@@ -215,7 +275,7 @@ defs["ImGui_ImplGlfw_ScrollCallback"][1]["call_args"] = "(window,xoffset,yoffset
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw:42"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw:44"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
@@ -230,7 +290,7 @@ defs["ImGui_ImplGlfw_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw:33"
+defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw:30"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
@@ -251,7 +311,7 @@ defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["call_args"] = "(window,focused)"
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_WindowFocusCallback"
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["funcname"] = "ImGui_ImplGlfw_WindowFocusCallback"
-defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["location"] = "imgui_impl_glfw:39"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["location"] = "imgui_impl_glfw:40"
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_WindowFocusCallback"
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["signature"] = "(GLFWwindow*,int)"
@@ -447,11 +507,11 @@ defs["ImGui_ImplOpenGL3_Init"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["name"] = "glsl_version"
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["type"] = "const char*"
-defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=((void*)0))"
+defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=nullptr)"
 defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
 defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "((void*)0)"
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "nullptr"
 defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3:25"
 defs["ImGui_ImplOpenGL3_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Init"
@@ -519,7 +579,7 @@ defs["ImGui_ImplSDL2_InitForD3D"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForD3D"][1]["funcname"] = "ImGui_ImplSDL2_InitForD3D"
-defs["ImGui_ImplSDL2_InitForD3D"][1]["location"] = "imgui_impl_sdl:28"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["location"] = "imgui_impl_sdl:29"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["signature"] = "(SDL_Window*)"
@@ -537,7 +597,7 @@ defs["ImGui_ImplSDL2_InitForMetal"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForMetal"][1]["funcname"] = "ImGui_ImplSDL2_InitForMetal"
-defs["ImGui_ImplSDL2_InitForMetal"][1]["location"] = "imgui_impl_sdl:29"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["location"] = "imgui_impl_sdl:30"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["signature"] = "(SDL_Window*)"
@@ -558,7 +618,7 @@ defs["ImGui_ImplSDL2_InitForOpenGL"][1]["call_args"] = "(window,sdl_gl_context)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl:26"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl:27"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["signature"] = "(SDL_Window*,void*)"
@@ -566,22 +626,25 @@ defs["ImGui_ImplSDL2_InitForOpenGL"][1]["stname"] = ""
 defs["ImGui_ImplSDL2_InitForOpenGL"]["(SDL_Window*,void*)"] = defs["ImGui_ImplSDL2_InitForOpenGL"][1]
 defs["ImGui_ImplSDL2_InitForSDLRenderer"] = {}
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1] = {}
-defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["args"] = "(SDL_Window* window,SDL_Renderer* renderer)"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"] = {}
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1] = {}
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["name"] = "window"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["type"] = "SDL_Window*"
-defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2] = {}
-defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2]["name"] = "renderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2]["type"] = "SDL_Renderer*"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsoriginal"] = "(SDL_Window* window,SDL_Renderer* renderer)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["call_args"] = "(window,renderer)"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["funcname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
-defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["location"] = "imgui_impl_sdl:30"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["location"] = "imgui_impl_sdl:31"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ret"] = "bool"
-defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["signature"] = "(SDL_Window*,SDL_Renderer*)"
 defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_InitForSDLRenderer"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]
+defs["ImGui_ImplSDL2_InitForSDLRenderer"]["(SDL_Window*,SDL_Renderer*)"] = defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]
 defs["ImGui_ImplSDL2_InitForVulkan"] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["args"] = "(SDL_Window* window)"
@@ -594,7 +657,7 @@ defs["ImGui_ImplSDL2_InitForVulkan"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl:27"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl:28"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["signature"] = "(SDL_Window*)"
@@ -609,7 +672,7 @@ defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl:32"
+defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl:33"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "()"
@@ -627,7 +690,7 @@ defs["ImGui_ImplSDL2_ProcessEvent"][1]["call_args"] = "(event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl:33"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl:34"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(const SDL_Event*)"
@@ -642,7 +705,7 @@ defs["ImGui_ImplSDL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl:31"
+defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl:32"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"

generator/output/overloads.txt

@@ -1,10 +1,10 @@
 ----------------overloadings---------------------------
 ImColor_ImColor	5
 1	nil	ImColor_ImColor_Nil ()
-2	nil	ImColor_ImColor_Int (int,int,int,int)
+2	nil	ImColor_ImColor_Float (float,float,float,float)
-3	nil	ImColor_ImColor_U32 (ImU32)
+3	nil	ImColor_ImColor_Vec4 (const ImVec4)
-4	nil	ImColor_ImColor_Float (float,float,float,float)
+4	nil	ImColor_ImColor_Int (int,int,int,int)
-5	nil	ImColor_ImColor_Vec4 (const ImVec4)
+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*)
@@ -26,10 +26,6 @@ ImGuiWindow_GetID	3
 1	ImGuiID	ImGuiWindow_GetID_Str (const char*,const char*)
 2	ImGuiID	ImGuiWindow_GetID_Ptr (const void*)
 3	ImGuiID	ImGuiWindow_GetID_Int (int)
-ImGuiWindow_GetIDNoKeepAlive	3
-1	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Str (const char*,const char*)
-2	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Ptr (const void*)
-3	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Int (int)
 ImPool_Remove	2
 1	void	ImPool_Remove_TPtr (ImGuiID,const T*)
 2	void	ImPool_Remove_PoolIdx (ImGuiID,ImPoolIdx)
@@ -75,7 +71,7 @@ ImVec4_ImVec4	2
 2	nil	ImVec4_ImVec4_Float (float,float,float,float)
 ImVector_ImVector	2
 1	nil	ImVector_ImVector_Nil ()
-2	nil	ImVector_ImVector_Vector (const ImVector)
+2	nil	ImVector_ImVector_Vector_T_ (const ImVector_T )
 ImVector_back	2
 1	T*	ImVector_back_Nil ()
 2	const T*	ImVector_back__const ()const
@@ -134,6 +130,9 @@ igImAbs	3
 igImFloor	2
 1	float	igImFloor_Float (float)
 2	ImVec2	igImFloor_Vec2 (const ImVec2)
+igImFloorSigned	2
+1	float	igImFloorSigned_Float (float)
+2	ImVec2	igImFloorSigned_Vec2 (const ImVec2)
 igImIsPowerOfTwo	2
 1	bool	igImIsPowerOfTwo_Int (int)
 2	bool	igImIsPowerOfTwo_U64 (ImU64)
@@ -156,6 +155,24 @@ igImRsqrt	2
 igImSign	2
 1	float	igImSign_Float (float)
 2	double	igImSign_double (double)
+igIsKeyDown	2
+1	bool	igIsKeyDown_Nil (ImGuiKey)
+2	bool	igIsKeyDown_ID (ImGuiKey,ImGuiID)
+igIsKeyPressed	2
+1	bool	igIsKeyPressed_Bool (ImGuiKey,bool)
+2	bool	igIsKeyPressed_ID (ImGuiKey,ImGuiID,ImGuiInputFlags)
+igIsKeyReleased	2
+1	bool	igIsKeyReleased_Nil (ImGuiKey)
+2	bool	igIsKeyReleased_ID (ImGuiKey,ImGuiID)
+igIsMouseClicked	2
+1	bool	igIsMouseClicked_Bool (ImGuiMouseButton,bool)
+2	bool	igIsMouseClicked_ID (ImGuiMouseButton,ImGuiID,ImGuiInputFlags)
+igIsMouseDown	2
+1	bool	igIsMouseDown_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDown_ID (ImGuiMouseButton,ImGuiID)
+igIsMouseReleased	2
+1	bool	igIsMouseReleased_Nil (ImGuiMouseButton)
+2	bool	igIsMouseReleased_ID (ImGuiMouseButton,ImGuiID)
 igIsPopupOpen	2
 1	bool	igIsPopupOpen_Str (const char*,ImGuiPopupFlags)
 2	bool	igIsPopupOpen_ID (ImGuiID,ImGuiPopupFlags)
@@ -227,6 +244,9 @@ igSetWindowSize	3
 1	void	igSetWindowSize_Vec2 (const ImVec2,ImGuiCond)
 2	void	igSetWindowSize_Str (const char*,const ImVec2,ImGuiCond)
 3	void	igSetWindowSize_WindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igTabItemCalcSize	2
+1	ImVec2	igTabItemCalcSize_Str (const char*,bool)
+2	ImVec2	igTabItemCalcSize_WindowPtr (ImGuiWindow*)
 igTableGcCompactTransientBuffers	2
 1	void	igTableGcCompactTransientBuffers_TablePtr (ImGuiTable*)
 2	void	igTableGcCompactTransientBuffers_TableTempDataPtr (ImGuiTableTempData*)
@@ -255,4 +275,4 @@ igValue	4
 2	void	igValue_Int (const char*,int)
 3	void	igValue_Uint (const char*,unsigned int)
 4	void	igValue_Float (const char*,float,const char*)
-180 overloaded
+193 overloaded

generator/output/typedefs_dict.json

@@ -1,4 +1,5 @@
 {
+  "ImBitArrayForNamedKeys": "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>",
   "ImBitVector": "struct ImBitVector",
   "ImColor": "struct ImColor",
   "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
@@ -40,6 +41,7 @@
   "ImGuiDataType": "int",
   "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
   "ImGuiDataTypeTempStorage": "struct ImGuiDataTypeTempStorage",
+  "ImGuiDebugLogFlags": "int",
   "ImGuiDir": "int",
   "ImGuiDockContext": "struct ImGuiDockContext",
   "ImGuiDockNode": "struct ImGuiDockNode",
@@ -53,28 +55,40 @@
   "ImGuiHoveredFlags": "int",
   "ImGuiID": "unsigned int",
   "ImGuiIO": "struct ImGuiIO",
+  "ImGuiInputEvent": "struct ImGuiInputEvent",
+  "ImGuiInputEventAppFocused": "struct ImGuiInputEventAppFocused",
+  "ImGuiInputEventKey": "struct ImGuiInputEventKey",
+  "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
+  "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
+  "ImGuiInputEventMouseViewport": "struct ImGuiInputEventMouseViewport",
+  "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
+  "ImGuiInputEventText": "struct ImGuiInputEventText",
+  "ImGuiInputFlags": "int",
   "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
   "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
   "ImGuiInputTextFlags": "int",
   "ImGuiInputTextState": "struct ImGuiInputTextState",
   "ImGuiItemFlags": "int",
   "ImGuiItemStatusFlags": "int",
-  "ImGuiKey": "int",
+  "ImGuiKeyChord": "int",
-  "ImGuiKeyModFlags": "int",
+  "ImGuiKeyData": "struct ImGuiKeyData",
+  "ImGuiKeyOwnerData": "struct ImGuiKeyOwnerData",
+  "ImGuiKeyRoutingData": "struct ImGuiKeyRoutingData",
+  "ImGuiKeyRoutingIndex": "ImS16",
+  "ImGuiKeyRoutingTable": "struct ImGuiKeyRoutingTable",
   "ImGuiLastItemData": "struct ImGuiLastItemData",
   "ImGuiLayoutType": "int",
   "ImGuiListClipper": "struct ImGuiListClipper",
   "ImGuiListClipperData": "struct ImGuiListClipperData",
   "ImGuiListClipperRange": "struct ImGuiListClipperRange",
+  "ImGuiLocEntry": "struct ImGuiLocEntry",
   "ImGuiMemAllocFunc": "void*(*)(size_t sz,void* user_data);",
   "ImGuiMemFreeFunc": "void(*)(void* ptr,void* user_data);",
   "ImGuiMenuColumns": "struct ImGuiMenuColumns",
   "ImGuiMetricsConfig": "struct ImGuiMetricsConfig",
   "ImGuiMouseButton": "int",
   "ImGuiMouseCursor": "int",
-  "ImGuiNavDirSourceFlags": "int",
   "ImGuiNavHighlightFlags": "int",
-  "ImGuiNavInput": "int",
   "ImGuiNavItemData": "struct ImGuiNavItemData",
   "ImGuiNavMoveFlags": "int",
   "ImGuiNextItemData": "struct ImGuiNextItemData",
@@ -87,6 +101,7 @@
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
   "ImGuiPayload": "struct ImGuiPayload",
   "ImGuiPlatformIO": "struct ImGuiPlatformIO",
+  "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
   "ImGuiPlatformMonitor": "struct ImGuiPlatformMonitor",
   "ImGuiPopupData": "struct ImGuiPopupData",
   "ImGuiPopupFlags": "int",
@@ -123,6 +138,7 @@
   "ImGuiTableColumnsSettings": "struct ImGuiTableColumnsSettings",
   "ImGuiTableDrawChannelIdx": "ImU8",
   "ImGuiTableFlags": "int",
+  "ImGuiTableInstanceData": "struct ImGuiTableInstanceData",
   "ImGuiTableRowFlags": "int",
   "ImGuiTableSettings": "struct ImGuiTableSettings",
   "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",
@@ -130,6 +146,7 @@
   "ImGuiTextBuffer": "struct ImGuiTextBuffer",
   "ImGuiTextFilter": "struct ImGuiTextFilter",
   "ImGuiTextFlags": "int",
+  "ImGuiTextIndex": "struct ImGuiTextIndex",
   "ImGuiTextRange": "struct ImGuiTextRange",
   "ImGuiTooltipFlags": "int",
   "ImGuiTreeNodeFlags": "int",
@@ -147,12 +164,12 @@
   "ImRect": "struct ImRect",
   "ImS16": "signed short",
   "ImS32": "signed int",
-  "ImS64": "int64_t",
+  "ImS64": "signed long long",
   "ImS8": "signed char",
   "ImTextureID": "void*",
   "ImU16": "unsigned short",
   "ImU32": "unsigned int",
-  "ImU64": "uint64_t",
+  "ImU64": "unsigned long long",
   "ImU8": "unsigned char",
   "ImVec1": "struct ImVec1",
   "ImVec2": "struct ImVec2",

generator/output/typedefs_dict.lua

@@ -1,4 +1,5 @@
 local defs = {}
+defs["ImBitArrayForNamedKeys"] = "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>"
 defs["ImBitVector"] = "struct ImBitVector"
 defs["ImColor"] = "struct ImColor"
 defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
@@ -40,6 +41,7 @@ defs["ImGuiDataAuthority"] = "int"
 defs["ImGuiDataType"] = "int"
 defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
 defs["ImGuiDataTypeTempStorage"] = "struct ImGuiDataTypeTempStorage"
+defs["ImGuiDebugLogFlags"] = "int"
 defs["ImGuiDir"] = "int"
 defs["ImGuiDockContext"] = "struct ImGuiDockContext"
 defs["ImGuiDockNode"] = "struct ImGuiDockNode"
@@ -53,28 +55,40 @@ defs["ImGuiGroupData"] = "struct ImGuiGroupData"
 defs["ImGuiHoveredFlags"] = "int"
 defs["ImGuiID"] = "unsigned int"
 defs["ImGuiIO"] = "struct ImGuiIO"
+defs["ImGuiInputEvent"] = "struct ImGuiInputEvent"
+defs["ImGuiInputEventAppFocused"] = "struct ImGuiInputEventAppFocused"
+defs["ImGuiInputEventKey"] = "struct ImGuiInputEventKey"
+defs["ImGuiInputEventMouseButton"] = "struct ImGuiInputEventMouseButton"
+defs["ImGuiInputEventMousePos"] = "struct ImGuiInputEventMousePos"
+defs["ImGuiInputEventMouseViewport"] = "struct ImGuiInputEventMouseViewport"
+defs["ImGuiInputEventMouseWheel"] = "struct ImGuiInputEventMouseWheel"
+defs["ImGuiInputEventText"] = "struct ImGuiInputEventText"
+defs["ImGuiInputFlags"] = "int"
 defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
 defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
 defs["ImGuiInputTextFlags"] = "int"
 defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
 defs["ImGuiItemFlags"] = "int"
 defs["ImGuiItemStatusFlags"] = "int"
-defs["ImGuiKey"] = "int"
+defs["ImGuiKeyChord"] = "int"
-defs["ImGuiKeyModFlags"] = "int"
+defs["ImGuiKeyData"] = "struct ImGuiKeyData"
+defs["ImGuiKeyOwnerData"] = "struct ImGuiKeyOwnerData"
+defs["ImGuiKeyRoutingData"] = "struct ImGuiKeyRoutingData"
+defs["ImGuiKeyRoutingIndex"] = "ImS16"
+defs["ImGuiKeyRoutingTable"] = "struct ImGuiKeyRoutingTable"
 defs["ImGuiLastItemData"] = "struct ImGuiLastItemData"
 defs["ImGuiLayoutType"] = "int"
 defs["ImGuiListClipper"] = "struct ImGuiListClipper"
 defs["ImGuiListClipperData"] = "struct ImGuiListClipperData"
 defs["ImGuiListClipperRange"] = "struct ImGuiListClipperRange"
+defs["ImGuiLocEntry"] = "struct ImGuiLocEntry"
 defs["ImGuiMemAllocFunc"] = "void*(*)(size_t sz,void* user_data);"
 defs["ImGuiMemFreeFunc"] = "void(*)(void* ptr,void* user_data);"
 defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
 defs["ImGuiMetricsConfig"] = "struct ImGuiMetricsConfig"
 defs["ImGuiMouseButton"] = "int"
 defs["ImGuiMouseCursor"] = "int"
-defs["ImGuiNavDirSourceFlags"] = "int"
 defs["ImGuiNavHighlightFlags"] = "int"
-defs["ImGuiNavInput"] = "int"
 defs["ImGuiNavItemData"] = "struct ImGuiNavItemData"
 defs["ImGuiNavMoveFlags"] = "int"
 defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
@@ -87,6 +101,7 @@ defs["ImGuiOldColumns"] = "struct ImGuiOldColumns"
 defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
 defs["ImGuiPayload"] = "struct ImGuiPayload"
 defs["ImGuiPlatformIO"] = "struct ImGuiPlatformIO"
+defs["ImGuiPlatformImeData"] = "struct ImGuiPlatformImeData"
 defs["ImGuiPlatformMonitor"] = "struct ImGuiPlatformMonitor"
 defs["ImGuiPopupData"] = "struct ImGuiPopupData"
 defs["ImGuiPopupFlags"] = "int"
@@ -123,6 +138,7 @@ defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
 defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
 defs["ImGuiTableDrawChannelIdx"] = "ImU8"
 defs["ImGuiTableFlags"] = "int"
+defs["ImGuiTableInstanceData"] = "struct ImGuiTableInstanceData"
 defs["ImGuiTableRowFlags"] = "int"
 defs["ImGuiTableSettings"] = "struct ImGuiTableSettings"
 defs["ImGuiTableSortSpecs"] = "struct ImGuiTableSortSpecs"
@@ -130,6 +146,7 @@ defs["ImGuiTableTempData"] = "struct ImGuiTableTempData"
 defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
 defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
 defs["ImGuiTextFlags"] = "int"
+defs["ImGuiTextIndex"] = "struct ImGuiTextIndex"
 defs["ImGuiTextRange"] = "struct ImGuiTextRange"
 defs["ImGuiTooltipFlags"] = "int"
 defs["ImGuiTreeNodeFlags"] = "int"
@@ -147,12 +164,12 @@ defs["ImPoolIdx"] = "int"
 defs["ImRect"] = "struct ImRect"
 defs["ImS16"] = "signed short"
 defs["ImS32"] = "signed int"
-defs["ImS64"] = "int64_t"
+defs["ImS64"] = "signed long long"
 defs["ImS8"] = "signed char"
 defs["ImTextureID"] = "void*"
 defs["ImU16"] = "unsigned short"
 defs["ImU32"] = "unsigned int"
-defs["ImU64"] = "uint64_t"
+defs["ImU64"] = "unsigned long long"
 defs["ImU8"] = "unsigned char"
 defs["ImVec1"] = "struct ImVec1"
 defs["ImVec2"] = "struct ImVec2"