pull imgui master 1.79 and generate

This way they can be copied and `https://github.com/cimgui/cimgui.git` won't be shortened to `cimgui/cimgui.git`.

.travis.yml

@@ -1,5 +1,5 @@
 language: cpp
-dist: trusty
+dist: focal
 
 os:
   - linux
@@ -10,20 +10,11 @@ compiler:
   - gcc
   - clang
 
-env:
-  - MSBUILD_PATH="c:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin"
-
 script:
   - 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
+  - cmake --build .
   - |
     if [ "$TRAVIS_OS_NAME" == "windows" ]; then
       ./Debug/cimgui_test.exe

CMakeLists.txt

@@ -12,6 +12,15 @@ file(GLOB IMGUI_SOURCES
 )
 
 set(IMGUI_STATIC "no" CACHE STRING "Build as a static library")
+set(IMGUI_FREETYPE "no" CACHE STRING "Build with freetype library")
+set(IMGUI_LIBRARIES )
+
+if(IMGUI_FREETYPE)
+	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
+	list(APPEND IMGUI_LIBRARIES freetype)
+	list(APPEND IMGUI_SOURCES imgui/misc/freetype/imgui_freetype.cpp)
+	add_definitions("-DCIMGUI_FREETYPE=1")
+endif(IMGUI_FREETYPE)
 
 #add library and link
 if (IMGUI_STATIC)
@@ -22,14 +31,15 @@ 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\)")
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t__declspec\(dllexport\))
 else (WIN32)
-    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" ")
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t)
 endif (WIN32)
 
 target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/imgui)
 set_target_properties(cimgui PROPERTIES PREFIX "")
+target_link_libraries(cimgui ${IMGUI_LIBRARIES})
 
 #install
 install(TARGETS cimgui

Makefile

@@ -12,6 +12,8 @@ CXXFLAGS=-O2 -fno-exceptions -fno-rtti
 
 UNAME_S := $(shell uname -s)
 
+AR := ar -rc
+
 ifeq ($(UNAME_S), Linux) #LINUX
 	ECHO_MESSAGE = "Linux"
 
@@ -49,6 +51,9 @@ endif
 all:$(OUTPUTNAME)
 	@echo Build complete for $(ECHO_MESSAGE)
 
+static:$(OBJS)
+	$(AR) libcimgui.a $(OBJS)
+
 $(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
 
@@ -60,4 +65,4 @@ fclean: clean
 
 re: fclean all
 
-.PHONY: all clean fclean re
+.PHONY: all clean fclean re static

README.md

@@ -11,7 +11,7 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.76 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.79 of Dear ImGui with internal api]
 * only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
 * if you are interested in imgui implementations you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
 * All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
@@ -20,10 +20,11 @@ Notes:
 # compilation
 
 * clone 
-  * git clone --recursive https://github.com/cimgui/cimgui.git
-  * git submodule update
+  * `git clone --recursive https://github.com/cimgui/cimgui.git`
+  * `git submodule update`
 * compile 
   * using makefile on linux/macOS/mingw (Or use CMake to generate project)
+  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location)
   * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
 
 # using generator
@@ -32,7 +33,7 @@ Notes:
 * you will need LuaJIT (https://github.com/LuaJIT/LuaJIT.git better 2.1 branch) or precompiled for linux/macOS/windows in https://luapower.com/luajit/download
 * you need to use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC). (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired implementations and whether imgui_internal is generated or not. 
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired implementations and whether imgui_internal is generated or not and Freetype2 is used or not. 
 * edit config_generator.lua for adding includes needed by your chosen implementations (vulkan needs that).
 * Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp` 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. 
@@ -50,19 +51,23 @@ Notes:
   * cimguiname : the name without overloading (this should be used if there is not ov_cimguiname)
   * ret : the return type
   * retref : is set 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)
+  * argsT : an array of collections (each one with type: argument type and name: the argument name, when the argument is a function pointer also ret: return type and signature: the function signature)
   * 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
   * defaults : a collection in which key is argument name and value is the default value.
   * manual : will be true if this function is hand-written (not generated)
+  * skipped : will be true if this function is not generated (and not hand-written)
   * isvararg : is set if some argument is a vararg
-  * constructor : is set if the function is a constructor for a class
-  * destructor : is set if the function is a destructor for a class
+  * constructor : is set if the function is a constructor for a class.
+  * destructor : is set if the function is a destructor for a class but not just a default destructor.
+  * realdestructor : is set if the function is a destructor for a class
   * templated : is set if the function belongs to a templated class (ImVector)
   * templatedgen: is set if the function belongs to a struct generated from template (ImVector_ImWchar)
   * nonUDT : if present the original function was returning a user defined type so that signature has been changed to accept a pointer to the UDT as first argument.
+  * location : name of the header file and linenumber this function comes from. (imgui:000, internal:123, imgui_impl_xxx:123)
+  * is_static_function : is setted when it is an struct static function.
 ### structs_and_enums description
-* Is is a collection with two items:
+* Is is a collection with three items:
   * under key enums we get the enums collection in which each key is the enum tagname and the value is an array of the ordered values represented as a collection with keys
     * name : the name of this enum value
     * value : the C string
@@ -71,7 +76,9 @@ Notes:
     * type : the type of the struct member
     * template_type : if type has a template argument (as ImVector) here will be
     * name : the name of the struct member
-	* bitfield : the bitfield width (in case it is a bitfield)
+    * size : the number of array elements (when it is an array)
+    * bitfield : the bitfield width (in case it is a bitfield)
+  * under key locations we get the locations collection in which each key is the enum tagname or the struct name and the value is the name of the header file and line number this comes from.
 # usage
 
 * use whatever method is in ImGui c++ namespace in the original [imgui.h](https://github.com/ocornut/imgui/blob/master/imgui.h) by prepending `ig`
@@ -81,13 +88,16 @@ Notes:
 
 # example bindings based on cimgui
 
-* [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
+* [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
 * [ImGui.NET](https://github.com/mellinoe/ImGui.NET)
-* [ImGuiCS](https://github.com/conatuscreative/ImGuiCS)
+* [nimgl/imgui](https://github.com/nimgl/imgui)
+* [kotlin-imgui](https://github.com/Dominaezzz/kotlin-imgui)
+* [CImGui.jl](https://github.com/Gnimuc/CImGui.jl)
+* [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
+* [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
 * [imgui-rs](https://github.com/Gekkio/imgui-rs)
 * [imgui-pas](https://github.com/dpethes/imgui-pas)
-* [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
-* [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
+
 
 # C examples based on cimgui
 

cimgui.cpp

@@ -1,8 +1,11 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.76" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.79" from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
 
 #include "./imgui/imgui.h"
+#ifdef CIMGUI_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
@@ -598,9 +601,9 @@ CIMGUI_API bool igSmallButton(const char* label)
 {
     return ImGui::SmallButton(label);
 }
-CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size)
+CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size,ImGuiButtonFlags flags)
 {
-    return ImGui::InvisibleButton(str_id,size);
+    return ImGui::InvisibleButton(str_id,size,flags);
 }
 CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir)
 {
@@ -654,113 +657,113 @@ CIMGUI_API bool igComboStr(const char* label,int* current_item,const char* items
 {
     return ImGui::Combo(label,current_item,items_separated_by_zeros,popup_max_height_in_items);
 }
-CIMGUI_API bool igComboFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)
+CIMGUI_API bool igComboFnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)
 {
     return ImGui::Combo(label,current_item,items_getter,data,items_count,popup_max_height_in_items);
 }
-CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,float power)
+CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
 {
-    return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power);
+    return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
 }
-CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format)
+CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragInt(label,v,v_speed,v_min,v_max,format);
+    return ImGui::DragInt(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format)
+CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format);
+    return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format)
+CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format);
+    return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format)
+CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format);
+    return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max)
+CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
 {
-    return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max);
+    return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
 }
-CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,float power)
+CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,power);
+    return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,flags);
 }
-CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,float power)
+CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,power);
+    return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,flags);
 }
-CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderFloat(label,v,v_min,v_max,format,power);
+    return ImGui::SliderFloat(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderFloat2(label,v,v_min,v_max,format,power);
+    return ImGui::SliderFloat2(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderFloat3(label,v,v_min,v_max,format,power);
+    return ImGui::SliderFloat3(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderFloat4(label,v,v_min,v_max,format,power);
+    return ImGui::SliderFloat4(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format)
+CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format);
+    return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format,flags);
 }
-CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format)
+CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderInt(label,v,v_min,v_max,format);
+    return ImGui::SliderInt(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format)
+CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderInt2(label,v,v_min,v_max,format);
+    return ImGui::SliderInt2(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format)
+CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderInt3(label,v,v_min,v_max,format);
+    return ImGui::SliderInt3(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format)
+CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderInt4(label,v,v_min,v_max,format);
+    return ImGui::SliderInt4(label,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,float power)
+CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,power);
+    return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,flags);
 }
-CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,float power)
+CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,power);
+    return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,flags);
 }
-CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power)
+CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,power);
+    return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format)
+CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::VSliderInt(label,size,v,v_min,v_max,format);
+    return ImGui::VSliderInt(label,size,v,v_min,v_max,format,flags);
 }
-CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,float power)
+CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,power);
+    return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,flags);
 }
 CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
@@ -938,7 +941,7 @@ CIMGUI_API bool igListBoxStr_arr(const char* label,int* current_item,const char*
 {
     return ImGui::ListBox(label,current_item,items,items_count,height_in_items);
 }
-CIMGUI_API bool igListBoxFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)
+CIMGUI_API bool igListBoxFnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)
 {
     return ImGui::ListBox(label,current_item,items_getter,data,items_count,height_in_items);
 }
@@ -958,7 +961,7 @@ CIMGUI_API void igPlotLinesFloatPtr(const char* label,const float* values,int va
 {
     return ImGui::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
 }
-CIMGUI_API void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
+CIMGUI_API void igPlotLinesFnFloatPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
 {
     return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
 }
@@ -966,7 +969,7 @@ CIMGUI_API void igPlotHistogramFloatPtr(const char* label,const float* values,in
 {
     return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
 }
-CIMGUI_API void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
+CIMGUI_API void igPlotHistogramFnFloatPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
 {
     return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
 }
@@ -1037,26 +1040,10 @@ CIMGUI_API void igSetTooltipV(const char* fmt,va_list args)
 {
     return ImGui::SetTooltipV(fmt,args);
 }
-CIMGUI_API void igOpenPopup(const char* str_id)
-{
-    return ImGui::OpenPopup(str_id);
-}
 CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
 {
     return ImGui::BeginPopup(str_id,flags);
 }
-CIMGUI_API bool igBeginPopupContextItem(const char* str_id,ImGuiMouseButton mouse_button)
-{
-    return ImGui::BeginPopupContextItem(str_id,mouse_button);
-}
-CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,ImGuiMouseButton mouse_button,bool also_over_items)
-{
-    return ImGui::BeginPopupContextWindow(str_id,mouse_button,also_over_items);
-}
-CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiMouseButton mouse_button)
-{
-    return ImGui::BeginPopupContextVoid(str_id,mouse_button);
-}
 CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags)
 {
     return ImGui::BeginPopupModal(name,p_open,flags);
@@ -1065,18 +1052,34 @@ CIMGUI_API void igEndPopup()
 {
     return ImGui::EndPopup();
 }
-CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,ImGuiMouseButton mouse_button)
+CIMGUI_API void igOpenPopup(const char* str_id,ImGuiPopupFlags popup_flags)
 {
-    return ImGui::OpenPopupOnItemClick(str_id,mouse_button);
+    return ImGui::OpenPopup(str_id,popup_flags);
 }
-CIMGUI_API bool igIsPopupOpenStr(const char* str_id)
+CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags)
 {
-    return ImGui::IsPopupOpen(str_id);
+    return ImGui::OpenPopupOnItemClick(str_id,popup_flags);
 }
 CIMGUI_API void igCloseCurrentPopup()
 {
     return ImGui::CloseCurrentPopup();
 }
+CIMGUI_API bool igBeginPopupContextItem(const char* str_id,ImGuiPopupFlags popup_flags)
+{
+    return ImGui::BeginPopupContextItem(str_id,popup_flags);
+}
+CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,ImGuiPopupFlags popup_flags)
+{
+    return ImGui::BeginPopupContextWindow(str_id,popup_flags);
+}
+CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiPopupFlags popup_flags)
+{
+    return ImGui::BeginPopupContextVoid(str_id,popup_flags);
+}
+CIMGUI_API bool igIsPopupOpenStr(const char* str_id,ImGuiPopupFlags flags)
+{
+    return ImGui::IsPopupOpen(str_id,flags);
+}
 CIMGUI_API void igColumns(int count,const char* id,bool border)
 {
     return ImGui::Columns(count,id,border);
@@ -1125,6 +1128,10 @@ CIMGUI_API void igEndTabItem()
 {
     return ImGui::EndTabItem();
 }
+CIMGUI_API bool igTabItemButton(const char* label,ImGuiTabItemFlags flags)
+{
+    return ImGui::TabItemButton(label,flags);
+}
 CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
 {
     return ImGui::SetTabItemClosed(tab_or_docked_window_label);
@@ -1325,6 +1332,14 @@ CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in)
 {
     return ImGui::ColorConvertFloat4ToU32(in);
 }
+CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float* out_h,float* out_s,float* out_v)
+{
+    return ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
+}
+CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,float* out_g,float* out_b)
+{
+    return ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
+}
 CIMGUI_API int igGetKeyIndex(ImGuiKey imgui_key)
 {
     return ImGui::GetKeyIndex(imgui_key);
@@ -1501,6 +1516,14 @@ CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackDat
 {
     return self->InsertChars(pos,text,text_end);
 }
+CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self)
+{
+    return self->SelectAll();
+}
+CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self)
+{
+    return self->ClearSelection();
+}
 CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
 {
     return self->HasSelection();
@@ -1705,18 +1728,14 @@ CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
 {
     return self->BuildSortByKey();
 }
-CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
+CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void)
 {
-    return IM_NEW(ImGuiListClipper)(items_count,items_height);
+    return IM_NEW(ImGuiListClipper)();
 }
 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);
@@ -1725,6 +1744,10 @@ CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
 {
     return self->End();
 }
+CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
+{
+    return self->Step();
+}
 CIMGUI_API ImColor* ImColor_ImColorNil(void)
 {
     return IM_NEW(ImColor)();
@@ -1753,9 +1776,9 @@ CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
 {
     return self->SetHSV(h,s,v,a);
 }
-CIMGUI_API void ImColor_HSV(ImColor *pOut,ImColor* self,float h,float s,float v,float a)
+CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a)
 {
-    *pOut = self->HSV(h,s,v,a);
+    *pOut = ImColor::HSV(h,s,v,a);
 }
 CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
 {
@@ -1969,14 +1992,6 @@ CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
 {
     return self->ChannelsSetCurrent(n);
 }
-CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
-{
-    return self->Clear();
-}
-CIMGUI_API void ImDrawList_ClearFreeMemory(ImDrawList* self)
-{
-    return self->ClearFreeMemory();
-}
 CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count)
 {
     return self->PrimReserve(idx_count,vtx_count);
@@ -2009,13 +2024,29 @@ CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec
 {
     return self->PrimVtx(pos,uv,col);
 }
-CIMGUI_API void ImDrawList_UpdateClipRect(ImDrawList* self)
+CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self)
 {
-    return self->UpdateClipRect();
+    return self->_ResetForNewFrame();
 }
-CIMGUI_API void ImDrawList_UpdateTextureID(ImDrawList* self)
+CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self)
 {
-    return self->UpdateTextureID();
+    return self->_ClearFreeMemory();
+}
+CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self)
+{
+    return self->_PopUnusedDrawCmd();
+}
+CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self)
+{
+    return self->_OnChangedClipRect();
+}
+CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self)
+{
+    return self->_OnChangedTextureID();
+}
+CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self)
+{
+    return self->_OnChangedVtxOffset();
 }
 CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void)
 {
@@ -2193,15 +2224,15 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self
 {
     return self->GetGlyphRangesVietnamese();
 }
-CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
+CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,int width,int height)
 {
-    return self->AddCustomRectRegular(id,width,height);
+    return self->AddCustomRectRegular(width,height);
 }
 CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)
 {
     return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
 }
-CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
+CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
 {
     return self->GetCustomRectByIndex(index);
 }
@@ -2269,9 +2300,9 @@ CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
 {
     return self->GrowIndex(new_size);
 }
-CIMGUI_API void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)
+CIMGUI_API void ImFont_AddGlyph(ImFont* self,const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)
 {
-    return self->AddGlyph(c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x);
+    return self->AddGlyph(src_cfg,c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x);
 }
 CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)
 {
@@ -2449,6 +2480,30 @@ CIMGUI_API double igImPowdouble(double x,double y)
 {
     return ImPow(x,y);
 }
+CIMGUI_API float igImLogFloat(float x)
+{
+    return ImLog(x);
+}
+CIMGUI_API double igImLogdouble(double x)
+{
+    return ImLog(x);
+}
+CIMGUI_API float igImAbsFloat(float x)
+{
+    return ImAbs(x);
+}
+CIMGUI_API double igImAbsdouble(double x)
+{
+    return ImAbs(x);
+}
+CIMGUI_API float igImSignFloat(float x)
+{
+    return ImSign(x);
+}
+CIMGUI_API double igImSigndouble(double x)
+{
+    return ImSign(x);
+}
 CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
 {
     *pOut = ImMin(lhs,rhs);
@@ -2541,9 +2596,9 @@ CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec
 {
     *pOut = ImTriangleClosestPoint(a,b,c,p);
 }
-CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float out_u,float out_v,float out_w)
+CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w)
 {
-    return ImTriangleBarycentricCoords(a,b,c,p,out_u,out_v,out_w);
+    return ImTriangleBarycentricCoords(a,b,c,p,*out_u,*out_v,*out_w);
 }
 CIMGUI_API float igImTriangleArea(const ImVec2 a,const ImVec2 b,const ImVec2 c)
 {
@@ -2553,42 +2608,6 @@ CIMGUI_API ImGuiDir igImGetDirQuadrantFromDelta(float dx,float dy)
 {
     return ImGetDirQuadrantFromDelta(dx,dy);
 }
-CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr,int n)
-{
-    return ImBitArrayTestBit(arr,n);
-}
-CIMGUI_API void igImBitArrayClearBit(ImU32* arr,int n)
-{
-    return ImBitArrayClearBit(arr,n);
-}
-CIMGUI_API void igImBitArraySetBit(ImU32* arr,int n)
-{
-    return ImBitArraySetBit(arr,n);
-}
-CIMGUI_API void igImBitArraySetBitRange(ImU32* arr,int n,int n2)
-{
-    return ImBitArraySetBitRange(arr,n,n2);
-}
-CIMGUI_API void ImBitVector_Create(ImBitVector* self,int sz)
-{
-    return self->Create(sz);
-}
-CIMGUI_API void ImBitVector_Clear(ImBitVector* self)
-{
-    return self->Clear();
-}
-CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self,int n)
-{
-    return self->TestBit(n);
-}
-CIMGUI_API void ImBitVector_SetBit(ImBitVector* self,int n)
-{
-    return self->SetBit(n);
-}
-CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self,int n)
-{
-    return self->ClearBit(n);
-}
 CIMGUI_API ImVec1* ImVec1_ImVec1Nil(void)
 {
     return IM_NEW(ImVec1)();
@@ -2725,6 +2744,70 @@ CIMGUI_API bool ImRect_IsInverted(ImRect* self)
 {
     return self->IsInverted();
 }
+CIMGUI_API void ImRect_ToVec4(ImVec4 *pOut,ImRect* self)
+{
+    *pOut = self->ToVec4();
+}
+CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr,int n)
+{
+    return ImBitArrayTestBit(arr,n);
+}
+CIMGUI_API void igImBitArrayClearBit(ImU32* arr,int n)
+{
+    return ImBitArrayClearBit(arr,n);
+}
+CIMGUI_API void igImBitArraySetBit(ImU32* arr,int n)
+{
+    return ImBitArraySetBit(arr,n);
+}
+CIMGUI_API void igImBitArraySetBitRange(ImU32* arr,int n,int n2)
+{
+    return ImBitArraySetBitRange(arr,n,n2);
+}
+CIMGUI_API void ImBitVector_Create(ImBitVector* self,int sz)
+{
+    return self->Create(sz);
+}
+CIMGUI_API void ImBitVector_Clear(ImBitVector* self)
+{
+    return self->Clear();
+}
+CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self,int n)
+{
+    return self->TestBit(n);
+}
+CIMGUI_API void ImBitVector_SetBit(ImBitVector* self,int n)
+{
+    return self->SetBit(n);
+}
+CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self,int n)
+{
+    return self->ClearBit(n);
+}
+CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(void)
+{
+    return IM_NEW(ImDrawListSharedData)();
+}
+CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImDrawListSharedData_SetCircleSegmentMaxError(ImDrawListSharedData* self,float max_error)
+{
+    return self->SetCircleSegmentMaxError(max_error);
+}
+CIMGUI_API void ImDrawDataBuilder_Clear(ImDrawDataBuilder* self)
+{
+    return self->Clear();
+}
+CIMGUI_API void ImDrawDataBuilder_ClearFreeMemory(ImDrawDataBuilder* self)
+{
+    return self->ClearFreeMemory();
+}
+CIMGUI_API void ImDrawDataBuilder_FlattenIntoSingleLayer(ImDrawDataBuilder* self)
+{
+    return self->FlattenIntoSingleLayer();
+}
 CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleModInt(ImGuiStyleVar idx,int v)
 {
     return IM_NEW(ImGuiStyleMod)(idx,v);
@@ -2809,26 +2892,6 @@ CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self)
 {
     return self->SelectAll();
 }
-CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void)
-{
-    return IM_NEW(ImGuiWindowSettings)();
-}
-CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self)
-{
-    return self->GetName();
-}
-CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(void)
-{
-    return IM_NEW(ImGuiSettingsHandler)();
-}
-CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self)
-{
-    IM_DELETE(self);
-}
 CIMGUI_API ImGuiPopupData* ImGuiPopupData_ImGuiPopupData(void)
 {
     return IM_NEW(ImGuiPopupData)();
@@ -2837,50 +2900,6 @@ CIMGUI_API void ImGuiPopupData_destroy(ImGuiPopupData* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API ImGuiColumnData* ImGuiColumnData_ImGuiColumnData(void)
-{
-    return IM_NEW(ImGuiColumnData)();
-}
-CIMGUI_API void ImGuiColumnData_destroy(ImGuiColumnData* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API ImGuiColumns* ImGuiColumns_ImGuiColumns(void)
-{
-    return IM_NEW(ImGuiColumns)();
-}
-CIMGUI_API void ImGuiColumns_destroy(ImGuiColumns* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API void ImGuiColumns_Clear(ImGuiColumns* self)
-{
-    return self->Clear();
-}
-CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(void)
-{
-    return IM_NEW(ImDrawListSharedData)();
-}
-CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API void ImDrawListSharedData_SetCircleSegmentMaxError(ImDrawListSharedData* self,float max_error)
-{
-    return self->SetCircleSegmentMaxError(max_error);
-}
-CIMGUI_API void ImDrawDataBuilder_Clear(ImDrawDataBuilder* self)
-{
-    return self->Clear();
-}
-CIMGUI_API void ImDrawDataBuilder_ClearFreeMemory(ImDrawDataBuilder* self)
-{
-    return self->ClearFreeMemory();
-}
-CIMGUI_API void ImDrawDataBuilder_FlattenIntoSingleLayer(ImDrawDataBuilder* self)
-{
-    return self->FlattenIntoSingleLayer();
-}
 CIMGUI_API ImGuiNavMoveResult* ImGuiNavMoveResult_ImGuiNavMoveResult(void)
 {
     return IM_NEW(ImGuiNavMoveResult)();
@@ -2929,6 +2948,46 @@ CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndexInt(int index)
 {
     return IM_NEW(ImGuiPtrOrIndex)(index);
 }
+CIMGUI_API ImGuiColumnData* ImGuiColumnData_ImGuiColumnData(void)
+{
+    return IM_NEW(ImGuiColumnData)();
+}
+CIMGUI_API void ImGuiColumnData_destroy(ImGuiColumnData* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API ImGuiColumns* ImGuiColumns_ImGuiColumns(void)
+{
+    return IM_NEW(ImGuiColumns)();
+}
+CIMGUI_API void ImGuiColumns_destroy(ImGuiColumns* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImGuiColumns_Clear(ImGuiColumns* self)
+{
+    return self->Clear();
+}
+CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void)
+{
+    return IM_NEW(ImGuiWindowSettings)();
+}
+CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self)
+{
+    return self->GetName();
+}
+CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(void)
+{
+    return IM_NEW(ImGuiSettingsHandler)();
+}
+CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self)
+{
+    IM_DELETE(self);
+}
 CIMGUI_API ImGuiContext* ImGuiContext_ImGuiContext(ImFontAtlas* shared_font_atlas)
 {
     return IM_NEW(ImGuiContext)(shared_font_atlas);
@@ -3005,19 +3064,19 @@ CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect *pOut,ImGuiWindow* self)
 {
     *pOut = self->MenuBarRect();
 }
-CIMGUI_API ImGuiItemHoveredDataBackup* ImGuiItemHoveredDataBackup_ImGuiItemHoveredDataBackup(void)
+CIMGUI_API ImGuiLastItemDataBackup* ImGuiLastItemDataBackup_ImGuiLastItemDataBackup(void)
 {
-    return IM_NEW(ImGuiItemHoveredDataBackup)();
+    return IM_NEW(ImGuiLastItemDataBackup)();
 }
-CIMGUI_API void ImGuiItemHoveredDataBackup_destroy(ImGuiItemHoveredDataBackup* self)
+CIMGUI_API void ImGuiLastItemDataBackup_destroy(ImGuiLastItemDataBackup* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImGuiItemHoveredDataBackup_Backup(ImGuiItemHoveredDataBackup* self)
+CIMGUI_API void ImGuiLastItemDataBackup_Backup(ImGuiLastItemDataBackup* self)
 {
     return self->Backup();
 }
-CIMGUI_API void ImGuiItemHoveredDataBackup_Restore(ImGuiItemHoveredDataBackup* self)
+CIMGUI_API void ImGuiLastItemDataBackup_Restore(ImGuiLastItemDataBackup* self)
 {
     return self->Restore();
 }
@@ -3093,6 +3152,10 @@ CIMGUI_API void igSetWindowCollapsedWindowPtr(ImGuiWindow* window,bool collapsed
 {
     return ImGui::SetWindowCollapsed(window,collapsed,cond);
 }
+CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,const ImVec2 pos,const ImVec2 size)
+{
+    return ImGui::SetWindowHitTestHole(window,pos,size);
+}
 CIMGUI_API void igFocusWindow(ImGuiWindow* window)
 {
     return ImGui::FocusWindow(window);
@@ -3157,6 +3220,10 @@ CIMGUI_API void igMarkIniSettingsDirtyWindowPtr(ImGuiWindow* window)
 {
     return ImGui::MarkIniSettingsDirty(window);
 }
+CIMGUI_API void igClearIniSettings()
+{
+    return ImGui::ClearIniSettings();
+}
 CIMGUI_API ImGuiWindowSettings* igCreateNewWindowSettings(const char* name)
 {
     return ImGui::CreateNewWindowSettings(name);
@@ -3173,13 +3240,17 @@ CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name)
 {
     return ImGui::FindSettingsHandler(type_name);
 }
-CIMGUI_API void igSetScrollXWindowPtr(ImGuiWindow* window,float new_scroll_x)
+CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll)
 {
-    return ImGui::SetScrollX(window,new_scroll_x);
+    return ImGui::SetNextWindowScroll(scroll);
 }
-CIMGUI_API void igSetScrollYWindowPtr(ImGuiWindow* window,float new_scroll_y)
+CIMGUI_API void igSetScrollXWindowPtr(ImGuiWindow* window,float scroll_x)
 {
-    return ImGui::SetScrollY(window,new_scroll_y);
+    return ImGui::SetScrollX(window,scroll_x);
+}
+CIMGUI_API void igSetScrollYWindowPtr(ImGuiWindow* window,float scroll_y)
+{
+    return ImGui::SetScrollY(window,scroll_y);
 }
 CIMGUI_API void igSetScrollFromPosXWindowPtr(ImGuiWindow* window,float local_x,float center_x_ratio)
 {
@@ -3241,6 +3312,10 @@ CIMGUI_API void igPushOverrideID(ImGuiID id)
 {
     return ImGui::PushOverrideID(id);
 }
+CIMGUI_API ImGuiID igGetIDWithSeed(const char* str_id_begin,const char* str_id_end,ImGuiID seed)
+{
+    return ImGui::GetIDWithSeed(str_id_begin,str_id_end,seed);
+}
 CIMGUI_API void igItemSizeVec2(const ImVec2 size,float text_baseline_y)
 {
     return ImGui::ItemSize(size,text_baseline_y);
@@ -3261,6 +3336,10 @@ CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID id,bool clip_even_when_log
 {
     return ImGui::IsClippedEx(bb,id,clip_even_when_logged);
 }
+CIMGUI_API void igSetLastItemData(ImGuiWindow* window,ImGuiID item_id,ImGuiItemStatusFlags status_flags,const ImRect item_rect)
+{
+    return ImGui::SetLastItemData(window,item_id,status_flags,item_rect);
+}
 CIMGUI_API bool igFocusableItemRegister(ImGuiWindow* window,ImGuiID id)
 {
     return ImGui::FocusableItemRegister(window,id);
@@ -3313,9 +3392,9 @@ CIMGUI_API bool igBeginChildEx(const char* name,ImGuiID id,const ImVec2 size_arg
 {
     return ImGui::BeginChildEx(name,id,size_arg,border,flags);
 }
-CIMGUI_API void igOpenPopupEx(ImGuiID id)
+CIMGUI_API void igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
-    return ImGui::OpenPopupEx(id);
+    return ImGui::OpenPopupEx(id,popup_flags);
 }
 CIMGUI_API void igClosePopupToLevel(int remaining,bool restore_focus_to_window_under_popup)
 {
@@ -3325,9 +3404,9 @@ CIMGUI_API void igClosePopupsOverWindow(ImGuiWindow* ref_window,bool restore_foc
 {
     return ImGui::ClosePopupsOverWindow(ref_window,restore_focus_to_window_under_popup);
 }
-CIMGUI_API bool igIsPopupOpenID(ImGuiID id)
+CIMGUI_API bool igIsPopupOpenID(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
-    return ImGui::IsPopupOpen(id);
+    return ImGui::IsPopupOpen(id,popup_flags);
 }
 CIMGUI_API bool igBeginPopupEx(ImGuiID id,ImGuiWindowFlags extra_flags)
 {
@@ -3449,6 +3528,10 @@ CIMGUI_API bool igIsDragDropPayloadBeingAccepted()
 {
     return ImGui::IsDragDropPayloadBeingAccepted();
 }
+CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect clip_rect)
+{
+    return ImGui::SetWindowClipRectBeforeSetChannel(window,clip_rect);
+}
 CIMGUI_API void igBeginColumns(const char* str_id,int count,ImGuiColumnsFlags flags)
 {
     return ImGui::BeginColumns(str_id,count,flags);
@@ -3501,9 +3584,13 @@ CIMGUI_API void igTabBarCloseTab(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)
 {
     return ImGui::TabBarCloseTab(tab_bar,tab);
 }
-CIMGUI_API void igTabBarQueueChangeTabOrder(ImGuiTabBar* tab_bar,const ImGuiTabItem* tab,int dir)
+CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,const ImGuiTabItem* tab,int dir)
 {
-    return ImGui::TabBarQueueChangeTabOrder(tab_bar,tab,dir);
+    return ImGui::TabBarQueueReorder(tab_bar,tab,dir);
+}
+CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar)
+{
+    return ImGui::TabBarProcessReorder(tab_bar);
 }
 CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags)
 {
@@ -3517,9 +3604,9 @@ CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiT
 {
     return ImGui::TabItemBackground(draw_list,bb,flags,col);
 }
-CIMGUI_API bool igTabItemLabelAndCloseButton(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id)
+CIMGUI_API bool igTabItemLabelAndCloseButton(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible)
 {
-    return ImGui::TabItemLabelAndCloseButton(draw_list,bb,flags,frame_padding,label,tab_id,close_button_id);
+    return ImGui::TabItemLabelAndCloseButton(draw_list,bb,flags,frame_padding,label,tab_id,close_button_id,is_contents_visible);
 }
 CIMGUI_API void igRenderText(ImVec2 pos,const char* text,const char* text_end,bool hide_text_after_hash)
 {
@@ -3589,6 +3676,10 @@ CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,const ImRect rect
 {
     return ImGui::RenderRectFilledRangeH(draw_list,rect,col,x_start_norm,x_end_norm,rounding);
 }
+CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,ImRect outer,ImRect inner,ImU32 col,float rounding)
+{
+    return ImGui::RenderRectFilledWithHole(draw_list,outer,inner,col,rounding);
+}
 CIMGUI_API void igTextEx(const char* text,const char* text_end,ImGuiTextFlags flags)
 {
     return ImGui::TextEx(text,text_end,flags);
@@ -3617,6 +3708,10 @@ CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,float* p
 {
     return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,rounding_corners);
 }
+CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec2 padding,const ImVec4 bg_col,const ImVec4 tint_col)
+{
+    return ImGui::ImageButtonEx(id,texture_id,size,uv0,uv1,padding,bg_col,tint_col);
+}
 CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)
 {
     *pOut = ImGui::GetWindowScrollbarRect(window,axis);
@@ -3637,13 +3732,13 @@ CIMGUI_API bool igButtonBehavior(const ImRect bb,ImGuiID id,bool* out_hovered,bo
 {
     return ImGui::ButtonBehavior(bb,id,out_hovered,out_held,flags);
 }
-CIMGUI_API bool igDragBehavior(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,float power,ImGuiDragFlags flags)
+CIMGUI_API bool igDragBehavior(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
 {
-    return ImGui::DragBehavior(id,data_type,p_v,v_speed,p_min,p_max,format,power,flags);
+    return ImGui::DragBehavior(id,data_type,p_v,v_speed,p_min,p_max,format,flags);
 }
-CIMGUI_API bool igSliderBehavior(const ImRect bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,float power,ImGuiSliderFlags flags,ImRect* out_grab_bb)
+CIMGUI_API bool igSliderBehavior(const ImRect bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags,ImRect* out_grab_bb)
 {
-    return ImGui::SliderBehavior(bb,id,data_type,p_v,p_min,p_max,format,power,flags,out_grab_bb);
+    return ImGui::SliderBehavior(bb,id,data_type,p_v,p_min,p_max,format,flags,out_grab_bb);
 }
 CIMGUI_API bool igSplitterBehavior(const ImRect bb,ImGuiID id,ImGuiAxis axis,float* size1,float* size2,float min_size1,float min_size2,float hover_extend,float hover_visibility_delay)
 {
@@ -3669,7 +3764,7 @@ CIMGUI_API int igDataTypeFormatString(char* buf,int buf_size,ImGuiDataType data_
 {
     return ImGui::DataTypeFormatString(buf,buf_size,data_type,p_data,format);
 }
-CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,int op,void* output,void* arg_1,const void* arg_2)
+CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,int op,void* output,const void* arg_1,const void* arg_2)
 {
     return ImGui::DataTypeApplyOp(data_type,op,output,arg_1,arg_2);
 }
@@ -3677,6 +3772,14 @@ CIMGUI_API bool igDataTypeApplyOpFromText(const char* buf,const char* initial_va
 {
     return ImGui::DataTypeApplyOpFromText(buf,initial_value_buf,data_type,p_data,format);
 }
+CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,const void* arg_1,const void* arg_2)
+{
+    return ImGui::DataTypeCompare(data_type,arg_1,arg_2);
+}
+CIMGUI_API bool igDataTypeClamp(ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max)
+{
+    return ImGui::DataTypeClamp(data_type,p_data,p_min,p_max);
+}
 CIMGUI_API bool igInputTextEx(const char* label,const char* hint,char* buf,int buf_size,const ImVec2 size_arg,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
     return ImGui::InputTextEx(label,hint,buf,buf_size,size_arg,flags,callback,user_data);
@@ -3685,9 +3788,9 @@ CIMGUI_API bool igTempInputText(const ImRect bb,ImGuiID id,const char* label,cha
 {
     return ImGui::TempInputText(bb,id,label,buf,buf_size,flags);
 }
-CIMGUI_API bool igTempInputScalar(const ImRect bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format)
+CIMGUI_API bool igTempInputScalar(const ImRect bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min,const void* p_clamp_max)
 {
-    return ImGui::TempInputScalar(bb,id,label,data_type,p_data,format);
+    return ImGui::TempInputScalar(bb,id,label,data_type,p_data,format,p_clamp_min,p_clamp_max);
 }
 CIMGUI_API bool igTempInputIsActive(ImGuiID id)
 {
@@ -3757,6 +3860,10 @@ CIMGUI_API void igImFontAtlasBuildFinish(ImFontAtlas* atlas)
 {
     return ImFontAtlasBuildFinish(atlas);
 }
+CIMGUI_API void igImFontAtlasBuildRender1bppRectFromString(ImFontAtlas* atlas,int atlas_x,int atlas_y,int w,int h,const char* in_str,char in_marker_char,unsigned char in_marker_pixel_value)
+{
+    return ImFontAtlasBuildRender1bppRectFromString(atlas,atlas_x,atlas_y,w,h,in_str,in_marker_char,in_marker_pixel_value);
+}
 CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256],float in_multiply_factor)
 {
     return ImFontAtlasBuildMultiplyCalcLookupTable(out_table,in_multiply_factor);
@@ -3791,14 +3898,7 @@ CIMGUI_API float igGET_FLT_MAX()
 {
     return FLT_MAX;
 }
-CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v)
-{
-    ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
-}
-CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b)
-{
-    ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
-}
+
 
 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {

generator/cimgui_template.cpp

@@ -1,5 +1,8 @@
 
 #include "./imgui/imgui.h"
+#ifdef CIMGUI_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
@@ -31,14 +34,7 @@ CIMGUI_API float igGET_FLT_MAX()
 {
     return FLT_MAX;
 }
-CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v)
-{
-    ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
-}
-CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b)
-{
-    ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
-}
+
 
 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {

generator/cimgui_template.h

@@ -55,9 +55,6 @@ CIMGUI_API void igLogText(CONST char *fmt, ...);
 CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
 //for getting FLT_MAX in bindings
 CIMGUI_API float igGET_FLT_MAX();
-//not const args from & to *
-CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v);
-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();

generator/generator.bat

@@ -15,9 +15,10 @@ set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\min
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
 :: arg[1] compiler name gcc, clang or cl
-:: arg[2] imgui_internal functions generation: true or false
+:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+:: examples: "" "internal" "internal freetype"
 :: arg[3..n] name of implementations to generate
-luajit ./generator.lua gcc true glfw opengl3 opengl2 sdl
+luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -6,7 +6,8 @@ assert(_VERSION=='Lua 5.1',"Must use LuaJIT")
 assert(bit,"Must use LuaJIT")
 local script_args = {...}
 local COMPILER = script_args[1]
-local INTERNAL_GENERATION = script_args[2]=="true" 
+local INTERNAL_GENERATION = script_args[2]:match("internal") and true or false
+local FREETYPE_GENERATION = script_args[2]:match("freetype") and true or false
 local CPRE,CTEST
 if COMPILER == "gcc" or COMPILER == "clang" then
     CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]
@@ -40,6 +41,7 @@ assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
 
 print("HAVE_COMPILER",HAVE_COMPILER)
 print("INTERNAL_GENERATION",INTERNAL_GENERATION)
+print("FREETYPE_GENERATION",FREETYPE_GENERATION)
 --get implementations
 local implementations = {}
 for i=3,#script_args do table.insert(implementations,script_args[i]) end
@@ -50,8 +52,8 @@ for i=3,#script_args do table.insert(implementations,script_args[i]) end
 local cimgui_manuals = {
     igLogText = true,
     ImGuiTextBuffer_appendf = true,
-    igColorConvertRGBtoHSV = true,
-    igColorConvertHSVtoRGB = true
+    --igColorConvertRGBtoHSV = true,
+    --igColorConvertHSVtoRGB = true
 }
 --------------------------------------------------------------------------
 --this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
@@ -115,151 +117,10 @@ local function func_header_impl_generate(FP)
     cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
     return cfuncsstr
 end
-local function func_header_generate(FP)
 
-    local outtab = {}
-    table.insert(outtab,"#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
-    for k,v in pairs(FP.embeded_structs) do
-        table.insert(outtab,"typedef "..v.." "..k..";\n")
-    end
+local func_header_generate = cpp2ffi.func_header_generate
+local func_implementation = cpp2ffi.func_implementation
 
-    for ttype,v in pairs(FP.templates) do
-		for ttypein,_ in pairs(v) do
-			local te = ttypein:gsub("%s","_")
-			te = te:gsub("%*","Ptr")
-        table.insert(outtab,"typedef "..ttype.."<"..ttypein.."> "..ttype.."_"..te..";\n")
-		end
-    end
-
-    table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
-    for _,t in ipairs(FP.funcdefs) do
-
-        if t.cimguiname then
-        local cimf = FP.defsT[t.cimguiname]
-        local def = cimf[t.signature]
-        assert(def,t.signature..t.cimguiname)
-        local manual = FP.get_manuals(def)
-        if not manual and not def.templated then
-
-            local addcoment = def.comment or ""
-            local empty = def.args:match("^%(%)") --no args
-            if def.constructor then
-                assert(def.stname ~= "","constructor without struct")
-                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
-            elseif def.destructor then
-                table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-            else --not constructor
-
-                if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
-                else
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-                end
-            end 
-        end
-        else --not cimguiname
-            table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
-        end
-    end
-
-    local cfuncsstr = table.concat(outtab)
-    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
-    return cfuncsstr
-end
-
-
-local function ImGui_f_implementation(outtab,def)
-    local ptret = def.retref and "&" or ""
-    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args.."\n")
-    table.insert(outtab,"{\n")
-	local namespace = def.namespace and def.namespace.."::" or ""
-    if def.isvararg then
-        local call_args = def.call_args:gsub("%.%.%.","args")
-        table.insert(outtab,"    va_list args;\n")
-        table.insert(outtab,"    va_start(args, fmt);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    "..def.ret.." ret = "..namespace..def.funcname.."V"..call_args..";\n")
-        else
-            table.insert(outtab,"    "..namespace..def.funcname.."V"..call_args..";\n")
-        end
-        table.insert(outtab,"    va_end(args);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    return ret;\n")
-        end
-    elseif def.nonUDT then
-        if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = "..namespace..def.funcname..def.call_args..";\n")
-        end
-    else --standard ImGui
-        table.insert(outtab,"    return "..ptret..namespace..def.funcname..def.call_args..";\n")
-    end
-    table.insert(outtab,"}\n")
-end
-local function struct_f_implementation(outtab,def)
-    local empty = def.args:match("^%(%)") --no args
-    local ptret = def.retref and "&" or ""
-
-    local imgui_stname = def.stname
-
-    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args.."\n")
-    table.insert(outtab,"{\n")
-    if def.isvararg then
-        local call_args = def.call_args:gsub("%.%.%.","args")
-        table.insert(outtab,"    va_list args;\n")
-        table.insert(outtab,"    va_start(args, fmt);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    "..def.ret.." ret = self->"..def.funcname.."V"..call_args..";\n")
-        else
-            table.insert(outtab,"    self->"..def.funcname.."V"..call_args..";\n")
-        end
-        table.insert(outtab,"    va_end(args);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    return ret;\n")
-        end
-    elseif def.nonUDT then
-        if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
-        end
-    else --standard struct
-        table.insert(outtab,"    return "..ptret.."self->"..def.funcname..def.call_args..";\n")
-    end
-    table.insert(outtab,"}\n")
-end
-local function func_implementation(FP)
-
-    local outtab = {}
-    for _,t in ipairs(FP.funcdefs) do
-        repeat -- continue simulation
-        if not t.cimguiname then break end
-        local cimf = FP.defsT[t.cimguiname]
-        local def = cimf[t.signature]
-        assert(def)
-        local manual = FP.get_manuals(def)
-        if not manual and not def.templated then 
-            if def.constructor then
-                assert(def.stname ~= "","constructor without struct")
-                local empty = def.args:match("^%(%)") --no args
-                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname..(empty and "(void)" or def.args).."\n")
-                table.insert(outtab,"{\n")
-                table.insert(outtab,"    return IM_NEW("..def.stname..")"..def.call_args..";\n")
-                table.insert(outtab,"}\n")
-            elseif def.destructor then
-                local args = "("..def.stname.."* self)"
-                local fname = def.stname.."_destroy" 
-                table.insert(outtab,"CIMGUI_API void "..fname..args.."\n")
-                table.insert(outtab,"{\n")
-                table.insert(outtab,"    IM_DELETE(self);\n")
-                table.insert(outtab,"}\n")
-            elseif def.stname == "" then
-                ImGui_f_implementation(outtab,def)
-            else -- stname
-                struct_f_implementation(outtab,def)
-            end
-        end
-        until true
-    end
-    return table.concat(outtab)
-end
 -------------------functions for getting and setting defines
 local function get_defines(t)
     if COMPILER == "cl" then print"can't get defines with cl compiler"; return {} end
@@ -317,32 +178,74 @@ local function DefsByStruct(FP)
     FP.defsBystruct = structs
 end  
 
-
-
-
-----------custom ImVector templates
-local function generate_templates(code,codeimpool,templates)
-    table.insert(code,"\n"..[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
-    for ttype,v in pairs(templates) do
-        --local te = k:gsub("%s","_")
-        --te = te:gsub("%*","Ptr")
-		if ttype == "ImVector" then
-			for te,newte in pairs(v) do
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+-- function for repairing funcdefs default values
+local function repair_defaults(defsT,str_and_enu)
+	local function deleteOuterPars(def)
+		local w = def:match("^%b()$")
+		if w then
+			w = w:gsub("^%((.+)%)$","%1")
+			return w
+		else 
+			return def 
+		end
+	end
+	local function CleanImU32(def)
+		def = def:gsub("%(ImU32%)","")
+		--quitar () de numeros
+		def = def:gsub("%((%d+)%)","%1")
+		def = deleteOuterPars(def)
+		local bb=cpp2ffi.strsplit(def,"|")
+		for i=1,#bb do
+			local val = deleteOuterPars(bb[i])
+			if val:match"<<" then
+				local v1,v2 = val:match("(%d+)%s*<<%s*(%d+)")
+				val = v1*2^v2
+				bb[i] = val
 			end
-		elseif ttype == "ImPool" then
-			--declare ImGuiStorage
-			for te,newte in pairs(v) do
-				table.insert(codeimpool,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(codeimpool,"typedef struct ImPool_"..newte.." {ImVector_"..te.." Buf;ImGuiStorage Map;ImPoolIdx FreeIdx;} ImPool_"..newte..";\n")
-			end
-		elseif ttype == "ImChunkStream" then
-			for te,newte in pairs(v) do
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(code,"typedef struct ImChunkStream_"..newte.." {ImVector_"..te.." Buf;} ImChunkStream_"..newte..";\n")
+			assert(type(bb[i])=="number")
+		end
+		local res = 0 
+		for i=1,#bb do res = res + bb[i] end 
+		return res
+	end
+	for k,defT in pairs(defsT) do
+		for i,def in ipairs(defT) do
+			for k,v in pairs(def.defaults) do
+				--do only if not a c string
+				local is_cstring = v:sub(1,1)=='"' and v:sub(-1,-1) =='"'
+				if not is_cstring then
+					def.defaults[k] = def.defaults[k]:gsub("%(%(void%s*%*%)0%)","NULL")
+					if def.defaults[k]:match"%(ImU32%)" then
+						def.defaults[k] = tostring(CleanImU32(def.defaults[k]))
+					end
+				end
 			end
 		end
-    end
+	end
+end
+
+----------custom ImVector templates
+local table_do_sorted = cpp2ffi.table_do_sorted
+local function generate_templates(code,codeimpool,templates)
+    table.insert(code,"\n"..[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
+	table_do_sorted(templates , function (ttype, v)
+		if ttype == "ImVector" then
+			table_do_sorted(v, function(te,newte)
+				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+			end)
+		elseif ttype == "ImPool" then
+			--declare ImGuiStorage
+			table_do_sorted(v, function(te, newte)
+				table.insert(codeimpool,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+				table.insert(codeimpool,"typedef struct ImPool_"..newte.." {ImVector_"..te.." Buf;ImGuiStorage Map;ImPoolIdx FreeIdx;} ImPool_"..newte..";\n")
+			end)
+		elseif ttype == "ImChunkStream" then
+			table_do_sorted(v, function(te,newte)
+				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+				table.insert(code,"typedef struct ImChunkStream_"..newte.." {ImVector_"..te.." Buf;} ImChunkStream_"..newte..";\n")
+			end)
+		end
+	end)
 end
 --generate cimgui.cpp cimgui.h 
 local function cimgui_generation(parser)
@@ -370,8 +273,7 @@ local function cimgui_generation(parser)
 	--------------------------------------------------
     local hstrfile = read_data"./cimgui_template.h"
 
-	local outpre,outpost = parser:gen_structs_and_enums()
-	parser.templates.ImVector.T = nil
+	local outpre,outpost = parser.structs_and_enums[1],parser.structs_and_enums[2]
 	cpp2ffi.prtable(parser.templates)
 	cpp2ffi.prtable(parser.typenames)
 	
@@ -419,6 +321,10 @@ if INTERNAL_GENERATION then
 	cimgui_header = cimgui_header..[[//with imgui_internal.h api
 ]]
 end
+if FREETYPE_GENERATION then
+	cimgui_header = cimgui_header..[[//with imgui_freetype.h api
+]]
+end
 print("IMGUI_VERSION",imgui_version)
 --get some defines----------------------------
 gdefines = get_defines{"IMGUI_VERSION","FLT_MAX"}
@@ -428,69 +334,58 @@ gdefines = get_defines{"IMGUI_VERSION","FLT_MAX"}
 local function parseImGuiHeader(header,names)
 	--prepare parser
 	local parser = cpp2ffi.Parser()
-	parser.getCname = function(stname,funcname)
-		local pre = (stname == "") and "ig" or stname.."_"
+	
+	parser.getCname = function(stname,funcname,namespace)
+		local pre = (stname == "") and (namespace and (namespace=="ImGui" and "ig" or namespace.."_") or "ig") or stname.."_"
 		return pre..funcname
 	end
 	parser.cname_overloads = cimgui_overloads
 	parser.manuals = cimgui_manuals
 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
 	
-	local pipe,err = io.popen(CPRE..header,"r")
+	local defines = parser:take_lines(CPRE..header,names,COMPILER)
 	
-	if not pipe then
-		error("could not execute COMPILER "..err)
-	end
-	
-	local iterator = cpp2ffi.location
-	
-	--[[
-	local tableo = {}
-	local line
-	repeat 
-		line =pipe:read"*l"
-		table.insert(tableo,line)
-	until not line
-	cpp2ffi.save_data("cdefs1.lua",table.concat(tableo,"\n"))
-	--]]
-	for line,loca,loca2 in iterator(pipe,names,{},COMPILER) do
-		parser:insert(line, loca)
-		--table.insert(tableo,line)
-		--print(loca,loca2)
-	end
-	--cpp2ffi.save_data("cdefs1.lua",table.concat(tableo))
-	pipe:close()
 	return parser
 end
 --generation
 print("------------------generation with "..COMPILER.."------------------------")
 local parser1
+local headers = [[#include "../imgui/imgui.h" 
+]]
+local headersT = {[[imgui]]}
 if INTERNAL_GENERATION then
-	save_data("headers.h",[[#include "../imgui/imgui.h" 
-	#include "../imgui/imgui_internal.h"]])
-	parser1 = parseImGuiHeader([[headers.h]],{[[imgui]],[[imgui_internal]],[[imstb_textedit]]})
-	os.remove("headers.h")
-else
-	parser1 = parseImGuiHeader([[../imgui/imgui.h]],{[[imgui]]})
+	headers = headers .. [[#include "../imgui/imgui_internal.h"
+	]]
+	headersT[#headersT + 1] = [[imgui_internal]]
+	headersT[#headersT + 1] = [[imstb_textedit]]
 end
+if FREETYPE_GENERATION then
+	headers = headers .. [[
+	#include "../imgui/misc/freetype/imgui_freetype.h"
+	]]
+	headersT[#headersT + 1] = [[imgui_freetype]]
+end
+save_data("headers.h",headers)
+local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
+local extra_includes = include_cmd.." ../imgui "
+local parser1 = parseImGuiHeader(extra_includes .. [[headers.h]],headersT)
+os.remove("headers.h")
 parser1:do_parse()
 
 save_data("./output/overloads.txt",parser1.overloadstxt)
 cimgui_generation(parser1)
 
-----------save fundefs in definitions.lua for using in bindings
---DefsByStruct(pFP)
-set_defines(parser1.defsT) 
-save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
-
 ----------save struct and enums lua table in structs_and_enums.lua for using in bindings
 
 local structs_and_enums_table = parser1:gen_structs_and_enums_table()
-
------------------------
 save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
 save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
 
+----------save fundefs in definitions.lua for using in bindings
+--DefsByStruct(pFP)
+set_defines(parser1.defsT) 
+repair_defaults(parser1.defsT, structs_and_enums_table)
+save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
 
 --check every function has ov_cimguiname
 -- for k,v in pairs(parser1.defsT) do
@@ -523,26 +418,16 @@ if #implementations > 0 then
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
+		
+		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 
-        local pipe,err = io.popen(CPRE..extra_defines..extra_includes..source,"r")
-
-        if not pipe then
-            error("could not get file: "..err)
-        end
-        
-        local iterator = cpp2ffi.location
-        
-        for line,locat in iterator(pipe,{locati},{},COMPILER) do
-            --local line, comment = split_comment(line)
-			parser2:insert(line,locat)
-        end
-        pipe:close()
     end
+	
     parser2:do_parse()
 
     -- save ./cimgui_impl.h
     local cfuncsstr = func_header_impl_generate(parser2) 
-    local cstructstr1,cstructstr2 = parser2:gen_structs_and_enums()
+	local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
     save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
 
     ----------save fundefs in impl_definitions.lua for using in bindings
@@ -565,14 +450,16 @@ local function json_prepare(defs)
 end
 ---[[
 local json = require"json"
-save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT)))
+save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),{dict_on_empty={defaults=true}}))
 save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
 save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
 if parser2 then
-    save_data("./output/impl_definitions.json",json.encode(json_prepare(parser2.defsT)))
+    save_data("./output/impl_definitions.json",json.encode(json_prepare(parser2.defsT),{dict_on_empty={defaults=true}}))
 end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
+os.remove("./output/cimgui.h")
+os.remove("./output/cimgui.cpp")
 print"all done!!"

generator/generator.sh

@@ -13,6 +13,7 @@
 
 #process  files
 # arg[1] compiler name gcc, clang, or cl
-# arg[2] imgui_internal functions generation: true or false
+# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+# examples: "" "internal" "internal freetype"
 # arg[3..n] name of implementations to generate
-luajit ./generator.lua gcc true glfw opengl3 opengl2 sdl
+luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl

generator/json.lua

@@ -21,7 +21,10 @@
 -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 -- SOFTWARE.
 --
-
+--changes---------------------------------------------------------------------
+--prettify: adding carriage return, indentation, dictionaries sorted by key
+--dict_on_empty: table to json.encode to make empty table a dictionary instead of array
+------------------------------------------------------------------------------
 local json = { _version = "0.1.1" }
 
 -------------------------------------------------------------------------------
@@ -30,6 +33,7 @@ local json = { _version = "0.1.1" }
 local TAB = "  "
 local rep = string.rep
 local encode
+local dict_on_empty = {}
 
 local escape_char_map = {
   [ "\\" ] = "\\\\",
@@ -90,7 +94,6 @@ local function encode_table(val, stack,level,isvalue)
     return rep(isvalue and "" or TAB,level).."[" .. inner .. "]"
 
   else
-  ---[[
     local ordered_keys = {}
     for k,v in pairs(val) do
         table.insert(ordered_keys,k)
@@ -99,12 +102,15 @@ local function encode_table(val, stack,level,isvalue)
     -- Treat as an object
     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,level+1) .. ": " .. encode(v, stack,level+1,true))
+      if type(v) == "table" and next(v) == nil and dict_on_empty[k] then
+          table.insert(res, encode(k, stack,level+1) .. ": {}")
+      else
+          table.insert(res, encode(k, stack,level+1) .. ": " .. encode(v, stack,level+1,true))
+      end
     end
     stack[val] = nil
     local inner = table.concat(res, ",\n")
@@ -147,7 +153,8 @@ encode = function(val, stack,level,isvalue)
 end
 
 
-function json.encode(val)
+function json.encode(val,opts)
+  dict_on_empty = opts and opts.dict_on_empty or {}
   return ( encode(val) )
 end
 
@@ -412,5 +419,4 @@ function json.decode(str)
   return res
 end
 
-
 return json

generator/output/impl_definitions.json

@@ -15,8 +15,9 @@
       "argsoriginal": "(GLFWwindow* window,unsigned int c)",
       "call_args": "(window,c)",
       "cimguiname": "ImGui_ImplGlfw_CharCallback",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_CharCallback",
+      "location": "imgui_impl_glfw:35",
       "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,unsigned int)",
@@ -39,8 +40,9 @@
       "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
       "call_args": "(window,install_callbacks)",
       "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOpenGL",
+      "location": "imgui_impl_glfw:24",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -63,8 +65,9 @@
       "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
       "call_args": "(window,install_callbacks)",
       "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForVulkan",
+      "location": "imgui_impl_glfw:25",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -99,8 +102,9 @@
       "argsoriginal": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
       "call_args": "(window,key,scancode,action,mods)",
       "cimguiname": "ImGui_ImplGlfw_KeyCallback",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_KeyCallback",
+      "location": "imgui_impl_glfw:34",
       "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int,int)",
@@ -131,8 +135,9 @@
       "argsoriginal": "(GLFWwindow* window,int button,int action,int mods)",
       "call_args": "(window,button,action,mods)",
       "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "location": "imgui_impl_glfw:32",
       "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int)",
@@ -146,8 +151,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplGlfw_NewFrame",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_NewFrame",
+      "location": "imgui_impl_glfw:27",
       "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -174,8 +180,9 @@
       "argsoriginal": "(GLFWwindow* window,double xoffset,double yoffset)",
       "call_args": "(window,xoffset,yoffset)",
       "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_ScrollCallback",
+      "location": "imgui_impl_glfw:33",
       "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
@@ -189,8 +196,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplGlfw_Shutdown",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplGlfw_Shutdown",
+      "location": "imgui_impl_glfw:26",
       "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -204,8 +212,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "location": "imgui_impl_opengl2:30",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
@@ -219,8 +228,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "location": "imgui_impl_opengl2:28",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
@@ -234,8 +244,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "location": "imgui_impl_opengl2:31",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
@@ -249,8 +260,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "location": "imgui_impl_opengl2:29",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
@@ -264,8 +276,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_Init",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Init",
+      "location": "imgui_impl_opengl2:22",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
       "ret": "bool",
       "signature": "()",
@@ -279,8 +292,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_NewFrame",
+      "location": "imgui_impl_opengl2:24",
       "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -299,8 +313,9 @@
       "argsoriginal": "(ImDrawData* draw_data)",
       "call_args": "(draw_data)",
       "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "location": "imgui_impl_opengl2:25",
       "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -314,8 +329,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Shutdown",
+      "location": "imgui_impl_opengl2:23",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -329,8 +345,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "location": "imgui_impl_opengl3:36",
       "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
@@ -344,8 +361,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "location": "imgui_impl_opengl3:34",
       "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
@@ -359,8 +377,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "location": "imgui_impl_opengl3:37",
       "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
@@ -374,8 +393,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "location": "imgui_impl_opengl3:35",
       "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
@@ -398,6 +418,7 @@
         "glsl_version": "((void*)0)"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
+      "location": "imgui_impl_opengl3:28",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
       "ret": "bool",
       "signature": "(const char*)",
@@ -411,8 +432,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_NewFrame",
+      "location": "imgui_impl_opengl3:30",
       "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -431,8 +453,9 @@
       "argsoriginal": "(ImDrawData* draw_data)",
       "call_args": "(draw_data)",
       "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "location": "imgui_impl_opengl3:31",
       "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -446,8 +469,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_Shutdown",
+      "location": "imgui_impl_opengl3:29",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -466,8 +490,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_InitForD3D",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForD3D",
+      "location": "imgui_impl_sdl:25",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -486,8 +511,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_InitForMetal",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForMetal",
+      "location": "imgui_impl_sdl:26",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -510,8 +536,9 @@
       "argsoriginal": "(SDL_Window* window,void* sdl_gl_context)",
       "call_args": "(window,sdl_gl_context)",
       "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForOpenGL",
+      "location": "imgui_impl_sdl:23",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "ret": "bool",
       "signature": "(SDL_Window*,void*)",
@@ -530,8 +557,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_InitForVulkan",
+      "location": "imgui_impl_sdl:24",
       "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "ret": "bool",
       "signature": "(SDL_Window*)",
@@ -550,8 +578,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_NewFrame",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_NewFrame",
+      "location": "imgui_impl_sdl:28",
       "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
       "ret": "void",
       "signature": "(SDL_Window*)",
@@ -570,8 +599,9 @@
       "argsoriginal": "(const SDL_Event* event)",
       "call_args": "(event)",
       "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_ProcessEvent",
+      "location": "imgui_impl_sdl:29",
       "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
@@ -585,8 +615,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplSDL2_Shutdown",
-      "defaults": [],
+      "defaults": {},
       "funcname": "ImGui_ImplSDL2_Shutdown",
+      "location": "imgui_impl_sdl:27",
       "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
       "ret": "void",
       "signature": "()",

generator/output/impl_definitions.lua

@@ -14,6 +14,7 @@ defs["ImGui_ImplGlfw_CharCallback"][1]["call_args"] = "(window,c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CharCallback"
 defs["ImGui_ImplGlfw_CharCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
+defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw:35"
 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)"
@@ -34,6 +35,7 @@ defs["ImGui_ImplGlfw_InitForOpenGL"][1]["call_args"] = "(window,install_callback
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw:24"
 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)"
@@ -54,6 +56,7 @@ defs["ImGui_ImplGlfw_InitForVulkan"][1]["call_args"] = "(window,install_callback
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw:25"
 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)"
@@ -83,6 +86,7 @@ defs["ImGui_ImplGlfw_KeyCallback"][1]["call_args"] = "(window,key,scancode,actio
 defs["ImGui_ImplGlfw_KeyCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw:34"
 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)"
@@ -109,6 +113,7 @@ defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["call_args"] = "(window,button,act
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw:32"
 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)"
@@ -123,6 +128,7 @@ defs["ImGui_ImplGlfw_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["cimguiname"] = "ImGui_ImplGlfw_NewFrame"
 defs["ImGui_ImplGlfw_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
+defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw:27"
 defs["ImGui_ImplGlfw_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_NewFrame"
 defs["ImGui_ImplGlfw_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_NewFrame"][1]["signature"] = "()"
@@ -146,6 +152,7 @@ defs["ImGui_ImplGlfw_ScrollCallback"][1]["call_args"] = "(window,xoffset,yoffset
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw:33"
 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)"
@@ -160,6 +167,7 @@ defs["ImGui_ImplGlfw_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
+defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw:26"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
@@ -174,6 +182,7 @@ defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2:30"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
@@ -188,6 +197,7 @@ defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2:28"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
@@ -202,6 +212,7 @@ defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2:31"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
@@ -216,6 +227,7 @@ defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2:29"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
@@ -230,6 +242,7 @@ defs["ImGui_ImplOpenGL2_Init"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
+defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2:22"
 defs["ImGui_ImplOpenGL2_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
@@ -244,6 +257,7 @@ defs["ImGui_ImplOpenGL2_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2:24"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
@@ -261,6 +275,7 @@ defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2:25"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
@@ -275,6 +290,7 @@ defs["ImGui_ImplOpenGL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2:23"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
@@ -289,6 +305,7 @@ defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3:36"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
@@ -303,6 +320,7 @@ defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3:34"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
@@ -317,6 +335,7 @@ defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3:37"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
@@ -331,6 +350,7 @@ defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3:35"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
@@ -349,6 +369,7 @@ defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "((void*)0)"
 defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3:28"
 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*)"
@@ -363,6 +384,7 @@ defs["ImGui_ImplOpenGL3_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3:30"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
@@ -380,6 +402,7 @@ defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3:31"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
@@ -394,6 +417,7 @@ defs["ImGui_ImplOpenGL3_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3:29"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
@@ -411,6 +435,7 @@ defs["ImGui_ImplSDL2_InitForD3D"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
 defs["ImGui_ImplSDL2_InitForD3D"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForD3D"][1]["funcname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["location"] = "imgui_impl_sdl:25"
 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*)"
@@ -428,6 +453,7 @@ defs["ImGui_ImplSDL2_InitForMetal"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForMetal"][1]["funcname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["location"] = "imgui_impl_sdl:26"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForMetal"][1]["signature"] = "(SDL_Window*)"
@@ -448,6 +474,7 @@ defs["ImGui_ImplSDL2_InitForOpenGL"][1]["call_args"] = "(window,sdl_gl_context)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl:23"
 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*)"
@@ -465,6 +492,7 @@ defs["ImGui_ImplSDL2_InitForVulkan"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl:24"
 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*)"
@@ -482,6 +510,7 @@ defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
+defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl:28"
 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*)"
@@ -499,6 +528,7 @@ defs["ImGui_ImplSDL2_ProcessEvent"][1]["call_args"] = "(event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl:29"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(const SDL_Event*)"
@@ -513,6 +543,7 @@ defs["ImGui_ImplSDL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
+defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl:27"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"

generator/output/overloads.txt

@@ -1,214 +1,223 @@
 ----------------overloadings---------------------------
-ImVector_resize	2
-1	void	ImVector_resizeNil (int)
-2	void	ImVector_resizeT (int,const T)
-igSetScrollFromPosY	2
-1	void	igSetScrollFromPosYFloat (float,float)
-2	void	igSetScrollFromPosYWindowPtr (ImGuiWindow*,float,float)
-ImVec4_ImVec4	2
-1	nil	ImVec4_ImVec4Nil ()
-2	nil	ImVec4_ImVec4Float (float,float,float,float)
-igValue	4
-1	void	igValueBool (const char*,bool)
-2	void	igValueInt (const char*,int)
-3	void	igValueUint (const char*,unsigned int)
-4	void	igValueFloat (const char*,float,const char*)
-igIsRectVisible	2
-1	bool	igIsRectVisibleNil (const ImVec2)
-2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
-igRadioButton	2
-1	bool	igRadioButtonBool (const char*,bool)
-2	bool	igRadioButtonIntPtr (const char*,int*,int)
-ImGuiTextRange_ImGuiTextRange	2
-1	nil	ImGuiTextRange_ImGuiTextRangeNil ()
-2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
-ImVec2_ImVec2	2
-1	nil	ImVec2_ImVec2Nil ()
-2	nil	ImVec2_ImVec2Float (float,float)
-ImVector_back	2
-1	T*	ImVector_backNil ()
-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	igGetIDStrStr (const char*,const char*)
-3	ImGuiID	igGetIDPtr (const void*)
-ImVec1_ImVec1	2
-1	nil	ImVec1_ImVec1Nil ()
-2	nil	ImVec1_ImVec1Float (float)
-igImPow	2
-1	float	igImPowFloat (float,float)
-2	double	igImPowdouble (double,double)
-igSetWindowPos	3
-1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
-3	void	igSetWindowPosWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
-igBeginChild	2
-1	bool	igBeginChildStr (const char*,const ImVec2,bool,ImGuiWindowFlags)
-2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
-igPushID	4
-1	void	igPushIDStr (const char*)
-2	void	igPushIDStrStr (const char*,const char*)
-3	void	igPushIDPtr (const void*)
-4	void	igPushIDInt (int)
-ImRect_Contains	2
-1	bool	ImRect_ContainsVec2 (const ImVec2)const
-2	bool	ImRect_ContainsRect (const ImRect)const
-ImRect_Add	2
-1	void	ImRect_AddVec2 (const ImVec2)
-2	void	ImRect_AddRect (const ImRect)
-ImGuiStoragePair_ImGuiStoragePair	3
-1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
-2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
-3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
-igSetScrollFromPosX	2
-1	void	igSetScrollFromPosXFloat (float,float)
-2	void	igSetScrollFromPosXWindowPtr (ImGuiWindow*,float,float)
-igGetForegroundDrawList	2
-1	ImDrawList*	igGetForegroundDrawListNil ()
-2	ImDrawList*	igGetForegroundDrawListWindowPtr (ImGuiWindow*)
-igTreeNodeEx	3
-1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
-2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
-3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
-igImLengthSqr	2
-1	float	igImLengthSqrVec2 (const ImVec2)
-2	float	igImLengthSqrVec4 (const ImVec4)
-igImFloor	2
-1	float	igImFloorFloat (float)
-2	ImVec2	igImFloorVec2 (const ImVec2)
-igTreeNode	3
-1	bool	igTreeNodeStr (const char*)
-2	bool	igTreeNodeStrStr (const char*,const char*,...)
-3	bool	igTreeNodePtr (const void*,const char*,...)
-igItemSize	2
-1	void	igItemSizeVec2 (const ImVec2,float)
-2	void	igItemSizeRect (const ImRect,float)
-igCombo	3
-1	bool	igComboStr_arr (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)
-igSetScrollY	2
-1	void	igSetScrollYFloat (float)
-2	void	igSetScrollYWindowPtr (ImGuiWindow*,float)
-ImVector_erase	2
-1	T*	ImVector_eraseNil (const T*)
-2	T*	ImVector_eraseTPtr (const T*,const T*)
-ImDrawList_AddText	2
-1	void	ImDrawList_AddTextVec2 (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	igSetWindowFocusNil ()
-2	void	igSetWindowFocusStr (const char*)
-igImLerp	3
-1	ImVec2	igImLerpVec2Float (const ImVec2,const ImVec2,float)
-2	ImVec2	igImLerpVec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
-3	ImVec4	igImLerpVec4 (const ImVec4,const ImVec4,float)
-ImVector_end	2
-1	T*	ImVector_endNil ()
-2	const T*	ImVector_end_const ()const
-igMarkIniSettingsDirty	2
-1	void	igMarkIniSettingsDirtyNil ()
-2	void	igMarkIniSettingsDirtyWindowPtr (ImGuiWindow*)
-igSetWindowSize	3
-1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
-3	void	igSetWindowSizeWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
-igIsPopupOpen	2
-1	bool	igIsPopupOpenStr (const char*)
-2	bool	igIsPopupOpenID (ImGuiID)
-ImVector_ImVector	2
-1	nil	ImVector_ImVectorNil ()
-2	nil	ImVector_ImVectorVector (const ImVector)
-igSetWindowCollapsed	3
-1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
-2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
-3	void	igSetWindowCollapsedWindowPtr (ImGuiWindow*,bool,ImGuiCond)
-igPlotLines	2
-1	void	igPlotLinesFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotLinesFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
-igPushStyleColor	2
-1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
-2	void	igPushStyleColorVec4 (ImGuiCol,const ImVec4)
-ImGuiWindow_GetIDNoKeepAlive	3
-1	ImGuiID	ImGuiWindow_GetIDNoKeepAliveStr (const char*,const char*)
-2	ImGuiID	ImGuiWindow_GetIDNoKeepAlivePtr (const void*)
-3	ImGuiID	ImGuiWindow_GetIDNoKeepAliveInt (int)
-ImGuiWindow_GetID	3
-1	ImGuiID	ImGuiWindow_GetIDStr (const char*,const char*)
-2	ImGuiID	ImGuiWindow_GetIDPtr (const void*)
-3	ImGuiID	ImGuiWindow_GetIDInt (int)
-igTreeNodeExV	2
-1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
-2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
-ImVec2ih_ImVec2ih	3
-1	nil	ImVec2ih_ImVec2ihNil ()
-2	nil	ImVec2ih_ImVec2ihshort (short,short)
-3	explicit	ImVec2ih_ImVec2ihVec2 (const ImVec2)
-ImGuiStyleMod_ImGuiStyleMod	3
-1	nil	ImGuiStyleMod_ImGuiStyleModInt (ImGuiStyleVar,int)
-2	nil	ImGuiStyleMod_ImGuiStyleModFloat (ImGuiStyleVar,float)
-3	nil	ImGuiStyleMod_ImGuiStyleModVec2 (ImGuiStyleVar,ImVec2)
-ImRect_Expand	2
-1	void	ImRect_ExpandFloat (const float)
-2	void	ImRect_ExpandVec2 (const ImVec2)
-ImPool_Remove	2
-1	void	ImPool_RemoveTPtr (ImGuiID,const T*)
-2	void	ImPool_RemovePoolIdx (ImGuiID,ImPoolIdx)
-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)
-ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
-1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexPtr (void*)
-2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexInt (int)
-ImRect_ImRect	4
-1	nil	ImRect_ImRectNil ()
-2	nil	ImRect_ImRectVec2 (const ImVec2,const ImVec2)
-3	nil	ImRect_ImRectVec4 (const ImVec4)
-4	nil	ImRect_ImRectFloat (float,float,float,float)
-igTreePush	2
-1	void	igTreePushStr (const char*)
-2	void	igTreePushPtr (const void*)
-igSelectable	2
-1	bool	igSelectableBool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
-igGetColorU32	3
-1	ImU32	igGetColorU32Col (ImGuiCol,float)
-2	ImU32	igGetColorU32Vec4 (const ImVec4)
-3	ImU32	igGetColorU32U32 (ImU32)
-ImVector_begin	2
-1	T*	ImVector_beginNil ()
-2	const T*	ImVector_begin_const ()const
 ImColor_ImColor	5
 1	nil	ImColor_ImColorNil ()
 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	igCollapsingHeaderTreeNodeFlags (const char*,ImGuiTreeNodeFlags)
-2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
-ImVector_front	2
-1	T*	ImVector_frontNil ()
-2	const T*	ImVector_front_const ()const
+ImDrawList_AddText	2
+1	void	ImDrawList_AddTextVec2 (const ImVec2,ImU32,const char*,const char*)
+2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
+1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexPtr (void*)
+2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexInt (int)
+ImGuiStoragePair_ImGuiStoragePair	3
+1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
+2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
+3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
+ImGuiStyleMod_ImGuiStyleMod	3
+1	nil	ImGuiStyleMod_ImGuiStyleModInt (ImGuiStyleVar,int)
+2	nil	ImGuiStyleMod_ImGuiStyleModFloat (ImGuiStyleVar,float)
+3	nil	ImGuiStyleMod_ImGuiStyleModVec2 (ImGuiStyleVar,ImVec2)
+ImGuiTextRange_ImGuiTextRange	2
+1	nil	ImGuiTextRange_ImGuiTextRangeNil ()
+2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
+ImGuiWindow_GetID	3
+1	ImGuiID	ImGuiWindow_GetIDStr (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetIDPtr (const void*)
+3	ImGuiID	ImGuiWindow_GetIDInt (int)
+ImGuiWindow_GetIDNoKeepAlive	3
+1	ImGuiID	ImGuiWindow_GetIDNoKeepAliveStr (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetIDNoKeepAlivePtr (const void*)
+3	ImGuiID	ImGuiWindow_GetIDNoKeepAliveInt (int)
+ImPool_Remove	2
+1	void	ImPool_RemoveTPtr (ImGuiID,const T*)
+2	void	ImPool_RemovePoolIdx (ImGuiID,ImPoolIdx)
+ImRect_Add	2
+1	void	ImRect_AddVec2 (const ImVec2)
+2	void	ImRect_AddRect (const ImRect)
+ImRect_Contains	2
+1	bool	ImRect_ContainsVec2 (const ImVec2)const
+2	bool	ImRect_ContainsRect (const ImRect)const
+ImRect_Expand	2
+1	void	ImRect_ExpandFloat (const float)
+2	void	ImRect_ExpandVec2 (const ImVec2)
+ImRect_ImRect	4
+1	nil	ImRect_ImRectNil ()
+2	nil	ImRect_ImRectVec2 (const ImVec2,const ImVec2)
+3	nil	ImRect_ImRectVec4 (const ImVec4)
+4	nil	ImRect_ImRectFloat (float,float,float,float)
+ImVec1_ImVec1	2
+1	nil	ImVec1_ImVec1Nil ()
+2	nil	ImVec1_ImVec1Float (float)
+ImVec2_ImVec2	2
+1	nil	ImVec2_ImVec2Nil ()
+2	nil	ImVec2_ImVec2Float (float,float)
+ImVec2ih_ImVec2ih	3
+1	nil	ImVec2ih_ImVec2ihNil ()
+2	nil	ImVec2ih_ImVec2ihshort (short,short)
+3	nil	ImVec2ih_ImVec2ihVec2 (const ImVec2)
+ImVec4_ImVec4	2
+1	nil	ImVec4_ImVec4Nil ()
+2	nil	ImVec4_ImVec4Float (float,float,float,float)
+ImVector_ImVector	2
+1	nil	ImVector_ImVectorNil ()
+2	nil	ImVector_ImVectorVector (const ImVector)
+ImVector_back	2
+1	T*	ImVector_backNil ()
+2	const T*	ImVector_back_const ()const
+ImVector_begin	2
+1	T*	ImVector_beginNil ()
+2	const T*	ImVector_begin_const ()const
+ImVector_end	2
+1	T*	ImVector_endNil ()
+2	const T*	ImVector_end_const ()const
+ImVector_erase	2
+1	T*	ImVector_eraseNil (const T*)
+2	T*	ImVector_eraseTPtr (const T*,const T*)
 ImVector_find	2
 1	T*	ImVector_findNil (const T)
 2	const T*	ImVector_find_const (const T)const
+ImVector_front	2
+1	T*	ImVector_frontNil ()
+2	const T*	ImVector_front_const ()const
+ImVector_resize	2
+1	void	ImVector_resizeNil (int)
+2	void	ImVector_resizeT (int,const T)
+igBeginChild	2
+1	bool	igBeginChildStr (const char*,const ImVec2,bool,ImGuiWindowFlags)
+2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+igCollapsingHeader	2
+1	bool	igCollapsingHeaderTreeNodeFlags (const char*,ImGuiTreeNodeFlags)
+2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+igCombo	3
+1	bool	igComboStr_arr (const char*,int*,const char* const[],int,int)
+2	bool	igComboStr (const char*,int*,const char*,int)
+3	bool	igComboFnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+igGetColorU32	3
+1	ImU32	igGetColorU32Col (ImGuiCol,float)
+2	ImU32	igGetColorU32Vec4 (const ImVec4)
+3	ImU32	igGetColorU32U32 (ImU32)
+igGetForegroundDrawList	2
+1	ImDrawList*	igGetForegroundDrawListNil ()
+2	ImDrawList*	igGetForegroundDrawListWindowPtr (ImGuiWindow*)
+igGetID	3
+1	ImGuiID	igGetIDStr (const char*)
+2	ImGuiID	igGetIDStrStr (const char*,const char*)
+3	ImGuiID	igGetIDPtr (const void*)
+igImAbs	2
+1	float	igImAbsFloat (float)
+2	double	igImAbsdouble (double)
+igImFloor	2
+1	float	igImFloorFloat (float)
+2	ImVec2	igImFloorVec2 (const ImVec2)
+igImLengthSqr	2
+1	float	igImLengthSqrVec2 (const ImVec2)
+2	float	igImLengthSqrVec4 (const ImVec4)
+igImLerp	3
+1	ImVec2	igImLerpVec2Float (const ImVec2,const ImVec2,float)
+2	ImVec2	igImLerpVec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
+3	ImVec4	igImLerpVec4 (const ImVec4,const ImVec4,float)
+igImLog	2
+1	float	igImLogFloat (float)
+2	double	igImLogdouble (double)
+igImPow	2
+1	float	igImPowFloat (float,float)
+2	double	igImPowdouble (double,double)
+igImSign	2
+1	float	igImSignFloat (float)
+2	double	igImSigndouble (double)
+igIsPopupOpen	2
+1	bool	igIsPopupOpenStr (const char*,ImGuiPopupFlags)
+2	bool	igIsPopupOpenID (ImGuiID,ImGuiPopupFlags)
+igIsRectVisible	2
+1	bool	igIsRectVisibleNil (const ImVec2)
+2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
+igItemSize	2
+1	void	igItemSizeVec2 (const ImVec2,float)
+2	void	igItemSizeRect (const ImRect,float)
+igListBox	2
+1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
+2	bool	igListBoxFnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
 igListBoxHeader	2
 1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
 2	bool	igListBoxHeaderInt (const char*,int,int)
-igSetScrollX	2
-1	void	igSetScrollXFloat (float)
-2	void	igSetScrollXWindowPtr (ImGuiWindow*,float)
+igMarkIniSettingsDirty	2
+1	void	igMarkIniSettingsDirtyNil ()
+2	void	igMarkIniSettingsDirtyWindowPtr (ImGuiWindow*)
 igMenuItem	2
 1	bool	igMenuItemBool (const char*,const char*,bool,bool)
 2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
+igPlotHistogram	2
+1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotHistogramFnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igPlotLines	2
+1	void	igPlotLinesFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotLinesFnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igPushID	4
+1	void	igPushIDStr (const char*)
+2	void	igPushIDStrStr (const char*,const char*)
+3	void	igPushIDPtr (const void*)
+4	void	igPushIDInt (int)
+igPushStyleColor	2
+1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
+2	void	igPushStyleColorVec4 (ImGuiCol,const ImVec4)
+igPushStyleVar	2
+1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
+2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
+igRadioButton	2
+1	bool	igRadioButtonBool (const char*,bool)
+2	bool	igRadioButtonIntPtr (const char*,int*,int)
+igSelectable	2
+1	bool	igSelectableBool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+igSetScrollFromPosX	2
+1	void	igSetScrollFromPosXFloat (float,float)
+2	void	igSetScrollFromPosXWindowPtr (ImGuiWindow*,float,float)
+igSetScrollFromPosY	2
+1	void	igSetScrollFromPosYFloat (float,float)
+2	void	igSetScrollFromPosYWindowPtr (ImGuiWindow*,float,float)
+igSetScrollX	2
+1	void	igSetScrollXFloat (float)
+2	void	igSetScrollXWindowPtr (ImGuiWindow*,float)
+igSetScrollY	2
+1	void	igSetScrollYFloat (float)
+2	void	igSetScrollYWindowPtr (ImGuiWindow*,float)
+igSetWindowCollapsed	3
+1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
+2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
+3	void	igSetWindowCollapsedWindowPtr (ImGuiWindow*,bool,ImGuiCond)
+igSetWindowFocus	2
+1	void	igSetWindowFocusNil ()
+2	void	igSetWindowFocusStr (const char*)
+igSetWindowPos	3
+1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowPosWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igSetWindowSize	3
+1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowSizeWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igTreeNode	3
+1	bool	igTreeNodeStr (const char*)
+2	bool	igTreeNodeStrStr (const char*,const char*,...)
+3	bool	igTreeNodePtr (const void*,const char*,...)
+igTreeNodeEx	3
+1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
+2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
+3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
+igTreeNodeExV	2
+1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
+2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
 igTreeNodeV	2
 1	bool	igTreeNodeVStr (const char*,const char*,va_list)
 2	bool	igTreeNodeVPtr (const void*,const char*,va_list)
-149 overloaded
+igTreePush	2
+1	void	igTreePushStr (const char*)
+2	void	igTreePushPtr (const void*)
+igValue	4
+1	void	igValueBool (const char*,bool)
+2	void	igValueInt (const char*,int)
+3	void	igValueUint (const char*,unsigned int)
+4	void	igValueFloat (const char*,float,const char*)
+155 overloaded

generator/output/typedefs_dict.json

@@ -35,23 +35,23 @@
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiDataType": "int",
   "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
+  "ImGuiDataTypeTempStorage": "struct ImGuiDataTypeTempStorage",
   "ImGuiDir": "int",
   "ImGuiDragDropFlags": "int",
-  "ImGuiDragFlags": "int",
   "ImGuiFocusedFlags": "int",
   "ImGuiGroupData": "struct ImGuiGroupData",
   "ImGuiHoveredFlags": "int",
   "ImGuiID": "unsigned int",
   "ImGuiIO": "struct ImGuiIO",
-  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData *data);",
+  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
   "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
   "ImGuiInputTextFlags": "int",
   "ImGuiInputTextState": "struct ImGuiInputTextState",
   "ImGuiItemFlags": "int",
-  "ImGuiItemHoveredDataBackup": "struct ImGuiItemHoveredDataBackup",
   "ImGuiItemStatusFlags": "int",
   "ImGuiKey": "int",
   "ImGuiKeyModFlags": "int",
+  "ImGuiLastItemDataBackup": "struct ImGuiLastItemDataBackup",
   "ImGuiLayoutType": "int",
   "ImGuiListClipper": "struct ImGuiListClipper",
   "ImGuiMenuColumns": "struct ImGuiMenuColumns",
@@ -69,6 +69,7 @@
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
   "ImGuiPayload": "struct ImGuiPayload",
   "ImGuiPopupData": "struct ImGuiPopupData",
+  "ImGuiPopupFlags": "int",
   "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
   "ImGuiSelectableFlags": "int",
   "ImGuiSeparatorFlags": "int",
@@ -114,6 +115,10 @@
   "ImWchar": "ImWchar16",
   "ImWchar16": "unsigned short",
   "ImWchar32": "unsigned int",
+  "STB_TexteditState": "struct STB_TexteditState",
+  "StbTexteditRow": "struct StbTexteditRow",
+  "StbUndoRecord": "struct StbUndoRecord",
+  "StbUndoState": "struct StbUndoState",
   "const_iterator": "const value_type*",
   "iterator": "value_type*",
   "value_type": "T"

generator/output/typedefs_dict.lua

@@ -35,23 +35,23 @@ defs["ImGuiConfigFlags"] = "int"
 defs["ImGuiContext"] = "struct ImGuiContext"
 defs["ImGuiDataType"] = "int"
 defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
+defs["ImGuiDataTypeTempStorage"] = "struct ImGuiDataTypeTempStorage"
 defs["ImGuiDir"] = "int"
 defs["ImGuiDragDropFlags"] = "int"
-defs["ImGuiDragFlags"] = "int"
 defs["ImGuiFocusedFlags"] = "int"
 defs["ImGuiGroupData"] = "struct ImGuiGroupData"
 defs["ImGuiHoveredFlags"] = "int"
 defs["ImGuiID"] = "unsigned int"
 defs["ImGuiIO"] = "struct ImGuiIO"
-defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData *data);"
+defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
 defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
 defs["ImGuiInputTextFlags"] = "int"
 defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
 defs["ImGuiItemFlags"] = "int"
-defs["ImGuiItemHoveredDataBackup"] = "struct ImGuiItemHoveredDataBackup"
 defs["ImGuiItemStatusFlags"] = "int"
 defs["ImGuiKey"] = "int"
 defs["ImGuiKeyModFlags"] = "int"
+defs["ImGuiLastItemDataBackup"] = "struct ImGuiLastItemDataBackup"
 defs["ImGuiLayoutType"] = "int"
 defs["ImGuiListClipper"] = "struct ImGuiListClipper"
 defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
@@ -69,6 +69,7 @@ defs["ImGuiNextWindowDataFlags"] = "int"
 defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
 defs["ImGuiPayload"] = "struct ImGuiPayload"
 defs["ImGuiPopupData"] = "struct ImGuiPopupData"
+defs["ImGuiPopupFlags"] = "int"
 defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
 defs["ImGuiSelectableFlags"] = "int"
 defs["ImGuiSeparatorFlags"] = "int"
@@ -114,6 +115,10 @@ defs["ImVec4"] = "struct ImVec4"
 defs["ImWchar"] = "ImWchar16"
 defs["ImWchar16"] = "unsigned short"
 defs["ImWchar32"] = "unsigned int"
+defs["STB_TexteditState"] = "struct STB_TexteditState"
+defs["StbTexteditRow"] = "struct StbTexteditRow"
+defs["StbUndoRecord"] = "struct StbUndoRecord"
+defs["StbUndoState"] = "struct StbUndoState"
 defs["const_iterator"] = "const value_type*"
 defs["iterator"] = "value_type*"
 defs["value_type"] = "T"