Merge branch 'docking_inter'

update readme
pull imgui 1.90.4 and generate
2025-08-10 11:58:30 +01:00 · 2024-02-24 13:15:42 +01:00 · 2024-02-24 13:05:48 +01:00 · 2024-02-24 13:03:13 +01:00 · 2024-02-16 11:36:05 +01:00 · 2024-02-16 11:31:30 +01:00
33 changed files with 22158 additions and 14822 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -29,7 +29,9 @@ jobs:
          sudo apt-get install -y luajit
        elif [ "$GITHUB_OS" == "windows-latest" ];
        then
-          vcpkg install luajit
+          vcpkg install luajit:x64-windows
+          echo "/C/vcpkg/installed/x64-windows/tools/luajit" >> $GITHUB_PATH
+          echo "/C/vcpkg/installed/x64-windows/bin"   >> $GITHUB_PATH
        fi

    - name: Download Submodules
@@ -47,7 +49,6 @@ jobs:
    - name: Generate Bindings
      shell: bash
      run: |
-        export PATH=$PATH:/C/vcpkg/packages/luajit_x86-windows/tools/:/C/vcpkg/packages/luajit_x86-windows/bin/
        cd ./generator
        bash ./generator.sh

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,9 @@
-cmake_minimum_required(VERSION 3.1)
-
+cmake_minimum_required(VERSION 3.15)
+cmake_policy(SET CMP0091 NEW)
 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()
--- a/8
+++ b/8
@@ -59,10 +59,18 @@ $(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)

 clean:
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OBJS))
+else
 	rm -f $(OBJS)
+endif

 fclean: clean
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OUTPUTNAME))
+else
 	rm -f $(OUTPUTNAME)
+endif

 re: fclean all

--- a/README.md
+++ b/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.90.4 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,13 +37,14 @@ 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. 
-* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, opengl2 and opengl3 as backends.
+* 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, vulkan, opengl2 and opengl3 as backends.
 * edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
 * Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp`, `cimgui.h` and `cimgui_impl.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the backends info. 
-* You can pass compiler flags to generator.sh or generator.bat at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
-
+* You can pass compiler flags to generator.sh or generator.bat by editing them at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+* You are able to pass any extra argument to generator.sh (.bat) in the command-line.
+* If you are using different options than cimgui repo and if you want to keep them after a cimgui update, you can keep them in a copy of generator.sh (.bat) outside of cimgui folder where `cd cimgui/generator` is used before luajit call. See https://github.com/cimgui/cimgui/issues/232#issuecomment-1497059497
 # generate binding
 * C interface is exposed by cimgui.h when you define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 * with your prefered language you can use the lua or json files generated as in:
@@ -93,7 +95,8 @@ Notes:

 # usage with backends

-* look at backend_test folder for a cmake module building with SDL and opengl3.
+* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan
+* read [How can cimgui backends be used](https://github.com/cimgui/cimgui/issues/157)

 # example bindings based on cimgui

--- a/backend_test/cimgui_extras.cpp
+++ b/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
--- a/backend_test/cimgui_extras.h
+++ b/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
--- a/backend_test/example_glfw_opengl3/CMakeLists.txt
+++ b/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)
+
+
--- a/backend_test/example_glfw_opengl3/main.c
+++ b/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;
+}
--- a/backend_test/example_sdl_opengl3/CMakeLists.txt
+++ b/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)
-	set(BAKENDS_FOLDER "../imgui/backends/")
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../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)
-	set(TABLES_SOURCE "../imgui/imgui_tables.cpp")
+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)
+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
+include_directories(../../)
+set(IMGUI_SOURCES 
+../../cimgui.cpp 
+../../imgui/imgui.cpp 
+../../imgui/imgui_draw.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
@@ -63,10 +66,16 @@ endif(WIN32)


 #sdl2
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl.cpp)
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
 if(DEFINED SDL_PATH)
 	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	FIND_PACKAGE(SDL2 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)
-	message(STATUS "SDL_PATH not defined")
-	set(IMGUI_SDL_LIBRARY SDL2)
-endif(DEFINED SDL_PATH)
+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/)
+include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL2)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
--- a/backend_test/example_sdl_opengl3/main.c
+++ b/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)
--- a/backend_test/example_sdl_vulkan/CMakeLists.txt
+++ b/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_sdl2.cpp)
+if(DEFINED SDL_PATH)
+	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
+else(DEFINED SDL_PATH)
+	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
+	find_package(SDL2)
+endif(DEFINED SDL_PATH)
+
+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_SDL2)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+
--- a/backend_test/example_sdl_vulkan/main.c
+++ b/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;
+}
--- a/cimgui.cpp
+++ b/cimgui.cpp
--- a/cimgui.h
+++ b/cimgui.h
--- a/generator/cimgui_template.cpp
+++ b/generator/cimgui_template.cpp
@@ -1,6 +1,14 @@
-
-#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#ifndef CIMGUI_FREETYPE
+#error "IMGUI_FREETYPE should be defined for Freetype linking"
+#endif
+#else
 #ifdef CIMGUI_FREETYPE
+#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
+#endif
+#endif
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
 #include "./imgui/misc/freetype/imgui_freetype.h"
 #endif
 #include "./imgui/imgui_internal.h"
--- a/generator/cimgui_template.h
+++ b/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);
--- a/generator/config_generator.lua
+++ b/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]]}
+} 
--- a/generator/cpp2ffi.lua
+++ b/generator/cpp2ffi.lua
--- a/generator/generator.bat
+++ b/generator/generator.bat
@@ -15,10 +15,10 @@ 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
-:: examples: "" "internal" "internal freetype"
+:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+:: 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
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 %*

 ::leave console open
 cmd /k
--- a/generator/generator.lua
+++ b/generator/generator.lua
@@ -8,6 +8,9 @@ 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 NOCHAR = script_args[2]:match("nochar") and true or false
+local NOIMSTRV = script_args[2]:match("noimstrv") and true or false
 local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
 local CFLAGS = ""
 local CPRE,CTEST
@@ -26,7 +29,11 @@ for i=3,#script_args do
    end
 end

-if COMPILER == "gcc" or COMPILER == "clang" then
+if FREETYPE_GENERATION then
+	CFLAGS = CFLAGS .. " -DIMGUI_ENABLE_FREETYPE "
+end
+
+if COMPILER == "gcc" or COMPILER == "clang" or COMPILER == "zig cc" then
    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]] .. CFLAGS
    CTEST = COMPILER.." --version"
 elseif COMPILER == "cl" then
@@ -59,6 +66,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
 --------------------------------------------------------------------------
@@ -68,6 +77,9 @@ local cimgui_manuals = {
    --igColorConvertRGBtoHSV = true,
    --igColorConvertHSVtoRGB = true
 }
+local cimgui_skipped = {
+	 --igShowDemoWindow = true
+}
 --------------------------------------------------------------------------
 --this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
 --first level is cimguiname without postfix, second level is the signature of the function, value is the
@@ -116,7 +128,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 +150,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 +170,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 +212,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,21 +243,17 @@ 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"
 	end
 	if gdefines.IMGUI_HAS_IMSTR then
+		if not (NOCHAR or NOIMSTRV) then
 		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_IMSTR       1\n"
+		end
 	end
 	
    hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
@@ -331,7 +267,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 +276,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
 ]]
@@ -358,7 +295,10 @@ if gdefines.IMGUI_HAS_DOCK then
 ]]
 	
 end
+assert(not NOCHAR or not NOIMSTRV,"nochar and noimstrv cant be set at the same time")
 print("IMGUI_HAS_IMSTR",gdefines.IMGUI_HAS_IMSTR)
+print("NOCHAR",NOCHAR)
+print("NOIMSTRV",NOIMSTRV)
 print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
 print("IMGUI_VERSION",gdefines.IMGUI_VERSION)

@@ -374,8 +314,12 @@ local function parseImGuiHeader(header,names)
 	end
 	parser.cname_overloads = cimgui_overloads
 	parser.manuals = cimgui_manuals
+	parser.skipped = cimgui_skipped
 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
-	
+	--parser.gen_template_typedef = gen_template_typedef --use auto
+	parser.COMMENTS_GENERATION = COMMENTS_GENERATION
+	parser.NOCHAR = NOCHAR
+	parser.NOIMSTRV = NOIMSTRV
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
 	
 	return parser
@@ -405,19 +349,24 @@ local parser1 = parseImGuiHeader(extra_includes .. [[headers.h]],headersT)
 os.remove("headers.h")
 parser1:do_parse()

+--to debug items parsing
+--save_data("./itemsarr2.txt",cpp2ffi.ToStr(parser1.itemsarr))
 save_data("./output/overloads.txt",parser1.overloadstxt)
 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 +393,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 +410,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 cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
-    save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
+    --local cfuncsstr = func_header_impl_generate(parser2) 
+	--local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
+    --save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
+	save_data("./output/cimgui_impl.h",impl_str)

    ----------save fundefs in impl_definitions.lua for using in bindings
    save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
@@ -492,6 +448,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
--- a/generator/generator.sh
+++ b/generator/generator.sh
@@ -1,4 +1,4 @@
-#!/usr/bin/sh
+#!/bin/bash

 # this script must be executed in this directory
 # all the output goes to generator/output folder
@@ -13,7 +13,65 @@

 #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
-# examples: "" "internal" "internal freetype"
+# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+# 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
+#
+
+# parse command line arguments
+# ref: https://stackoverflow.com/questions/192249/how-do-i-parse-command-line-arguments-in-bash
+POSITIONAL_ARGS=()
+
+TARGETS="internal noimstrv"
+CFLAGS="glfw opengl3 opengl2 sdl2"
+
+help() {
+        cat <<EOF
+Usage of generator.sh:
+   -t --target    specify which imgui features should be generated
+                  (default: $TARGETS)
+   -c --cflags    specify additional gcc flags
+                  (default: $CFLAGS
+   -h --help      show this message and exit
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    -c|--cflags)
+      CFLAGS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -t|--target)
+      TARGETS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -h|--help)
+      help
+      exit 0
+      ;;
+    -*|--*)
+      echo "Unknown option $1"
+      help
+      exit 1
+      ;;
+    *)
+      POSITIONAL_ARGS+=("$1") # save positional arg
+      shift # past argument
+      ;;
+  esac
+done
+
+set -- "${POSITIONAL_ARGS[@]}" # restore positional parameters
+
+# if [[ "$OSTYPE" == "cygwin" || "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]];
+# then
+#   suffix='.exe'
+# fi
+
+echo "CFLAGS: " $CFLAGS
+echo "TARGETS: " $TARGETS
+
+luajit$suffix ./generator.lua gcc "$TARGETS" $CFLAGS
--- a/generator/output/cimgui_impl.h
+++ b/generator/output/cimgui_impl.h
@@ -1,44 +1,66 @@
-typedef struct SDL_Window SDL_Window;
-typedef struct GLFWmonitor GLFWmonitor;
+#ifdef CIMGUI_USE_GLFW
+
 typedef struct GLFWwindow GLFWwindow;
-
+typedef struct GLFWmonitor GLFWmonitor;
 struct GLFWwindow;
-struct GLFWmonitor;
-
-struct SDL_Window;
-typedef union SDL_Event SDL_Event;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+struct GLFWmonitor;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown();
-CIMGUI_API void ImGui_ImplGlfw_NewFrame();
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
 CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
 CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
 CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
 CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
 CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
 CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+
+#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_NewFrame();
+CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplOpenGL2_Init();
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown();
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame();
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL2
+CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+
+#endif
+#ifdef CIMGUI_USE_SDL2
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct _SDL_GameController _SDL_GameController;
+struct SDL_Window;
+struct SDL_Renderer;
+struct _SDL_GameController;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown();
-CIMGUI_API void ImGui_ImplSDL2_NewFrame();
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
--- a/generator/output/definitions.json
+++ b/generator/output/definitions.json
--- a/generator/output/definitions.lua
+++ b/generator/output/definitions.lua
--- a/generator/output/impl_definitions.json
+++ b/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:55",
      "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:50",
      "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:51",
+      "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:41",
+      "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:54",
      "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:56",
      "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:52",
      "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:42",
+      "ov_cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "ret": "void",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
  "ImGui_ImplGlfw_ScrollCallback": [
    {
      "args": "(GLFWwindow* window,double xoffset,double yoffset)",
@@ -257,13 +328,34 @@
      "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
      "defaults": {},
      "funcname": "ImGui_ImplGlfw_ScrollCallback",
-      "location": "imgui_impl_glfw:42",
+      "location": "imgui_impl_glfw:53",
      "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
      "ret": "void",
      "signature": "(GLFWwindow*,double,double)",
      "stname": ""
    }
  ],
+  "ImGui_ImplGlfw_SetCallbacksChainForAllWindows": [
+    {
+      "args": "(bool chain_for_all_windows)",
+      "argsT": [
+        {
+          "name": "chain_for_all_windows",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool chain_for_all_windows)",
+      "call_args": "(chain_for_all_windows)",
+      "cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "location": "imgui_impl_glfw:46",
+      "ov_cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
  "ImGui_ImplGlfw_Shutdown": [
    {
      "args": "()",
@@ -273,7 +365,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 +390,7 @@
      "cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
      "defaults": {},
      "funcname": "ImGui_ImplGlfw_WindowFocusCallback",
-      "location": "imgui_impl_glfw:39",
+      "location": "imgui_impl_glfw:49",
      "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
      "ret": "void",
      "signature": "(GLFWwindow*,int)",
@@ -314,7 +406,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:32",
+      "location": "imgui_impl_opengl2:35",
      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
      "ret": "bool",
      "signature": "()",
@@ -330,7 +422,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "location": "imgui_impl_opengl2:30",
+      "location": "imgui_impl_opengl2:33",
      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
      "ret": "bool",
      "signature": "()",
@@ -346,7 +438,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2:33",
+      "location": "imgui_impl_opengl2:36",
      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
      "ret": "void",
      "signature": "()",
@@ -362,7 +454,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "location": "imgui_impl_opengl2:31",
+      "location": "imgui_impl_opengl2:34",
      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
      "ret": "void",
      "signature": "()",
@@ -378,7 +470,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_Init",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_Init",
-      "location": "imgui_impl_opengl2:24",
+      "location": "imgui_impl_opengl2:27",
      "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
      "ret": "bool",
      "signature": "()",
@@ -394,7 +486,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_NewFrame",
-      "location": "imgui_impl_opengl2:26",
+      "location": "imgui_impl_opengl2:29",
      "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -415,7 +507,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "location": "imgui_impl_opengl2:27",
+      "location": "imgui_impl_opengl2:30",
      "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
      "ret": "void",
      "signature": "(ImDrawData*)",
@@ -431,7 +523,7 @@
      "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_Shutdown",
-      "location": "imgui_impl_opengl2:25",
+      "location": "imgui_impl_opengl2:28",
      "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
      "ret": "void",
      "signature": "()",
@@ -447,7 +539,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "location": "imgui_impl_opengl3:33",
+      "location": "imgui_impl_opengl3:41",
      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
      "ret": "bool",
      "signature": "()",
@@ -463,7 +555,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "location": "imgui_impl_opengl3:31",
+      "location": "imgui_impl_opengl3:39",
      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
      "ret": "bool",
      "signature": "()",
@@ -479,7 +571,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl3:34",
+      "location": "imgui_impl_opengl3:42",
      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
      "ret": "void",
      "signature": "()",
@@ -495,7 +587,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "location": "imgui_impl_opengl3:32",
+      "location": "imgui_impl_opengl3:40",
      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
      "ret": "void",
      "signature": "()",
@@ -511,14 +603,14 @@
          "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",
+      "location": "imgui_impl_opengl3:33",
      "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
      "ret": "bool",
      "signature": "(const char*)",
@@ -534,7 +626,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_NewFrame",
-      "location": "imgui_impl_opengl3:27",
+      "location": "imgui_impl_opengl3:35",
      "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -555,7 +647,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "location": "imgui_impl_opengl3:28",
+      "location": "imgui_impl_opengl3:36",
      "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
      "ret": "void",
      "signature": "(ImDrawData*)",
@@ -571,7 +663,7 @@
      "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_Shutdown",
-      "location": "imgui_impl_opengl3:26",
+      "location": "imgui_impl_opengl3:34",
      "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
      "ret": "void",
      "signature": "()",
@@ -592,7 +684,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForD3D",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForD3D",
-      "location": "imgui_impl_sdl:28",
+      "location": "imgui_impl_sdl2:32",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -613,7 +705,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForMetal",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForMetal",
-      "location": "imgui_impl_sdl:29",
+      "location": "imgui_impl_sdl2:33",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -638,14 +730,14 @@
      "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForOpenGL",
-      "location": "imgui_impl_sdl:26",
+      "location": "imgui_impl_sdl2:30",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
      "ret": "bool",
      "signature": "(SDL_Window*,void*)",
      "stname": ""
    }
  ],
-  "ImGui_ImplSDL2_InitForSDLRenderer": [
+  "ImGui_ImplSDL2_InitForOther": [
    {
      "args": "(SDL_Window* window)",
      "argsT": [
@@ -656,13 +748,38 @@
      ],
      "argsoriginal": "(SDL_Window* window)",
      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForOther",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForOther",
+      "location": "imgui_impl_sdl2:35",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOther",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForSDLRenderer": [
+    {
+      "args": "(SDL_Window* window,SDL_Renderer* renderer)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        },
+        {
+          "name": "renderer",
+          "type": "SDL_Renderer*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window,SDL_Renderer* renderer)",
+      "call_args": "(window,renderer)",
      "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
-      "location": "imgui_impl_sdl:30",
+      "location": "imgui_impl_sdl2:34",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
      "ret": "bool",
-      "signature": "(SDL_Window*)",
+      "signature": "(SDL_Window*,SDL_Renderer*)",
      "stname": ""
    }
  ],
@@ -680,7 +797,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForVulkan",
-      "location": "imgui_impl_sdl:27",
+      "location": "imgui_impl_sdl2:31",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -696,7 +813,7 @@
      "cimguiname": "ImGui_ImplSDL2_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_NewFrame",
-      "location": "imgui_impl_sdl:32",
+      "location": "imgui_impl_sdl2:37",
      "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -717,13 +834,45 @@
      "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_ProcessEvent",
-      "location": "imgui_impl_sdl:33",
+      "location": "imgui_impl_sdl2:38",
      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
      "ret": "bool",
      "signature": "(const SDL_Event*)",
      "stname": ""
    }
  ],
+  "ImGui_ImplSDL2_SetGamepadMode": [
+    {
+      "args": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count)",
+      "argsT": [
+        {
+          "name": "mode",
+          "type": "ImGui_ImplSDL2_GamepadMode"
+        },
+        {
+          "name": "manual_gamepads_array",
+          "type": "struct _SDL_GameController**"
+        },
+        {
+          "name": "manual_gamepads_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)",
+      "call_args": "(mode,manual_gamepads_array,manual_gamepads_count)",
+      "cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
+      "defaults": {
+        "manual_gamepads_array": "NULL",
+        "manual_gamepads_count": "-1"
+      },
+      "funcname": "ImGui_ImplSDL2_SetGamepadMode",
+      "location": "imgui_impl_sdl2:43",
+      "ov_cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
+      "ret": "void",
+      "signature": "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)",
+      "stname": ""
+    }
+  ],
  "ImGui_ImplSDL2_Shutdown": [
    {
      "args": "()",
@@ -733,7 +882,7 @@
      "cimguiname": "ImGui_ImplSDL2_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_Shutdown",
-      "location": "imgui_impl_sdl:31",
+      "location": "imgui_impl_sdl2:36",
      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
      "ret": "void",
      "signature": "()",
--- a/generator/output/impl_definitions.lua
+++ b/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:55"
 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:50"
 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:51"
+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:41"
+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:54"
 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:56"
 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:52"
 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:42"
+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,12 +275,30 @@ 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:53"
 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)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["stname"] = ""
 defs["ImGui_ImplGlfw_ScrollCallback"]["(GLFWwindow*,double,double)"] = defs["ImGui_ImplGlfw_ScrollCallback"][1]
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["args"] = "(bool chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1]["name"] = "chain_for_all_windows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1]["type"] = "bool"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsoriginal"] = "(bool chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["call_args"] = "(chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["cimguiname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["funcname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["location"] = "imgui_impl_glfw:46"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["signature"] = "(bool)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"]["(bool)"] = defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]
 defs["ImGui_ImplGlfw_Shutdown"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["args"] = "()"
@@ -230,7 +308,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 +329,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:49"
 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)"
@@ -266,7 +344,7 @@ defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2:32"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2:35"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
@@ -281,7 +359,7 @@ defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2:30"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2:33"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
@@ -296,7 +374,7 @@ defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2:33"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2:36"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
@@ -311,7 +389,7 @@ defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2:31"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2:34"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
@@ -326,7 +404,7 @@ defs["ImGui_ImplOpenGL2_Init"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2:24"
+defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2:27"
 defs["ImGui_ImplOpenGL2_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
@@ -341,7 +419,7 @@ defs["ImGui_ImplOpenGL2_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2:26"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2:29"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
@@ -359,7 +437,7 @@ defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2:27"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2:30"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
@@ -374,7 +452,7 @@ defs["ImGui_ImplOpenGL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2:25"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2:28"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
@@ -389,7 +467,7 @@ defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3:33"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3:41"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
@@ -404,7 +482,7 @@ defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3:31"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3:39"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
@@ -419,7 +497,7 @@ defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3:34"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3:42"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
@@ -434,7 +512,7 @@ defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3:32"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3:40"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
@@ -447,13 +525,13 @@ 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]["location"] = "imgui_impl_opengl3:33"
 defs["ImGui_ImplOpenGL3_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_Init"][1]["signature"] = "(const char*)"
@@ -468,7 +546,7 @@ defs["ImGui_ImplOpenGL3_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3:27"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3:35"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
@@ -486,7 +564,7 @@ defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3:28"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3:36"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
@@ -501,7 +579,7 @@ defs["ImGui_ImplOpenGL3_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3:26"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3:34"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
@@ -519,7 +597,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_sdl2:32"
 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 +615,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_sdl2:33"
 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,30 +636,51 @@ 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_sdl2:30"
 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*)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["stname"] = ""
 defs["ImGui_ImplSDL2_InitForOpenGL"]["(SDL_Window*,void*)"] = defs["ImGui_ImplSDL2_InitForOpenGL"][1]
+defs["ImGui_ImplSDL2_InitForOther"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["funcname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["location"] = "imgui_impl_sdl2:35"
+defs["ImGui_ImplSDL2_InitForOther"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForOther"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForOther"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForOther"][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]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2] = {}
+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_sdl2:34"
 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 +693,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_sdl2:31"
 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 +708,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_sdl2:37"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "()"
@@ -627,12 +726,38 @@ 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_sdl2:38"
 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*)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["stname"] = ""
 defs["ImGui_ImplSDL2_ProcessEvent"]["(const SDL_Event*)"] = defs["ImGui_ImplSDL2_ProcessEvent"][1]
+defs["ImGui_ImplSDL2_SetGamepadMode"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["args"] = "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1]["name"] = "mode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1]["type"] = "ImGui_ImplSDL2_GamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2]["name"] = "manual_gamepads_array"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2]["type"] = "struct _SDL_GameController**"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3]["name"] = "manual_gamepads_count"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3]["type"] = "int"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsoriginal"] = "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["call_args"] = "(mode,manual_gamepads_array,manual_gamepads_count)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["cimguiname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"]["manual_gamepads_array"] = "NULL"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"]["manual_gamepads_count"] = "-1"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["funcname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["location"] = "imgui_impl_sdl2:43"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["ret"] = "void"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["signature"] = "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_SetGamepadMode"]["(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)"] = defs["ImGui_ImplSDL2_SetGamepadMode"][1]
 defs["ImGui_ImplSDL2_Shutdown"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["args"] = "()"
@@ -642,7 +767,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_sdl2:36"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"
--- a/generator/output/overloads.txt
+++ b/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)
-3	nil	ImColor_ImColor_U32 (ImU32)
-4	nil	ImColor_ImColor_Float (float,float,float,float)
-5	nil	ImColor_ImColor_Vec4 (const ImVec4)
+2	nil	ImColor_ImColor_Float (float,float,float,float)
+3	nil	ImColor_ImColor_Vec4 (const ImVec4)
+4	nil	ImColor_ImColor_Int (int,int,int,int)
+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
@@ -98,8 +94,8 @@ ImVector_resize	2
 1	void	ImVector_resize_Nil (int)
 2	void	ImVector_resize_T (int,const T)
 igBeginChild	2
-1	bool	igBeginChild_Str (const char*,const ImVec2,bool,ImGuiWindowFlags)
-2	bool	igBeginChild_ID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+1	bool	igBeginChild_Str (const char*,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
+2	bool	igBeginChild_ID (ImGuiID,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
 igCheckboxFlags	4
 1	bool	igCheckboxFlags_IntPtr (const char*,int*,int)
 2	bool	igCheckboxFlags_UintPtr (const char*,unsigned int*,unsigned int)
@@ -111,22 +107,28 @@ igCollapsingHeader	2
 igCombo	3
 1	bool	igCombo_Str_arr (const char*,int*,const char* const[],int,int)
 2	bool	igCombo_Str (const char*,int*,const char*,int)
-3	bool	igCombo_FnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+3	bool	igCombo_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
 igGetBackgroundDrawList	2
 1	ImDrawList*	igGetBackgroundDrawList_Nil ()
 2	ImDrawList*	igGetBackgroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetColorU32	3
 1	ImU32	igGetColorU32_Col (ImGuiCol,float)
 2	ImU32	igGetColorU32_Vec4 (const ImVec4)
-3	ImU32	igGetColorU32_U32 (ImU32)
+3	ImU32	igGetColorU32_U32 (ImU32,float)
 igGetForegroundDrawList	3
 1	ImDrawList*	igGetForegroundDrawList_Nil ()
-2	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
-3	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
+2	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
+3	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetID	3
 1	ImGuiID	igGetID_Str (const char*)
 2	ImGuiID	igGetID_StrStr (const char*,const char*)
 3	ImGuiID	igGetID_Ptr (const void*)
+igGetIDWithSeed	2
+1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
+2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
+igGetKeyData	2
+1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
+2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
 igImAbs	3
 1	int	igImAbs_Int (int)
 2	float	igImAbs_Float (float)
@@ -156,6 +158,33 @@ igImRsqrt	2
 igImSign	2
 1	float	igImSign_Float (float)
 2	double	igImSign_double (double)
+igImTrunc	2
+1	float	igImTrunc_Float (float)
+2	ImVec2	igImTrunc_Vec2 (const ImVec2)
+igIsKeyChordPressed	2
+1	bool	igIsKeyChordPressed_Nil (ImGuiKeyChord)
+2	bool	igIsKeyChordPressed_ID (ImGuiKeyChord,ImGuiID,ImGuiInputFlags)
+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)
+igIsMouseDoubleClicked	2
+1	bool	igIsMouseDoubleClicked_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDoubleClicked_ID (ImGuiMouseButton,ImGuiID)
+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)
@@ -167,7 +196,7 @@ igItemSize	2
 2	void	igItemSize_Rect (const ImRect,float)
 igListBox	2
 1	bool	igListBox_Str_arr (const char*,int*,const char* const[],int,int)
-2	bool	igListBox_FnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+2	bool	igListBox_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
 igMarkIniSettingsDirty	2
 1	void	igMarkIniSettingsDirty_Nil ()
 2	void	igMarkIniSettingsDirty_WindowPtr (ImGuiWindow*)
@@ -227,6 +256,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 +287,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
+201 overloaded
--- a/generator/output/structs_and_enums.json
+++ b/generator/output/structs_and_enums.json
--- a/generator/output/structs_and_enums.lua
+++ b/generator/output/structs_and_enums.lua
--- a/generator/output/typedefs_dict.json
+++ b/generator/output/typedefs_dict.json
@@ -1,4 +1,6 @@
 {
+  "ImBitArrayForNamedKeys": "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>",
+  "ImBitArrayPtr": "ImU32*",
  "ImBitVector": "struct ImBitVector",
  "ImColor": "struct ImColor",
  "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
@@ -26,6 +28,7 @@
  "ImGuiActivateFlags": "int",
  "ImGuiBackendFlags": "int",
  "ImGuiButtonFlags": "int",
+  "ImGuiChildFlags": "int",
  "ImGuiCol": "int",
  "ImGuiColorEditFlags": "int",
  "ImGuiColorMod": "struct ImGuiColorMod",
@@ -36,47 +39,62 @@
  "ImGuiContext": "struct ImGuiContext",
  "ImGuiContextHook": "struct ImGuiContextHook",
  "ImGuiContextHookCallback": "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);",
-  "ImGuiDataAuthority": "int",
  "ImGuiDataType": "int",
  "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
  "ImGuiDataTypeTempStorage": "struct ImGuiDataTypeTempStorage",
+  "ImGuiDataVarInfo": "struct ImGuiDataVarInfo",
+  "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
+  "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
+  "ImGuiDebugLogFlags": "int",
  "ImGuiDir": "int",
-  "ImGuiDockContext": "struct ImGuiDockContext",
-  "ImGuiDockNode": "struct ImGuiDockNode",
-  "ImGuiDockNodeFlags": "int",
-  "ImGuiDockNodeSettings": "struct ImGuiDockNodeSettings",
-  "ImGuiDockRequest": "struct ImGuiDockRequest",
  "ImGuiDragDropFlags": "int",
  "ImGuiErrorLogCallback": "void(*)(void* user_data,const char* fmt,...);",
+  "ImGuiFocusRequestFlags": "int",
+  "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
  "ImGuiFocusedFlags": "int",
  "ImGuiGroupData": "struct ImGuiGroupData",
  "ImGuiHoveredFlags": "int",
  "ImGuiID": "unsigned int",
+  "ImGuiIDStackTool": "struct ImGuiIDStackTool",
  "ImGuiIO": "struct ImGuiIO",
+  "ImGuiInputEvent": "struct ImGuiInputEvent",
+  "ImGuiInputEventAppFocused": "struct ImGuiInputEventAppFocused",
+  "ImGuiInputEventKey": "struct ImGuiInputEventKey",
+  "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
+  "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
+  "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
+  "ImGuiInputEventText": "struct ImGuiInputEventText",
+  "ImGuiInputFlags": "int",
  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
  "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
+  "ImGuiInputTextDeactivateData": "struct ImGuiInputTextDeactivateData",
+  "ImGuiInputTextDeactivatedState": "struct ImGuiInputTextDeactivatedState",
  "ImGuiInputTextFlags": "int",
  "ImGuiInputTextState": "struct ImGuiInputTextState",
  "ImGuiItemFlags": "int",
  "ImGuiItemStatusFlags": "int",
-  "ImGuiKey": "int",
-  "ImGuiKeyModFlags": "int",
+  "ImGuiKeyChord": "int",
+  "ImGuiKeyData": "struct ImGuiKeyData",
+  "ImGuiKeyOwnerData": "struct ImGuiKeyOwnerData",
+  "ImGuiKeyRoutingData": "struct ImGuiKeyRoutingData",
+  "ImGuiKeyRoutingIndex": "ImS16",
+  "ImGuiKeyRoutingTable": "struct ImGuiKeyRoutingTable",
  "ImGuiLastItemData": "struct ImGuiLastItemData",
  "ImGuiLayoutType": "int",
  "ImGuiListClipper": "struct ImGuiListClipper",
  "ImGuiListClipperData": "struct ImGuiListClipperData",
  "ImGuiListClipperRange": "struct ImGuiListClipperRange",
+  "ImGuiLocEntry": "struct ImGuiLocEntry",
  "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",
+  "ImGuiNavTreeNodeData": "struct ImGuiNavTreeNodeData",
  "ImGuiNextItemData": "struct ImGuiNextItemData",
  "ImGuiNextItemDataFlags": "int",
  "ImGuiNextWindowData": "struct ImGuiNextWindowData",
@@ -86,13 +104,13 @@
  "ImGuiOldColumns": "struct ImGuiOldColumns",
  "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
  "ImGuiPayload": "struct ImGuiPayload",
-  "ImGuiPlatformIO": "struct ImGuiPlatformIO",
-  "ImGuiPlatformMonitor": "struct ImGuiPlatformMonitor",
+  "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
  "ImGuiPopupData": "struct ImGuiPopupData",
  "ImGuiPopupFlags": "int",
  "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
  "ImGuiScrollFlags": "int",
  "ImGuiSelectableFlags": "int",
+  "ImGuiSelectionUserData": "ImS64",
  "ImGuiSeparatorFlags": "int",
  "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
  "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
@@ -102,7 +120,6 @@
  "ImGuiSortDirection": "int",
  "ImGuiStackLevelInfo": "struct ImGuiStackLevelInfo",
  "ImGuiStackSizes": "struct ImGuiStackSizes",
-  "ImGuiStackTool": "struct ImGuiStackTool",
  "ImGuiStorage": "struct ImGuiStorage",
  "ImGuiStoragePair": "struct ImGuiStoragePair",
  "ImGuiStyle": "struct ImGuiStyle",
@@ -117,12 +134,13 @@
  "ImGuiTableCellData": "struct ImGuiTableCellData",
  "ImGuiTableColumn": "struct ImGuiTableColumn",
  "ImGuiTableColumnFlags": "int",
-  "ImGuiTableColumnIdx": "ImS8",
+  "ImGuiTableColumnIdx": "ImS16",
  "ImGuiTableColumnSettings": "struct ImGuiTableColumnSettings",
  "ImGuiTableColumnSortSpecs": "struct ImGuiTableColumnSortSpecs",
  "ImGuiTableColumnsSettings": "struct ImGuiTableColumnsSettings",
-  "ImGuiTableDrawChannelIdx": "ImU8",
+  "ImGuiTableDrawChannelIdx": "ImU16",
  "ImGuiTableFlags": "int",
+  "ImGuiTableInstanceData": "struct ImGuiTableInstanceData",
  "ImGuiTableRowFlags": "int",
  "ImGuiTableSettings": "struct ImGuiTableSettings",
  "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",
@@ -130,15 +148,17 @@
  "ImGuiTextBuffer": "struct ImGuiTextBuffer",
  "ImGuiTextFilter": "struct ImGuiTextFilter",
  "ImGuiTextFlags": "int",
+  "ImGuiTextIndex": "struct ImGuiTextIndex",
  "ImGuiTextRange": "struct ImGuiTextRange",
  "ImGuiTooltipFlags": "int",
  "ImGuiTreeNodeFlags": "int",
+  "ImGuiTypingSelectFlags": "int",
+  "ImGuiTypingSelectRequest": "struct ImGuiTypingSelectRequest",
+  "ImGuiTypingSelectState": "struct ImGuiTypingSelectState",
  "ImGuiViewport": "struct ImGuiViewport",
  "ImGuiViewportFlags": "int",
  "ImGuiViewportP": "struct ImGuiViewportP",
  "ImGuiWindow": "struct ImGuiWindow",
-  "ImGuiWindowClass": "struct ImGuiWindowClass",
-  "ImGuiWindowDockStyle": "struct ImGuiWindowDockStyle",
  "ImGuiWindowFlags": "int",
  "ImGuiWindowSettings": "struct ImGuiWindowSettings",
  "ImGuiWindowStackData": "struct ImGuiWindowStackData",
@@ -147,12 +167,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",
--- a/generator/output/typedefs_dict.lua
+++ b/generator/output/typedefs_dict.lua
@@ -1,4 +1,6 @@
 local defs = {}
+defs["ImBitArrayForNamedKeys"] = "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>"
+defs["ImBitArrayPtr"] = "ImU32*"
 defs["ImBitVector"] = "struct ImBitVector"
 defs["ImColor"] = "struct ImColor"
 defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
@@ -26,6 +28,7 @@ defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
 defs["ImGuiActivateFlags"] = "int"
 defs["ImGuiBackendFlags"] = "int"
 defs["ImGuiButtonFlags"] = "int"
+defs["ImGuiChildFlags"] = "int"
 defs["ImGuiCol"] = "int"
 defs["ImGuiColorEditFlags"] = "int"
 defs["ImGuiColorMod"] = "struct ImGuiColorMod"
@@ -36,47 +39,62 @@ defs["ImGuiConfigFlags"] = "int"
 defs["ImGuiContext"] = "struct ImGuiContext"
 defs["ImGuiContextHook"] = "struct ImGuiContextHook"
 defs["ImGuiContextHookCallback"] = "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);"
-defs["ImGuiDataAuthority"] = "int"
 defs["ImGuiDataType"] = "int"
 defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
 defs["ImGuiDataTypeTempStorage"] = "struct ImGuiDataTypeTempStorage"
+defs["ImGuiDataVarInfo"] = "struct ImGuiDataVarInfo"
+defs["ImGuiDebugAllocEntry"] = "struct ImGuiDebugAllocEntry"
+defs["ImGuiDebugAllocInfo"] = "struct ImGuiDebugAllocInfo"
+defs["ImGuiDebugLogFlags"] = "int"
 defs["ImGuiDir"] = "int"
-defs["ImGuiDockContext"] = "struct ImGuiDockContext"
-defs["ImGuiDockNode"] = "struct ImGuiDockNode"
-defs["ImGuiDockNodeFlags"] = "int"
-defs["ImGuiDockNodeSettings"] = "struct ImGuiDockNodeSettings"
-defs["ImGuiDockRequest"] = "struct ImGuiDockRequest"
 defs["ImGuiDragDropFlags"] = "int"
 defs["ImGuiErrorLogCallback"] = "void(*)(void* user_data,const char* fmt,...);"
+defs["ImGuiFocusRequestFlags"] = "int"
+defs["ImGuiFocusScopeData"] = "struct ImGuiFocusScopeData"
 defs["ImGuiFocusedFlags"] = "int"
 defs["ImGuiGroupData"] = "struct ImGuiGroupData"
 defs["ImGuiHoveredFlags"] = "int"
 defs["ImGuiID"] = "unsigned int"
+defs["ImGuiIDStackTool"] = "struct ImGuiIDStackTool"
 defs["ImGuiIO"] = "struct ImGuiIO"
+defs["ImGuiInputEvent"] = "struct ImGuiInputEvent"
+defs["ImGuiInputEventAppFocused"] = "struct ImGuiInputEventAppFocused"
+defs["ImGuiInputEventKey"] = "struct ImGuiInputEventKey"
+defs["ImGuiInputEventMouseButton"] = "struct ImGuiInputEventMouseButton"
+defs["ImGuiInputEventMousePos"] = "struct ImGuiInputEventMousePos"
+defs["ImGuiInputEventMouseWheel"] = "struct ImGuiInputEventMouseWheel"
+defs["ImGuiInputEventText"] = "struct ImGuiInputEventText"
+defs["ImGuiInputFlags"] = "int"
 defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
 defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
+defs["ImGuiInputTextDeactivateData"] = "struct ImGuiInputTextDeactivateData"
+defs["ImGuiInputTextDeactivatedState"] = "struct ImGuiInputTextDeactivatedState"
 defs["ImGuiInputTextFlags"] = "int"
 defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
 defs["ImGuiItemFlags"] = "int"
 defs["ImGuiItemStatusFlags"] = "int"
-defs["ImGuiKey"] = "int"
-defs["ImGuiKeyModFlags"] = "int"
+defs["ImGuiKeyChord"] = "int"
+defs["ImGuiKeyData"] = "struct ImGuiKeyData"
+defs["ImGuiKeyOwnerData"] = "struct ImGuiKeyOwnerData"
+defs["ImGuiKeyRoutingData"] = "struct ImGuiKeyRoutingData"
+defs["ImGuiKeyRoutingIndex"] = "ImS16"
+defs["ImGuiKeyRoutingTable"] = "struct ImGuiKeyRoutingTable"
 defs["ImGuiLastItemData"] = "struct ImGuiLastItemData"
 defs["ImGuiLayoutType"] = "int"
 defs["ImGuiListClipper"] = "struct ImGuiListClipper"
 defs["ImGuiListClipperData"] = "struct ImGuiListClipperData"
 defs["ImGuiListClipperRange"] = "struct ImGuiListClipperRange"
+defs["ImGuiLocEntry"] = "struct ImGuiLocEntry"
 defs["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["ImGuiNavTreeNodeData"] = "struct ImGuiNavTreeNodeData"
 defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
 defs["ImGuiNextItemDataFlags"] = "int"
 defs["ImGuiNextWindowData"] = "struct ImGuiNextWindowData"
@@ -86,13 +104,13 @@ defs["ImGuiOldColumnFlags"] = "int"
 defs["ImGuiOldColumns"] = "struct ImGuiOldColumns"
 defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
 defs["ImGuiPayload"] = "struct ImGuiPayload"
-defs["ImGuiPlatformIO"] = "struct ImGuiPlatformIO"
-defs["ImGuiPlatformMonitor"] = "struct ImGuiPlatformMonitor"
+defs["ImGuiPlatformImeData"] = "struct ImGuiPlatformImeData"
 defs["ImGuiPopupData"] = "struct ImGuiPopupData"
 defs["ImGuiPopupFlags"] = "int"
 defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
 defs["ImGuiScrollFlags"] = "int"
 defs["ImGuiSelectableFlags"] = "int"
+defs["ImGuiSelectionUserData"] = "ImS64"
 defs["ImGuiSeparatorFlags"] = "int"
 defs["ImGuiSettingsHandler"] = "struct ImGuiSettingsHandler"
 defs["ImGuiShrinkWidthItem"] = "struct ImGuiShrinkWidthItem"
@@ -102,7 +120,6 @@ defs["ImGuiSliderFlags"] = "int"
 defs["ImGuiSortDirection"] = "int"
 defs["ImGuiStackLevelInfo"] = "struct ImGuiStackLevelInfo"
 defs["ImGuiStackSizes"] = "struct ImGuiStackSizes"
-defs["ImGuiStackTool"] = "struct ImGuiStackTool"
 defs["ImGuiStorage"] = "struct ImGuiStorage"
 defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
 defs["ImGuiStyle"] = "struct ImGuiStyle"
@@ -117,12 +134,13 @@ defs["ImGuiTableBgTarget"] = "int"
 defs["ImGuiTableCellData"] = "struct ImGuiTableCellData"
 defs["ImGuiTableColumn"] = "struct ImGuiTableColumn"
 defs["ImGuiTableColumnFlags"] = "int"
-defs["ImGuiTableColumnIdx"] = "ImS8"
+defs["ImGuiTableColumnIdx"] = "ImS16"
 defs["ImGuiTableColumnSettings"] = "struct ImGuiTableColumnSettings"
 defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
 defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
-defs["ImGuiTableDrawChannelIdx"] = "ImU8"
+defs["ImGuiTableDrawChannelIdx"] = "ImU16"
 defs["ImGuiTableFlags"] = "int"
+defs["ImGuiTableInstanceData"] = "struct ImGuiTableInstanceData"
 defs["ImGuiTableRowFlags"] = "int"
 defs["ImGuiTableSettings"] = "struct ImGuiTableSettings"
 defs["ImGuiTableSortSpecs"] = "struct ImGuiTableSortSpecs"
@@ -130,15 +148,17 @@ defs["ImGuiTableTempData"] = "struct ImGuiTableTempData"
 defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
 defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
 defs["ImGuiTextFlags"] = "int"
+defs["ImGuiTextIndex"] = "struct ImGuiTextIndex"
 defs["ImGuiTextRange"] = "struct ImGuiTextRange"
 defs["ImGuiTooltipFlags"] = "int"
 defs["ImGuiTreeNodeFlags"] = "int"
+defs["ImGuiTypingSelectFlags"] = "int"
+defs["ImGuiTypingSelectRequest"] = "struct ImGuiTypingSelectRequest"
+defs["ImGuiTypingSelectState"] = "struct ImGuiTypingSelectState"
 defs["ImGuiViewport"] = "struct ImGuiViewport"
 defs["ImGuiViewportFlags"] = "int"
 defs["ImGuiViewportP"] = "struct ImGuiViewportP"
 defs["ImGuiWindow"] = "struct ImGuiWindow"
-defs["ImGuiWindowClass"] = "struct ImGuiWindowClass"
-defs["ImGuiWindowDockStyle"] = "struct ImGuiWindowDockStyle"
 defs["ImGuiWindowFlags"] = "int"
 defs["ImGuiWindowSettings"] = "struct ImGuiWindowSettings"
 defs["ImGuiWindowStackData"] = "struct ImGuiWindowStackData"
@@ -147,12 +167,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"
--- a/generator/print_defines.cpp
+++ b/generator/print_defines.cpp
@@ -8,6 +8,10 @@
 #pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION))
 #endif

+#ifdef IMGUI_VERSION_NUM
+#pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION_NUM))
+#endif
+
 #ifdef IMGUI_HAS_DOCK
 #pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_DOCK))
 #endif
--- a/2
+++ b/2
Author	SHA1	Message	Date
sonoro1234	f0fb387921	Merge branch 'docking_inter'	2024-02-24 13:15:42 +01:00
sonoro1234	4486dace2a	update readme	2024-02-24 13:05:48 +01:00
sonoro1234	bd0a584e56	pull imgui 1.90.4 and generate	2024-02-24 13:03:13 +01:00
sonoro1234	c7133969db	Merge branch 'docking_inter'	2024-02-16 11:36:05 +01:00
sonoro1234	7ea55fbcea	pull imgui 1.90.3 docking and generate	2024-02-16 11:31:30 +01:00
sonoro1234	0821a31dfe	Merge branch 'docking_inter'	2024-02-14 11:17:50 +01:00
sonoro1234	53580da638	pull imgui 1.90.2 and generate	2024-02-14 11:11:46 +01:00
Victor Bombi	04961a999e	Merge pull request #260 from Sirius902/zig-cc Allow use of zig cc in generator.lua	2024-01-27 12:51:42 +01:00
Sirius902	b8ae217fd1	Allow use of zig cc in generator	2024-01-26 14:17:33 -08:00
sonoro1234	9009dd72e9	Merge branch 'docking_inter' 1.90.1	2024-01-12 11:27:04 +01:00
sonoro1234	831f155f60	pull imgui 1.90.1 docking and generate	2024-01-12 11:21:08 +01:00
sonoro1234	6fd23e83ff	README.md: update backends information	2023-11-21 11:19:50 +01:00
sonoro1234	21e7106aa1	print_defines.cpp: add IMGUI_VERSION_NUM	2023-11-17 11:18:17 +01:00
sonoro1234	b6e02f4131	Merge branch 'docking_inter'	2023-11-17 11:08:06 +01:00
sonoro1234	0a31d9d923	update readme	2023-11-17 11:01:26 +01:00
sonoro1234	37f347e062	pull imgui 1.90 and generate	2023-11-17 11:00:07 +01:00
sonoro1234	86f59d7e9b	cpp2ffi: more returns in name_overloadsAlgo	2023-11-17 10:57:34 +01:00
sonoro1234	4ca6b29166	CMakeLists.txt: allow using CMAKE_MSVC_RUNTIME_LIBRARY	2023-09-20 11:01:32 +02:00
sonoro1234	5140ea5c81	cpp2ffi: correct embeded_structs for untagged structs (ImNodes needs that)	2023-09-12 10:02:06 +02:00
sonoro1234	935ca882ec	cpp2ffi: fix unamed nested struct and do string substitution (ImNodes needs it)	2023-09-11 18:38:07 +02:00
sonoro1234	b28023c3f6	Merge branch 'docking_inter'	2023-09-08 18:09:15 +02:00
sonoro1234	925b29db67	cpp2ffi: take care of unamed nested structs and brace initializers (rokups/ImNodes needs that)	2023-09-06 17:29:41 +02:00
sonoro1234	44769f63d4	pull imgui 1.89.9 docking and generate	2023-09-04 18:53:07 +02:00
sonoro1234	a21e28e740	update readme	2023-08-02 17:50:11 +02:00
sonoro1234	35fc7d191e	pull imgui 1.89.8 and generate	2023-08-02 17:45:25 +02:00
sonoro1234	6c31357d99	take care of pointers to templates	2023-08-02 17:44:18 +02:00
Victor Bombi	c62361059e	Merge pull request #248 from KhankNyo/windows_makeclean Makefile: clean target for windows	2023-07-27 11:26:55 +02:00
Khanh	dcad905f2e	Merge branch 'windows_makeclean' of https://github.com/KhankNyo/cimgui into windows_makeclean added checks in clean and fclean target to use Windows's "del" command Windows does not have "rm"	2023-07-25 12:13:10 -07:00
Khanh	8fa77b6ad4	Makefile: clean target for windows	2023-07-25 12:11:37 -07:00
Khanh	a518ecc934	make clean target for windows	2023-07-25 12:06:08 -07:00
sonoro1234	b15f98a4c0	avoid deleting info for JSON and generate (issue #245 )	2023-07-15 17:23:15 +02:00
sonoro1234	c8c5add506	pull imgui 1.89.7 docking and generate	2023-07-04 18:19:48 +02:00
Victor Bombi	dccbce96fb	Merge pull request #243 from xEgoist/docking_inter use "installed" directory for vcpkg instead of packages and explicitly install x64 target	2023-06-22 10:14:50 +02:00
xEgoist	705cd9d8a5	CI: use x64-windows target triplet for vcpkg Since vcpkg is transitioning to the host triplet by default in September 2023, this should help the CI mitigate this transition by explicitly using x64-windows target triplet.	2023-06-22 02:13:41 -05:00
xEgoist	b8dcf08413	CI: use installed directory for vcpkg instead of packages	2023-06-22 01:51:25 -05:00
sonoro1234	5c09c391af	try to make github actions happy again	2023-06-18 19:15:23 +02:00
sonoro1234	55c6f914a7	pull imgui 1.89.6 and generate	2023-06-18 18:57:27 +02:00
sonoro1234	a5f9979d90	clean debug output	2023-06-18 18:56:17 +02:00
sonoro1234	a65bf47a5f	solve union with comments #241	2023-06-18 18:50:28 +02:00
sonoro1234	925d24572d	cpp2ffi: sanitize_comments to clean curly braces from comments	2023-04-22 14:03:40 +02:00
sonoro1234	1bb9cd7347	Merge branch 'docking_inter'	2023-04-18 10:43:06 +02:00
sonoro1234	ffda7805d2	pull imgui 1.89.5 and generate	2023-04-18 10:35:57 +02:00
Victor Bombi	9ae8e827fa	Merge pull request #238 from gucio321/sh-generator-pass-cmdline-args Sh generator: pass cmdline args	2023-04-17 18:30:44 +02:00
gucio321	9ac8211a3d	generator: add help page	2023-04-17 17:13:38 +02:00
M.Sz	0c22b34cb6	generator: set default values	2023-04-17 10:13:09 +00:00
M.Sz	e2093ffbc1	generator: remove unnecessary header comment	2023-04-17 07:15:34 +00:00
M.Sz	fa81118e09	generator: add -t/--tagret options	2023-04-17 07:13:26 +00:00
M.Sz	ff19d727b7	Revert "Revert "generattor: add --cflags command line flag"" This reverts commit `2ae35c8b46`.	2023-04-17 07:06:29 +00:00
sonoro1234	a0d46db2f2	readme: generation customization instructions	2023-04-05 11:02:47 +02:00
Victor Bombi	aad088b954	Merge pull request #233 from gucio321/sh-generator-pass-cmdline-args generator.sh (.bat): pass extra command-line arguments.	2023-04-05 10:52:56 +02:00
gucio321	9d1e63d306	generator.bat: pass cmd line arguments to luajit	2023-04-05 10:49:45 +02:00
gucio321	2ae35c8b46	Revert "generattor: add --cflags command line flag" This reverts commit `4d19dd5e17`.	2023-04-05 10:49:02 +02:00
gucio321	4d19dd5e17	generattor: add --cflags command line flag	2023-04-05 10:30:26 +02:00
sonoro1234	2b9eaf3eff	readme: edit cflags	2023-04-05 09:27:19 +02:00
gucio321	27aedcd3c4	generator: pass command-line arguments to GCC	2023-04-05 09:26:19 +02:00
sonoro1234	e25f9f6844	add generator options "nochar" and "noimstrv" according to issue #186	2023-03-24 17:23:28 +01:00
sonoro1234	2c8eab86f7	pull imgui 1.89.4 and generate	2023-03-14 17:52:56 +01:00
sonoro1234	ce1015bb84	backends: CIMGUI_USE_SDL is now CIMGUI_USE_SDL2	2023-02-20 20:14:51 +01:00
sonoro1234	d24246adfd	Merge branch 'docking_inter'	2023-02-15 10:18:15 +01:00
sonoro1234	1187e22308	pull imgui 1.89.3 generate correct sdl2 backend inclusion	2023-02-15 09:55:35 +01:00
sonoro1234	5a857ee68d	cpp2ffi: dont error on not loca	2023-01-09 09:57:43 +01:00
sonoro1234	18e5891710	generator.lua add table cimgui_skipped	2023-01-08 14:38:06 +01:00
sonoro1234	6dba58d90f	merge from docking_inter	2023-01-07 11:34:35 +01:00
sonoro1234	56fdbf845b	pull imgui docking 1.89.2 and generate	2023-01-07 10:34:35 +01:00
sonoro1234	d159c2622d	correction after merge?!!	2022-12-15 10:44:29 +01:00
Victor Bombi	56892a4e3a	Merge pull request #227 from rokups/rk/fix-ci Fix windows CI builds (#226)	2022-12-15 10:29:40 +01:00
Rokas Kupstys	0a953b7102	Fix CI builds. For some reason bash on windows no longer recognizes luajit without .exe suffix. Fixes #226	2022-12-15 10:23:58 +02:00
sonoro1234	0348715500	pull imgui 1.89.1 and generate	2022-11-26 09:10:06 +01:00
sonoro1234	68483775b3	pull imgui 1.89.1 docking and generate	2022-11-26 08:32:02 +01:00
sonoro1234	0369ceb1b4	generator.lua: use IMGUI_VERSION_NUM	2022-11-25 10:27:13 +01:00
sonoro1234	4f089273b1	cpp2ffi.lua: changes to keep comments from struct and enums (from branch comments4000)	2022-11-16 17:13:33 +01:00
sonoro1234	b0649485e9	correcting errors on last merge: example_glfw_opengl3	2022-11-16 11:15:37 +01:00
Victor Bombi	a0a7ca3ca2	Merge pull request #224 from seafork/docking_inter Adding an example for GLFW + OpenGL	2022-11-16 11:02:33 +01:00
seafork	3e823cd2ee	fixed misspelt cmake file	2022-11-15 23:06:35 -05:00
seafork	6a2b18fa65	made glfw more portable	2022-11-15 22:59:36 -05:00
seafork	75ec483e75	fixed compilation error on windows.	2022-11-15 22:09:06 -05:00
seafork	08f24307b8	cleaned up a comment	2022-11-15 19:44:24 -05:00
seafork	a9a9fa4e9e	add example for glfw3 and opengl3	2022-11-15 19:27:21 -05:00
sonoro1234	ce3b504e11	update readme version	2022-11-15 17:40:22 +01:00
sonoro1234	4230a5566e	pull imgui 1.89 and generate	2022-11-15 17:38:24 +01:00
sonoro1234	9ce2c32dad	add info about comments generation	2022-10-06 11:11:50 +02:00
sonoro1234	3d676ffb8b	cpp2ffi: skip enum forward declarations	2022-09-27 12:58:11 +02:00
sonoro1234	b9ebd289e0	CleanImU32 not called when value is sizeof(ImU32)	2022-09-16 15:34:21 +02:00
sonoro1234	9da5c5fe7c	repair_defaults from generator to cpp2ffi	2022-09-16 14:07:24 +02:00
sonoro1234	3d50615659	cpp2ffi: cleanStruct and parseStructLine comments correction	2022-09-09 15:44:51 +02:00
sonoro1234	938d146a41	cpp2ffi and generator: delete bad comments on functionD_re, repair split_comment	2022-09-09 12:00:01 +02:00
sonoro1234	7225c4ae3c	generator.lua: prepare for comments	2022-09-08 13:46:03 +02:00
sonoro1234	feb7829edc	cpp2ffi: prepare parser:parseItems for comments	2022-09-08 13:31:13 +02:00
sonoro1234	6eb85e7d5c	generator: Clearly fail when parse fails; exclude obsolete fns for cl. Thanks to @idbrii	2022-09-01 19:06:19 +02:00
sonoro1234	068e91970d	cpp2ffi: add custom generation machinery	2022-08-30 12:56:58 +02:00
sonoro1234	b5cce9f1a5	update .gitsubmodules	2022-08-08 11:03:54 +02:00
sonoro1234	ea5b077fbe	vardef_re modified for = {} initialization	2022-08-05 14:49:26 +02:00
sonoro1234	a44ce77641	cpp2ffi: add clean_functypedef (cimplot needs it https://github.com/cimgui/cimplot/issues/11 )	2022-07-25 13:11:24 +02:00
sonoro1234	15e4f5015d	backend test sdl: add c++11 to CMakeLists.txt	2022-07-18 10:48:47 +02:00
sonoro1234	9b7d045962	Merge branch 'master' into docking_inter	2022-06-22 18:32:03 +02:00
sonoro1234	44b388121a	generator: dont error if VULKAN_SDK==nil (because it is executed in no vulkan generation also)	2022-06-22 12:43:41 +02:00
sonoro1234	13c4f47172	generator: use VULKAN_SDK env variable to find vulkan	2022-06-22 12:33:46 +02:00
sonoro1234	d1f60f24e1	example_vulkan: add CIMGUI_USE_VULKAN and SDL	2022-06-22 12:18:03 +02:00
Victor Bombi	4c1fd9fc0a	Merge pull request #204 from Sand3r-/example/sdl_vulkan Add Vulkan example	2022-06-22 11:45:13 +02:00
sonoro1234	1616776d77	extraclean	2022-06-22 11:42:23 +02:00
Michal 'Sand3r-' Gallus	eccb961bc7	Add vulkan example info to README.md	2022-06-21 22:38:30 +02:00
Michal 'Sand3r-' Gallus	e3d115bce2	Add SDL2+Vulkan example	2022-06-21 22:38:27 +02:00
sonoro1234	82b8c66f59	extraclean	2022-06-21 22:21:25 +02:00
sonoro1234	08d5ad7f93	pull imgui 1.88 and generate	2022-06-21 20:03:54 +02:00
sonoro1234	8e625e95fd	pull imgui docking and generate	2022-06-21 19:59:10 +02:00
sonoro1234	b5d0aba261	implementations generation	2022-06-21 19:54:13 +02:00
sonoro1234	0b8015191d	Merge branch 'docking_inter'	2022-06-21 19:43:16 +02:00
sonoro1234	433cccd795	backend_test folder modification for several examples	2022-06-21 19:35:37 +02:00
sonoro1234	633fe954bf	backend_test: modification for CIMGUI_USE	2022-06-21 19:23:41 +02:00
sonoro1234	a66528f9b1	generator.lua: impl generation now has guards CIMGUI_USE_	2022-06-21 19:20:40 +02:00
sonoro1234	439bae8107	generation	2022-02-25 11:24:02 +01:00
sonoro1234	261250f88f	generation	2022-02-25 11:22:51 +01:00
sonoro1234	069b850526	Merge branch 'master' into docking_inter	2022-02-25 11:20:45 +01:00
Victor Bombi	9a87a0d5f6	Merge pull request #197 from Xyene/Wstrict-prototypes generator: generate `-Wstrict-prototypes`-compatible code	2022-02-25 11:13:54 +01:00
Tudor Brindus	987cf98e9c	generator: generate `-Wstrict-prototypes`-compatible code	2022-02-24 21:23:39 -05:00
sonoro1234	618ca008ea	Merge branch 'master' into docking_inter	2022-02-22 17:04:07 +01:00
Victor Bombi	881777a2fc	Merge pull request #199 from rokups/rk/fix-ci Use C++11 standard (required by Dear ImGui).	2022-02-22 16:47:04 +01:00
Rokas Kupstys	cf04541b41	Use C++11 standard (required by Dear ImGui). Fixes #198.	2022-02-22 16:50:20 +02:00
sonoro1234	aef3787bb1	cpp2ffi: ignore constexpr	2022-02-21 16:26:54 +01:00
sonoro1234	94e632a253	cpp2ffi: ignore constexpr	2022-02-21 16:24:55 +01:00
sonoro1234	bd5a043957	pull imgui 1.87 and generate	2022-02-07 19:07:25 +01:00
sonoro1234	4492660bb9	pull imgui docking 1.87 and generate	2022-02-07 18:56:16 +01:00
sonoro1234	88e0bc9a9a	Merge branch 'docking_inter'	2022-01-31 19:14:58 +01:00
sonoro1234	1afd93dd45	generation of 1.86dock with new generator	2022-01-31 17:59:15 +01:00
sonoro1234	dac713c763	generator: use gen_template_typedef_auto	2022-01-31 17:56:42 +01:00
sonoro1234	938f8ccf87	cpp2ffi: function_re changed to allow __attribute__ after function declaration, save and load cimgui_inherited, save preprocessed.h	2022-01-31 17:56:42 +01:00
sonoro1234	e6705a8522	cpp2ffi: add gen_template_typedef_auto so that user does not need to provide function	2022-01-31 17:56:42 +01:00
sonoro1234	fdc9511bd7	cpp2ffi: simplify gen_template_typedef	2022-01-31 17:56:42 +01:00
sonoro1234	fe4dff78bd	cpp2ffi: clean_spaces: no spaces around >> operator	2022-01-31 17:56:42 +01:00
sonoro1234	07ceedf37b	cpp2ffi: save templated structs	2022-01-31 17:56:42 +01:00
sonoro1234	0be2b20a16	cpp2ffi: check_template: dont add space between template and *	2022-01-29 16:14:28 +01:00
sonoro1234	b5f5a03851	newtypedefs generation3	2022-01-29 12:50:01 +01:00
sonoro1234	a51a8f7a86	newtypedefs generation2	2022-01-29 12:50:01 +01:00
sonoro1234	de25c00ddd	generator and cpp2ffi: new typedefs generation	2022-01-29 12:50:01 +01:00
sonoro1234	678887ee99	cpp2ffi: parse_enum_value add - operator, when not loca take parent location, templates take full template string	2022-01-26 13:08:10 +01:00
sonoro1234	b0cfee6183	backend_test: no need for gl3w initialization (done by imgui opengl3 impl)	2022-01-15 20:08:58 +01:00
sonoro1234	d0bcf4551b	backend_test: no need for gl3w initialization (done by imgui opengl3 impl)	2022-01-15 20:06:15 +01:00
Victor Bombi	49d45008e0	pull imgui 1.86docking and generate	2021-12-29 12:27:34 +01:00
Victor Bombi	ad929978e9	Merge pull request #192 from GrimMaple/master Add SDL2 fallback in backend_test\CMakeLists.txt	2021-12-27 09:48:31 +01:00
Victor Bombi	b949d47c8b	Merge branch 'docking_inter'	2021-12-27 09:41:02 +01:00
Victor Bombi	d359d907af	generator: add IMGUI_ENABLE_FREETYPE on freetype generation	2021-12-27 09:36:31 +01:00
Grim Maple	52bbaf1117	Remove IMGUI_SDL_LIBRARY	2021-12-26 20:06:20 +03:00
Grim Maple	d5f713caa1	Add SDL2 fallback in backend_test\CMakeLists.txt If SDL was installed using CMake, it normally goes to a location Where it can be found by `find_package`. There is no need to force `SDL_PATH` on users, and this commit allows building `backend_test` Without having to specify it. Backwards compatible.	2021-12-25 22:35:30 +03:00
Victor Bombi	afce852875	Merge branch 'docking_inter'	2021-12-24 11:54:12 +01:00
Victor Bombi	e938d7e0f5	Merge branch 'docking_inter'	2021-12-06 19:41:17 +01:00
Victor Bombi	05d7db048c	Merge branch 'docking_inter'	2021-10-18 19:17:22 +02:00
Victor Bombi	b679737444	Merge branch 'docking_inter'	2021-09-13 11:43:10 +02:00
Victor Bombi	00946c45e4	Merge pull request #190 from THE-FYP/fix-cl Fix generation with MSVC	2021-09-10 11:05:41 +02:00
N/A	9ac28a2d94	Fix flag arguments parsed wrong due to a bug in compiler check	2021-09-09 23:01:57 +03:00
N/A	d0e4aaa2c0	Disable unnecessary pragmas that break generator with the cl compiler	2021-09-09 22:55:55 +03:00
N/A	7362cca7ec	Implement defines extraction with cl compiler	2021-09-09 22:49:28 +03:00
Victor Bombi	17ffa736d3	backend_test: use custom imgui gl3w	2021-08-22 13:50:21 +02:00
Victor Bombi	f16cdc74aa	really pull imgui	2021-08-22 12:12:46 +02:00
Victor Bombi	27c328b506	pull imgui 1.84.1 and generate	2021-08-22 12:12:19 +02:00
Victor Bombi	6a98f4bbed	Merge branch 'docking_inter'	2021-04-07 16:48:35 +02:00
Victor Bombi	a6b16c6da5	Merge branch 'docking_inter'	2021-04-06 18:16:55 +02:00
Victor Bombi	ea9720b412	Merge branch 'docking_inter'	2021-03-21 12:17:59 +01:00
Victor Bombi	2951194915	Merge branch 'docking_inter'	2021-03-21 09:48:38 +01:00
Victor Bombi	83f729b093	pull imgui master 1.82	2021-03-16 13:05:20 +01:00
Victor Bombi	34a48996e6	Merge branch 'docking_inter' # Conflicts: # cimgui.cpp # cimgui.h # generator/output/definitions.json # generator/output/definitions.lua # generator/output/structs_and_enums.json # generator/output/structs_and_enums.lua # imgui	2021-03-16 13:00:24 +01:00
Victor Bombi	c401f71eea	Merge branch 'docking_inter'	2021-03-04 13:33:42 +01:00
Victor Bombi	1ffc9e53c5	Merge branch 'docking_inter'	2021-03-04 12:46:16 +01:00
Victor Bombi	ceda975a5b	Merge branch 'docking_inter'	2021-03-01 20:19:21 +01:00
Victor Bombi	25aa25bd83	Merge branch 'docking_inter'	2021-02-11 14:58:25 +01:00
Victor Bombi	ba9ec30e64	Merge branch 'docking_inter'	2021-02-05 18:12:21 +01:00
Victor Bombi	6791a95f79	Merge branch 'docking_inter'	2021-01-27 10:54:09 +01:00
Victor Bombi	1bdfc0964e	pull submodule imgui master	2021-01-24 13:15:57 +01:00
Victor Bombi	7b9f0c7499	pull imgui master and generate	2021-01-24 11:34:52 +01:00