pull imgui 1.73

drop ImVector functions
Merge pull request #102 from lmariscal/ci
2025-08-11 12:18:30 +01:00 · 2019-09-25 12:44:17 +02:00 · 2019-09-25 12:39:51 +02:00 · 2019-08-01 18:41:43 +02:00 · 2019-08-01 18:37:28 +02:00 · 2019-08-01 07:59:37 -05:00
34 changed files with 28388 additions and 15314 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -32,7 +32,10 @@ cimgui/cimgui.sdf
 cimgui/cimgui.v12.suo
 cimgui/Release/
 .idea
-CMakeLists.txt
 cimgui/.vs/
 cimgui/cimgui.vcxproj.user
 cimgui/x64/
+
+# Test / Build
+bld/
+build/
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,32 @@
 language: cpp
+dist: trusty

 os:
  - linux
+  - osx
+  - windows

 compiler:
  - gcc
  - clang

+env:
+  - MSBUILD_PATH="c:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin"
+
 script:
-  make
+  - mkdir bld
+  - cd bld
+  - cmake -D CIMGUI_TEST=1 ..
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      export PATH=$MSBUILD_PATH:$PATH
+      MSBuild.exe cimgui.sln
+    else
+      make
+    fi
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      ./Debug/cimgui_test.exe
+    else
+      ./cimgui_test
+    fi
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,30 +1,46 @@
-Project(cimgui)
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.1)
+
+project(cimgui)

 #general settings
-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)
-
-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)
+file(GLOB IMGUI_SOURCES
+    cimgui.cpp
+    imgui/imgui.cpp
+    imgui/imgui_draw.cpp
+    imgui/imgui_demo.cpp
+    imgui/imgui_widgets.cpp
+)

+set(IMGUI_STATIC "no" CACHE STRING "Build as a static library")

 #add library and link
-add_library(cimgui SHARED ${IMGUI_SOURCES})
-target_link_libraries(cimgui ${IMGUI_LIBRARIES})
+if (IMGUI_STATIC)
+    add_library(cimgui STATIC ${IMGUI_SOURCES})
+else (IMGUI_STATIC)
+    add_library(cimgui SHARED ${IMGUI_SOURCES})
+endif (IMGUI_STATIC)
+
+target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
+if (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" __declspec\(dllexport\)")
+else (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" ")
+endif (WIN32)
+
+target_include_directories(cimgui PUBLIC ${CMAKE_SOURCE_DIR})
+target_include_directories(cimgui PUBLIC ${CMAKE_SOURCE_DIR}/imgui)
 set_target_properties(cimgui PROPERTIES PREFIX "")

 #install
 install(TARGETS cimgui
-              RUNTIME DESTINATION  .
-              LIBRARY DESTINATION  .
-              #ARCHIVE DESTINATION lib 
-              )
+    RUNTIME DESTINATION  .
+    LIBRARY DESTINATION  .
+    ARCHIVE DESTINATION  .
+)
+
+#test
+set(CIMGUI_TEST "no" CACHE STRING "Enable compilation of a test unit based on imgui null")
+
+if (CIMGUI_TEST)
+  add_subdirectory(test)
+endif ()
--- a/13
+++ b/13
@@ -46,11 +46,18 @@ endif
 .cpp.o:
 	$(CXX) $(CXXFLAGS) -c -o $@ $<

-all:imgui_example
+all:$(OUTPUTNAME)
 	@echo Build complete for $(ECHO_MESSAGE)

-imgui_example:$(OBJS)
+$(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)

 clean:
-	rm $(OBJS)
+	rm -f $(OBJS)
+
+fclean: clean
+	rm -f $(OUTPUTNAME)
+
+re: fclean all
+
+.PHONY: all clean fclean re
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# cimgui [![Build Status](https://travis-ci.org/sonoro1234/cimgui.svg?branch=master)](https://travis-ci.org/sonoro1234/cimgui)
+# cimgui [![Build Status](https://travis-ci.org/cimgui/cimgui.svg?branch=master)](https://travis-ci.org/cimgui/cimgui)


 This is a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui [Dear ImGui](https://github.com/ocornut/imgui).
-All functions are programmatically wrapped except `ImVector` constructors and destructors. (Unless someone find a use case for them)(Now they exist for `ImVector_ImWchar`)
+All imgui.h functions are programmatically wrapped.
 Generated files are: `cimgui.cpp`, `cimgui.h` for C compilation. Also for helping in bindings creation, `definitions.lua` with function definition information and `structs_and_enums.lua`.
 This library is intended as a intermediate layer to be able to use Dear ImGui from other languages that can interface with C (like D - see [D-binding](https://github.com/Extrawurst/DerelictImgui))

@@ -11,7 +11,9 @@ 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.66 of Dear ImGui]
+* currently this wrapper is based on version [1.73 of Dear ImGui]
+* only functions, structs and enums from imgui.h are wrapped.
+* if you are interested in imgui implementations you should look LuaJIT-ImGui project.
 * overloaded function names try to be the most compatible with traditional cimgui names. So all naming is algorithmic except for those names that were in conflict with widely used cimgui names and were thus coded in a table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L58). Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)

 # compilation
@@ -25,10 +27,11 @@ Notes:

 # using generator

+* this is only needed (before compilation) if you want an imgui version different from the one provided, otherwise generation is already done.
 * 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 can use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC) or not use a compiler (experimental nocompiler option) at all. (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` (or make a .sh version and please PR) to choose between gcc, clang, cl or nocompiler. Run it with gcc, clang or cl and LuaJIT on your PATH.
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, cl or nocompiler. Run it with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp` and `cimgui.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 implementations info. 

 # generate binding
@@ -39,10 +42,11 @@ Notes:
 ### definitions description
 * It is a collection in which key is the cimgui name that would result without overloadings and the value is an array of overloadings (may be only one overloading)
 * Each overloading is a collection. Some relevant keys and values are:
-  * stname : the name of the struct the function belongs to (may be ImGui if it is top level in ImGui namespace)
+  * stname : the name of the struct the function belongs to (will be "" if it is top level in ImGui namespace)
  * ov_cimguiname : the overloaded cimgui name (if absent it would be taken from cimguiname)
  * cimguiname : the name without overloading (this should be used if there is not ov_cimguiname)
  * ret : the return type
+  * retref : is setted if original return type is a reference. (will be a pointer in cimgui)
  * argsT : an array of collections (each one with type: argument type and name: the argument name)
  * args : a string of argsT concatenated and separated by commas
  * call_args : a string with the argument names separated by commas for calling imgui function
@@ -50,7 +54,9 @@ Notes:
  * manual : will be true if this function is hand-written (not generated)
  * isvararg : is setted if some argument is a vararg
  * constructor : is setted if the function is a constructor for a class
-  * destructor : is setted if the functions is a destructor for a class
+  * destructor : is setted if the function is a destructor for a class
+  * templated : is setted if the function belongs to a templated class (ImVector)
+  * templatedgen: is setted if the function belongs to a struct generated from template (ImVector_ImWchar)
  * nonUDT : if present can be 1 or 2 (explained meaning in usage) if return type was a user defined type
 ### structs_and_enums description
 * Is is a collection with two items:
--- a/cimgui.cpp
+++ b/cimgui.cpp
@@ -1,5 +1,5 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.66" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.73" from Dear ImGui https://github.com/ocornut/imgui

 #include "./imgui/imgui.h"
 #include "cimgui.h"
@@ -46,9 +46,9 @@ CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
 {
    return ImGui::SetCurrentContext(ctx);
 }
-CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)
+CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
 {
-    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert);
+    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
 }
 CIMGUI_API ImGuiIO* igGetIO()
 {
@@ -78,6 +78,10 @@ CIMGUI_API void igShowDemoWindow(bool* p_open)
 {
    return ImGui::ShowDemoWindow(p_open);
 }
+CIMGUI_API void igShowAboutWindow(bool* p_open)
+{
+    return ImGui::ShowAboutWindow(p_open);
+}
 CIMGUI_API void igShowMetricsWindow(bool* p_open)
 {
    return ImGui::ShowMetricsWindow(p_open);
@@ -170,30 +174,6 @@ CIMGUI_API float igGetWindowHeight()
 {
    return ImGui::GetWindowHeight();
 }
-CIMGUI_API ImVec2 igGetContentRegionMax()
-{
-    return ImGui::GetContentRegionMax();
-}
-CIMGUI_API ImVec2 igGetContentRegionAvail()
-{
-    return ImGui::GetContentRegionAvail();
-}
-CIMGUI_API float igGetContentRegionAvailWidth()
-{
-    return ImGui::GetContentRegionAvailWidth();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMin()
-{
-    return ImGui::GetWindowContentRegionMin();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMax()
-{
-    return ImGui::GetWindowContentRegionMax();
-}
-CIMGUI_API float igGetWindowContentRegionWidth()
-{
-    return ImGui::GetWindowContentRegionWidth();
-}
 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
 {
    return ImGui::SetNextWindowPos(pos,cond,pivot);
@@ -258,6 +238,26 @@ CIMGUI_API void igSetWindowFocusStr(const char* name)
 {
    return ImGui::SetWindowFocus(name);
 }
+CIMGUI_API ImVec2 igGetContentRegionMax()
+{
+    return ImGui::GetContentRegionMax();
+}
+CIMGUI_API ImVec2 igGetContentRegionAvail()
+{
+    return ImGui::GetContentRegionAvail();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMin()
+{
+    return ImGui::GetWindowContentRegionMin();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMax()
+{
+    return ImGui::GetWindowContentRegionMax();
+}
+CIMGUI_API float igGetWindowContentRegionWidth()
+{
+    return ImGui::GetWindowContentRegionWidth();
+}
 CIMGUI_API float igGetScrollX()
 {
    return ImGui::GetScrollX();
@@ -282,13 +282,21 @@ CIMGUI_API void igSetScrollY(float scroll_y)
 {
    return ImGui::SetScrollY(scroll_y);
 }
+CIMGUI_API void igSetScrollHereX(float center_x_ratio)
+{
+    return ImGui::SetScrollHereX(center_x_ratio);
+}
 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
 {
    return ImGui::SetScrollHereY(center_y_ratio);
 }
-CIMGUI_API void igSetScrollFromPosY(float pos_y,float center_y_ratio)
+CIMGUI_API void igSetScrollFromPosX(float local_x,float center_x_ratio)
 {
-    return ImGui::SetScrollFromPosY(pos_y,center_y_ratio);
+    return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
+}
+CIMGUI_API void igSetScrollFromPosY(float local_y,float center_y_ratio)
+{
+    return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
 }
 CIMGUI_API void igPushFont(ImFont* font)
 {
@@ -358,13 +366,17 @@ CIMGUI_API void igPopItemWidth()
 {
    return ImGui::PopItemWidth();
 }
+CIMGUI_API void igSetNextItemWidth(float item_width)
+{
+    return ImGui::SetNextItemWidth(item_width);
+}
 CIMGUI_API float igCalcItemWidth()
 {
    return ImGui::CalcItemWidth();
 }
-CIMGUI_API void igPushTextWrapPos(float wrap_pos_x)
+CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x)
 {
-    return ImGui::PushTextWrapPos(wrap_pos_x);
+    return ImGui::PushTextWrapPos(wrap_local_pos_x);
 }
 CIMGUI_API void igPopTextWrapPos()
 {
@@ -390,9 +402,9 @@ CIMGUI_API void igSeparator()
 {
    return ImGui::Separator();
 }
-CIMGUI_API void igSameLine(float pos_x,float spacing_w)
+CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
 {
-    return ImGui::SameLine(pos_x,spacing_w);
+    return ImGui::SameLine(offset_from_start_x,spacing);
 }
 CIMGUI_API void igNewLine()
 {
@@ -438,13 +450,13 @@ CIMGUI_API void igSetCursorPos(const ImVec2 local_pos)
 {
    return ImGui::SetCursorPos(local_pos);
 }
-CIMGUI_API void igSetCursorPosX(float x)
+CIMGUI_API void igSetCursorPosX(float local_x)
 {
-    return ImGui::SetCursorPosX(x);
+    return ImGui::SetCursorPosX(local_x);
 }
-CIMGUI_API void igSetCursorPosY(float y)
+CIMGUI_API void igSetCursorPosY(float local_y)
 {
-    return ImGui::SetCursorPosY(y);
+    return ImGui::SetCursorPosY(local_y);
 }
 CIMGUI_API ImVec2 igGetCursorStartPos()
 {
@@ -454,9 +466,9 @@ CIMGUI_API ImVec2 igGetCursorScreenPos()
 {
    return ImGui::GetCursorScreenPos();
 }
-CIMGUI_API void igSetCursorScreenPos(const ImVec2 screen_pos)
+CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
 {
-    return ImGui::SetCursorScreenPos(screen_pos);
+    return ImGui::SetCursorScreenPos(pos);
 }
 CIMGUI_API void igAlignTextToFramePadding()
 {
@@ -760,49 +772,53 @@ CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size
 {
    return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
 }
-CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
-    return ImGui::InputFloat(label,v,step,step_fast,format,extra_flags);
+    return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
 }
-CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat2(label,v,format,extra_flags);
+    return ImGui::InputFloat(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat3(label,v,format,extra_flags);
+    return ImGui::InputFloat2(label,v,format,flags);
 }
-CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat4(label,v,format,extra_flags);
+    return ImGui::InputFloat3(label,v,format,flags);
 }
-CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt(label,v,step,step_fast,extra_flags);
+    return ImGui::InputFloat4(label,v,format,flags);
 }
-CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt2(label,v,extra_flags);
+    return ImGui::InputInt(label,v,step,step_fast,flags);
 }
-CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt3(label,v,extra_flags);
+    return ImGui::InputInt2(label,v,flags);
 }
-CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt4(label,v,extra_flags);
+    return ImGui::InputInt3(label,v,flags);
 }
-CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputDouble(label,v,step,step_fast,format,extra_flags);
+    return ImGui::InputInt4(label,v,flags);
 }
-CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,extra_flags);
+    return ImGui::InputDouble(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,extra_flags);
+    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,flags);
+}
+CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+{
+    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,flags);
 }
 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
 {
@@ -896,18 +912,10 @@ CIMGUI_API void igTreePop()
 {
    return ImGui::TreePop();
 }
-CIMGUI_API void igTreeAdvanceToLabelPos()
-{
-    return ImGui::TreeAdvanceToLabelPos();
-}
 CIMGUI_API float igGetTreeNodeToLabelSpacing()
 {
    return ImGui::GetTreeNodeToLabelSpacing();
 }
-CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond)
-{
-    return ImGui::SetNextTreeNodeOpen(is_open,cond);
-}
 CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags)
 {
    return ImGui::CollapsingHeader(label,flags);
@@ -916,6 +924,10 @@ CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTr
 {
    return ImGui::CollapsingHeader(label,p_open,flags);
 }
+CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
+{
+    return ImGui::SetNextItemOpen(is_open,cond);
+}
 CIMGUI_API bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
 {
    return ImGui::Selectable(label,selected,flags,size);
@@ -1099,17 +1111,37 @@ CIMGUI_API int igGetColumnsCount()
 {
    return ImGui::GetColumnsCount();
 }
-CIMGUI_API void igLogToTTY(int max_depth)
+CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags)
 {
-    return ImGui::LogToTTY(max_depth);
+    return ImGui::BeginTabBar(str_id,flags);
 }
-CIMGUI_API void igLogToFile(int max_depth,const char* filename)
+CIMGUI_API void igEndTabBar()
 {
-    return ImGui::LogToFile(max_depth,filename);
+    return ImGui::EndTabBar();
 }
-CIMGUI_API void igLogToClipboard(int max_depth)
+CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags)
 {
-    return ImGui::LogToClipboard(max_depth);
+    return ImGui::BeginTabItem(label,p_open,flags);
+}
+CIMGUI_API void igEndTabItem()
+{
+    return ImGui::EndTabItem();
+}
+CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
+{
+    return ImGui::SetTabItemClosed(tab_or_docked_window_label);
+}
+CIMGUI_API void igLogToTTY(int auto_open_depth)
+{
+    return ImGui::LogToTTY(auto_open_depth);
+}
+CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
+{
+    return ImGui::LogToFile(auto_open_depth,filename);
+}
+CIMGUI_API void igLogToClipboard(int auto_open_depth)
+{
+    return ImGui::LogToClipboard(auto_open_depth);
 }
 CIMGUI_API void igLogFinish()
 {
@@ -1123,9 +1155,9 @@ CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
 {
    return ImGui::BeginDragDropSource(flags);
 }
-CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond)
+CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
 {
-    return ImGui::SetDragDropPayload(type,data,size,cond);
+    return ImGui::SetDragDropPayload(type,data,sz,cond);
 }
 CIMGUI_API void igEndDragDropSource()
 {
@@ -1187,6 +1219,10 @@ CIMGUI_API bool igIsItemEdited()
 {
    return ImGui::IsItemEdited();
 }
+CIMGUI_API bool igIsItemActivated()
+{
+    return ImGui::IsItemActivated();
+}
 CIMGUI_API bool igIsItemDeactivated()
 {
    return ImGui::IsItemDeactivated();
@@ -1239,9 +1275,13 @@ CIMGUI_API int igGetFrameCount()
 {
    return ImGui::GetFrameCount();
 }
-CIMGUI_API ImDrawList* igGetOverlayDrawList()
+CIMGUI_API ImDrawList* igGetBackgroundDrawList()
 {
-    return ImGui::GetOverlayDrawList();
+    return ImGui::GetBackgroundDrawList();
+}
+CIMGUI_API ImDrawList* igGetForegroundDrawList()
+{
+    return ImGui::GetForegroundDrawList();
 }
 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
 {
@@ -1359,13 +1399,13 @@ CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type)
 {
    return ImGui::SetMouseCursor(type);
 }
-CIMGUI_API void igCaptureKeyboardFromApp(bool capture)
+CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
 {
-    return ImGui::CaptureKeyboardFromApp(capture);
+    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
 }
-CIMGUI_API void igCaptureMouseFromApp(bool capture)
+CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
 {
-    return ImGui::CaptureMouseFromApp(capture);
+    return ImGui::CaptureMouseFromApp(want_capture_mouse_value);
 }
 CIMGUI_API const char* igGetClipboardText()
 {
@@ -1415,13 +1455,13 @@ CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
 {
    return self->ScaleAllSizes(scale_factor);
 }
-CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c)
+CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
 {
    return self->AddInputCharacter(c);
 }
-CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* utf8_chars)
+CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
 {
-    return self->AddInputCharactersUTF8(utf8_chars);
+    return self->AddInputCharactersUTF8(str);
 }
 CIMGUI_API void ImGuiIO_ClearInputCharacters(ImGuiIO* self)
 {
@@ -1435,6 +1475,50 @@ CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
+{
+    return IM_NEW(ImGuiInputTextCallbackData)();
+}
+CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
+{
+    return self->DeleteChars(pos,bytes_count);
+}
+CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
+{
+    return self->InsertChars(pos,text,text_end);
+}
+CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
+{
+    return self->HasSelection();
+}
+CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
+{
+    return IM_NEW(ImGuiPayload)();
+}
+CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
+{
+    return self->Clear();
+}
+CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
+{
+    return self->IsDataType(type);
+}
+CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
+{
+    return self->IsPreview();
+}
+CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
+{
+    return self->IsDelivery();
+}
 CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void)
 {
    return IM_NEW(ImGuiOnceUponAFrame)();
@@ -1471,31 +1555,23 @@ CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
 {
    return self->IsActive();
 }
-CIMGUI_API TextRange* TextRange_TextRange(void)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void)
 {
-    return IM_NEW(TextRange)();
+    return IM_NEW(ImGuiTextRange)();
 }
-CIMGUI_API void TextRange_destroy(TextRange* self)
+CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API TextRange* TextRange_TextRangeStr(const char* _b,const char* _e)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
 {
-    return IM_NEW(TextRange)(_b,_e);
+    return IM_NEW(ImGuiTextRange)(_b,_e);
 }
-CIMGUI_API const char* TextRange_begin(TextRange* self)
-{
-    return self->begin();
-}
-CIMGUI_API const char* TextRange_end(TextRange* self)
-{
-    return self->end();
-}
-CIMGUI_API bool TextRange_empty(TextRange* self)
+CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
 {
    return self->empty();
 }
-CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange* out)
+CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
 {
    return self->split(separator,out);
 }
@@ -1535,25 +1611,29 @@ CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
 {
    return self->c_str();
 }
+CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
+{
+    return self->append(str,str_end);
+}
 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
 {
    return self->appendfv(fmt,args);
 }
-CIMGUI_API Pair* Pair_PairInt(ImGuiID _key,int _val_i)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
 {
-    return IM_NEW(Pair)(_key,_val_i);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_i);
 }
-CIMGUI_API void Pair_destroy(Pair* self)
+CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API Pair* Pair_PairFloat(ImGuiID _key,float _val_f)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
 {
-    return IM_NEW(Pair)(_key,_val_f);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_f);
 }
-CIMGUI_API Pair* Pair_PairPtr(ImGuiID _key,void* _val_p)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
 {
-    return IM_NEW(Pair)(_key,_val_p);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_p);
 }
 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
 {
@@ -1615,49 +1695,25 @@ CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
 {
    return self->BuildSortByKey();
 }
-CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
+CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
 {
-    return IM_NEW(ImGuiInputTextCallbackData)();
+    return IM_NEW(ImGuiListClipper)(items_count,items_height);
 }
-CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
+CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
+CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
 {
-    return self->DeleteChars(pos,bytes_count);
+    return self->Step();
 }
-CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
+CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
 {
-    return self->InsertChars(pos,text,text_end);
+    return self->Begin(items_count,items_height);
 }
-CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
+CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
 {
-    return self->HasSelection();
-}
-CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
-{
-    return IM_NEW(ImGuiPayload)();
-}
-CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
-{
-    return self->Clear();
-}
-CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
-{
-    return self->IsDataType(type);
-}
-CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
-{
-    return self->IsPreview();
-}
-CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
-{
-    return self->IsDelivery();
+    return self->End();
 }
 CIMGUI_API ImColor* ImColor_ImColor(void)
 {
@@ -1691,26 +1747,6 @@ CIMGUI_API ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a)
 {
    return self->HSV(h,s,v,a);
 }
-CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
-{
-    return IM_NEW(ImGuiListClipper)(items_count,items_height);
-}
-CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
-{
-    return self->Step();
-}
-CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
-{
-    return self->Begin(items_count,items_height);
-}
-CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
-{
-    return self->End();
-}
 CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
 {
    return IM_NEW(ImDrawCmd)();
@@ -1719,6 +1755,34 @@ CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
+{
+    return IM_NEW(ImDrawListSplitter)();
+}
+CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
+{
+    return self->Clear();
+}
+CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
+{
+    return self->ClearFreeMemory();
+}
+CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
+{
+    return self->Split(draw_list,count);
+}
+CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
+{
+    return self->Merge(draw_list);
+}
+CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
+{
+    return self->SetCurrentChannel(draw_list,channel_idx);
+}
 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
 {
    return IM_NEW(ImDrawList)(shared_data);
@@ -1755,45 +1819,45 @@ CIMGUI_API ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self)
 {
    return self->GetClipRectMax();
 }
-CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
 {
-    return self->AddLine(a,b,col,thickness);
+    return self->AddLine(p1,p2,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness)
+CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
 {
-    return self->AddRect(a,b,col,rounding,rounding_corners_flags,thickness);
+    return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
 }
-CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->AddRectFilled(a,b,col,rounding,rounding_corners_flags);
+    return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
 }
-CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
+CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
 {
-    return self->AddRectFilledMultiColor(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
+    return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
 }
-CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
 {
-    return self->AddQuad(a,b,c,d,col,thickness);
+    return self->AddQuad(p1,p2,p3,p4,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col)
+CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
 {
-    return self->AddQuadFilled(a,b,c,d,col);
+    return self->AddQuadFilled(p1,p2,p3,p4,col);
 }
-CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
 {
-    return self->AddTriangle(a,b,c,col,thickness);
+    return self->AddTriangle(p1,p2,p3,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col)
+CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
 {
-    return self->AddTriangleFilled(a,b,c,col);
+    return self->AddTriangleFilled(p1,p2,p3,col);
 }
-CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness)
+CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
 {
-    return self->AddCircle(centre,radius,col,num_segments,thickness);
+    return self->AddCircle(center,radius,col,num_segments,thickness);
 }
-CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments)
+CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
 {
-    return self->AddCircleFilled(centre,radius,col,num_segments);
+    return self->AddCircleFilled(center,radius,col,num_segments);
 }
 CIMGUI_API void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
 {
@@ -1803,23 +1867,11 @@ CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,fl
 {
    return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
 }
-CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
-{
-    return self->AddImage(user_texture_id,a,b,uv_a,uv_b,col);
-}
-CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
-{
-    return self->AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
-}
-CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners)
-{
-    return self->AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners);
-}
-CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)
+CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
 {
    return self->AddPolyline(points,num_points,col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col)
+CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
 {
    return self->AddConvexPolyFilled(points,num_points,col);
 }
@@ -1827,6 +1879,18 @@ CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,con
 {
    return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments);
 }
+CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
+{
+    return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
+}
+CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
+{
+    return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
+}
+CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
+{
+    return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
+}
 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
 {
    return self->PathClear();
@@ -1847,33 +1911,21 @@ CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,flo
 {
    return self->PathStroke(col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments)
+CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
 {
-    return self->PathArcTo(centre,radius,a_min,a_max,num_segments);
+    return self->PathArcTo(center,radius,a_min,a_max,num_segments);
 }
-CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12)
+CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
 {
-    return self->PathArcToFast(centre,radius,a_min_of_12,a_max_of_12);
+    return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
 }
 CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)
 {
    return self->PathBezierCurveTo(p1,p2,p3,num_segments);
 }
-CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->PathRect(rect_min,rect_max,rounding,rounding_corners_flags);
-}
-CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count)
-{
-    return self->ChannelsSplit(channels_count);
-}
-CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
-{
-    return self->ChannelsMerge();
-}
-CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index)
-{
-    return self->ChannelsSetCurrent(channel_index);
+    return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
 {
@@ -1887,6 +1939,18 @@ CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
 {
    return self->CloneOutput();
 }
+CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
+{
+    return self->ChannelsSplit(count);
+}
+CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
+{
+    return self->ChannelsMerge();
+}
+CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
+{
+    return self->ChannelsSetCurrent(n);
+}
 CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
 {
    return self->Clear();
@@ -1947,9 +2011,9 @@ CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
 {
    return self->DeIndexAllBuffers();
 }
-CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc)
+CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
 {
-    return self->ScaleClipRects(sc);
+    return self->ScaleClipRects(fb_scale);
 }
 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
 {
@@ -1959,6 +2023,54 @@ CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void)
+{
+    return IM_NEW(ImFontGlyphRangesBuilder)();
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
+{
+    return self->Clear();
+}
+CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n)
+{
+    return self->GetBit(n);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,int n)
+{
+    return self->SetBit(n);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c)
+{
+    return self->AddChar(c);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)
+{
+    return self->AddText(text,text_end);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)
+{
+    return self->AddRanges(ranges);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
+{
+    return self->BuildRanges(out_ranges);
+}
+CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
+{
+    return IM_NEW(ImFontAtlasCustomRect)();
+}
+CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
+{
+    return self->IsPacked();
+}
 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
 {
    return IM_NEW(ImFontAtlas)();
@@ -2011,10 +2123,6 @@ CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self)
 {
    return self->Build();
 }
-CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
-{
-    return self->IsBuilt();
-}
 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
 {
    return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel);
@@ -2023,6 +2131,10 @@ CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char**
 {
    return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel);
 }
+CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
+{
+    return self->IsBuilt();
+}
 CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id)
 {
    return self->SetTexID(id);
@@ -2055,49 +2167,9 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
 {
    return self->GetGlyphRangesThai();
 }
-CIMGUI_API GlyphRangesBuilder* GlyphRangesBuilder_GlyphRangesBuilder(void)
+CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
 {
-    return IM_NEW(GlyphRangesBuilder)();
-}
-CIMGUI_API void GlyphRangesBuilder_destroy(GlyphRangesBuilder* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool GlyphRangesBuilder_GetBit(GlyphRangesBuilder* self,int n)
-{
-    return self->GetBit(n);
-}
-CIMGUI_API void GlyphRangesBuilder_SetBit(GlyphRangesBuilder* self,int n)
-{
-    return self->SetBit(n);
-}
-CIMGUI_API void GlyphRangesBuilder_AddChar(GlyphRangesBuilder* self,ImWchar c)
-{
-    return self->AddChar(c);
-}
-CIMGUI_API void GlyphRangesBuilder_AddText(GlyphRangesBuilder* self,const char* text,const char* text_end)
-{
-    return self->AddText(text,text_end);
-}
-CIMGUI_API void GlyphRangesBuilder_AddRanges(GlyphRangesBuilder* self,const ImWchar* ranges)
-{
-    return self->AddRanges(ranges);
-}
-CIMGUI_API void GlyphRangesBuilder_BuildRanges(GlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
-{
-    return self->BuildRanges(out_ranges);
-}
-CIMGUI_API CustomRect* CustomRect_CustomRect(void)
-{
-    return IM_NEW(CustomRect)();
-}
-CIMGUI_API void CustomRect_destroy(CustomRect* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool CustomRect_IsPacked(CustomRect* self)
-{
-    return self->IsPacked();
+    return self->GetGlyphRangesVietnamese();
 }
 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
 {
@@ -2107,11 +2179,11 @@ CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font
 {
    return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
 }
-CIMGUI_API const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
+CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
 {
    return self->GetCustomRectByIndex(index);
 }
-CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
+CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
 {
    return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
 }
@@ -2127,14 +2199,6 @@ CIMGUI_API void ImFont_destroy(ImFont* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
-{
-    return self->ClearOutputData();
-}
-CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
-{
-    return self->BuildLookupTable();
-}
 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
 {
    return self->FindGlyph(c);
@@ -2143,10 +2207,6 @@ CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
 {
    return self->FindGlyphNoFallback(c);
 }
-CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
-{
-    return self->SetFallbackChar(c);
-}
 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
 {
    return self->GetCharAdvance(c);
@@ -2175,6 +2235,14 @@ CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,
 {
    return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
 }
+CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
+{
+    return self->BuildLookupTable();
+}
+CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
+{
+    return self->ClearOutputData();
+}
 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
 {
    return self->GrowIndex(new_size);
@@ -2187,6 +2255,10 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool ov
 {
    return self->AddRemapChar(dst,src,overwrite_dst);
 }
+CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
+{
+    return self->SetFallbackChar(c);
+}
 CIMGUI_API void igGetWindowPos_nonUDT(ImVec2 *pOut)
 {
    *pOut = ImGui::GetWindowPos();
@@ -2446,10 +2518,7 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
-{
-	IM_DELETE(p);
-}
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
--- a/cimgui.h
+++ b/cimgui.h
--- a/generator/cimgui_template.cpp
+++ b/generator/cimgui_template.cpp
@@ -43,10 +43,7 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
-{
-	IM_DELETE(p);
-}
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
--- a/generator/cimgui_template.h
+++ b/generator/cimgui_template.h
@@ -83,7 +83,6 @@ CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,floa
 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b);

 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
 #endif //CIMGUI_INCLUDED
--- a/generator/cpp2ffi.lua
+++ b/generator/cpp2ffi.lua
--- a/generator/generator.bat
+++ b/generator/generator.bat
@@ -10,7 +10,7 @@
 :: impl_definitions.lua for implementation function definitions

 :: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
-:: set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
+set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
--- a/generator/generator.lua
+++ b/generator/generator.lua
--- a/generator/generator.sh
+++ b/generator/generator.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/sh
+
+# this script must be executed in this directory
+# all the output goes to generator/output folder
+# .cpp and .h files:
+# cimgui.h and cimgui.cpp with gcc preprocess
+# cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+# cimgui_impl.h with implementation function cdefs
+# lua and json files:
+# definitions.lua for function definitions
+# structs_and_enums.lua with struct and enum information-definitions
+# impl_definitions.lua for implementation function definitions
+
+#process  files
+# arg[1] compiler name gcc, clang, cl or nocompiler
+# arg[2..n] name of implementations to generate
+luajit ./generator.lua gcc glfw opengl3 opengl2 sdl
--- a/generator/generator_old.bat
+++ b/generator/generator_old.bat
@@ -0,0 +1,23 @@
+:: this script must be executed in this directory
+:: all the output goes to generator/output folder
+:: .cpp and .h files:
+:: cimgui.h and cimgui.cpp with gcc preprocess
+:: cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+:: cimgui_impl.h with implementation function cdefs
+:: lua and json files:
+:: definitions.lua for function definitions
+:: structs_and_enums.lua with struct and enum information-definitions
+:: impl_definitions.lua for implementation function definitions
+
+:: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
+set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
+:: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
+:: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
+::process  files
+:: arg[1] compiler name gcc, clang, cl or nocompiler
+:: arg[2..n] name of implementations to generate
+luajit ./generator_old.lua gcc glfw opengl3 opengl2 sdl
+
+::leave console open
+cmd /k
+
--- a/generator/generator_old.lua
+++ b/generator/generator_old.lua
--- a/generator/json.lua
+++ b/generator/json.lua
@@ -27,7 +27,8 @@ local json = { _version = "0.1.1" }
 -------------------------------------------------------------------------------
 -- Encode
 -------------------------------------------------------------------------------
-
+local TAB = "  "
+local rep = string.rep
 local encode

 local escape_char_map = {
@@ -56,10 +57,10 @@ local function encode_nil(val)
 end


-local function encode_table(val, stack)
+local function encode_table(val, stack,level,isvalue)
  local res = {}
  stack = stack or {}
-
+  level = level or 0
  -- Circular reference?
  if stack[val] then error("circular reference") end

@@ -77,38 +78,53 @@ local function encode_table(val, stack)
    if n ~= #val then
      error("invalid table: sparse array")
    end
+
    -- Encode
    for i, v in ipairs(val) do
-      table.insert(res, encode(v, stack))
+      table.insert(res, encode(v, stack,level+1))
    end
+
    stack[val] = nil
-    return "[" .. table.concat(res, ",\n") .. "]"
+    local inner = table.concat(res, ",\n")
+    if #inner > 0 then inner = "\n"..inner.."\n"..rep(TAB,level) end
+    return rep(isvalue and "" or TAB,level).."[" .. inner .. "]"

  else
+  ---[[
+    local ordered_keys = {}
+    for k,v in pairs(val) do
+        table.insert(ordered_keys,k)
+    end
+    table.sort(ordered_keys)
    -- Treat as an object
-    for k, v in pairs(val) do
+    for _,k in ipairs(ordered_keys) do
+      local v = val[k]
+    --]]
+    --for k, v in pairs(val) do
      if type(k) ~= "string" then
        error("invalid table: mixed or invalid key types")
      end
-      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+      table.insert(res, encode(k, stack,level+1) .. ": " .. encode(v, stack,level+1,true))
    end
    stack[val] = nil
-    return "{" .. table.concat(res, ",\n") .. "}"
+    local inner = table.concat(res, ",\n")
+    if #inner > 0 then inner = "\n"..inner.."\n"..rep(TAB,level) end
+    return rep(isvalue and "" or TAB,level).."{" .. inner .. "}"
  end
 end


-local function encode_string(val)
-  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+local function encode_string(val,stack,level,isvalue)
+  return rep(isvalue and "" or TAB,level)..'"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
 end


-local function encode_number(val)
+local function encode_number(val,stack,level,isvalue)
  -- Check for NaN, -inf and inf
  if val ~= val or val <= -math.huge or val >= math.huge then
    error("unexpected number value '" .. tostring(val) .. "'")
  end
-  return string.format("%.14g", val)
+  return rep(isvalue and "" or TAB,level)..string.format("%.14g", val)
 end


@@ -121,11 +137,11 @@ local type_func_map = {
 }


-encode = function(val, stack)
+encode = function(val, stack,level,isvalue)
  local t = type(val)
  local f = type_func_map[t]
  if f then
-    return f(val, stack)
+    return f(val, stack,level,isvalue)
  end
  error("unexpected type '" .. t .. "'")
 end
--- a/generator/output/cimgui.cpp
+++ b/generator/output/cimgui.cpp
@@ -1,5 +1,5 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.66" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.73" from Dear ImGui https://github.com/ocornut/imgui

 #include "./imgui/imgui.h"
 #include "cimgui.h"
@@ -46,9 +46,9 @@ CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
 {
    return ImGui::SetCurrentContext(ctx);
 }
-CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)
+CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
 {
-    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert);
+    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
 }
 CIMGUI_API ImGuiIO* igGetIO()
 {
@@ -78,6 +78,10 @@ CIMGUI_API void igShowDemoWindow(bool* p_open)
 {
    return ImGui::ShowDemoWindow(p_open);
 }
+CIMGUI_API void igShowAboutWindow(bool* p_open)
+{
+    return ImGui::ShowAboutWindow(p_open);
+}
 CIMGUI_API void igShowMetricsWindow(bool* p_open)
 {
    return ImGui::ShowMetricsWindow(p_open);
@@ -170,30 +174,6 @@ CIMGUI_API float igGetWindowHeight()
 {
    return ImGui::GetWindowHeight();
 }
-CIMGUI_API ImVec2 igGetContentRegionMax()
-{
-    return ImGui::GetContentRegionMax();
-}
-CIMGUI_API ImVec2 igGetContentRegionAvail()
-{
-    return ImGui::GetContentRegionAvail();
-}
-CIMGUI_API float igGetContentRegionAvailWidth()
-{
-    return ImGui::GetContentRegionAvailWidth();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMin()
-{
-    return ImGui::GetWindowContentRegionMin();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMax()
-{
-    return ImGui::GetWindowContentRegionMax();
-}
-CIMGUI_API float igGetWindowContentRegionWidth()
-{
-    return ImGui::GetWindowContentRegionWidth();
-}
 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
 {
    return ImGui::SetNextWindowPos(pos,cond,pivot);
@@ -258,6 +238,26 @@ CIMGUI_API void igSetWindowFocusStr(const char* name)
 {
    return ImGui::SetWindowFocus(name);
 }
+CIMGUI_API ImVec2 igGetContentRegionMax()
+{
+    return ImGui::GetContentRegionMax();
+}
+CIMGUI_API ImVec2 igGetContentRegionAvail()
+{
+    return ImGui::GetContentRegionAvail();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMin()
+{
+    return ImGui::GetWindowContentRegionMin();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMax()
+{
+    return ImGui::GetWindowContentRegionMax();
+}
+CIMGUI_API float igGetWindowContentRegionWidth()
+{
+    return ImGui::GetWindowContentRegionWidth();
+}
 CIMGUI_API float igGetScrollX()
 {
    return ImGui::GetScrollX();
@@ -282,13 +282,21 @@ CIMGUI_API void igSetScrollY(float scroll_y)
 {
    return ImGui::SetScrollY(scroll_y);
 }
+CIMGUI_API void igSetScrollHereX(float center_x_ratio)
+{
+    return ImGui::SetScrollHereX(center_x_ratio);
+}
 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
 {
    return ImGui::SetScrollHereY(center_y_ratio);
 }
-CIMGUI_API void igSetScrollFromPosY(float pos_y,float center_y_ratio)
+CIMGUI_API void igSetScrollFromPosX(float local_x,float center_x_ratio)
 {
-    return ImGui::SetScrollFromPosY(pos_y,center_y_ratio);
+    return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
+}
+CIMGUI_API void igSetScrollFromPosY(float local_y,float center_y_ratio)
+{
+    return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
 }
 CIMGUI_API void igPushFont(ImFont* font)
 {
@@ -358,13 +366,17 @@ CIMGUI_API void igPopItemWidth()
 {
    return ImGui::PopItemWidth();
 }
+CIMGUI_API void igSetNextItemWidth(float item_width)
+{
+    return ImGui::SetNextItemWidth(item_width);
+}
 CIMGUI_API float igCalcItemWidth()
 {
    return ImGui::CalcItemWidth();
 }
-CIMGUI_API void igPushTextWrapPos(float wrap_pos_x)
+CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x)
 {
-    return ImGui::PushTextWrapPos(wrap_pos_x);
+    return ImGui::PushTextWrapPos(wrap_local_pos_x);
 }
 CIMGUI_API void igPopTextWrapPos()
 {
@@ -390,9 +402,9 @@ CIMGUI_API void igSeparator()
 {
    return ImGui::Separator();
 }
-CIMGUI_API void igSameLine(float pos_x,float spacing_w)
+CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
 {
-    return ImGui::SameLine(pos_x,spacing_w);
+    return ImGui::SameLine(offset_from_start_x,spacing);
 }
 CIMGUI_API void igNewLine()
 {
@@ -438,13 +450,13 @@ CIMGUI_API void igSetCursorPos(const ImVec2 local_pos)
 {
    return ImGui::SetCursorPos(local_pos);
 }
-CIMGUI_API void igSetCursorPosX(float x)
+CIMGUI_API void igSetCursorPosX(float local_x)
 {
-    return ImGui::SetCursorPosX(x);
+    return ImGui::SetCursorPosX(local_x);
 }
-CIMGUI_API void igSetCursorPosY(float y)
+CIMGUI_API void igSetCursorPosY(float local_y)
 {
-    return ImGui::SetCursorPosY(y);
+    return ImGui::SetCursorPosY(local_y);
 }
 CIMGUI_API ImVec2 igGetCursorStartPos()
 {
@@ -454,9 +466,9 @@ CIMGUI_API ImVec2 igGetCursorScreenPos()
 {
    return ImGui::GetCursorScreenPos();
 }
-CIMGUI_API void igSetCursorScreenPos(const ImVec2 screen_pos)
+CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
 {
-    return ImGui::SetCursorScreenPos(screen_pos);
+    return ImGui::SetCursorScreenPos(pos);
 }
 CIMGUI_API void igAlignTextToFramePadding()
 {
@@ -760,49 +772,53 @@ CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size
 {
    return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
 }
-CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
-    return ImGui::InputFloat(label,v,step,step_fast,format,extra_flags);
+    return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
 }
-CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat2(label,v,format,extra_flags);
+    return ImGui::InputFloat(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat3(label,v,format,extra_flags);
+    return ImGui::InputFloat2(label,v,format,flags);
 }
-CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputFloat4(label,v,format,extra_flags);
+    return ImGui::InputFloat3(label,v,format,flags);
 }
-CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt(label,v,step,step_fast,extra_flags);
+    return ImGui::InputFloat4(label,v,format,flags);
 }
-CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt2(label,v,extra_flags);
+    return ImGui::InputInt(label,v,step,step_fast,flags);
 }
-CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt3(label,v,extra_flags);
+    return ImGui::InputInt2(label,v,flags);
 }
-CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputInt4(label,v,extra_flags);
+    return ImGui::InputInt3(label,v,flags);
 }
-CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags)
 {
-    return ImGui::InputDouble(label,v,step,step_fast,format,extra_flags);
+    return ImGui::InputInt4(label,v,flags);
 }
-CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,extra_flags);
+    return ImGui::InputDouble(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags extra_flags)
+CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,extra_flags);
+    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,flags);
+}
+CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+{
+    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,flags);
 }
 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
 {
@@ -896,18 +912,10 @@ CIMGUI_API void igTreePop()
 {
    return ImGui::TreePop();
 }
-CIMGUI_API void igTreeAdvanceToLabelPos()
-{
-    return ImGui::TreeAdvanceToLabelPos();
-}
 CIMGUI_API float igGetTreeNodeToLabelSpacing()
 {
    return ImGui::GetTreeNodeToLabelSpacing();
 }
-CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond)
-{
-    return ImGui::SetNextTreeNodeOpen(is_open,cond);
-}
 CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags)
 {
    return ImGui::CollapsingHeader(label,flags);
@@ -916,6 +924,10 @@ CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTr
 {
    return ImGui::CollapsingHeader(label,p_open,flags);
 }
+CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
+{
+    return ImGui::SetNextItemOpen(is_open,cond);
+}
 CIMGUI_API bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
 {
    return ImGui::Selectable(label,selected,flags,size);
@@ -1099,17 +1111,37 @@ CIMGUI_API int igGetColumnsCount()
 {
    return ImGui::GetColumnsCount();
 }
-CIMGUI_API void igLogToTTY(int max_depth)
+CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags)
 {
-    return ImGui::LogToTTY(max_depth);
+    return ImGui::BeginTabBar(str_id,flags);
 }
-CIMGUI_API void igLogToFile(int max_depth,const char* filename)
+CIMGUI_API void igEndTabBar()
 {
-    return ImGui::LogToFile(max_depth,filename);
+    return ImGui::EndTabBar();
 }
-CIMGUI_API void igLogToClipboard(int max_depth)
+CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags)
 {
-    return ImGui::LogToClipboard(max_depth);
+    return ImGui::BeginTabItem(label,p_open,flags);
+}
+CIMGUI_API void igEndTabItem()
+{
+    return ImGui::EndTabItem();
+}
+CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
+{
+    return ImGui::SetTabItemClosed(tab_or_docked_window_label);
+}
+CIMGUI_API void igLogToTTY(int auto_open_depth)
+{
+    return ImGui::LogToTTY(auto_open_depth);
+}
+CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
+{
+    return ImGui::LogToFile(auto_open_depth,filename);
+}
+CIMGUI_API void igLogToClipboard(int auto_open_depth)
+{
+    return ImGui::LogToClipboard(auto_open_depth);
 }
 CIMGUI_API void igLogFinish()
 {
@@ -1123,9 +1155,9 @@ CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
 {
    return ImGui::BeginDragDropSource(flags);
 }
-CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond)
+CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
 {
-    return ImGui::SetDragDropPayload(type,data,size,cond);
+    return ImGui::SetDragDropPayload(type,data,sz,cond);
 }
 CIMGUI_API void igEndDragDropSource()
 {
@@ -1187,6 +1219,10 @@ CIMGUI_API bool igIsItemEdited()
 {
    return ImGui::IsItemEdited();
 }
+CIMGUI_API bool igIsItemActivated()
+{
+    return ImGui::IsItemActivated();
+}
 CIMGUI_API bool igIsItemDeactivated()
 {
    return ImGui::IsItemDeactivated();
@@ -1239,9 +1275,13 @@ CIMGUI_API int igGetFrameCount()
 {
    return ImGui::GetFrameCount();
 }
-CIMGUI_API ImDrawList* igGetOverlayDrawList()
+CIMGUI_API ImDrawList* igGetBackgroundDrawList()
 {
-    return ImGui::GetOverlayDrawList();
+    return ImGui::GetBackgroundDrawList();
+}
+CIMGUI_API ImDrawList* igGetForegroundDrawList()
+{
+    return ImGui::GetForegroundDrawList();
 }
 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
 {
@@ -1359,13 +1399,13 @@ CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type)
 {
    return ImGui::SetMouseCursor(type);
 }
-CIMGUI_API void igCaptureKeyboardFromApp(bool capture)
+CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
 {
-    return ImGui::CaptureKeyboardFromApp(capture);
+    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
 }
-CIMGUI_API void igCaptureMouseFromApp(bool capture)
+CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
 {
-    return ImGui::CaptureMouseFromApp(capture);
+    return ImGui::CaptureMouseFromApp(want_capture_mouse_value);
 }
 CIMGUI_API const char* igGetClipboardText()
 {
@@ -1415,13 +1455,13 @@ CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
 {
    return self->ScaleAllSizes(scale_factor);
 }
-CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c)
+CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
 {
    return self->AddInputCharacter(c);
 }
-CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* utf8_chars)
+CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
 {
-    return self->AddInputCharactersUTF8(utf8_chars);
+    return self->AddInputCharactersUTF8(str);
 }
 CIMGUI_API void ImGuiIO_ClearInputCharacters(ImGuiIO* self)
 {
@@ -1435,6 +1475,50 @@ CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
+{
+    return IM_NEW(ImGuiInputTextCallbackData)();
+}
+CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
+{
+    return self->DeleteChars(pos,bytes_count);
+}
+CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
+{
+    return self->InsertChars(pos,text,text_end);
+}
+CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
+{
+    return self->HasSelection();
+}
+CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
+{
+    return IM_NEW(ImGuiPayload)();
+}
+CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
+{
+    return self->Clear();
+}
+CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
+{
+    return self->IsDataType(type);
+}
+CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
+{
+    return self->IsPreview();
+}
+CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
+{
+    return self->IsDelivery();
+}
 CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void)
 {
    return IM_NEW(ImGuiOnceUponAFrame)();
@@ -1471,31 +1555,23 @@ CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
 {
    return self->IsActive();
 }
-CIMGUI_API TextRange* TextRange_TextRange(void)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void)
 {
-    return IM_NEW(TextRange)();
+    return IM_NEW(ImGuiTextRange)();
 }
-CIMGUI_API void TextRange_destroy(TextRange* self)
+CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API TextRange* TextRange_TextRangeStr(const char* _b,const char* _e)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
 {
-    return IM_NEW(TextRange)(_b,_e);
+    return IM_NEW(ImGuiTextRange)(_b,_e);
 }
-CIMGUI_API const char* TextRange_begin(TextRange* self)
-{
-    return self->begin();
-}
-CIMGUI_API const char* TextRange_end(TextRange* self)
-{
-    return self->end();
-}
-CIMGUI_API bool TextRange_empty(TextRange* self)
+CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
 {
    return self->empty();
 }
-CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange* out)
+CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
 {
    return self->split(separator,out);
 }
@@ -1535,25 +1611,29 @@ CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
 {
    return self->c_str();
 }
+CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
+{
+    return self->append(str,str_end);
+}
 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
 {
    return self->appendfv(fmt,args);
 }
-CIMGUI_API Pair* Pair_PairInt(ImGuiID _key,int _val_i)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
 {
-    return IM_NEW(Pair)(_key,_val_i);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_i);
 }
-CIMGUI_API void Pair_destroy(Pair* self)
+CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API Pair* Pair_PairFloat(ImGuiID _key,float _val_f)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
 {
-    return IM_NEW(Pair)(_key,_val_f);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_f);
 }
-CIMGUI_API Pair* Pair_PairPtr(ImGuiID _key,void* _val_p)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
 {
-    return IM_NEW(Pair)(_key,_val_p);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_p);
 }
 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
 {
@@ -1615,49 +1695,25 @@ CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
 {
    return self->BuildSortByKey();
 }
-CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
+CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
 {
-    return IM_NEW(ImGuiInputTextCallbackData)();
+    return IM_NEW(ImGuiListClipper)(items_count,items_height);
 }
-CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
+CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
+CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
 {
-    return self->DeleteChars(pos,bytes_count);
+    return self->Step();
 }
-CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
+CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
 {
-    return self->InsertChars(pos,text,text_end);
+    return self->Begin(items_count,items_height);
 }
-CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
+CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
 {
-    return self->HasSelection();
-}
-CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
-{
-    return IM_NEW(ImGuiPayload)();
-}
-CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
-{
-    return self->Clear();
-}
-CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
-{
-    return self->IsDataType(type);
-}
-CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
-{
-    return self->IsPreview();
-}
-CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
-{
-    return self->IsDelivery();
+    return self->End();
 }
 CIMGUI_API ImColor* ImColor_ImColor(void)
 {
@@ -1691,26 +1747,6 @@ CIMGUI_API ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a)
 {
    return self->HSV(h,s,v,a);
 }
-CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
-{
-    return IM_NEW(ImGuiListClipper)(items_count,items_height);
-}
-CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
-{
-    return self->Step();
-}
-CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
-{
-    return self->Begin(items_count,items_height);
-}
-CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
-{
-    return self->End();
-}
 CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
 {
    return IM_NEW(ImDrawCmd)();
@@ -1719,6 +1755,34 @@ CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
+{
+    return IM_NEW(ImDrawListSplitter)();
+}
+CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
+{
+    return self->Clear();
+}
+CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
+{
+    return self->ClearFreeMemory();
+}
+CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
+{
+    return self->Split(draw_list,count);
+}
+CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
+{
+    return self->Merge(draw_list);
+}
+CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
+{
+    return self->SetCurrentChannel(draw_list,channel_idx);
+}
 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
 {
    return IM_NEW(ImDrawList)(shared_data);
@@ -1755,45 +1819,45 @@ CIMGUI_API ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self)
 {
    return self->GetClipRectMax();
 }
-CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
 {
-    return self->AddLine(a,b,col,thickness);
+    return self->AddLine(p1,p2,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness)
+CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
 {
-    return self->AddRect(a,b,col,rounding,rounding_corners_flags,thickness);
+    return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
 }
-CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->AddRectFilled(a,b,col,rounding,rounding_corners_flags);
+    return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
 }
-CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
+CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
 {
-    return self->AddRectFilledMultiColor(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
+    return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
 }
-CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
 {
-    return self->AddQuad(a,b,c,d,col,thickness);
+    return self->AddQuad(p1,p2,p3,p4,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col)
+CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
 {
-    return self->AddQuadFilled(a,b,c,d,col);
+    return self->AddQuadFilled(p1,p2,p3,p4,col);
 }
-CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
 {
-    return self->AddTriangle(a,b,c,col,thickness);
+    return self->AddTriangle(p1,p2,p3,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col)
+CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
 {
-    return self->AddTriangleFilled(a,b,c,col);
+    return self->AddTriangleFilled(p1,p2,p3,col);
 }
-CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness)
+CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
 {
-    return self->AddCircle(centre,radius,col,num_segments,thickness);
+    return self->AddCircle(center,radius,col,num_segments,thickness);
 }
-CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments)
+CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
 {
-    return self->AddCircleFilled(centre,radius,col,num_segments);
+    return self->AddCircleFilled(center,radius,col,num_segments);
 }
 CIMGUI_API void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
 {
@@ -1803,23 +1867,11 @@ CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,fl
 {
    return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
 }
-CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
-{
-    return self->AddImage(user_texture_id,a,b,uv_a,uv_b,col);
-}
-CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
-{
-    return self->AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
-}
-CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners)
-{
-    return self->AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners);
-}
-CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)
+CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
 {
    return self->AddPolyline(points,num_points,col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col)
+CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
 {
    return self->AddConvexPolyFilled(points,num_points,col);
 }
@@ -1827,6 +1879,18 @@ CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,con
 {
    return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments);
 }
+CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
+{
+    return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
+}
+CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
+{
+    return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
+}
+CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
+{
+    return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
+}
 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
 {
    return self->PathClear();
@@ -1847,33 +1911,21 @@ CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,flo
 {
    return self->PathStroke(col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments)
+CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
 {
-    return self->PathArcTo(centre,radius,a_min,a_max,num_segments);
+    return self->PathArcTo(center,radius,a_min,a_max,num_segments);
 }
-CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12)
+CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
 {
-    return self->PathArcToFast(centre,radius,a_min_of_12,a_max_of_12);
+    return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
 }
 CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)
 {
    return self->PathBezierCurveTo(p1,p2,p3,num_segments);
 }
-CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->PathRect(rect_min,rect_max,rounding,rounding_corners_flags);
-}
-CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count)
-{
-    return self->ChannelsSplit(channels_count);
-}
-CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
-{
-    return self->ChannelsMerge();
-}
-CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index)
-{
-    return self->ChannelsSetCurrent(channel_index);
+    return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
 {
@@ -1887,6 +1939,18 @@ CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
 {
    return self->CloneOutput();
 }
+CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
+{
+    return self->ChannelsSplit(count);
+}
+CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
+{
+    return self->ChannelsMerge();
+}
+CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
+{
+    return self->ChannelsSetCurrent(n);
+}
 CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
 {
    return self->Clear();
@@ -1947,9 +2011,9 @@ CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
 {
    return self->DeIndexAllBuffers();
 }
-CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc)
+CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
 {
-    return self->ScaleClipRects(sc);
+    return self->ScaleClipRects(fb_scale);
 }
 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
 {
@@ -1959,6 +2023,54 @@ CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self)
 {
    IM_DELETE(self);
 }
+CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void)
+{
+    return IM_NEW(ImFontGlyphRangesBuilder)();
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
+{
+    return self->Clear();
+}
+CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n)
+{
+    return self->GetBit(n);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,int n)
+{
+    return self->SetBit(n);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c)
+{
+    return self->AddChar(c);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)
+{
+    return self->AddText(text,text_end);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)
+{
+    return self->AddRanges(ranges);
+}
+CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
+{
+    return self->BuildRanges(out_ranges);
+}
+CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
+{
+    return IM_NEW(ImFontAtlasCustomRect)();
+}
+CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
+{
+    return self->IsPacked();
+}
 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
 {
    return IM_NEW(ImFontAtlas)();
@@ -2011,10 +2123,6 @@ CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self)
 {
    return self->Build();
 }
-CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
-{
-    return self->IsBuilt();
-}
 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
 {
    return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel);
@@ -2023,6 +2131,10 @@ CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char**
 {
    return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel);
 }
+CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
+{
+    return self->IsBuilt();
+}
 CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id)
 {
    return self->SetTexID(id);
@@ -2055,49 +2167,9 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
 {
    return self->GetGlyphRangesThai();
 }
-CIMGUI_API GlyphRangesBuilder* GlyphRangesBuilder_GlyphRangesBuilder(void)
+CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
 {
-    return IM_NEW(GlyphRangesBuilder)();
-}
-CIMGUI_API void GlyphRangesBuilder_destroy(GlyphRangesBuilder* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool GlyphRangesBuilder_GetBit(GlyphRangesBuilder* self,int n)
-{
-    return self->GetBit(n);
-}
-CIMGUI_API void GlyphRangesBuilder_SetBit(GlyphRangesBuilder* self,int n)
-{
-    return self->SetBit(n);
-}
-CIMGUI_API void GlyphRangesBuilder_AddChar(GlyphRangesBuilder* self,ImWchar c)
-{
-    return self->AddChar(c);
-}
-CIMGUI_API void GlyphRangesBuilder_AddText(GlyphRangesBuilder* self,const char* text,const char* text_end)
-{
-    return self->AddText(text,text_end);
-}
-CIMGUI_API void GlyphRangesBuilder_AddRanges(GlyphRangesBuilder* self,const ImWchar* ranges)
-{
-    return self->AddRanges(ranges);
-}
-CIMGUI_API void GlyphRangesBuilder_BuildRanges(GlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
-{
-    return self->BuildRanges(out_ranges);
-}
-CIMGUI_API CustomRect* CustomRect_CustomRect(void)
-{
-    return IM_NEW(CustomRect)();
-}
-CIMGUI_API void CustomRect_destroy(CustomRect* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool CustomRect_IsPacked(CustomRect* self)
-{
-    return self->IsPacked();
+    return self->GetGlyphRangesVietnamese();
 }
 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
 {
@@ -2107,11 +2179,11 @@ CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font
 {
    return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
 }
-CIMGUI_API const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
+CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
 {
    return self->GetCustomRectByIndex(index);
 }
-CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
+CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
 {
    return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
 }
@@ -2127,14 +2199,6 @@ CIMGUI_API void ImFont_destroy(ImFont* self)
 {
    IM_DELETE(self);
 }
-CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
-{
-    return self->ClearOutputData();
-}
-CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
-{
-    return self->BuildLookupTable();
-}
 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
 {
    return self->FindGlyph(c);
@@ -2143,10 +2207,6 @@ CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
 {
    return self->FindGlyphNoFallback(c);
 }
-CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
-{
-    return self->SetFallbackChar(c);
-}
 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
 {
    return self->GetCharAdvance(c);
@@ -2175,6 +2235,14 @@ CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,
 {
    return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
 }
+CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
+{
+    return self->BuildLookupTable();
+}
+CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
+{
+    return self->ClearOutputData();
+}
 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
 {
    return self->GrowIndex(new_size);
@@ -2187,6 +2255,10 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool ov
 {
    return self->AddRemapChar(dst,src,overwrite_dst);
 }
+CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
+{
+    return self->SetFallbackChar(c);
+}
 CIMGUI_API void igGetWindowPos_nonUDT(ImVec2 *pOut)
 {
    *pOut = ImGui::GetWindowPos();
@@ -2446,10 +2518,7 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
-{
-	IM_DELETE(p);
-}
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
--- a/generator/output/cimgui.h
+++ b/generator/output/cimgui.h
--- a/generator/output/cimgui_impl.h
+++ b/generator/output/cimgui_impl.h
@@ -1,9 +1,10 @@
 typedef struct SDL_Window SDL_Window;
 typedef struct GLFWwindow GLFWwindow;
+
 struct GLFWwindow;
+
 struct SDL_Window;
-typedef union SDL_Event SDL_Event;
-CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+typedef union SDL_Event SDL_Event;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API void ImGui_ImplGlfw_Shutdown();
 CIMGUI_API void ImGui_ImplGlfw_NewFrame();
@@ -29,6 +30,7 @@ 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_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_Shutdown();
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(SDL_Event* event);
+CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
--- 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
@@ -1,387 +1,576 @@
-{"ImGui_ImplOpenGL3_NewFrame":[{"funcname":"ImGui_ImplOpenGL3_NewFrame",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_NewFrame"}],
-"ImGui_ImplSDL2_Shutdown":[{"funcname":"ImGui_ImplSDL2_Shutdown",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_sdl",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplSDL2_Shutdown"}],
-"ImGui_ImplGlfw_KeyCallback":[{"funcname":"ImGui_ImplGlfw_KeyCallback",
-"args":"(GLFWwindow* window,int key,int scancode,int action,int mods)",
-"ret":"void",
-"comment":"",
-"call_args":"(window,key,scancode,action,mods)",
-"argsoriginal":"(GLFWwindow* window,int key,int scancode,int action,int mods)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"int",
-"name":"key"},
-{"type":"int",
-"name":"scancode"},
-{"type":"int",
-"name":"action"},
-{"type":"int",
-"name":"mods"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,int,int,int,int)",
-"cimguiname":"ImGui_ImplGlfw_KeyCallback"}],
-"ImGui_ImplGlfw_InitForVulkan":[{"funcname":"ImGui_ImplGlfw_InitForVulkan",
-"args":"(GLFWwindow* window,bool install_callbacks)",
-"ret":"bool",
-"comment":"",
-"call_args":"(window,install_callbacks)",
-"argsoriginal":"(GLFWwindow* window,bool install_callbacks)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"bool",
-"name":"install_callbacks"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,bool)",
-"cimguiname":"ImGui_ImplGlfw_InitForVulkan"}],
-"ImGui_ImplSDL2_NewFrame":[{"funcname":"ImGui_ImplSDL2_NewFrame",
-"args":"(SDL_Window* window)",
-"ret":"void",
-"comment":"",
-"call_args":"(window)",
-"argsoriginal":"(SDL_Window* window)",
-"stname":"",
-"argsT":[{"type":"SDL_Window*",
-"name":"window"}],
-"location":"imgui_impl_sdl",
-"defaults":[],
-"signature":"(SDL_Window*)",
-"cimguiname":"ImGui_ImplSDL2_NewFrame"}],
-"ImGui_ImplSDL2_InitForVulkan":[{"funcname":"ImGui_ImplSDL2_InitForVulkan",
-"args":"(SDL_Window* window)",
-"ret":"bool",
-"comment":"",
-"call_args":"(window)",
-"argsoriginal":"(SDL_Window* window)",
-"stname":"",
-"argsT":[{"type":"SDL_Window*",
-"name":"window"}],
-"location":"imgui_impl_sdl",
-"defaults":[],
-"signature":"(SDL_Window*)",
-"cimguiname":"ImGui_ImplSDL2_InitForVulkan"}],
-"ImGui_ImplGlfw_ScrollCallback":[{"funcname":"ImGui_ImplGlfw_ScrollCallback",
-"args":"(GLFWwindow* window,double xoffset,double yoffset)",
-"ret":"void",
-"comment":"",
-"call_args":"(window,xoffset,yoffset)",
-"argsoriginal":"(GLFWwindow* window,double xoffset,double yoffset)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"double",
-"name":"xoffset"},
-{"type":"double",
-"name":"yoffset"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,double,double)",
-"cimguiname":"ImGui_ImplGlfw_ScrollCallback"}],
-"ImGui_ImplOpenGL3_Init":[{"funcname":"ImGui_ImplOpenGL3_Init",
-"args":"(const char* glsl_version)",
-"ret":"bool",
-"comment":"",
-"call_args":"(glsl_version)",
-"argsoriginal":"(const char* glsl_version=NULL)",
-"stname":"",
-"argsT":[{"type":"const char*",
-"name":"glsl_version"}],
-"location":"imgui_impl_opengl3",
-"defaults":{"glsl_version":"NULL"},
-"signature":"(const char*)",
-"cimguiname":"ImGui_ImplOpenGL3_Init"}],
-"ImGui_ImplSDL2_InitForOpenGL":[{"funcname":"ImGui_ImplSDL2_InitForOpenGL",
-"args":"(SDL_Window* window,void* sdl_gl_context)",
-"ret":"bool",
-"comment":"",
-"call_args":"(window,sdl_gl_context)",
-"argsoriginal":"(SDL_Window* window,void* sdl_gl_context)",
-"stname":"",
-"argsT":[{"type":"SDL_Window*",
-"name":"window"},
-{"type":"void*",
-"name":"sdl_gl_context"}],
-"location":"imgui_impl_sdl",
-"defaults":[],
-"signature":"(SDL_Window*,void*)",
-"cimguiname":"ImGui_ImplSDL2_InitForOpenGL"}],
-"ImGui_ImplGlfw_InitForOpenGL":[{"funcname":"ImGui_ImplGlfw_InitForOpenGL",
-"args":"(GLFWwindow* window,bool install_callbacks)",
-"ret":"bool",
-"comment":"",
-"call_args":"(window,install_callbacks)",
-"argsoriginal":"(GLFWwindow* window,bool install_callbacks)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"bool",
-"name":"install_callbacks"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,bool)",
-"cimguiname":"ImGui_ImplGlfw_InitForOpenGL"}],
-"ImGui_ImplOpenGL2_DestroyDeviceObjects":[{"funcname":"ImGui_ImplOpenGL2_DestroyDeviceObjects",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_DestroyDeviceObjects"}],
-"ImGui_ImplOpenGL2_DestroyFontsTexture":[{"funcname":"ImGui_ImplOpenGL2_DestroyFontsTexture",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_DestroyFontsTexture"}],
-"ImGui_ImplOpenGL2_CreateDeviceObjects":[{"funcname":"ImGui_ImplOpenGL2_CreateDeviceObjects",
-"args":"()",
-"ret":"bool",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_CreateDeviceObjects"}],
-"ImGui_ImplOpenGL3_CreateFontsTexture":[{"funcname":"ImGui_ImplOpenGL3_CreateFontsTexture",
-"args":"()",
-"ret":"bool",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_CreateFontsTexture"}],
-"ImGui_ImplGlfw_Shutdown":[{"funcname":"ImGui_ImplGlfw_Shutdown",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplGlfw_Shutdown"}],
-"ImGui_ImplOpenGL2_RenderDrawData":[{"funcname":"ImGui_ImplOpenGL2_RenderDrawData",
-"args":"(ImDrawData* draw_data)",
-"ret":"void",
-"comment":"",
-"call_args":"(draw_data)",
-"argsoriginal":"(ImDrawData* draw_data)",
-"stname":"",
-"argsT":[{"type":"ImDrawData*",
-"name":"draw_data"}],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"(ImDrawData*)",
-"cimguiname":"ImGui_ImplOpenGL2_RenderDrawData"}],
-"ImGui_ImplOpenGL2_NewFrame":[{"funcname":"ImGui_ImplOpenGL2_NewFrame",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_NewFrame"}],
-"ImGui_ImplOpenGL2_Shutdown":[{"funcname":"ImGui_ImplOpenGL2_Shutdown",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_Shutdown"}],
-"ImGui_ImplOpenGL3_DestroyDeviceObjects":[{"funcname":"ImGui_ImplOpenGL3_DestroyDeviceObjects",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_DestroyDeviceObjects"}],
-"ImGui_ImplGlfw_NewFrame":[{"funcname":"ImGui_ImplGlfw_NewFrame",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplGlfw_NewFrame"}],
-"ImGui_ImplOpenGL3_Shutdown":[{"funcname":"ImGui_ImplOpenGL3_Shutdown",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_Shutdown"}],
-"ImGui_ImplOpenGL2_Init":[{"funcname":"ImGui_ImplOpenGL2_Init",
-"args":"()",
-"ret":"bool",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_Init"}],
-"ImGui_ImplSDL2_ProcessEvent":[{"funcname":"ImGui_ImplSDL2_ProcessEvent",
-"args":"(SDL_Event* event)",
-"ret":"bool",
-"comment":"",
-"call_args":"(event)",
-"argsoriginal":"(SDL_Event* event)",
-"stname":"",
-"argsT":[{"type":"SDL_Event*",
-"name":"event"}],
-"location":"imgui_impl_sdl",
-"defaults":[],
-"signature":"(SDL_Event*)",
-"cimguiname":"ImGui_ImplSDL2_ProcessEvent"}],
-"ImGui_ImplGlfw_MouseButtonCallback":[{"funcname":"ImGui_ImplGlfw_MouseButtonCallback",
-"args":"(GLFWwindow* window,int button,int action,int mods)",
-"ret":"void",
-"comment":"",
-"call_args":"(window,button,action,mods)",
-"argsoriginal":"(GLFWwindow* window,int button,int action,int mods)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"int",
-"name":"button"},
-{"type":"int",
-"name":"action"},
-{"type":"int",
-"name":"mods"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,int,int,int)",
-"cimguiname":"ImGui_ImplGlfw_MouseButtonCallback"}],
-"ImGui_ImplOpenGL2_CreateFontsTexture":[{"funcname":"ImGui_ImplOpenGL2_CreateFontsTexture",
-"args":"()",
-"ret":"bool",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl2",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL2_CreateFontsTexture"}],
-"ImGui_ImplOpenGL3_DestroyFontsTexture":[{"funcname":"ImGui_ImplOpenGL3_DestroyFontsTexture",
-"args":"()",
-"ret":"void",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_DestroyFontsTexture"}],
-"ImGui_ImplGlfw_CharCallback":[{"funcname":"ImGui_ImplGlfw_CharCallback",
-"args":"(GLFWwindow* window,unsigned int c)",
-"ret":"void",
-"comment":"",
-"call_args":"(window,c)",
-"argsoriginal":"(GLFWwindow* window,unsigned int c)",
-"stname":"",
-"argsT":[{"type":"GLFWwindow*",
-"name":"window"},
-{"type":"unsigned int",
-"name":"c"}],
-"location":"imgui_impl_glfw",
-"defaults":[],
-"signature":"(GLFWwindow*,unsigned int)",
-"cimguiname":"ImGui_ImplGlfw_CharCallback"}],
-"ImGui_ImplOpenGL3_RenderDrawData":[{"funcname":"ImGui_ImplOpenGL3_RenderDrawData",
-"args":"(ImDrawData* draw_data)",
-"ret":"void",
-"comment":"",
-"call_args":"(draw_data)",
-"argsoriginal":"(ImDrawData* draw_data)",
-"stname":"",
-"argsT":[{"type":"ImDrawData*",
-"name":"draw_data"}],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"(ImDrawData*)",
-"cimguiname":"ImGui_ImplOpenGL3_RenderDrawData"}],
-"ImGui_ImplOpenGL3_CreateDeviceObjects":[{"funcname":"ImGui_ImplOpenGL3_CreateDeviceObjects",
-"args":"()",
-"ret":"bool",
-"comment":"",
-"call_args":"()",
-"argsoriginal":"()",
-"stname":"",
-"argsT":[],
-"location":"imgui_impl_opengl3",
-"defaults":[],
-"signature":"()",
-"cimguiname":"ImGui_ImplOpenGL3_CreateDeviceObjects"}]}
+{
+  "ImGui_ImplGlfw_CharCallback": [
+    {
+      "args": "(GLFWwindow* window,unsigned int c)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,unsigned int c)",
+      "call_args": "(window,c)",
+      "cimguiname": "ImGui_ImplGlfw_CharCallback",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_CharCallback",
+      "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,unsigned int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForOpenGL": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_InitForOpenGL",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForVulkan": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_InitForVulkan",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_KeyCallback": [
+    {
+      "args": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "key",
+          "type": "int"
+        },
+        {
+          "name": "scancode",
+          "type": "int"
+        },
+        {
+          "name": "action",
+          "type": "int"
+        },
+        {
+          "name": "mods",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "call_args": "(window,key,scancode,action,mods)",
+      "cimguiname": "ImGui_ImplGlfw_KeyCallback",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_KeyCallback",
+      "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_MouseButtonCallback": [
+    {
+      "args": "(GLFWwindow* window,int button,int action,int mods)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "button",
+          "type": "int"
+        },
+        {
+          "name": "action",
+          "type": "int"
+        },
+        {
+          "name": "mods",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int button,int action,int mods)",
+      "call_args": "(window,button,action,mods)",
+      "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplGlfw_NewFrame",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_NewFrame",
+      "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_ScrollCallback": [
+    {
+      "args": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "xoffset",
+          "type": "double"
+        },
+        {
+          "name": "yoffset",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "call_args": "(window,xoffset,yoffset)",
+      "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_ScrollCallback",
+      "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplGlfw_Shutdown",
+      "defaults": [],
+      "funcname": "ImGui_ImplGlfw_Shutdown",
+      "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_CreateDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_CreateFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_DestroyDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_DestroyFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_Init": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_Init",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_Init",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_NewFrame",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data)",
+      "call_args": "(draw_data)",
+      "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL2_Shutdown",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_CreateDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_CreateFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_DestroyDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_DestroyFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_Init": [
+    {
+      "args": "(const char* glsl_version)",
+      "argsT": [
+        {
+          "name": "glsl_version",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* glsl_version=NULL)",
+      "call_args": "(glsl_version)",
+      "cimguiname": "ImGui_ImplOpenGL3_Init",
+      "defaults": {
+        "glsl_version": "NULL"
+      },
+      "funcname": "ImGui_ImplOpenGL3_Init",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_NewFrame",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data)",
+      "call_args": "(draw_data)",
+      "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
+      "defaults": [],
+      "funcname": "ImGui_ImplOpenGL3_Shutdown",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForD3D": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForD3D",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForOpenGL": [
+    {
+      "args": "(SDL_Window* window,void* sdl_gl_context)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        },
+        {
+          "name": "sdl_gl_context",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window,void* sdl_gl_context)",
+      "call_args": "(window,sdl_gl_context)",
+      "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForOpenGL",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
+      "ret": "bool",
+      "signature": "(SDL_Window*,void*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForVulkan": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForVulkan",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_NewFrame": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_NewFrame",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_NewFrame",
+      "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
+      "ret": "void",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_ProcessEvent": [
+    {
+      "args": "(const SDL_Event* event)",
+      "argsT": [
+        {
+          "name": "event",
+          "type": "const SDL_Event*"
+        }
+      ],
+      "argsoriginal": "(const SDL_Event* event)",
+      "call_args": "(event)",
+      "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_ProcessEvent",
+      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
+      "ret": "bool",
+      "signature": "(const SDL_Event*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_Shutdown",
+      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ]
+}
--- a/generator/output/impl_definitions.lua
+++ b/generator/output/impl_definitions.lua
@@ -12,10 +12,9 @@ defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][2]["type"] = "unsigned int"
 defs["ImGui_ImplGlfw_CharCallback"][1]["argsoriginal"] = "(GLFWwindow* window,unsigned int c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["call_args"] = "(window,c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_CharCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw"
+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)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["stname"] = ""
@@ -33,10 +32,9 @@ defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][2]["type"] = "bool"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["call_args"] = "(window,install_callbacks)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw"
+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)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["stname"] = ""
@@ -54,10 +52,9 @@ defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][2]["type"] = "bool"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["call_args"] = "(window,install_callbacks)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw"
+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"] = ""
@@ -84,10 +81,9 @@ defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][5]["type"] = "int"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["call_args"] = "(window,key,scancode,action,mods)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_KeyCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw"
+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)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["stname"] = ""
@@ -111,10 +107,9 @@ defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][4]["type"] = "int"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int button,int action,int mods)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["call_args"] = "(window,button,action,mods)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw"
+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)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["stname"] = ""
@@ -126,10 +121,9 @@ defs["ImGui_ImplGlfw_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["cimguiname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw"
+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"] = ""
@@ -150,10 +144,9 @@ defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][3]["type"] = "double"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsoriginal"] = "(GLFWwindow* window,double xoffset,double yoffset)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["call_args"] = "(window,xoffset,yoffset)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw"
+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"] = ""
@@ -165,10 +158,9 @@ defs["ImGui_ImplGlfw_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["cimguiname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["stname"] = ""
@@ -180,10 +172,9 @@ defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["stname"] = ""
@@ -195,10 +186,9 @@ defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["stname"] = ""
@@ -210,10 +200,9 @@ defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["stname"] = ""
@@ -225,10 +214,9 @@ defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["stname"] = ""
@@ -240,10 +228,9 @@ defs["ImGui_ImplOpenGL2_Init"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["stname"] = ""
@@ -255,10 +242,9 @@ defs["ImGui_ImplOpenGL2_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["stname"] = ""
@@ -273,10 +259,9 @@ defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsT"][1]["type"] = "ImDrawData*"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["stname"] = ""
@@ -288,10 +273,9 @@ defs["ImGui_ImplOpenGL2_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["stname"] = ""
@@ -303,10 +287,9 @@ defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["stname"] = ""
@@ -318,10 +301,9 @@ defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["stname"] = ""
@@ -333,10 +315,9 @@ defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["stname"] = ""
@@ -348,10 +329,9 @@ defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["stname"] = ""
@@ -366,11 +346,10 @@ defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["type"] = "const char*"
 defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=NULL)"
 defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
 defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "NULL"
 defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3"
+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*)"
 defs["ImGui_ImplOpenGL3_Init"][1]["stname"] = ""
@@ -382,10 +361,9 @@ defs["ImGui_ImplOpenGL3_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["stname"] = ""
@@ -400,10 +378,9 @@ defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsT"][1]["type"] = "ImDrawData*"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["stname"] = ""
@@ -415,14 +392,30 @@ defs["ImGui_ImplOpenGL3_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["stname"] = ""
 defs["ImGui_ImplOpenGL3_Shutdown"]["()"] = defs["ImGui_ImplOpenGL3_Shutdown"][1]
+defs["ImGui_ImplSDL2_InitForD3D"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsoriginal"] = "(SDL_Window* window)"
+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]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForD3D"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForD3D"][1]
 defs["ImGui_ImplSDL2_InitForOpenGL"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["args"] = "(SDL_Window* window,void* sdl_gl_context)"
@@ -436,10 +429,9 @@ defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][2]["type"] = "void*"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsoriginal"] = "(SDL_Window* window,void* sdl_gl_context)"
 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]["comment"] = ""
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl"
+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"] = ""
@@ -454,10 +446,9 @@ defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsT"][1]["type"] = "SDL_Window*"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsoriginal"] = "(SDL_Window* window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl"
+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*)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["stname"] = ""
@@ -472,32 +463,30 @@ defs["ImGui_ImplSDL2_NewFrame"][1]["argsT"][1]["type"] = "SDL_Window*"
 defs["ImGui_ImplSDL2_NewFrame"][1]["argsoriginal"] = "(SDL_Window* window)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "(SDL_Window*)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["stname"] = ""
 defs["ImGui_ImplSDL2_NewFrame"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_NewFrame"][1]
 defs["ImGui_ImplSDL2_ProcessEvent"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1] = {}
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["args"] = "(SDL_Event* event)"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["args"] = "(const SDL_Event* event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["name"] = "event"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["type"] = "SDL_Event*"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsoriginal"] = "(SDL_Event* event)"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["type"] = "const SDL_Event*"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsoriginal"] = "(const SDL_Event* event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["call_args"] = "(event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(SDL_Event*)"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(const SDL_Event*)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_ProcessEvent"]["(SDL_Event*)"] = defs["ImGui_ImplSDL2_ProcessEvent"][1]
+defs["ImGui_ImplSDL2_ProcessEvent"]["(const SDL_Event*)"] = defs["ImGui_ImplSDL2_ProcessEvent"][1]
 defs["ImGui_ImplSDL2_Shutdown"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["args"] = "()"
@@ -505,10 +494,9 @@ defs["ImGui_ImplSDL2_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["stname"] = ""
--- a/generator/output/overloads.txt
+++ b/generator/output/overloads.txt
@@ -1,8 +1,7 @@
 ----------------overloadings---------------------------
-igCombo	3
-1	bool	igCombo (const char*,int*,const char* const[],int,int)
-2	bool	igComboStr (const char*,int*,const char*,int)
-3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+ImVector_resize	2
+1	void	ImVector_resize (int)
+2	void	ImVector_resizeT (int,const T)
 ImVec4_ImVec4	2
 1	nil	ImVec4_ImVec4 ()
 2	nil	ImVec4_ImVec4Float (float,float,float,float)
@@ -11,18 +10,66 @@ igValue	4
 2	void	igValueInt (const char*,int)
 3	void	igValueUint (const char*,unsigned int)
 4	void	igValueFloat (const char*,float,const char*)
-igPushStyleVar	2
-1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
-2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
 igIsRectVisible	2
 1	bool	igIsRectVisible (const ImVec2)
 2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
 igRadioButton	2
 1	bool	igRadioButtonBool (const char*,bool)
 2	bool	igRadioButtonIntPtr (const char*,int*,int)
-igSetWindowSize	2
-1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
+ImGuiTextRange_ImGuiTextRange	2
+1	nil	ImGuiTextRange_ImGuiTextRange ()
+2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
+ImVector_back	2
+1	T*	ImVector_back ()
+2	const T*	ImVector_back_const ()const
+igPlotHistogram	2
+1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotHistogramFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igGetID	3
+1	ImGuiID	igGetIDStr (const char*)
+2	ImGuiID	igGetIDRange (const char*,const char*)
+3	ImGuiID	igGetIDPtr (const void*)
+igSetWindowPos	2
+1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
+igBeginChild	2
+1	bool	igBeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags)
+2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+igPushID	4
+1	void	igPushIDStr (const char*)
+2	void	igPushIDRange (const char*,const char*)
+3	void	igPushIDPtr (const void*)
+4	void	igPushIDInt (int)
+ImGuiStoragePair_ImGuiStoragePair	3
+1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
+2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
+3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
+igTreeNode	3
+1	bool	igTreeNodeStr (const char*)
+2	bool	igTreeNodeStrStr (const char*,const char*,...)
+3	bool	igTreeNodePtr (const void*,const char*,...)
+igCombo	3
+1	bool	igCombo (const char*,int*,const char* const[],int,int)
+2	bool	igComboStr (const char*,int*,const char*,int)
+3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+ImVector_erase	2
+1	T*	ImVector_erase (const T*)
+2	T*	ImVector_eraseTPtr (const T*,const T*)
+ImDrawList_AddText	2
+1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
+2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+igPushStyleVar	2
+1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
+2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
+igSetWindowFocus	2
+1	void	igSetWindowFocus ()
+2	void	igSetWindowFocusStr (const char*)
+ImVector_end	2
+1	T*	ImVector_end ()
+2	const T*	ImVector_end_const ()const
+ImVector_ImVector	2
+1	nil	ImVector_ImVector ()
+2	nil	ImVector_ImVectorVector (const ImVector)
 igSetWindowCollapsed	2
 1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
 2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
@@ -32,80 +79,57 @@ igPlotLines	2
 igListBoxHeader	2
 1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
 2	bool	igListBoxHeaderInt (const char*,int,int)
-igPlotHistogram	2
-1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotHistogramFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
 igTreeNodeExV	2
 1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
 2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
-igGetID	3
-1	ImGuiID	igGetIDStr (const char*)
-2	ImGuiID	igGetIDRange (const char*,const char*)
-3	ImGuiID	igGetIDPtr (const void*)
+igListBox	2
+1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
+2	bool	igListBoxFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+ImVec2_ImVec2	2
+1	nil	ImVec2_ImVec2 ()
+2	nil	ImVec2_ImVec2Float (float,float)
+igCollapsingHeader	2
+1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
+2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+igTreePush	2
+1	void	igTreePushStr (const char*)
+2	void	igTreePushPtr (const void*)
 igGetColorU32	3
 1	ImU32	igGetColorU32 (ImGuiCol,float)
 2	ImU32	igGetColorU32Vec4 (const ImVec4)
 3	ImU32	igGetColorU32U32 (ImU32)
-igBeginChild	2
-1	bool	igBeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags)
-2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
-ImDrawList_AddText	2
-1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
-igSelectable	2
-1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
-igListBox	2
-1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
-2	bool	igListBoxFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
-igSetWindowFocus	2
-1	void	igSetWindowFocus ()
-2	void	igSetWindowFocusStr (const char*)
-igPushID	4
-1	void	igPushIDStr (const char*)
-2	void	igPushIDRange (const char*,const char*)
-3	void	igPushIDPtr (const void*)
-4	void	igPushIDInt (int)
-igTreeNodeEx	3
-1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
-2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
-3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
-Pair_Pair	3
-1	nil	Pair_PairInt (ImGuiID,int)
-2	nil	Pair_PairFloat (ImGuiID,float)
-3	nil	Pair_PairPtr (ImGuiID,void*)
-igTreePush	2
-1	void	igTreePushStr (const char*)
-2	void	igTreePushPtr (const void*)
-TextRange_TextRange	2
-1	nil	TextRange_TextRange ()
-2	nil	TextRange_TextRangeStr (const char*,const char*)
-igPushStyleColor	2
-1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
-2	void	igPushStyleColor (ImGuiCol,const ImVec4)
 ImColor_ImColor	5
 1	nil	ImColor_ImColor ()
 2	nil	ImColor_ImColorInt (int,int,int,int)
 3	nil	ImColor_ImColorU32 (ImU32)
 4	nil	ImColor_ImColorFloat (float,float,float,float)
 5	nil	ImColor_ImColorVec4 (const ImVec4)
-igCollapsingHeader	2
-1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
-2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+ImVector_front	2
+1	T*	ImVector_front ()
+2	const T*	ImVector_front_const ()const
+ImVector_begin	2
+1	T*	ImVector_begin ()
+2	const T*	ImVector_begin_const ()const
+igPushStyleColor	2
+1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
+2	void	igPushStyleColor (ImGuiCol,const ImVec4)
+igTreeNodeEx	3
+1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
+2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
+3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
+igSelectable	2
+1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+ImVector_find	2
+1	T*	ImVector_find (const T)
+2	const T*	ImVector_find_const (const T)const
 igMenuItem	2
 1	bool	igMenuItemBool (const char*,const char*,bool,bool)
 2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
-igSetWindowPos	2
-1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
-ImVec2_ImVec2	2
-1	nil	ImVec2_ImVec2 ()
-2	nil	ImVec2_ImVec2Float (float,float)
-igTreeNode	3
-1	bool	igTreeNodeStr (const char*)
-2	bool	igTreeNodeStrStr (const char*,const char*,...)
-3	bool	igTreeNodePtr (const void*,const char*,...)
+igSetWindowSize	2
+1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
 igTreeNodeV	2
 1	bool	igTreeNodeVStr (const char*,const char*,va_list)
 2	bool	igTreeNodeVPtr (const void*,const char*,va_list)
-77 overloaded
+93 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,65 +1,73 @@
-{"ImGuiColumnsFlags":"int",
-"ImFontConfig":"struct ImFontConfig",
-"ImS32":"signed int",
-"ImGuiTreeNodeFlags":"int",
-"ImGuiFocusedFlags":"int",
-"ImGuiHoveredFlags":"int",
-"ImU64":"uint64_t",
-"ImGuiID":"unsigned int",
-"ImGuiStyle":"struct ImGuiStyle",
-"ImDrawData":"struct ImDrawData",
-"ImDrawListFlags":"int",
-"ImGuiBackendFlags":"int",
-"ImGuiMouseCursor":"int",
-"ImDrawListSharedData":"struct ImDrawListSharedData",
-"ImGuiStyleVar":"int",
-"ImGuiDir":"int",
-"ImFontAtlas":"struct ImFontAtlas",
-"ImGuiCol":"int",
-"ImGuiOnceUponAFrame":"struct ImGuiOnceUponAFrame",
-"value_type":"T",
-"iterator":"value_type*",
-"ImGuiTextFilter":"struct ImGuiTextFilter",
-"ImDrawIdx":"unsigned short",
-"ImGuiComboFlags":"int",
-"ImDrawCornerFlags":"int",
-"ImWchar":"unsigned short",
-"const_iterator":"const value_type*",
-"ImDrawVert":"struct ImDrawVert",
-"GlyphRangesBuilder":"struct GlyphRangesBuilder",
-"ImVec4":"struct ImVec4",
-"ImGuiSizeCallback":"void(*)(ImGuiSizeCallbackData* data);",
-"ImGuiConfigFlags":"int",
-"ImGuiTextBuffer":"struct ImGuiTextBuffer",
-"ImGuiContext":"struct ImGuiContext",
-"ImColor":"struct ImColor",
-"ImGuiInputTextCallback":"int(*)(ImGuiInputTextCallbackData *data);",
-"ImVec2":"struct ImVec2",
-"ImFontGlyph":"struct ImFontGlyph",
-"ImGuiWindowFlags":"int",
-"Pair":"struct Pair",
-"ImGuiKey":"int",
-"ImGuiInputTextFlags":"int",
-"ImGuiListClipper":"struct ImGuiListClipper",
-"ImGuiDataType":"int",
-"ImDrawChannel":"struct ImDrawChannel",
-"ImGuiIO":"struct ImGuiIO",
-"ImGuiStorage":"struct ImGuiStorage",
-"ImGuiCond":"int",
-"ImU32":"unsigned int",
-"ImGuiNavInput":"int",
-"ImGuiColorEditFlags":"int",
-"ImFont":"struct ImFont",
-"ImGuiSelectableFlags":"int",
-"ImDrawCallback":"void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
-"ImTextureID":"void*",
-"ImDrawList":"struct ImDrawList",
-"TextRange":"struct TextRange",
-"CustomRect":"struct CustomRect",
-"ImFontAtlasFlags":"int",
-"ImGuiInputTextCallbackData":"struct ImGuiInputTextCallbackData",
-"ImDrawCmd":"struct ImDrawCmd",
-"ImGuiSizeCallbackData":"struct ImGuiSizeCallbackData",
-"ImS64":"int64_t",
-"ImGuiDragDropFlags":"int",
-"ImGuiPayload":"struct ImGuiPayload"}
+{
+  "ImColor": "struct ImColor",
+  "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
+  "ImDrawChannel": "struct ImDrawChannel",
+  "ImDrawCmd": "struct ImDrawCmd",
+  "ImDrawCornerFlags": "int",
+  "ImDrawData": "struct ImDrawData",
+  "ImDrawIdx": "unsigned short",
+  "ImDrawList": "struct ImDrawList",
+  "ImDrawListFlags": "int",
+  "ImDrawListSharedData": "struct ImDrawListSharedData",
+  "ImDrawListSplitter": "struct ImDrawListSplitter",
+  "ImDrawVert": "struct ImDrawVert",
+  "ImFont": "struct ImFont",
+  "ImFontAtlas": "struct ImFontAtlas",
+  "ImFontAtlasCustomRect": "struct ImFontAtlasCustomRect",
+  "ImFontAtlasFlags": "int",
+  "ImFontConfig": "struct ImFontConfig",
+  "ImFontGlyph": "struct ImFontGlyph",
+  "ImFontGlyphRangesBuilder": "struct ImFontGlyphRangesBuilder",
+  "ImGuiBackendFlags": "int",
+  "ImGuiCol": "int",
+  "ImGuiColorEditFlags": "int",
+  "ImGuiComboFlags": "int",
+  "ImGuiCond": "int",
+  "ImGuiConfigFlags": "int",
+  "ImGuiContext": "struct ImGuiContext",
+  "ImGuiDataType": "int",
+  "ImGuiDir": "int",
+  "ImGuiDragDropFlags": "int",
+  "ImGuiFocusedFlags": "int",
+  "ImGuiHoveredFlags": "int",
+  "ImGuiID": "unsigned int",
+  "ImGuiIO": "struct ImGuiIO",
+  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData *data);",
+  "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
+  "ImGuiInputTextFlags": "int",
+  "ImGuiKey": "int",
+  "ImGuiListClipper": "struct ImGuiListClipper",
+  "ImGuiMouseCursor": "int",
+  "ImGuiNavInput": "int",
+  "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
+  "ImGuiPayload": "struct ImGuiPayload",
+  "ImGuiSelectableFlags": "int",
+  "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
+  "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
+  "ImGuiStorage": "struct ImGuiStorage",
+  "ImGuiStoragePair": "struct ImGuiStoragePair",
+  "ImGuiStyle": "struct ImGuiStyle",
+  "ImGuiStyleVar": "int",
+  "ImGuiTabBarFlags": "int",
+  "ImGuiTabItemFlags": "int",
+  "ImGuiTextBuffer": "struct ImGuiTextBuffer",
+  "ImGuiTextFilter": "struct ImGuiTextFilter",
+  "ImGuiTextRange": "struct ImGuiTextRange",
+  "ImGuiTreeNodeFlags": "int",
+  "ImGuiWindowFlags": "int",
+  "ImS16": "signed short",
+  "ImS32": "signed int",
+  "ImS64": "int64_t",
+  "ImS8": "signed char",
+  "ImTextureID": "void*",
+  "ImU16": "unsigned short",
+  "ImU32": "unsigned int",
+  "ImU64": "uint64_t",
+  "ImU8": "unsigned char",
+  "ImVec2": "struct ImVec2",
+  "ImVec4": "struct ImVec4",
+  "ImWchar": "unsigned short",
+  "const_iterator": "const value_type*",
+  "iterator": "value_type*",
+  "value_type": "T"
+}
--- a/generator/output/typedefs_dict.lua
+++ b/generator/output/typedefs_dict.lua
@@ -1,6 +1,4 @@
 local defs = {}
-defs["CustomRect"] = "struct CustomRect"
-defs["GlyphRangesBuilder"] = "struct GlyphRangesBuilder"
 defs["ImColor"] = "struct ImColor"
 defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
 defs["ImDrawChannel"] = "struct ImDrawChannel"
@@ -11,16 +9,18 @@ defs["ImDrawIdx"] = "unsigned short"
 defs["ImDrawList"] = "struct ImDrawList"
 defs["ImDrawListFlags"] = "int"
 defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
+defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
 defs["ImDrawVert"] = "struct ImDrawVert"
 defs["ImFont"] = "struct ImFont"
 defs["ImFontAtlas"] = "struct ImFontAtlas"
+defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
 defs["ImFontAtlasFlags"] = "int"
 defs["ImFontConfig"] = "struct ImFontConfig"
 defs["ImFontGlyph"] = "struct ImFontGlyph"
+defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
 defs["ImGuiBackendFlags"] = "int"
 defs["ImGuiCol"] = "int"
 defs["ImGuiColorEditFlags"] = "int"
-defs["ImGuiColumnsFlags"] = "int"
 defs["ImGuiComboFlags"] = "int"
 defs["ImGuiCond"] = "int"
 defs["ImGuiConfigFlags"] = "int"
@@ -45,22 +45,28 @@ defs["ImGuiSelectableFlags"] = "int"
 defs["ImGuiSizeCallback"] = "void(*)(ImGuiSizeCallbackData* data);"
 defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
 defs["ImGuiStorage"] = "struct ImGuiStorage"
+defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
 defs["ImGuiStyle"] = "struct ImGuiStyle"
 defs["ImGuiStyleVar"] = "int"
+defs["ImGuiTabBarFlags"] = "int"
+defs["ImGuiTabItemFlags"] = "int"
 defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
 defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
+defs["ImGuiTextRange"] = "struct ImGuiTextRange"
 defs["ImGuiTreeNodeFlags"] = "int"
 defs["ImGuiWindowFlags"] = "int"
+defs["ImS16"] = "signed short"
 defs["ImS32"] = "signed int"
 defs["ImS64"] = "int64_t"
+defs["ImS8"] = "signed char"
 defs["ImTextureID"] = "void*"
+defs["ImU16"] = "unsigned short"
 defs["ImU32"] = "unsigned int"
 defs["ImU64"] = "uint64_t"
+defs["ImU8"] = "unsigned char"
 defs["ImVec2"] = "struct ImVec2"
 defs["ImVec4"] = "struct ImVec4"
 defs["ImWchar"] = "unsigned short"
-defs["Pair"] = "struct Pair"
-defs["TextRange"] = "struct TextRange"
 defs["const_iterator"] = "const value_type*"
 defs["iterator"] = "value_type*"
 defs["value_type"] = "T"
--- a/2
+++ b/2
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+file(GLOB CIMGUI_TEST_SOURCES
+    main.c
+)
+
+add_executable(cimgui_test ${CIMGUI_TEST_SOURCES})
+
+set_target_properties(cimgui_test PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set_property(TARGET cimgui_test PROPERTY C_STANDARD 99)
+
+target_compile_definitions(cimgui_test PRIVATE CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1)
+target_link_libraries(cimgui_test PRIVATE cimgui)
--- a/test/main.c
+++ b/test/main.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <assert.h>
+#include "../cimgui.h"
+
+int main(void)
+{
+  assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
+                                          sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert),
+                                          sizeof(ImDrawIdx)));
+  printf("CreateContext() - v%s\n", igGetVersion());
+  igCreateContext(NULL);
+  ImGuiIO *io = igGetIO();
+
+  unsigned char *text_pixels = NULL;
+  int text_w, text_h;
+  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+
+  for (int n = 0; n < 20; n++) {
+    printf("NewFrame() %d\n", n);
+
+    ImVec2 display_size;
+    display_size.x = 1920;
+    display_size.y = 1080;
+    io->DisplaySize = display_size;
+    io->DeltaTime = 1.0f / 60.0f;
+    igNewFrame();
+
+    static float f = 0.0f;
+    igText("Hello World!");
+    igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 1.0f);
+    igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+    igShowDemoWindow(NULL);
+
+    igRender();
+  }
+
+  printf("DestroyContext()\n");
+  igDestroyContext(NULL);
+
+  return 0;
+}
--- a/testbuildc/build.bat
+++ b/testbuildc/build.bat
@@ -1,6 +0,0 @@
-set PATH=%PATH%;C:\mingw32\bin;
-::set PATH=%PATH%;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
-::gcc -std=c99 -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-::gcc  -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-gcc  -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k
--- a/testbuildc/cimguitest.c
+++ b/testbuildc/cimguitest.c
@@ -1,5 +0,0 @@
-#include "../cimgui.h"
-
-void main(void)
-{
-}
--- a/testbuildc/testcl.bat
+++ b/testbuildc/testcl.bat
@@ -1,13 +0,0 @@
-::set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
-::gcc -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h > 11.txt
-
-::set PATH=%PATH%;C:\luaGL;
-::set PATH=%PATH%;C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\bin\Hostx64\x64;
-
-::ejecutar en cmd esto 
-::"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-::cl /P /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ../imgui/imgui.h 
-:: > clout.txt
-cl  /P /DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k
Author	SHA1	Message	Date
sonoro1234	1c65ee2bdc	pull imgui 1.73	2019-09-25 12:44:17 +02:00
sonoro1234	0f5aa16fe8	drop ImVector functions	2019-09-25 12:39:51 +02:00
Victor Bombi	cde83f9fe8	Merge pull request #102 from lmariscal/ci Update CMake to a modern module system and create simple test	2019-08-01 18:41:43 +02:00
sonoro1234	eefd229b68	readme: use cimgui travis account	2019-08-01 18:37:28 +02:00
Leonardo Mariscal	df61f2c552	Add Windows to travis CI	2019-08-01 07:59:37 -05:00
sonoro1234	c0d75f6f8d	pull imgui 1.72b	2019-08-01 12:23:17 +02:00
Leonardo Mariscal	14e8be9af1	Update CMake to a more modern module management system and create simple test based on imgui null example	2019-07-31 19:37:51 -05:00
Victor Bombi	ccf494d1c3	Merge pull request #101 from AODQ/master adds generator shell script	2019-07-31 10:13:05 +02:00
aodq	8c817de195	adds generator shell script	2019-07-30 23:15:39 -04:00
sonoro1234	8f3ab64917	Do with ImGuiStoragePair what was done with Pair (unnamed union correction)	2019-07-29 12:42:50 +02:00
sonoro1234	14251bb176	update readme	2019-07-29 12:20:19 +02:00
sonoro1234	e61825224b	pull imgui 1.72 and regenerate	2019-07-29 12:17:38 +02:00
sonoro1234	94ab1adf9e	generator corrections for vector<type>name to vector<type> name and take care of Pair not present (after 1.71)	2019-07-29 12:16:29 +02:00
sonoro1234	094a52e6b6	revert ApplicationServices linking if APPLE(only needed in 1.71)	2019-07-29 12:14:13 +02:00
sonoro1234	f7520ee03d	Revert "revert last commit see: https://github.com/cimgui/cimgui/pull/98#issuecomment-513867796 " This reverts commit `b0c65144ab`. will have to be reverted in 1.72	2019-07-22 19:53:20 +02:00
sonoro1234	b0c65144ab	revert last commit see: https://github.com/cimgui/cimgui/pull/98#issuecomment-513867796	2019-07-22 19:14:41 +02:00
Victor Bombi	50ded57ba3	Merge pull request #98 from mellinoe/fix-macos-build Link to ApplicationServices.framework on macOS.	2019-07-17 19:39:22 +02:00
Eric Mellino	50ae38591a	Link to ApplicationServices.framework on macOS.	2019-07-17 09:52:54 -07:00
sonoro1234	975a735d38	rename generator2 to generator and generator to generator_old	2019-06-25 10:50:04 +02:00
sonoro1234	2b03f434d4	one day I wont forget readme	2019-06-12 19:47:52 +02:00
sonoro1234	37c52332f4	pull imgui 1.71 and generate	2019-06-12 19:45:37 +02:00
sonoro1234	84932b4830	update README.md	2019-05-07 15:56:11 +02:00
sonoro1234	022f60320f	add characters \| < to defaults parsing	2019-05-06 16:41:40 +02:00
sonoro1234	1aeb9ad132	pull imgui 1.70 and generate	2019-05-06 15:59:27 +02:00
sonoro1234	648cf587c9	README.md update for 1.69	2019-04-29 11:45:37 +02:00
Victor Bombi	aa99302d24	Merge pull request #94 from nihuynh/Makefile_fix fixing makefile	2019-04-16 12:45:18 +02:00
Nicolas Huynh	4fca16eada	fixing makefile	2019-04-16 02:15:52 +02:00
sonoro1234	ff404142f4	readme : use generator before compilation	2019-04-03 13:50:49 +02:00
sonoro1234	4be0522d9f	pull imgui 1.69 and generate	2019-03-13 17:05:22 +01:00
sonoro1234	bc6f6e664e	readme use generator2.bat	2019-03-06 11:00:21 +01:00
sonoro1234	343a8e4ea5	update README.md	2019-02-19 13:18:20 +01:00
Victor Bombi	0d4fa8b8bc	Merge pull request #91 from cimgui/ImVector Im vector	2019-02-19 13:13:02 +01:00
sonoro1234	666a687e0f	pull imgui 1.68	2019-02-19 13:11:06 +01:00
sonoro1234	806ff124a1	build test -Wall std=99 -Wpedantic	2019-02-18 12:33:12 +01:00
sonoro1234	186ebd8f06	drop comments and update README.md for top level functions	2019-02-15 16:54:23 +01:00
sonoro1234	d331453422	correct issue #88 (Pair union member)	2019-02-15 12:24:06 +01:00
sonoro1234	e125f405e3	more README.md update	2019-02-15 12:10:52 +01:00
sonoro1234	498f9802d1	update README.md	2019-02-15 11:17:51 +01:00
sonoro1234	6c9a018705	drop ImVector:contains() for not applicable types	2019-02-14 20:15:33 +01:00
sonoro1234	347d8d58b0	with templated structs generated	2019-02-14 13:05:49 +01:00
sonoro1234	161385607d	not templated structs generated	2019-02-12 19:59:39 +01:00
sonoro1234	23f2a1f026	get template typenames generated	2019-02-12 19:40:00 +01:00
sonoro1234	490effa341	get template typenames	2019-02-12 18:52:00 +01:00
sonoro1234	0d864f94bd	ImVector functions inclusion	2019-02-12 12:16:21 +01:00
sonoro1234	55f1afa2db	update readme	2019-01-27 22:51:31 +01:00
sonoro1234	71a9410ce6	cpp2ffi take care or type and name separated by * without spaces	2019-01-27 17:20:07 +01:00
Victor Bombi	036d2c1f9e	Merge pull request #86 from mellinoe/update-to-1.67 Update imgui submodule to 1.67 and re-generate.	2019-01-17 16:43:00 +01:00
Eric Mellino	b5c7ed5862	Update imgui submodule to 1.67 and re-generate.	2019-01-14 18:42:10 -08:00
sonoro1234	d2ee8fc7dd	improve functionD_re	2018-12-24 12:28:37 +01:00
sonoro1234	593867e320	generator2 files	2018-12-23 19:53:14 +01:00
sonoro1234	907c2fddce	generator.lua take care of type and name separated by * without spaces	2018-12-21 11:59:35 +01:00
sonoro1234	67f3b097a5	pull imgui 1.66b	2018-12-03 16:46:17 +01:00
sonoro1234	fd0199809d	json: TAB 2 spaces solves #82 ?	2018-12-03 10:02:33 +01:00
sonoro1234	d174a02a0f	indented json files	2018-12-02 18:37:52 +01:00
sonoro1234	291922f72c	alphabetical sorted json files	2018-12-02 11:15:17 +01:00
Victor Bombi	7d963113c9	Merge pull request #84 from dos1/static cmake: add an option to build as a static library	2018-11-28 19:37:05 +01:00
Sebastian Krzyszkowiak	8cbdca3344	cmake: add an option to build as a static library Useful when including cimgui as a subproject in another CMake project.	2018-11-28 18:19:52 +01:00