update README.md

Fix Typo

.github/workflows/build.yml

@@ -0,0 +1,76 @@
+name: Build
+
+on:
+  push: {}
+  pull_request: {}
+  schedule:
+    - cron:  '0 9 * * 1'
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Install Dependencies
+      shell: bash
+      env:
+        GITHUB_OS: ${{ matrix.os }}
+      run: |
+        if [ "$GITHUB_OS" == "macOS-latest" ];
+        then
+          brew install luajit
+        elif [ "$GITHUB_OS" == "ubuntu-latest" ];
+        then
+          sudo apt-get install -y luajit
+        elif [ "$GITHUB_OS" == "windows-latest" ];
+        then
+          vcpkg install luajit
+        fi
+
+    - name: Download Submodules
+      run: |
+        git submodule update --init --recursive
+      if: github.event_name != 'schedule'
+
+    - name: Download Latest ImGui
+      shell: bash
+      run: |
+        rm -rf imgui
+        git clone https://github.com/ocornut/imgui.git
+      if: github.event_name == 'schedule'
+
+    - name: Generate Bindings
+      shell: bash
+      run: |
+        export PATH=$PATH:/C/vcpkg/packages/luajit_x86-windows/tools/:/C/vcpkg/packages/luajit_x86-windows/bin/
+        cd ./generator
+        bash ./generator.sh
+
+    - name: CMake
+      run: |
+        mkdir cmake-build
+        cd cmake-build
+        cmake -DCIMGUI_TEST=1 ..
+
+    - name: Build
+      working-directory: cmake-build
+      run: |
+        cmake --build .
+
+    - name: Test
+      shell: bash
+      env:
+        GITHUB_OS: ${{ matrix.os }}
+      working-directory: cmake-build
+      run: |
+        if [ "$GITHUB_OS" == "windows-latest" ];
+        then
+          ./Debug/cimgui_test.exe
+        else
+          ./cimgui_test
+        fi

.gitignore

@@ -32,7 +32,10 @@ cimgui/cimgui.sdf
 cimgui/cimgui.v12.suo
 cimgui/Release/
 .idea
-CMakeLists.txt
 cimgui/.vs/
 cimgui/cimgui.vcxproj.user
 cimgui/x64/
+
+# Test / Build
+bld/
+build/

.travis.yml

@@ -1,11 +1,32 @@
 language: cpp
+dist: trusty
 
 os:
   - linux
+  - osx
+  - windows
 
 compiler:
   - gcc
   - clang
 
+env:
+  - MSBUILD_PATH="c:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin"
+
 script:
-  make
+  - mkdir bld
+  - cd bld
+  - cmake -D CIMGUI_TEST=1 ..
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      export PATH=$MSBUILD_PATH:$PATH
+      MSBuild.exe cimgui.sln
+    else
+      make
+    fi
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      ./Debug/cimgui_test.exe
+    else
+      ./cimgui_test
+    fi

CMakeLists.txt

@@ -1,20 +1,15 @@
-Project(cimgui)
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.1)
+
+project(cimgui)
 
 #general settings
-include_directories(imgui)
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
-
-include_directories(.)
-set(IMGUI_SOURCES ./cimgui.cpp ./imgui/imgui.cpp ./imgui/imgui_draw.cpp ./imgui/imgui_demo.cpp ./imgui/imgui_widgets.cpp)
-
-set(IMGUI_LIBRARIES )
-
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
+file(GLOB IMGUI_SOURCES
+    cimgui.cpp
+    imgui/imgui.cpp
+    imgui/imgui_draw.cpp
+    imgui/imgui_demo.cpp
+    imgui/imgui_widgets.cpp
+)
 
 set(IMGUI_STATIC "no" CACHE STRING "Build as a static library")
 
@@ -25,12 +20,27 @@ else (IMGUI_STATIC)
     add_library(cimgui SHARED ${IMGUI_SOURCES})
 endif (IMGUI_STATIC)
 
-target_link_libraries(cimgui ${IMGUI_LIBRARIES})
+target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
+if (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" __declspec\(dllexport\)")
+else (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" ")
+endif (WIN32)
+
+target_include_directories(cimgui PUBLIC ${CMAKE_SOURCE_DIR})
+target_include_directories(cimgui PUBLIC ${CMAKE_SOURCE_DIR}/imgui)
 set_target_properties(cimgui PROPERTIES PREFIX "")
 
 #install
 install(TARGETS cimgui
-              RUNTIME DESTINATION  .
-              LIBRARY DESTINATION  .
-              ARCHIVE DESTINATION  .
-              )
+    RUNTIME DESTINATION  .
+    LIBRARY DESTINATION  .
+    ARCHIVE DESTINATION  .
+)
+
+#test
+set(CIMGUI_TEST "no" CACHE STRING "Enable compilation of a test unit based on imgui null")
+
+if (CIMGUI_TEST)
+  add_subdirectory(test)
+endif ()

Makefile

@@ -8,7 +8,7 @@ OBJS += ./imgui/imgui_draw.o
 OBJS += ./imgui/imgui_demo.o
 OBJS += ./imgui/imgui_widgets.o
 
-CXXFLAGS=-O2
+CXXFLAGS=-O2 -fno-exceptions -fno-rtti
 
 UNAME_S := $(shell uname -s)
 
@@ -46,11 +46,18 @@ endif
 .cpp.o:
 	$(CXX) $(CXXFLAGS) -c -o $@ $<
 
-all:imgui_example
+all:$(OUTPUTNAME)
 	@echo Build complete for $(ECHO_MESSAGE)
 
-imgui_example:$(OBJS)
+$(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
 
 clean:
-	rm $(OBJS)
+	rm -f $(OBJS)
+
+fclean: clean
+	rm -f $(OUTPUTNAME)
+
+re: fclean all
+
+.PHONY: all clean fclean re

README.md

@@ -1,8 +1,8 @@
-# cimgui [![Build Status](https://travis-ci.org/sonoro1234/cimgui.svg?branch=master)](https://travis-ci.org/sonoro1234/cimgui)
+# cimgui [![Build Status](https://travis-ci.org/cimgui/cimgui.svg?branch=master)](https://travis-ci.org/cimgui/cimgui)
 
 
 This is a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui [Dear ImGui](https://github.com/ocornut/imgui).
-All functions are programmatically wrapped except `ImVector` constructors and destructors. (Unless someone find a use case for them)(Now they exist for `ImVector_ImWchar`)
+All imgui.h functions are programmatically wrapped.
 Generated files are: `cimgui.cpp`, `cimgui.h` for C compilation. Also for helping in bindings creation, `definitions.lua` with function definition information and `structs_and_enums.lua`.
 This library is intended as a intermediate layer to be able to use Dear ImGui from other languages that can interface with C (like D - see [D-binding](https://github.com/Extrawurst/DerelictImgui))
 
@@ -11,7 +11,9 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.66b of Dear ImGui]
+* currently this wrapper is based on version [1.75 of Dear ImGui]
+* only functions, structs and enums from imgui.h are wrapped.
+* if you are interested in imgui implementations you should look LuaJIT-ImGui project.
 * overloaded function names try to be the most compatible with traditional cimgui names. So all naming is algorithmic except for those names that were in conflict with widely used cimgui names and were thus coded in a table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L58). Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)
 
 # compilation
@@ -25,10 +27,13 @@ Notes:
 
 # using generator
 
+* this is only needed (before compilation) if you want an imgui version different from the one provided, otherwise generation is already done.
 * you will need LuaJIT (https://github.com/LuaJIT/LuaJIT.git better 2.1 branch) or precompiled for linux/macOS/windows in https://luapower.com/luajit/download
 * you can use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC) or not use a compiler (experimental nocompiler option) at all. (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` (or make a .sh version and please PR) to choose between gcc, clang, cl or nocompiler. Run it with gcc, clang or cl and LuaJIT on your PATH.
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, cl or nocompiler and to choose desired implementations. 
+* edit config_generator.lua for adding includes needed by your chosen implementations.
+* 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. 
 
 # generate binding
@@ -39,18 +44,21 @@ Notes:
 ### definitions description
 * It is a collection in which key is the cimgui name that would result without overloadings and the value is an array of overloadings (may be only one overloading)
 * Each overloading is a collection. Some relevant keys and values are:
-  * stname : the name of the struct the function belongs to (may be ImGui if it is top level in ImGui namespace)
+  * stname : the name of the struct the function belongs to (will be "" if it is top level in ImGui namespace)
   * ov_cimguiname : the overloaded cimgui name (if absent it would be taken from cimguiname)
   * cimguiname : the name without overloading (this should be used if there is not ov_cimguiname)
   * ret : the return type
+  * retref : is 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)
   * 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)
-  * isvararg : is setted if some argument is a vararg
-  * constructor : is setted if the function is a constructor for a class
-  * destructor : is setted if the functions is a destructor for a class
+  * 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
+  * 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 can be 1 or 2 (explained meaning in usage) if return type was a user defined type
 ### structs_and_enums description
 * Is is a collection with two items:

cimgui.cpp

@@ -1,10 +1,11 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.67" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.75" from Dear ImGui https://github.com/ocornut/imgui
 
 #include "./imgui/imgui.h"
+#include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#include "./imgui/imgui_internal.h"
+
 
 CIMGUI_API ImVec2* ImVec2_ImVec2(void)
 {
@@ -46,9 +47,9 @@ CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
 {
     return ImGui::SetCurrentContext(ctx);
 }
-CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)
+CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
 {
-    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert);
+    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
 }
 CIMGUI_API ImGuiIO* igGetIO()
 {
@@ -174,30 +175,6 @@ CIMGUI_API float igGetWindowHeight()
 {
     return ImGui::GetWindowHeight();
 }
-CIMGUI_API ImVec2 igGetContentRegionMax()
-{
-    return ImGui::GetContentRegionMax();
-}
-CIMGUI_API ImVec2 igGetContentRegionAvail()
-{
-    return ImGui::GetContentRegionAvail();
-}
-CIMGUI_API float igGetContentRegionAvailWidth()
-{
-    return ImGui::GetContentRegionAvailWidth();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMin()
-{
-    return ImGui::GetWindowContentRegionMin();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMax()
-{
-    return ImGui::GetWindowContentRegionMax();
-}
-CIMGUI_API float igGetWindowContentRegionWidth()
-{
-    return ImGui::GetWindowContentRegionWidth();
-}
 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
 {
     return ImGui::SetNextWindowPos(pos,cond,pivot);
@@ -262,6 +239,26 @@ CIMGUI_API void igSetWindowFocusStr(const char* name)
 {
     return ImGui::SetWindowFocus(name);
 }
+CIMGUI_API ImVec2 igGetContentRegionMax()
+{
+    return ImGui::GetContentRegionMax();
+}
+CIMGUI_API ImVec2 igGetContentRegionAvail()
+{
+    return ImGui::GetContentRegionAvail();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMin()
+{
+    return ImGui::GetWindowContentRegionMin();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMax()
+{
+    return ImGui::GetWindowContentRegionMax();
+}
+CIMGUI_API float igGetWindowContentRegionWidth()
+{
+    return ImGui::GetWindowContentRegionWidth();
+}
 CIMGUI_API float igGetScrollX()
 {
     return ImGui::GetScrollX();
@@ -286,10 +283,18 @@ CIMGUI_API void igSetScrollY(float scroll_y)
 {
     return ImGui::SetScrollY(scroll_y);
 }
+CIMGUI_API void igSetScrollHereX(float center_x_ratio)
+{
+    return ImGui::SetScrollHereX(center_x_ratio);
+}
 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
 {
     return ImGui::SetScrollHereY(center_y_ratio);
 }
+CIMGUI_API void igSetScrollFromPosX(float local_x,float center_x_ratio)
+{
+    return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
+}
 CIMGUI_API void igSetScrollFromPosY(float local_y,float center_y_ratio)
 {
     return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
@@ -362,6 +367,10 @@ CIMGUI_API void igPopItemWidth()
 {
     return ImGui::PopItemWidth();
 }
+CIMGUI_API void igSetNextItemWidth(float item_width)
+{
+    return ImGui::SetNextItemWidth(item_width);
+}
 CIMGUI_API float igCalcItemWidth()
 {
     return ImGui::CalcItemWidth();
@@ -394,9 +403,9 @@ CIMGUI_API void igSeparator()
 {
     return ImGui::Separator();
 }
-CIMGUI_API void igSameLine(float local_pos_x,float spacing_w)
+CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
 {
-    return ImGui::SameLine(local_pos_x,spacing_w);
+    return ImGui::SameLine(offset_from_start_x,spacing);
 }
 CIMGUI_API void igNewLine()
 {
@@ -692,13 +701,13 @@ CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_curr
 {
     return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max);
 }
-CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::DragScalar(label,data_type,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,power);
 }
-CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::DragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power);
+    return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,power);
 }
 CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power)
 {
@@ -736,13 +745,13 @@ CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,cons
 {
     return ImGui::SliderInt4(label,v,v_min,v_max,format);
 }
-CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::SliderScalar(label,data_type,v,v_min,v_max,format,power);
+    return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,power);
 }
-CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::SliderScalarN(label,data_type,v,components,v_min,v_max,format,power);
+    return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,power);
 }
 CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power)
 {
@@ -752,9 +761,9 @@ CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_mi
 {
     return ImGui::VSliderInt(label,size,v,v_min,v_max,format);
 }
-CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::VSliderScalar(label,size,data_type,v,v_min,v_max,format,power);
+    return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,power);
 }
 CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
@@ -764,6 +773,10 @@ CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size
 {
     return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
 }
+CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
+{
+    return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
+}
 CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
 {
     return ImGui::InputFloat(label,v,step,step_fast,format,flags);
@@ -800,13 +813,13 @@ CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double ste
 {
     return ImGui::InputDouble(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,flags);
+    return ImGui::InputScalar(label,data_type,p_data,p_step,p_step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,flags);
+    return ImGui::InputScalarN(label,data_type,p_data,components,p_step,p_step_fast,format,flags);
 }
 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
 {
@@ -900,18 +913,10 @@ CIMGUI_API void igTreePop()
 {
     return ImGui::TreePop();
 }
-CIMGUI_API void igTreeAdvanceToLabelPos()
-{
-    return ImGui::TreeAdvanceToLabelPos();
-}
 CIMGUI_API float igGetTreeNodeToLabelSpacing()
 {
     return ImGui::GetTreeNodeToLabelSpacing();
 }
-CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond)
-{
-    return ImGui::SetNextTreeNodeOpen(is_open,cond);
-}
 CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags)
 {
     return ImGui::CollapsingHeader(label,flags);
@@ -920,6 +925,10 @@ CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTr
 {
     return ImGui::CollapsingHeader(label,p_open,flags);
 }
+CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
+{
+    return ImGui::SetNextItemOpen(is_open,cond);
+}
 CIMGUI_API bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
 {
     return ImGui::Selectable(label,selected,flags,size);
@@ -980,14 +989,6 @@ CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format
 {
     return ImGui::Value(prefix,v,float_format);
 }
-CIMGUI_API bool igBeginMainMenuBar()
-{
-    return ImGui::BeginMainMenuBar();
-}
-CIMGUI_API void igEndMainMenuBar()
-{
-    return ImGui::EndMainMenuBar();
-}
 CIMGUI_API bool igBeginMenuBar()
 {
     return ImGui::BeginMenuBar();
@@ -996,6 +997,14 @@ CIMGUI_API void igEndMenuBar()
 {
     return ImGui::EndMenuBar();
 }
+CIMGUI_API bool igBeginMainMenuBar()
+{
+    return ImGui::BeginMainMenuBar();
+}
+CIMGUI_API void igEndMainMenuBar()
+{
+    return ImGui::EndMainMenuBar();
+}
 CIMGUI_API bool igBeginMenu(const char* label,bool enabled)
 {
     return ImGui::BeginMenu(label,enabled);
@@ -1039,15 +1048,15 @@ CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
 {
     return ImGui::BeginPopup(str_id,flags);
 }
-CIMGUI_API bool igBeginPopupContextItem(const char* str_id,int mouse_button)
+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,int mouse_button,bool also_over_items)
+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,int mouse_button)
+CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiMouseButton mouse_button)
 {
     return ImGui::BeginPopupContextVoid(str_id,mouse_button);
 }
@@ -1059,7 +1068,7 @@ CIMGUI_API void igEndPopup()
 {
     return ImGui::EndPopup();
 }
-CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,int mouse_button)
+CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,ImGuiMouseButton mouse_button)
 {
     return ImGui::OpenPopupOnItemClick(str_id,mouse_button);
 }
@@ -1123,17 +1132,17 @@ CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
 {
     return ImGui::SetTabItemClosed(tab_or_docked_window_label);
 }
-CIMGUI_API void igLogToTTY(int max_depth)
+CIMGUI_API void igLogToTTY(int auto_open_depth)
 {
-    return ImGui::LogToTTY(max_depth);
+    return ImGui::LogToTTY(auto_open_depth);
 }
-CIMGUI_API void igLogToFile(int max_depth,const char* filename)
+CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
 {
-    return ImGui::LogToFile(max_depth,filename);
+    return ImGui::LogToFile(auto_open_depth,filename);
 }
-CIMGUI_API void igLogToClipboard(int max_depth)
+CIMGUI_API void igLogToClipboard(int auto_open_depth)
 {
-    return ImGui::LogToClipboard(max_depth);
+    return ImGui::LogToClipboard(auto_open_depth);
 }
 CIMGUI_API void igLogFinish()
 {
@@ -1147,9 +1156,9 @@ CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
 {
     return ImGui::BeginDragDropSource(flags);
 }
-CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond)
+CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
 {
-    return ImGui::SetDragDropPayload(type,data,size,cond);
+    return ImGui::SetDragDropPayload(type,data,sz,cond);
 }
 CIMGUI_API void igEndDragDropSource()
 {
@@ -1199,7 +1208,7 @@ CIMGUI_API bool igIsItemFocused()
 {
     return ImGui::IsItemFocused();
 }
-CIMGUI_API bool igIsItemClicked(int mouse_button)
+CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button)
 {
     return ImGui::IsItemClicked(mouse_button);
 }
@@ -1211,6 +1220,10 @@ CIMGUI_API bool igIsItemEdited()
 {
     return ImGui::IsItemEdited();
 }
+CIMGUI_API bool igIsItemActivated()
+{
+    return ImGui::IsItemActivated();
+}
 CIMGUI_API bool igIsItemDeactivated()
 {
     return ImGui::IsItemDeactivated();
@@ -1219,6 +1232,10 @@ CIMGUI_API bool igIsItemDeactivatedAfterEdit()
 {
     return ImGui::IsItemDeactivatedAfterEdit();
 }
+CIMGUI_API bool igIsItemToggledOpen()
+{
+    return ImGui::IsItemToggledOpen();
+}
 CIMGUI_API bool igIsAnyItemHovered()
 {
     return ImGui::IsAnyItemHovered();
@@ -1263,9 +1280,13 @@ CIMGUI_API int igGetFrameCount()
 {
     return ImGui::GetFrameCount();
 }
-CIMGUI_API ImDrawList* igGetOverlayDrawList()
+CIMGUI_API ImDrawList* igGetBackgroundDrawList()
 {
-    return ImGui::GetOverlayDrawList();
+    return ImGui::GetBackgroundDrawList();
+}
+CIMGUI_API ImDrawList* igGetForegroundDrawList()
+{
+    return ImGui::GetForegroundDrawList();
 }
 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
 {
@@ -1327,29 +1348,25 @@ CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate
 {
     return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate);
 }
-CIMGUI_API bool igIsMouseDown(int button)
+CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
+{
+    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
+}
+CIMGUI_API bool igIsMouseDown(ImGuiMouseButton button)
 {
     return ImGui::IsMouseDown(button);
 }
-CIMGUI_API bool igIsAnyMouseDown()
-{
-    return ImGui::IsAnyMouseDown();
-}
-CIMGUI_API bool igIsMouseClicked(int button,bool repeat)
+CIMGUI_API bool igIsMouseClicked(ImGuiMouseButton button,bool repeat)
 {
     return ImGui::IsMouseClicked(button,repeat);
 }
-CIMGUI_API bool igIsMouseDoubleClicked(int button)
-{
-    return ImGui::IsMouseDoubleClicked(button);
-}
-CIMGUI_API bool igIsMouseReleased(int button)
+CIMGUI_API bool igIsMouseReleased(ImGuiMouseButton button)
 {
     return ImGui::IsMouseReleased(button);
 }
-CIMGUI_API bool igIsMouseDragging(int button,float lock_threshold)
+CIMGUI_API bool igIsMouseDoubleClicked(ImGuiMouseButton button)
 {
-    return ImGui::IsMouseDragging(button,lock_threshold);
+    return ImGui::IsMouseDoubleClicked(button);
 }
 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip)
 {
@@ -1359,6 +1376,10 @@ CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos)
 {
     return ImGui::IsMousePosValid(mouse_pos);
 }
+CIMGUI_API bool igIsAnyMouseDown()
+{
+    return ImGui::IsAnyMouseDown();
+}
 CIMGUI_API ImVec2 igGetMousePos()
 {
     return ImGui::GetMousePos();
@@ -1367,11 +1388,15 @@ CIMGUI_API ImVec2 igGetMousePosOnOpeningCurrentPopup()
 {
     return ImGui::GetMousePosOnOpeningCurrentPopup();
 }
-CIMGUI_API ImVec2 igGetMouseDragDelta(int button,float lock_threshold)
+CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold)
+{
+    return ImGui::IsMouseDragging(button,lock_threshold);
+}
+CIMGUI_API ImVec2 igGetMouseDragDelta(ImGuiMouseButton button,float lock_threshold)
 {
     return ImGui::GetMouseDragDelta(button,lock_threshold);
 }
-CIMGUI_API void igResetMouseDragDelta(int button)
+CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button)
 {
     return ImGui::ResetMouseDragDelta(button);
 }
@@ -1379,13 +1404,9 @@ CIMGUI_API ImGuiMouseCursor igGetMouseCursor()
 {
     return ImGui::GetMouseCursor();
 }
-CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type)
+CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type)
 {
-    return ImGui::SetMouseCursor(type);
-}
-CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
-{
-    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
+    return ImGui::SetMouseCursor(cursor_type);
 }
 CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
 {
@@ -1439,7 +1460,7 @@ CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
 {
     return self->ScaleAllSizes(scale_factor);
 }
-CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c)
+CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
 {
     return self->AddInputCharacter(c);
 }
@@ -1539,31 +1560,23 @@ CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
 {
     return self->IsActive();
 }
-CIMGUI_API TextRange* TextRange_TextRange(void)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void)
 {
-    return IM_NEW(TextRange)();
+    return IM_NEW(ImGuiTextRange)();
 }
-CIMGUI_API void TextRange_destroy(TextRange* self)
+CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API TextRange* TextRange_TextRangeStr(const char* _b,const char* _e)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
 {
-    return IM_NEW(TextRange)(_b,_e);
+    return IM_NEW(ImGuiTextRange)(_b,_e);
 }
-CIMGUI_API const char* TextRange_begin(TextRange* self)
-{
-    return self->begin();
-}
-CIMGUI_API const char* TextRange_end(TextRange* self)
-{
-    return self->end();
-}
-CIMGUI_API bool TextRange_empty(TextRange* self)
+CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
 {
     return self->empty();
 }
-CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange* out)
+CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
 {
     return self->split(separator,out);
 }
@@ -1603,25 +1616,29 @@ CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
 {
     return self->c_str();
 }
+CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
+{
+    return self->append(str,str_end);
+}
 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
 {
     return self->appendfv(fmt,args);
 }
-CIMGUI_API Pair* Pair_PairInt(ImGuiID _key,int _val_i)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
 {
-    return IM_NEW(Pair)(_key,_val_i);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_i);
 }
-CIMGUI_API void Pair_destroy(Pair* self)
+CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API Pair* Pair_PairFloat(ImGuiID _key,float _val_f)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
 {
-    return IM_NEW(Pair)(_key,_val_f);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_f);
 }
-CIMGUI_API Pair* Pair_PairPtr(ImGuiID _key,void* _val_p)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
 {
-    return IM_NEW(Pair)(_key,_val_p);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_p);
 }
 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
 {
@@ -1743,6 +1760,34 @@ CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
+{
+    return IM_NEW(ImDrawListSplitter)();
+}
+CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
+{
+    return self->Clear();
+}
+CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
+{
+    return self->ClearFreeMemory();
+}
+CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
+{
+    return self->Split(draw_list,count);
+}
+CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
+{
+    return self->Merge(draw_list);
+}
+CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
+{
+    return self->SetCurrentChannel(draw_list,channel_idx);
+}
 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
 {
     return IM_NEW(ImDrawList)(shared_data);
@@ -1779,45 +1824,53 @@ CIMGUI_API ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self)
 {
     return self->GetClipRectMax();
 }
-CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
 {
-    return self->AddLine(a,b,col,thickness);
+    return self->AddLine(p1,p2,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness)
+CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
 {
-    return self->AddRect(a,b,col,rounding,rounding_corners_flags,thickness);
+    return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
 }
-CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->AddRectFilled(a,b,col,rounding,rounding_corners_flags);
+    return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
 }
-CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
+CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
 {
-    return self->AddRectFilledMultiColor(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
+    return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
 }
-CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
 {
-    return self->AddQuad(a,b,c,d,col,thickness);
+    return self->AddQuad(p1,p2,p3,p4,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col)
+CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
 {
-    return self->AddQuadFilled(a,b,c,d,col);
+    return self->AddQuadFilled(p1,p2,p3,p4,col);
 }
-CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
 {
-    return self->AddTriangle(a,b,c,col,thickness);
+    return self->AddTriangle(p1,p2,p3,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col)
+CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
 {
-    return self->AddTriangleFilled(a,b,c,col);
+    return self->AddTriangleFilled(p1,p2,p3,col);
 }
-CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness)
+CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
 {
-    return self->AddCircle(centre,radius,col,num_segments,thickness);
+    return self->AddCircle(center,radius,col,num_segments,thickness);
 }
-CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments)
+CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
 {
-    return self->AddCircleFilled(centre,radius,col,num_segments);
+    return self->AddCircleFilled(center,radius,col,num_segments);
+}
+CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
+{
+    return self->AddNgon(center,radius,col,num_segments,thickness);
+}
+CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
+{
+    return self->AddNgonFilled(center,radius,col,num_segments);
 }
 CIMGUI_API void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
 {
@@ -1827,29 +1880,29 @@ CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,fl
 {
     return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
 }
-CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
-{
-    return self->AddImage(user_texture_id,a,b,uv_a,uv_b,col);
-}
-CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
-{
-    return self->AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
-}
-CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners)
-{
-    return self->AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners);
-}
-CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)
+CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
 {
     return self->AddPolyline(points,num_points,col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col)
+CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
 {
     return self->AddConvexPolyFilled(points,num_points,col);
 }
-CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments)
+CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments)
 {
-    return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments);
+    return self->AddBezierCurve(p1,p2,p3,p4,col,thickness,num_segments);
+}
+CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
+{
+    return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
+}
+CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
+{
+    return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
+}
+CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
+{
+    return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
 {
@@ -1871,33 +1924,21 @@ CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,flo
 {
     return self->PathStroke(col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments)
+CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
 {
-    return self->PathArcTo(centre,radius,a_min,a_max,num_segments);
+    return self->PathArcTo(center,radius,a_min,a_max,num_segments);
 }
-CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12)
+CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
 {
-    return self->PathArcToFast(centre,radius,a_min_of_12,a_max_of_12);
+    return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
 }
-CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)
+CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments)
 {
-    return self->PathBezierCurveTo(p1,p2,p3,num_segments);
+    return self->PathBezierCurveTo(p2,p3,p4,num_segments);
 }
-CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->PathRect(rect_min,rect_max,rounding,rounding_corners_flags);
-}
-CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count)
-{
-    return self->ChannelsSplit(channels_count);
-}
-CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
-{
-    return self->ChannelsMerge();
-}
-CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index)
-{
-    return self->ChannelsSetCurrent(channel_index);
+    return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
 {
@@ -1911,6 +1952,18 @@ CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
 {
     return self->CloneOutput();
 }
+CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
+{
+    return self->ChannelsSplit(count);
+}
+CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
+{
+    return self->ChannelsMerge();
+}
+CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
+{
+    return self->ChannelsSetCurrent(n);
+}
 CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
 {
     return self->Clear();
@@ -1923,6 +1976,10 @@ CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_co
 {
     return self->PrimReserve(idx_count,vtx_count);
 }
+CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,int idx_count,int vtx_count)
+{
+    return self->PrimUnreserve(idx_count,vtx_count);
+}
 CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)
 {
     return self->PrimRect(a,b,col);
@@ -1971,9 +2028,9 @@ CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
 {
     return self->DeIndexAllBuffers();
 }
-CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc)
+CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
 {
-    return self->ScaleClipRects(sc);
+    return self->ScaleClipRects(fb_scale);
 }
 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
 {
@@ -1991,6 +2048,10 @@ CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
+{
+    return self->Clear();
+}
 CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n)
 {
     return self->GetBit(n);
@@ -2015,6 +2076,18 @@ CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* s
 {
     return self->BuildRanges(out_ranges);
 }
+CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
+{
+    return IM_NEW(ImFontAtlasCustomRect)();
+}
+CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
+{
+    return self->IsPacked();
+}
 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
 {
     return IM_NEW(ImFontAtlas)();
@@ -2111,17 +2184,9 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
 {
     return self->GetGlyphRangesThai();
 }
-CIMGUI_API CustomRect* CustomRect_CustomRect(void)
+CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
 {
-    return IM_NEW(CustomRect)();
-}
-CIMGUI_API void CustomRect_destroy(CustomRect* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool CustomRect_IsPacked(CustomRect* self)
-{
-    return self->IsPacked();
+    return self->GetGlyphRangesVietnamese();
 }
 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
 {
@@ -2131,11 +2196,11 @@ CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font
 {
     return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
 }
-CIMGUI_API const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
+CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
 {
     return self->GetCustomRectByIndex(index);
 }
-CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
+CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
 {
     return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
 }
@@ -2151,14 +2216,6 @@ CIMGUI_API void ImFont_destroy(ImFont* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
-{
-    return self->ClearOutputData();
-}
-CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
-{
-    return self->BuildLookupTable();
-}
 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
 {
     return self->FindGlyph(c);
@@ -2167,10 +2224,6 @@ CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
 {
     return self->FindGlyphNoFallback(c);
 }
-CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
-{
-    return self->SetFallbackChar(c);
-}
 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
 {
     return self->GetCharAdvance(c);
@@ -2199,6 +2252,14 @@ CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,
 {
     return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
 }
+CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
+{
+    return self->BuildLookupTable();
+}
+CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
+{
+    return self->ClearOutputData();
+}
 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
 {
     return self->GrowIndex(new_size);
@@ -2211,6 +2272,10 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool ov
 {
     return self->AddRemapChar(dst,src,overwrite_dst);
 }
+CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
+{
+    return self->SetFallbackChar(c);
+}
 CIMGUI_API void igGetWindowPos_nonUDT(ImVec2 *pOut)
 {
     *pOut = ImGui::GetWindowPos();
@@ -2381,11 +2446,11 @@ CIMGUI_API ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2()
     ImVec2_Simple ret2 = ImVec2ToSimple(ret);
     return ret2;
 }
-CIMGUI_API void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,int button,float lock_threshold)
+CIMGUI_API void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)
 {
     *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
 }
-CIMGUI_API ImVec2_Simple igGetMouseDragDelta_nonUDT2(int button,float lock_threshold)
+CIMGUI_API ImVec2_Simple igGetMouseDragDelta_nonUDT2(ImGuiMouseButton button,float lock_threshold)
 {
     ImVec2 ret = ImGui::GetMouseDragDelta(button,lock_threshold);
     ImVec2_Simple ret2 = ImVec2ToSimple(ret);
@@ -2470,10 +2535,12 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
+
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
 {
-	IM_DELETE(p);
+    IM_DELETE(self);
 }
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();

generator/cimgui_template.cpp

@@ -1,8 +1,9 @@
 
 #include "./imgui/imgui.h"
+#include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#include "./imgui/imgui_internal.h"
+
 
 #include "auto_funcs.cpp"
 
@@ -43,10 +44,12 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
+
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
 {
-	IM_DELETE(p);
+    IM_DELETE(self);
 }
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();

generator/cimgui_template.h

@@ -83,7 +83,7 @@ CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,floa
 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b);
 
 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p);
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
 #endif //CIMGUI_INCLUDED

generator/config_generator.lua

@@ -0,0 +1,3 @@
+return {
+	vulkan = {[[C:\VulkanSDK\1.1.130.0\Include]]}
+}

generator/cpp2ffi.lua

@@ -1,5 +1,80 @@
 local M = {}
 
+local function ToStr(t,dometatables)
+	local function basicToStr (o)
+		if type(o) == "number" or type(o)=="boolean" then
+			return tostring(o)
+		elseif type(o) == "string" then
+			return string.format("%q", o)
+		else
+			return tostring(o) --"nil"
+		end
+	end
+	local strTG = {}
+	--local basicToStr= basicSerialize --tostring
+	if type(t) ~="table" then  return basicToStr(t) end
+	local recG = 0
+	local nameG="SELF"..recG
+	local ancest ={}
+	local function _ToStr(t,strT,rec,name)
+		if ancest[t] then
+			strT[#strT + 1]=ancest[t]
+			return
+		end
+		rec = rec + 1
+		ancest[t]=name
+		strT[#strT + 1]='{'
+		local count=0
+		-------------
+		--if t.name then strT[#strT + 1]=string.rep("\t",rec).."name:"..tostring(t.name) end
+		----------------
+		for k,v in pairs(t) do
+			count=count+1
+			strT[#strT + 1]="\n"
+			local kstr
+			if type(k) == "table" then
+				local name2=string.format("%s.KEY%d",name,count)
+				strT[#strT + 1]=string.rep("\t",rec).."["
+				local strTK = {}
+				_ToStr(k,strTK,rec,name2)
+				kstr=table.concat(strTK)
+				strT[#strT + 1]=kstr.."]="
+			else
+				kstr = basicToStr(k)
+				strT[#strT + 1]=string.rep("\t",rec).."["..kstr.."]="
+			end
+			
+			if type(v) == "table" then
+					local name2=string.format("%s[%s]",name,kstr)
+					_ToStr(v,strT,rec,name2)
+			else
+				strT[#strT + 1]=basicToStr(v)
+			end
+		end
+		if dometatables then
+			local mt = getmetatable(t)
+			if mt then
+				local namemt = string.format("%s.METATABLE",name)
+				local strMT = {}
+				_ToStr(mt,strMT,rec,namemt)
+				local metastr=table.concat(strMT)
+				strT[#strT + 1] = "\n"..string.rep("\t",rec).."[METATABLE]="..metastr
+			end
+		end
+		strT[#strT + 1]='}'
+		rec = rec - 1
+		return
+	end
+	_ToStr(t,strTG,recG,nameG)
+	return table.concat(strTG)
+end
+function M.prtable(...)
+	for i=1, select('#', ...) do
+		local t = select(i, ...)
+		print(ToStr(t))
+		print("\n")
+	end
+end
 local function str_split(str, pat)
 	local t = {} 
 	local fpat = "(.-)" .. pat
@@ -29,7 +104,7 @@ local function strip(cad)
     return cad:gsub("^%s*(.-)%s*$","%1") --remove initial and final spaces
 end
 local function strip_end(cad)
-    return cad:gsub("^(.-)%s*$","%1") --remove initial and final spaces
+    return cad:gsub("^(.-)%s*$","%1") --remove  final spaces
 end
 local function clean_spaces(cad)
     cad = strip(cad)
@@ -173,7 +248,14 @@ local function name_overloadsAlgo(v)
     local maxnum = 0
     for i,t in ipairs(v) do
         bb[i] = ""
-        local signature = t.signature:sub(2,-2) -- without parenthesis
+        --local signature = t.signature:sub(2,-2) -- without parenthesis
+		--inside parenthesis
+		local signature = t.signature:match("%b()")
+		signature = signature:sub(2,-2)
+		--add const function
+		if t.signature:match("const$") then
+			signature = signature .. ",_const"
+		end
         aa[i] = {}
         local num = 1
         --for typec in t.signature:gmatch(".-([^,%(%s]+)[,%)]") do
@@ -260,9 +342,11 @@ local function parseFunction(self,stname,lineorig,namespace)
 	--skip template
 	if line:match("template") then return end
     
-    local ret = line:match("([^%(%)]+[%*%s])%s?~?[_%w]+%b()")
-    local funcname, args = line:match("(~?[_%w]+)%s*(%b())")
-	
+    local ret = line:match("([^%(%):,]+[%*%s])%s?~?[_%w]+%b()")
+    --local funcname, args = line:match("(~?[_%w]+)%s*(%b())")
+	local funcname, args, extraconst = line:match("(~?[_%w]+)%s*(%b())(.*)")
+	extraconst = extraconst:match("const")
+
 	if not args then
 	print"not gettint args in"
 	print(line,lineorig)
@@ -282,16 +366,21 @@ local function parseFunction(self,stname,lineorig,namespace)
 
 	--for _,ttype in ipairs(self.templatedTypes) do
     --local template = argscsinpars:match(ttype.."%s*<(.+)>")
+	--TODO several diferent templates
 	local ttype,template = argscsinpars:match("([^%s,%(%)]+)%s*<(.+)>")
 	local te=""
 	if template then
+		if self.typenames[stname] ~= template then --rule out template typename
 		te = template:gsub("%s","_")
         te = te:gsub("%*","Ptr")
+		te = "_"..te
+
 		self.templates[ttype] = self.templates[ttype] or {}
 		self.templates[ttype][template] = te
+		end
 	end
 	--end
-    argscsinpars = argscsinpars:gsub("<([%w_%*]+)>","_"..te) --ImVector
+    argscsinpars = argscsinpars:gsub("<([%w_%*]+)>",te) --ImVector
     
     local argsArr = {}
     local functype_re =       "^%s*[%w%s%*]+%(%*[%w_]+%)%([^%(%)]*%)"
@@ -354,6 +443,7 @@ local function parseFunction(self,stname,lineorig,namespace)
     signature = signature:gsub(",%s*",",")--space after ,
     signature = signature:gsub("([%w_]+)%s[%w_]+(%[%d*%])","%1%2") -- float[2]
     signature = signature:gsub("(%(%*)[%w_]+(%)%([^%(%)]*%))","%1%2") --func defs
+	signature = signature .. (extraconst or "")
     
     local call_args = argscsinpars:gsub("([%w_]+%s[%w_]+)%[%d*%]","%1") --float[2]
     call_args = call_args:gsub("%(%*([%w_]+)%)%([^%(%)]*%)"," %1") --func type
@@ -368,7 +458,7 @@ local function parseFunction(self,stname,lineorig,namespace)
     end
     
     local cimguiname = self.getCname(stname,funcname)
-    table.insert(self.funcdefs,{stname=stname,funcname=funcname,args=args,argsc=argscsinpars,signature=signature,cimguiname=cimguiname,call_args=call_args,ret =ret,comment=comment})
+    table.insert(self.funcdefs,{stname=stname,funcname=funcname,args=args,argsc=argscsinpars,signature=signature,cimguiname=cimguiname,call_args=call_args,ret =ret})
 	local defsT = self.defsT
 	            defsT[cimguiname] = defsT[cimguiname] or {}
                 table.insert(defsT[cimguiname],{})
@@ -376,9 +466,10 @@ local function parseFunction(self,stname,lineorig,namespace)
     defT.defaults = {}
     --for k,def in args:gmatch("([%w%s%*_]+)=([%w_%(%)%s,%*]+)[,%)]") do
     --for k,def in args:gmatch("([%w_]+)=([%w_%(%)%s,%*%.%-]+)[,%)]") do
-    for k,def in args:gmatch('([%w_]+)=([%w_%(%)%s,%*%.%-%+%%"]+)[,%)]') do
+    for k,def in args:gmatch('([%w_]+)=([|<%w_%(%)%s,%*%.%-%+%%"]+)[,%)]') do
         defT.defaults[k]=def
     end
+	defT.templated = self.typenames[stname] and true
 	defT.namespace = namespace
     defT.cimguiname = cimguiname
     defT.stname = stname
@@ -389,7 +480,7 @@ local function parseFunction(self,stname,lineorig,namespace)
     defT.call_args = call_args
     defT.isvararg = signature:match("%.%.%.%)$")
     defT.location = locat
-    defT.comment = "" --comment
+    --defT.comment = "" --comment
     defT.argsT = argsArr
     if self.get_manuals(defT) then
         defT.manual = true
@@ -462,7 +553,7 @@ local function ADDnonUDT(FP)
             defT2.retref = nil
             defsT[t.cimguiname][#defsT[t.cimguiname] + 1] = defT2
             defsT[t.cimguiname][t.signature.."nonUDT"] = defT2
-            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret,comment=comment})
+            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret})
             --converting to Simple type----------------------------------------------------
             local defT3 = {}
             --first strings
@@ -483,7 +574,7 @@ local function ADDnonUDT(FP)
             defT3.retref = nil
             defsT[t.cimguiname][#defsT[t.cimguiname] + 1] = defT3
             defsT[t.cimguiname][t.signature.."nonUDT2"] = defT3
-            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT2",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret,comment=comment})
+            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT2",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret})
         end
         end
 		--end
@@ -511,9 +602,13 @@ local function ADDdestructors(FP)
             for j,cons in ipairs(defT) do
                 cons.constructor = true
             end
-            assert(defT[1].stname==defT[1].funcname)
+            if(defT[1].stname~=defT[1].funcname) then
+				print(defT[1].stname, defT[1].funcname)
+				error"names should be equal"
+			end
             local def = {}
             def.stname = defT[1].stname
+			def.templated = defT[1].templated
             def.ret = "void"
             def.ov_cimguiname = def.stname.."_destroy"
             def.cimguiname = def.ov_cimguiname
@@ -535,6 +630,7 @@ end
 
 --only basic ending
 local c_types = {
+    ["bool"]=true,
     ["char"]=true,
     ["int"]=true,
     ["float"]=true,
@@ -546,6 +642,7 @@ local c_types = {
     ["size_t"]=true,
     ["ptrdiff_t"]=true,
 }
+M.c_types = c_types
 local function check_arg_detection(fdefs,typedefs)
     print"-----------------check arg detection---------------------------"
     for k,defT in pairs(fdefs) do
@@ -587,6 +684,7 @@ function M.Parser()
 	par.embeded_structs = {}
 	par.inerstructs = {}
 	par.templates = {}
+	par.typenames = {}
 	par.typedefs_dict = {}
 	par.cname_overloads = {}
 	par.manuals = {}
@@ -612,6 +710,9 @@ function M.Parser()
 		self:parseItems()
 		self:parseFunctions()
 		self:compute_overloads()
+		self:gen_structs_and_enums()
+		--self:compute_templated()
+		ADDdestructors(self)
 	end
 	function par:parseItems()
 		--typedefs dictionary
@@ -643,7 +744,8 @@ function M.Parser()
 		printItems(items)
 	end
 	par.parseFunction = parseFunction
-
+	
+	--get all function definitions and template structs
 	function par:parseFunctions()
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "function_re" or it.re_name == "functionD_re" then
@@ -658,8 +760,14 @@ function M.Parser()
 					end
 				end
 			elseif it.re_name == "struct_re" then
+				--check template struct
+				local typename = it.item:match("%s*template%s*<%s*typename%s*(%S+)%s*>")
 				local nsp = it.item:match("%b{}"):sub(2,-2)
 				local stname = it.item:match("struct%s+(%S+)")
+				if typename then -- it is a struct template
+					self.typenames = self.typenames or {}
+					self.typenames[stname] = typename
+				end
 				local nspparr,itemsnsp = parseItems(nsp)
 				for insp,itnsp in ipairs(nspparr) do
 					if itnsp.re_name == "function_re" or itnsp.re_name == "functionD_re" then
@@ -702,14 +810,18 @@ function M.Parser()
 				--local ttype,template = it.item:match("([^%s,%(%)]+)%s*<(.+)>")
 				local ttype,template =    it.item:match"([^%s,%(%)]+)%s*<(.+)>"
 				if template then
+					--if template=="T" then print("T found in---------");print(stru) end
 					local te = template:gsub("%s","_")
 					te = te:gsub("%*","Ptr")
 					self.templates[ttype] = self.templates[ttype] or {}
 					self.templates[ttype][template] = te
+					it2 = it2:gsub("(<[%w_%*%s]+>)([^%s])","%1 %2") --add if not present space after <>
 					it2 = it2:gsub("<([%w_%*%s]+)>","_"..te)
 				end
 				--clean mutable
 				it2 = it2:gsub("mutable","")
+				--clean namespaces
+				it2 = it2:gsub("%w+::","")
 				--skip static variables
 				if not (it.re_name == "vardef_re" and it2:match"static") then
 					table.insert(outtab,it2)
@@ -723,10 +835,11 @@ function M.Parser()
 		return table.concat(outtab,""),stname,outtab
 	end
 	function par:gen_structs_and_enums()
-		local outtab = {}
+		local outtab = {} 
 		local outtabpre = {}
 		local typedefs_table = {}
-
+		self.inerstructs = {}
+		
 		--first typedefs
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "typedef_re" or it.re_name == "functypedef_re" or it.re_name == "vardef_re" then
@@ -739,13 +852,30 @@ function M.Parser()
 				end
 			end
 		end
+		--get structs in namespace
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "namespace_re" then
+				local nsp = it.item:match("%b{}"):sub(2,-2)
+				local namespace = it.item:match("namespace%s+(%S+)")
+				local nspparr,itemsnsp = parseItems(nsp)
+				for insp,itnsp in ipairs(nspparr) do
+					if itnsp.re_name == "struct_re" then --or itnsp.re_name == "functionD_re" then
+						--print("in mamespace",itnsp.item,namespace)
+						table.insert(outtab,itnsp.item)
+					end
+				end
+			end
+		end
 		--then structs and enums
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "enum_re" then
-				table.insert(outtab,it.item)
+				local enumname, enumbody = it.item:match"^%s*enum%s+([^%s;{}]+)[%s\n\r]*(%b{})"
+				--print("enum is:",enumname, enumbody)
+				table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";")
 			elseif it.re_name == "struct_re" then
 				local cleanst,structname = self:clean_struct(it.item)
-				if structname then
+				--if not void stname or templated
+				if structname and not self.typenames[structname] then
 				table.insert(outtab,cleanst)
 				table.insert(typedefs_table,"typedef struct "..structname.." "..structname..";\n")
 				self.typedefs_dict[structname]="struct "..structname
@@ -785,6 +915,9 @@ function M.Parser()
 			local typen,rest = line:match("%s*([^,]+)%s(%S+[,;])")
 			--local template_type = typen:match("/%*<(.+)>%*/")
 			--if template_type then typen = typen:match("(.+)/%*") end
+                if not typen then -- Lets try Type*name
+                    typen,rest = line:match("([^,]+%*)(%S+[,;])")
+                end
 			local template_type 
 			for k,v in pairs(self.templates) do
 				template_type = typen:match(k.."_(.+)")
@@ -801,15 +934,44 @@ function M.Parser()
 	end
 	function par:gen_structs_and_enums_table()
 		local outtab = {enums={},structs={}}
-		local outtabpre = {}
-		local typedefs_table = {}
+		self.typedefs_table = {}
+		self.vardefs = {}
 
 		self.inerstructs = {}
+		self.order = {}
+		
+		--first typedefs
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "typedef_re" then --or it.re_name == "functypedef_re" or it.re_name == "vardef_re" then
+				local typedefdef,typedefname = it.item:match"typedef(.+)%s([^%s;]+);$"
+				typedefname = strip(typedefname)
+				self.typedefs_table[typedefname] = strip(typedefdef)
+				self.order[typedefname] = i
+				-- add typedef after struct name
+				-- if it.re_name == "vardef_re" and it.item:match"struct" then
+					-- local stname = it.item:match("struct%s*(%S+)%s*;")
+					-- table.insert(typedefs_table,"typedef struct "..stname.." "..stname..";\n")
+					-- self.typedefs_dict[stname]="struct "..stname
+				-- end
+			end
+		end
+		--vardefs
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "vardef_re" then 
+				local stname = it.item:match"struct%s(%S+)$"
+				if stname then
+					stname = strip(stname)
+					self.vardefs[stname] = true
+					self.order[stname] = i
+				end
+			end
+		end
 		--then structs and enums
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "enum_re" then
 				local enumname = it.item:match"^%s*enum%s+([^%s;{}]+)"
 				outtab.enums[enumname] = {}
+				self.order[enumname] = i
 				local inner = strip_end(it.item:match("%b{}"):sub(2,-2))
 				local enumarr = str_split(inner,",")
 				for j,line in ipairs(enumarr) do
@@ -825,8 +987,11 @@ function M.Parser()
 				end
 			elseif it.re_name == "struct_re" then
 				local cleanst,structname,strtab = self:clean_struct(it.item)
-				if structname then --not empty struc
+				--if not void stname or templated
+				--M.prtable(cleanst,structname,strtab)
+				if structname and not self.typenames[structname] then
 					outtab.structs[structname] = {}
+					self.order[structname]=i
 					for j=3,#strtab-1 do
 						self:parse_struct_line(strtab[j],outtab.structs[structname])
 					end
@@ -949,9 +1114,113 @@ function M.Parser()
         table.insert(strt,string.format("%d overloaded",numoverloaded))
 		AdjustArguments(self)
 		ADDnonUDT(self)
-		ADDdestructors(self)
+		--ADDdestructors(self)
         self.overloadstxt  = table.concat(strt,"\n")
     end
+	local function typename_gsub(cad,typename,tname)
+		local str,n = "",0
+		if tname:match"%*" then
+		str,n = cad:gsub("(const%s+)("..typename..")", tname.." %1")
+		end
+		if n==0 then
+		str,n = cad:gsub("(const%s+)("..typename..")(%s*%*)", tname.." %1%3")
+		end
+		if n==0 then
+		str,n = cad:gsub("([^_%w])("..typename..")([^_%w])", "%1"..tname.."%3")
+		end
+		if n==0 then
+		str,n = cad:gsub("([^_%w])("..typename..")$", "%1"..tname)
+		end
+		if n==0 then
+		str,n = cad:gsub("^("..typename..")(%s*%*)", tname.."%2")
+		end
+		return str
+	end
+	function par:compute_templated()
+		local defsT = self.defsT
+		local newcdefs = {}
+		for numcdef,t in ipairs(self.funcdefs) do
+			if t.cimguiname then
+			local cimf = defsT[t.cimguiname]
+			local defT = cimf[t.signature]
+			if defT.templated then
+				local templates = self.templates[defT.stname]
+				local typename = self.typenames[defT.stname]
+				for tname,tnamestr in pairs(templates) do
+					--local tnamestr = typetoStr(tname)
+					local stname = defT.stname .. "_" .. tnamestr
+					local cimguiname = t.cimguiname:gsub(defT.stname,stname)
+					local ov_cimguiname = defT.ov_cimguiname:gsub(defT.stname,stname)
+					local signature = defT.signature:gsub(typename, tname)
+					local ret 
+					if defT.ret then
+						--ret = defT.ret:gsub(typename, tname)
+						ret = typename_gsub(defT.ret, typename, tname)
+					end
+
+					local args = defT.args:gsub(defT.stname,stname)
+
+					args = typename_gsub(args, typename, tname)
+					
+					local argsT = {}
+					for i,ar in ipairs(defT.argsT) do
+						argsT[i] = {}
+						for k,v in pairs(ar) do
+							if k=="type" then
+								v = v:gsub(defT.stname,stname)
+								v = typename_gsub(v, typename, tname)
+							end
+							argsT[i][k]=v
+						end
+					end
+					-----------reconstruct args
+					--if(#argsT==0 and not defT.constructor) then M.prtable(defT) end
+					--if is const function make self const
+					if #argsT>0 and signature:match"const$" then
+						argsT[1].type = "const "..argsT[1].type
+					end
+					
+					args = "("
+					for i=1,#argsT-1 do
+						local ar = argsT[i]
+						args = args .. ar.type .. " " ..ar.name .. ","
+					end
+					local ar = argsT[#argsT]
+					if ar then args = args .. ar.type .. " " ..ar.name .. ")" 
+					else args = args .. ")" end
+					args = args:gsub("&","")
+					------------------------------
+					
+					defTnew = {}
+					defTnew.cimguiname = cimguiname
+					defTnew.ov_cimguiname = ov_cimguiname
+					defTnew.signature = signature
+					defTnew.ret = ret
+					defTnew.retref = defT.retref
+					defTnew.templatedgen = true
+					defTnew.call_args = defT.call_args
+					defTnew.stname = stname
+					local funcname = defT.funcname
+					if funcname == defT.stname then --is constructor
+						funcname = stname
+					end
+					defTnew.funcname = funcname
+					defTnew.args = args
+					defTnew.argsT = argsT
+					defTnew.defaults = {}
+					--print(cimguiname,ov_cimguiname, signature , ret)
+					defsT[cimguiname] = defsT[cimguiname] or {}
+					defsT[cimguiname][#defsT[cimguiname] + 1] = defTnew
+					defsT[cimguiname][signature] = defTnew
+					table.insert(newcdefs,{stname=stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=signature,cimguiname=cimguiname,call_args=call_args,ret =t.ret})
+				end
+			end -- templated
+			end --cimguiname
+		end
+		for i,v in ipairs(newcdefs) do
+			table.insert(self.funcdefs,v)
+		end
+	end
 	return par
 end
 
@@ -1021,7 +1290,7 @@ M.serializeTableF = function(t)
 	return M.serializeTable("defs",t).."\nreturn defs"
 end
 --iterates lines from a gcc/clang -E in a specific location
-local function location(file,locpathT,defines)
+local function location(file,locpathT,defines,COMPILER)
 	local define_re = "^#define%s+([^%s]+)%s+([^%s]+)$"
 	local number_re = "^-?[0-9]+u*$"
 	local hex_re = "0x[0-9a-fA-F]+u*$"
@@ -1031,6 +1300,7 @@ local function location(file,locpathT,defines)
     else --gcc, clang
         location_re = '^# (%d+) "([^"]*)"'
     end
+
     local path_reT = {}
     for i,locpath in ipairs(locpathT) do
         table.insert(path_reT,'^.*[\\/]('..locpath..')%.h$')
@@ -1056,6 +1326,7 @@ local function location(file,locpathT,defines)
             if #line==0 then --nothing on emptyline
             elseif not line:match("%S") then --nothing if only spaces
             elseif line:sub(1,1) == "#" then
+			--elseif line:match"^%s*#" then
                 -- Is this a location pragma?
                 local loc_num_t,location_match = line:match(location_re)
                 if location_match then

generator/generator.bat

@@ -10,13 +10,13 @@
 :: impl_definitions.lua for implementation function definitions
 
 :: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
-:: set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
+set PATH=%PATH%;C:\anima;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
 :: arg[1] compiler name gcc, clang, cl or nocompiler
 :: arg[2..n] name of implementations to generate
-luajit ./generator.lua clang glfw opengl3 opengl2 sdl
+luajit ./generator.lua gcc glfw opengl3 opengl2 sdl
 
 ::leave console open
 cmd /k

generator/generator.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/sh
+
+# this script must be executed in this directory
+# all the output goes to generator/output folder
+# .cpp and .h files:
+# cimgui.h and cimgui.cpp with gcc preprocess
+# cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+# cimgui_impl.h with implementation function cdefs
+# lua and json files:
+# definitions.lua for function definitions
+# structs_and_enums.lua with struct and enum information-definitions
+# impl_definitions.lua for implementation function definitions
+
+#process  files
+# arg[1] compiler name gcc, clang, cl or nocompiler
+# arg[2..n] name of implementations to generate
+luajit ./generator.lua gcc glfw opengl3 opengl2 sdl

generator/generator2.lua

@@ -1,609 +0,0 @@
---------------------------------------------------------------------------
---script for auto_funcs.h and auto_funcs.cpp generation
---expects LuaJIT
---------------------------------------------------------------------------
-assert(_VERSION=='Lua 5.1',"Must use LuaJIT")
-assert(bit,"Must use LuaJIT")
-local script_args = {...}
-local COMPILER = script_args[1]
-local CPRE,CTEST
-if COMPILER == "gcc" or COMPILER == "clang" then
-    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]
-    CTEST = COMPILER.." --version"
-elseif COMPILER == "cl" then
-    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ]]
-    CTEST = COMPILER
-else
-    print("Working without compiler ")
-end
---test compiler present
-local HAVE_COMPILER = false
-if CTEST then
-    local pipe,err = io.popen(CTEST,"r")
-    if pipe then
-        local str = pipe:read"*a"
-        print(str)
-        pipe:close()
-        if str=="" then
-            HAVE_COMPILER = false
-        else
-            HAVE_COMPILER = true
-        end
-    else
-        HAVE_COMPILER = false
-        print(err)
-    end
-    assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
-end --CTEST
-
-print("HAVE_COMPILER",HAVE_COMPILER)
---get implementations
-local implementations = {}
-for i=2,#script_args do table.insert(implementations,script_args[i]) end
-
---------------------------------------------------------------------------
---this table has the functions to be skipped in generation
---------------------------------------------------------------------------
-local cimgui_manuals = {
-    igLogText = true,
-    ImGuiTextBuffer_appendf = true,
-    igColorConvertRGBtoHSV = true,
-    igColorConvertHSVtoRGB = true
-}
---------------------------------------------------------------------------
---this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
---first level is cimguiname without postfix, second level is the signature of the function, value is the
---desired name
----------------------------------------------------------------------------
-local cimgui_overloads = {
-    igPushID = {
-        --["(const char*)"] =           "igPushIDStr",
-        ["(const char*,const char*)"] = "igPushIDRange",
-        --["(const void*)"] =           "igPushIDPtr",
-        --["(int)"] =                   "igPushIDInt"
-    },
-    igGetID = {
-        ["(const char*,const char*)"] = "igGetIDRange",
-    },
-    ImDrawList_AddText = {
-        ["(const ImVec2,ImU32,const char*,const char*)"] = "ImDrawList_AddText",
-    },
-    igGetColorU32 = {
-        ["(ImGuiCol,float)"] = "igGetColorU32",
-    },
-    igCollapsingHeader = {
-        ["(const char*,ImGuiTreeNodeFlags)"] =  "igCollapsingHeader",
-    },
-    igCombo = {
-        ["(const char*,int*,const char* const[],int,int)"] = "igCombo",
-    },
-    igPlotLines = {
-        ["(const char*,const float*,int,int,const char*,float,float,ImVec2,int)"] = "igPlotLines",
-    },
-    igBeginChild = {
-        ["(const char*,const ImVec2,bool,ImGuiWindowFlags)"] = "igBeginChild",
-    },
-    igSelectable = {
-        ["(const char*,bool,ImGuiSelectableFlags,const ImVec2)"] = "igSelectable"
-    },
-    igPushStyleColor = {
-        ["(ImGuiCol,const ImVec4)"] = "igPushStyleColor"
-    }
-}
-
---------------------------header definitions
-local cimgui_header = 
-[[//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version XXX from Dear ImGui https://github.com/ocornut/imgui
-]]
-local gdefines = {} --for FLT_MAX and others
---------------------------------------------------------------------------
---helper functions
-
-
----------------------------minimal preprocessor without compiler for ImGui.h
-local function filelines(file,locats)
-    local split_comment = require"cpp2ffi".split_comment
-    local iflevels = {}
-   --generated known prepros
-local prepro = {
-["#if"]={
-    [   "defined(__clang__) || defined(__GNUC__)"       ]=false,
-    [   "defined(__clang__)"    ]=false,
-    [   "defined(_MSC_VER) && !defined(__clang__)"      ]=false,
-    [   "!defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)"       ]=false,
-    [   "!defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)     \\"        ]=false,
-},
-["#elif"]={
-    [   "defined(__GNUC__) && __GNUC__ >= 8"    ]=false,
-    [   "(defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)"   ]=false,
-},
-["#ifdef"]={
-    [   "IM_VEC4_CLASS_EXTRA"   ]=false,
-    [   "IMGUI_USER_CONFIG"     ]=false,
-    [   "IMGUI_INCLUDE_IMGUI_USER_H"    ]=false,
-    [   "IMGUI_USE_BGRA_PACKED_COLOR"   ]=false,
-    [   "IM_VEC2_CLASS_EXTRA"   ]=false,
-},
-["#ifndef"]={
-    [   "IMGUI_API"     ]=false,
-    [   "IMGUI_IMPL_API"        ]=false,
-    [   "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" ]=true,
-    [   "IM_ASSERT"     ]=false,
-    [   "ImTextureID"   ]=true,
-    [   "ImDrawIdx"     ]=true,
-    [   "IMGUI_DISABLE_OBSOLETE_FUNCTIONS"      ]=false,
-},
-}
-
-    local function prepro_boolif(pre,cond)
-        local conds = prepro[pre]
-        assert(conds,pre.." has no conds-----------------------------")
-        local res = conds[cond]
-        --assert(type(res)~="nil",cond.." not found")
-        if type(res)=="nil" then
-            print(pre,cond,"not found in precompiler database, returning false.")
-            res = false
-        end
-        return res
-    end
-    local function location_it()
-        repeat
-            local line = file:read"*l"
-
-            if not line then return nil end
-            line,_ = split_comment(line)
-            --if line:sub(1,1) == "#" then
-            if line:match("^%s*#") then
-                
-                local pre,cond = line:match("^%s*(#%S*)%s+(.*)%s*$")
-                if line:match("#if") then 
-                    iflevels[#iflevels +1 ] = prepro_boolif(pre,cond)
-                elseif line:match("#endif") then
-                    iflevels[#iflevels] = nil
-                elseif line:match("#elif") then
-                    if not iflevels[#iflevels] then
-                        iflevels[#iflevels] = prepro_boolif(pre,cond)
-                    else --was true
-                        iflevels[#iflevels] = false
-                    end
-                elseif line:match("#else") then
-                    iflevels[#iflevels] = not iflevels[#iflevels]
-                else
-                    if not (pre:match("#define") or pre:match"#include" or pre:match"#pragma") then
-                        print("not expected preprocessor directive ",pre)
-                    end
-                end
-                -- skip
-            elseif #iflevels == 0 or iflevels[#iflevels] then
-                -- drop IMGUI_APIX
-                line = line:gsub("IMGUI_IMPL_API","")
-                -- drop IMGUI_API
-                line = line:gsub("IMGUI_API","")
-                return line,locats[1]
-            end
-        until false
-    end
-    return location_it
-end
-
-
---------------------------------functions for C generation
-local function func_header_impl_generate(FP)
-
-    local outtab = {}
-    
-    for _,t in ipairs(FP.funcdefs) do
-        if t.cimguiname then
-            local cimf = FP.defsT[t.cimguiname]
-            local def = cimf[t.signature]
-            if def.ret then --not constructor
-                local addcoment = def.comment or ""
-                if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-                else
-                    error("class function in implementations")
-                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 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
-    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 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")
-    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 = ImGui::"..def.funcname.."V"..call_args..";\n")
-        else
-            table.insert(outtab,"    ImGui::"..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 = ImGui::"..def.funcname..def.call_args..";\n")
-        else --nonUDT==2
-            table.insert(outtab,"    "..def.retorig.." ret = ImGui::"..def.funcname..def.call_args..";\n")
-            table.insert(outtab,"    "..def.ret.." ret2 = "..def.retorig.."ToSimple(ret);\n")
-            table.insert(outtab,"    return ret2;\n")
-        end
-    else --standard ImGui
-        table.insert(outtab,"    return "..ptret.."ImGui::"..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")
-        else --nonUDT==2
-            table.insert(outtab,"    "..def.retorig.." ret = self->"..def.funcname..def.call_args..";\n")
-            table.insert(outtab,"    "..def.ret.." ret2 = "..def.retorig.."ToSimple(ret);\n")
-            table.insert(outtab,"    return ret2;\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 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
-    local pipe,err = io.popen(COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h]],"r")
-    local defines = {}
-    while true do
-        local line = pipe:read"*l"
-        if not line then break end
-        local key,value = line:match([[#define%s+(%S+)%s+(.+)]])
-        if not key or not value then 
-            --print(line)
-        else
-            defines[key]=value
-        end
-    end
-    pipe:close()
-    --require"anima.utils"
-    --prtable(defines)
-    --FLT_MAX
-    local ret = {}
-    for i,v in ipairs(t) do
-        local aa = defines[v]
-        while true do
-            local tmp = defines[aa]
-            if not tmp then 
-                break
-            else
-                aa = tmp
-            end
-        end
-        ret[v] = aa
-    end
-    return ret
-end
-  --subtitution of FLT_MAX value for FLT_MAX 
-local function set_defines(fdefs)
-    for k,defT in pairs(fdefs) do
-        for i,def in ipairs(defT) do
-            for name,default in pairs(def.defaults) do
-                if default == gdefines.FLT_MAX then
-                    def.defaults[name] = "FLT_MAX"
-                end
-            end
-        end
-    end
-end 
---this creates defsBystruct in case you need to list by struct container
-local function DefsByStruct(FP)
-    local structs = {}
-    for fun,defs in pairs(FP.defsT) do
-        local stname = defs[1].stname
-        structs[stname] = structs[stname] or {}
-        table.insert(structs[stname],defs)--fun)
-    end
-    FP.defsBystruct = structs
-end  
-
-
---load parser module
-local cpp2ffi = require"cpp2ffi"
-local read_data = cpp2ffi.read_data
-local save_data = cpp2ffi.save_data
-local copyfile = cpp2ffi.copyfile
-local serializeTableF = cpp2ffi.serializeTableF
-
-----------custom ImVector templates
-local function generate_templates(code,templates)
-    table.insert(code,[[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")
-		end
-		end
-    end
-end
---generate cimgui.cpp cimgui.h 
-local function cimgui_generation(parser)
-
-    local hstrfile = read_data"./cimgui_template.h"
-
-	local outpre,outpost = parser:gen_structs_and_enums()
-
-	local outtab = {}
-    generate_templates(outtab,parser.templates)
-	local cstructsstr = outpre..table.concat(outtab,"")..outpost
-
-    hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
-    local cfuncsstr = func_header_generate(parser)
-    hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
-    save_data("./output/cimgui.h",cimgui_header,hstrfile)
-    
-    --merge it in cimgui_template.cpp to cimgui.cpp
-    local cimplem = func_implementation(parser)
-
-    local hstrfile = read_data"./cimgui_template.cpp"
-
-    hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
-    save_data("./output/cimgui.cpp",cimgui_header,hstrfile)
-
-end
---------------------------------------------------------
------------------------------do it----------------------
---------------------------------------------------------
---get imgui.h version--------------------------
-local pipe,err = io.open("../imgui/imgui.h","r")
-if not pipe then
-    error("could not open file:"..err)
-end
-local imgui_version
-while true do
-    local line = pipe:read"*l"
-    imgui_version = line:match([[#define%s+IMGUI_VERSION%s+(".+")]])
-    if imgui_version then break end
-end
-pipe:close()
-cimgui_header = cimgui_header:gsub("XXX",imgui_version)
-print("IMGUI_VERSION",imgui_version)
---get some defines----------------------------
-if HAVE_COMPILER then
-    gdefines = get_defines{"IMGUI_VERSION","FLT_MAX"}
-end                                 
-
---generation
-print("------------------generation with "..COMPILER.."------------------------")
-local typedefs_dict2
---prepare parser
-local parser1 = cpp2ffi.Parser()
-parser1.getCname = function(stname,funcname)
-    local pre = (stname == "") and "ig" or stname.."_"
-    return pre..funcname
-end
-parser1.cname_overloads = cimgui_overloads
-parser1.manuals = cimgui_manuals
-parser1.UDTs = {"ImVec2","ImVec4","ImColor"}
-
-local pipe,err
-if HAVE_COMPILER then
-    pipe,err = io.popen(CPRE..[[../imgui/imgui.h]],"r")
-else
-    pipe,err = io.open([[../imgui/imgui.h]],"r")
-end
-
-if not pipe then
-    error("could not execute gcc "..err)
-end
-
-local iterator = (HAVE_COMPILER and cpp2ffi.location) or filelines
-
-for line in iterator(pipe,{"imgui"},{}) do
-	parser1:insert(line)
-end
-pipe:close()
-
-parser1:do_parse()
-
---parser1:dump_alltypes()
---parser1:printItems()
-
-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))
-
---check every function has ov_cimguiname
--- for k,v in pairs(parser1.defsT) do
-	-- for _,def in ipairs(v) do
-		-- assert(def.ov_cimguiname)
-	-- end
--- end
---=================================Now implementations
-
-local parser2
-
-if #implementations > 0 then
-
-    parser2 = cpp2ffi.Parser()
-
-    
-    for i,impl in ipairs(implementations) do
-        local source = [[../imgui/examples/imgui_impl_]].. impl .. ".h "
-        local locati = [[imgui_impl_]].. impl
-        local pipe,err
-        if HAVE_COMPILER then
-            pipe,err = io.popen(CPRE..source,"r")
-        else
-            pipe,err = io.open(source,"r")
-        end
-        if not pipe then
-            error("could not get file: "..err)
-        end
-        
-        local iterator = (HAVE_COMPILER and cpp2ffi.location) or filelines
-        
-        for line,locat in iterator(pipe,{locati},{}) do
-            --local line, comment = split_comment(line)
-			parser2:insert(line)
-        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()
-    save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
-
-    ----------save fundefs in impl_definitions.lua for using in bindings
-    save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
-
-end -- #implementations > 0 then
-
--------------------------------json saving
---avoid mixed tables (with string and integer keys)
-local function json_prepare(defs)
-    --delete signatures in function
-    for k,def in pairs(defs) do
-        for k2,v in pairs(def) do
-            if type(k2)=="string" then
-                def[k2] = nil
-            end
-        end
-    end
-    return defs
-end
----[[
-local json = require"json"
-save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT)))
-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)))
-end
---]]
--------------------copy C files to repo root
-copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui.cpp", "../cimgui.cpp")
-print"all done!!"

generator/generator_old.bat

@@ -16,7 +16,7 @@ set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
 ::process  files
 :: arg[1] compiler name gcc, clang, cl or nocompiler
 :: arg[2..n] name of implementations to generate
-luajit ./generator2.lua gcc glfw opengl3 opengl2 sdl
+luajit ./generator_old.lua gcc glfw opengl3 opengl2 sdl
 
 ::leave console open
 cmd /k

generator/output/cimgui.cpp

@@ -1,10 +1,11 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.67" from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.75" from Dear ImGui https://github.com/ocornut/imgui
 
 #include "./imgui/imgui.h"
+#include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#include "./imgui/imgui_internal.h"
+
 
 CIMGUI_API ImVec2* ImVec2_ImVec2(void)
 {
@@ -46,9 +47,9 @@ CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
 {
     return ImGui::SetCurrentContext(ctx);
 }
-CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)
+CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
 {
-    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert);
+    return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
 }
 CIMGUI_API ImGuiIO* igGetIO()
 {
@@ -174,30 +175,6 @@ CIMGUI_API float igGetWindowHeight()
 {
     return ImGui::GetWindowHeight();
 }
-CIMGUI_API ImVec2 igGetContentRegionMax()
-{
-    return ImGui::GetContentRegionMax();
-}
-CIMGUI_API ImVec2 igGetContentRegionAvail()
-{
-    return ImGui::GetContentRegionAvail();
-}
-CIMGUI_API float igGetContentRegionAvailWidth()
-{
-    return ImGui::GetContentRegionAvailWidth();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMin()
-{
-    return ImGui::GetWindowContentRegionMin();
-}
-CIMGUI_API ImVec2 igGetWindowContentRegionMax()
-{
-    return ImGui::GetWindowContentRegionMax();
-}
-CIMGUI_API float igGetWindowContentRegionWidth()
-{
-    return ImGui::GetWindowContentRegionWidth();
-}
 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
 {
     return ImGui::SetNextWindowPos(pos,cond,pivot);
@@ -262,6 +239,26 @@ CIMGUI_API void igSetWindowFocusStr(const char* name)
 {
     return ImGui::SetWindowFocus(name);
 }
+CIMGUI_API ImVec2 igGetContentRegionMax()
+{
+    return ImGui::GetContentRegionMax();
+}
+CIMGUI_API ImVec2 igGetContentRegionAvail()
+{
+    return ImGui::GetContentRegionAvail();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMin()
+{
+    return ImGui::GetWindowContentRegionMin();
+}
+CIMGUI_API ImVec2 igGetWindowContentRegionMax()
+{
+    return ImGui::GetWindowContentRegionMax();
+}
+CIMGUI_API float igGetWindowContentRegionWidth()
+{
+    return ImGui::GetWindowContentRegionWidth();
+}
 CIMGUI_API float igGetScrollX()
 {
     return ImGui::GetScrollX();
@@ -286,10 +283,18 @@ CIMGUI_API void igSetScrollY(float scroll_y)
 {
     return ImGui::SetScrollY(scroll_y);
 }
+CIMGUI_API void igSetScrollHereX(float center_x_ratio)
+{
+    return ImGui::SetScrollHereX(center_x_ratio);
+}
 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
 {
     return ImGui::SetScrollHereY(center_y_ratio);
 }
+CIMGUI_API void igSetScrollFromPosX(float local_x,float center_x_ratio)
+{
+    return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
+}
 CIMGUI_API void igSetScrollFromPosY(float local_y,float center_y_ratio)
 {
     return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
@@ -362,6 +367,10 @@ CIMGUI_API void igPopItemWidth()
 {
     return ImGui::PopItemWidth();
 }
+CIMGUI_API void igSetNextItemWidth(float item_width)
+{
+    return ImGui::SetNextItemWidth(item_width);
+}
 CIMGUI_API float igCalcItemWidth()
 {
     return ImGui::CalcItemWidth();
@@ -394,9 +403,9 @@ CIMGUI_API void igSeparator()
 {
     return ImGui::Separator();
 }
-CIMGUI_API void igSameLine(float local_pos_x,float spacing_w)
+CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
 {
-    return ImGui::SameLine(local_pos_x,spacing_w);
+    return ImGui::SameLine(offset_from_start_x,spacing);
 }
 CIMGUI_API void igNewLine()
 {
@@ -692,13 +701,13 @@ CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_curr
 {
     return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max);
 }
-CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::DragScalar(label,data_type,v,v_speed,v_min,v_max,format,power);
+    return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,power);
 }
-CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::DragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power);
+    return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,power);
 }
 CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power)
 {
@@ -736,13 +745,13 @@ CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,cons
 {
     return ImGui::SliderInt4(label,v,v_min,v_max,format);
 }
-CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::SliderScalar(label,data_type,v,v_min,v_max,format,power);
+    return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,power);
 }
-CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::SliderScalarN(label,data_type,v,components,v_min,v_max,format,power);
+    return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,power);
 }
 CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power)
 {
@@ -752,9 +761,9 @@ CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_mi
 {
     return ImGui::VSliderInt(label,size,v,v_min,v_max,format);
 }
-CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_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,float power)
 {
-    return ImGui::VSliderScalar(label,size,data_type,v,v_min,v_max,format,power);
+    return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,power);
 }
 CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
@@ -764,6 +773,10 @@ CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size
 {
     return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
 }
+CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
+{
+    return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
+}
 CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
 {
     return ImGui::InputFloat(label,v,step,step_fast,format,flags);
@@ -800,13 +813,13 @@ CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double ste
 {
     return ImGui::InputDouble(label,v,step,step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalar(label,data_type,v,step,step_fast,format,flags);
+    return ImGui::InputScalar(label,data_type,p_data,p_step,p_step_fast,format,flags);
 }
-CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
+CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
 {
-    return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,flags);
+    return ImGui::InputScalarN(label,data_type,p_data,components,p_step,p_step_fast,format,flags);
 }
 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
 {
@@ -900,18 +913,10 @@ CIMGUI_API void igTreePop()
 {
     return ImGui::TreePop();
 }
-CIMGUI_API void igTreeAdvanceToLabelPos()
-{
-    return ImGui::TreeAdvanceToLabelPos();
-}
 CIMGUI_API float igGetTreeNodeToLabelSpacing()
 {
     return ImGui::GetTreeNodeToLabelSpacing();
 }
-CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond)
-{
-    return ImGui::SetNextTreeNodeOpen(is_open,cond);
-}
 CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags)
 {
     return ImGui::CollapsingHeader(label,flags);
@@ -920,6 +925,10 @@ CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTr
 {
     return ImGui::CollapsingHeader(label,p_open,flags);
 }
+CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
+{
+    return ImGui::SetNextItemOpen(is_open,cond);
+}
 CIMGUI_API bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
 {
     return ImGui::Selectable(label,selected,flags,size);
@@ -980,14 +989,6 @@ CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format
 {
     return ImGui::Value(prefix,v,float_format);
 }
-CIMGUI_API bool igBeginMainMenuBar()
-{
-    return ImGui::BeginMainMenuBar();
-}
-CIMGUI_API void igEndMainMenuBar()
-{
-    return ImGui::EndMainMenuBar();
-}
 CIMGUI_API bool igBeginMenuBar()
 {
     return ImGui::BeginMenuBar();
@@ -996,6 +997,14 @@ CIMGUI_API void igEndMenuBar()
 {
     return ImGui::EndMenuBar();
 }
+CIMGUI_API bool igBeginMainMenuBar()
+{
+    return ImGui::BeginMainMenuBar();
+}
+CIMGUI_API void igEndMainMenuBar()
+{
+    return ImGui::EndMainMenuBar();
+}
 CIMGUI_API bool igBeginMenu(const char* label,bool enabled)
 {
     return ImGui::BeginMenu(label,enabled);
@@ -1039,15 +1048,15 @@ CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
 {
     return ImGui::BeginPopup(str_id,flags);
 }
-CIMGUI_API bool igBeginPopupContextItem(const char* str_id,int mouse_button)
+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,int mouse_button,bool also_over_items)
+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,int mouse_button)
+CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiMouseButton mouse_button)
 {
     return ImGui::BeginPopupContextVoid(str_id,mouse_button);
 }
@@ -1059,7 +1068,7 @@ CIMGUI_API void igEndPopup()
 {
     return ImGui::EndPopup();
 }
-CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,int mouse_button)
+CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,ImGuiMouseButton mouse_button)
 {
     return ImGui::OpenPopupOnItemClick(str_id,mouse_button);
 }
@@ -1123,17 +1132,17 @@ CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
 {
     return ImGui::SetTabItemClosed(tab_or_docked_window_label);
 }
-CIMGUI_API void igLogToTTY(int max_depth)
+CIMGUI_API void igLogToTTY(int auto_open_depth)
 {
-    return ImGui::LogToTTY(max_depth);
+    return ImGui::LogToTTY(auto_open_depth);
 }
-CIMGUI_API void igLogToFile(int max_depth,const char* filename)
+CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
 {
-    return ImGui::LogToFile(max_depth,filename);
+    return ImGui::LogToFile(auto_open_depth,filename);
 }
-CIMGUI_API void igLogToClipboard(int max_depth)
+CIMGUI_API void igLogToClipboard(int auto_open_depth)
 {
-    return ImGui::LogToClipboard(max_depth);
+    return ImGui::LogToClipboard(auto_open_depth);
 }
 CIMGUI_API void igLogFinish()
 {
@@ -1147,9 +1156,9 @@ CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
 {
     return ImGui::BeginDragDropSource(flags);
 }
-CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond)
+CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
 {
-    return ImGui::SetDragDropPayload(type,data,size,cond);
+    return ImGui::SetDragDropPayload(type,data,sz,cond);
 }
 CIMGUI_API void igEndDragDropSource()
 {
@@ -1199,7 +1208,7 @@ CIMGUI_API bool igIsItemFocused()
 {
     return ImGui::IsItemFocused();
 }
-CIMGUI_API bool igIsItemClicked(int mouse_button)
+CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button)
 {
     return ImGui::IsItemClicked(mouse_button);
 }
@@ -1211,6 +1220,10 @@ CIMGUI_API bool igIsItemEdited()
 {
     return ImGui::IsItemEdited();
 }
+CIMGUI_API bool igIsItemActivated()
+{
+    return ImGui::IsItemActivated();
+}
 CIMGUI_API bool igIsItemDeactivated()
 {
     return ImGui::IsItemDeactivated();
@@ -1219,6 +1232,10 @@ CIMGUI_API bool igIsItemDeactivatedAfterEdit()
 {
     return ImGui::IsItemDeactivatedAfterEdit();
 }
+CIMGUI_API bool igIsItemToggledOpen()
+{
+    return ImGui::IsItemToggledOpen();
+}
 CIMGUI_API bool igIsAnyItemHovered()
 {
     return ImGui::IsAnyItemHovered();
@@ -1263,9 +1280,13 @@ CIMGUI_API int igGetFrameCount()
 {
     return ImGui::GetFrameCount();
 }
-CIMGUI_API ImDrawList* igGetOverlayDrawList()
+CIMGUI_API ImDrawList* igGetBackgroundDrawList()
 {
-    return ImGui::GetOverlayDrawList();
+    return ImGui::GetBackgroundDrawList();
+}
+CIMGUI_API ImDrawList* igGetForegroundDrawList()
+{
+    return ImGui::GetForegroundDrawList();
 }
 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
 {
@@ -1327,29 +1348,25 @@ CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate
 {
     return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate);
 }
-CIMGUI_API bool igIsMouseDown(int button)
+CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
+{
+    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
+}
+CIMGUI_API bool igIsMouseDown(ImGuiMouseButton button)
 {
     return ImGui::IsMouseDown(button);
 }
-CIMGUI_API bool igIsAnyMouseDown()
-{
-    return ImGui::IsAnyMouseDown();
-}
-CIMGUI_API bool igIsMouseClicked(int button,bool repeat)
+CIMGUI_API bool igIsMouseClicked(ImGuiMouseButton button,bool repeat)
 {
     return ImGui::IsMouseClicked(button,repeat);
 }
-CIMGUI_API bool igIsMouseDoubleClicked(int button)
-{
-    return ImGui::IsMouseDoubleClicked(button);
-}
-CIMGUI_API bool igIsMouseReleased(int button)
+CIMGUI_API bool igIsMouseReleased(ImGuiMouseButton button)
 {
     return ImGui::IsMouseReleased(button);
 }
-CIMGUI_API bool igIsMouseDragging(int button,float lock_threshold)
+CIMGUI_API bool igIsMouseDoubleClicked(ImGuiMouseButton button)
 {
-    return ImGui::IsMouseDragging(button,lock_threshold);
+    return ImGui::IsMouseDoubleClicked(button);
 }
 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip)
 {
@@ -1359,6 +1376,10 @@ CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos)
 {
     return ImGui::IsMousePosValid(mouse_pos);
 }
+CIMGUI_API bool igIsAnyMouseDown()
+{
+    return ImGui::IsAnyMouseDown();
+}
 CIMGUI_API ImVec2 igGetMousePos()
 {
     return ImGui::GetMousePos();
@@ -1367,11 +1388,15 @@ CIMGUI_API ImVec2 igGetMousePosOnOpeningCurrentPopup()
 {
     return ImGui::GetMousePosOnOpeningCurrentPopup();
 }
-CIMGUI_API ImVec2 igGetMouseDragDelta(int button,float lock_threshold)
+CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold)
+{
+    return ImGui::IsMouseDragging(button,lock_threshold);
+}
+CIMGUI_API ImVec2 igGetMouseDragDelta(ImGuiMouseButton button,float lock_threshold)
 {
     return ImGui::GetMouseDragDelta(button,lock_threshold);
 }
-CIMGUI_API void igResetMouseDragDelta(int button)
+CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button)
 {
     return ImGui::ResetMouseDragDelta(button);
 }
@@ -1379,13 +1404,9 @@ CIMGUI_API ImGuiMouseCursor igGetMouseCursor()
 {
     return ImGui::GetMouseCursor();
 }
-CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type)
+CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type)
 {
-    return ImGui::SetMouseCursor(type);
-}
-CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
-{
-    return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
+    return ImGui::SetMouseCursor(cursor_type);
 }
 CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
 {
@@ -1439,7 +1460,7 @@ CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
 {
     return self->ScaleAllSizes(scale_factor);
 }
-CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c)
+CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
 {
     return self->AddInputCharacter(c);
 }
@@ -1539,31 +1560,23 @@ CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
 {
     return self->IsActive();
 }
-CIMGUI_API TextRange* TextRange_TextRange(void)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void)
 {
-    return IM_NEW(TextRange)();
+    return IM_NEW(ImGuiTextRange)();
 }
-CIMGUI_API void TextRange_destroy(TextRange* self)
+CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API TextRange* TextRange_TextRangeStr(const char* _b,const char* _e)
+CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
 {
-    return IM_NEW(TextRange)(_b,_e);
+    return IM_NEW(ImGuiTextRange)(_b,_e);
 }
-CIMGUI_API const char* TextRange_begin(TextRange* self)
-{
-    return self->begin();
-}
-CIMGUI_API const char* TextRange_end(TextRange* self)
-{
-    return self->end();
-}
-CIMGUI_API bool TextRange_empty(TextRange* self)
+CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
 {
     return self->empty();
 }
-CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange* out)
+CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
 {
     return self->split(separator,out);
 }
@@ -1603,25 +1616,29 @@ CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
 {
     return self->c_str();
 }
+CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
+{
+    return self->append(str,str_end);
+}
 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
 {
     return self->appendfv(fmt,args);
 }
-CIMGUI_API Pair* Pair_PairInt(ImGuiID _key,int _val_i)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
 {
-    return IM_NEW(Pair)(_key,_val_i);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_i);
 }
-CIMGUI_API void Pair_destroy(Pair* self)
+CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API Pair* Pair_PairFloat(ImGuiID _key,float _val_f)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
 {
-    return IM_NEW(Pair)(_key,_val_f);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_f);
 }
-CIMGUI_API Pair* Pair_PairPtr(ImGuiID _key,void* _val_p)
+CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
 {
-    return IM_NEW(Pair)(_key,_val_p);
+    return IM_NEW(ImGuiStoragePair)(_key,_val_p);
 }
 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
 {
@@ -1743,6 +1760,34 @@ CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
+{
+    return IM_NEW(ImDrawListSplitter)();
+}
+CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
+{
+    return self->Clear();
+}
+CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
+{
+    return self->ClearFreeMemory();
+}
+CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
+{
+    return self->Split(draw_list,count);
+}
+CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
+{
+    return self->Merge(draw_list);
+}
+CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
+{
+    return self->SetCurrentChannel(draw_list,channel_idx);
+}
 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
 {
     return IM_NEW(ImDrawList)(shared_data);
@@ -1779,45 +1824,53 @@ CIMGUI_API ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self)
 {
     return self->GetClipRectMax();
 }
-CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
 {
-    return self->AddLine(a,b,col,thickness);
+    return self->AddLine(p1,p2,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness)
+CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
 {
-    return self->AddRect(a,b,col,rounding,rounding_corners_flags,thickness);
+    return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
 }
-CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->AddRectFilled(a,b,col,rounding,rounding_corners_flags);
+    return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
 }
-CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
+CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
 {
-    return self->AddRectFilledMultiColor(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
+    return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
 }
-CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
 {
-    return self->AddQuad(a,b,c,d,col,thickness);
+    return self->AddQuad(p1,p2,p3,p4,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col)
+CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
 {
-    return self->AddQuadFilled(a,b,c,d,col);
+    return self->AddQuadFilled(p1,p2,p3,p4,col);
 }
-CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness)
+CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
 {
-    return self->AddTriangle(a,b,c,col,thickness);
+    return self->AddTriangle(p1,p2,p3,col,thickness);
 }
-CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col)
+CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
 {
-    return self->AddTriangleFilled(a,b,c,col);
+    return self->AddTriangleFilled(p1,p2,p3,col);
 }
-CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness)
+CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
 {
-    return self->AddCircle(centre,radius,col,num_segments,thickness);
+    return self->AddCircle(center,radius,col,num_segments,thickness);
 }
-CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments)
+CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
 {
-    return self->AddCircleFilled(centre,radius,col,num_segments);
+    return self->AddCircleFilled(center,radius,col,num_segments);
+}
+CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
+{
+    return self->AddNgon(center,radius,col,num_segments,thickness);
+}
+CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
+{
+    return self->AddNgonFilled(center,radius,col,num_segments);
 }
 CIMGUI_API void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
 {
@@ -1827,29 +1880,29 @@ CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,fl
 {
     return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
 }
-CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
-{
-    return self->AddImage(user_texture_id,a,b,uv_a,uv_b,col);
-}
-CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
-{
-    return self->AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
-}
-CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners)
-{
-    return self->AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners);
-}
-CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)
+CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
 {
     return self->AddPolyline(points,num_points,col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col)
+CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
 {
     return self->AddConvexPolyFilled(points,num_points,col);
 }
-CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments)
+CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments)
 {
-    return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments);
+    return self->AddBezierCurve(p1,p2,p3,p4,col,thickness,num_segments);
+}
+CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
+{
+    return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
+}
+CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
+{
+    return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
+}
+CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
+{
+    return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
 {
@@ -1871,33 +1924,21 @@ CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,flo
 {
     return self->PathStroke(col,closed,thickness);
 }
-CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments)
+CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
 {
-    return self->PathArcTo(centre,radius,a_min,a_max,num_segments);
+    return self->PathArcTo(center,radius,a_min,a_max,num_segments);
 }
-CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12)
+CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
 {
-    return self->PathArcToFast(centre,radius,a_min_of_12,a_max_of_12);
+    return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
 }
-CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)
+CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments)
 {
-    return self->PathBezierCurveTo(p1,p2,p3,num_segments);
+    return self->PathBezierCurveTo(p2,p3,p4,num_segments);
 }
-CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags)
+CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
 {
-    return self->PathRect(rect_min,rect_max,rounding,rounding_corners_flags);
-}
-CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count)
-{
-    return self->ChannelsSplit(channels_count);
-}
-CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
-{
-    return self->ChannelsMerge();
-}
-CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index)
-{
-    return self->ChannelsSetCurrent(channel_index);
+    return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
 }
 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
 {
@@ -1911,6 +1952,18 @@ CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
 {
     return self->CloneOutput();
 }
+CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
+{
+    return self->ChannelsSplit(count);
+}
+CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
+{
+    return self->ChannelsMerge();
+}
+CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
+{
+    return self->ChannelsSetCurrent(n);
+}
 CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
 {
     return self->Clear();
@@ -1923,6 +1976,10 @@ CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_co
 {
     return self->PrimReserve(idx_count,vtx_count);
 }
+CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,int idx_count,int vtx_count)
+{
+    return self->PrimUnreserve(idx_count,vtx_count);
+}
 CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)
 {
     return self->PrimRect(a,b,col);
@@ -1971,9 +2028,9 @@ CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
 {
     return self->DeIndexAllBuffers();
 }
-CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc)
+CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
 {
-    return self->ScaleClipRects(sc);
+    return self->ScaleClipRects(fb_scale);
 }
 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
 {
@@ -1991,6 +2048,10 @@ CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
 {
     IM_DELETE(self);
 }
+CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
+{
+    return self->Clear();
+}
 CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n)
 {
     return self->GetBit(n);
@@ -2015,6 +2076,18 @@ CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* s
 {
     return self->BuildRanges(out_ranges);
 }
+CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
+{
+    return IM_NEW(ImFontAtlasCustomRect)();
+}
+CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
+{
+    return self->IsPacked();
+}
 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
 {
     return IM_NEW(ImFontAtlas)();
@@ -2111,17 +2184,9 @@ CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
 {
     return self->GetGlyphRangesThai();
 }
-CIMGUI_API CustomRect* CustomRect_CustomRect(void)
+CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
 {
-    return IM_NEW(CustomRect)();
-}
-CIMGUI_API void CustomRect_destroy(CustomRect* self)
-{
-    IM_DELETE(self);
-}
-CIMGUI_API bool CustomRect_IsPacked(CustomRect* self)
-{
-    return self->IsPacked();
+    return self->GetGlyphRangesVietnamese();
 }
 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
 {
@@ -2131,11 +2196,11 @@ CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font
 {
     return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
 }
-CIMGUI_API const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
+CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
 {
     return self->GetCustomRectByIndex(index);
 }
-CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
+CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
 {
     return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
 }
@@ -2151,14 +2216,6 @@ CIMGUI_API void ImFont_destroy(ImFont* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
-{
-    return self->ClearOutputData();
-}
-CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
-{
-    return self->BuildLookupTable();
-}
 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
 {
     return self->FindGlyph(c);
@@ -2167,10 +2224,6 @@ CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
 {
     return self->FindGlyphNoFallback(c);
 }
-CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
-{
-    return self->SetFallbackChar(c);
-}
 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
 {
     return self->GetCharAdvance(c);
@@ -2199,6 +2252,14 @@ CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,
 {
     return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
 }
+CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
+{
+    return self->BuildLookupTable();
+}
+CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
+{
+    return self->ClearOutputData();
+}
 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
 {
     return self->GrowIndex(new_size);
@@ -2211,6 +2272,10 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool ov
 {
     return self->AddRemapChar(dst,src,overwrite_dst);
 }
+CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
+{
+    return self->SetFallbackChar(c);
+}
 CIMGUI_API void igGetWindowPos_nonUDT(ImVec2 *pOut)
 {
     *pOut = ImGui::GetWindowPos();
@@ -2381,11 +2446,11 @@ CIMGUI_API ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2()
     ImVec2_Simple ret2 = ImVec2ToSimple(ret);
     return ret2;
 }
-CIMGUI_API void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,int button,float lock_threshold)
+CIMGUI_API void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)
 {
     *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
 }
-CIMGUI_API ImVec2_Simple igGetMouseDragDelta_nonUDT2(int button,float lock_threshold)
+CIMGUI_API ImVec2_Simple igGetMouseDragDelta_nonUDT2(ImGuiMouseButton button,float lock_threshold)
 {
     ImVec2 ret = ImGui::GetMouseDragDelta(button,lock_threshold);
     ImVec2_Simple ret2 = ImVec2ToSimple(ret);
@@ -2470,10 +2535,12 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 {
 	return IM_NEW(ImVector<ImWchar>) ();
 }
-CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* p)
+
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
 {
-	IM_DELETE(p);
+    IM_DELETE(self);
 }
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();

generator/output/cimgui_impl.h

@@ -1,9 +1,10 @@
 typedef struct SDL_Window SDL_Window;
 typedef struct GLFWwindow GLFWwindow;
+
 struct GLFWwindow;
+
 struct SDL_Window;
-typedef union SDL_Event SDL_Event;
-CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+typedef union SDL_Event SDL_Event;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
 CIMGUI_API void ImGui_ImplGlfw_Shutdown();
 CIMGUI_API void ImGui_ImplGlfw_NewFrame();
@@ -29,6 +30,7 @@ CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
 CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
 CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_Shutdown();
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);

generator/output/impl_definitions.json

@@ -15,10 +15,9 @@
       "argsoriginal": "(GLFWwindow* window,unsigned int c)",
       "call_args": "(window,c)",
       "cimguiname": "ImGui_ImplGlfw_CharCallback",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_CharCallback",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,unsigned int)",
       "stname": ""
@@ -40,10 +39,9 @@
       "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
       "call_args": "(window,install_callbacks)",
       "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_InitForOpenGL",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
       "stname": ""
@@ -65,10 +63,9 @@
       "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
       "call_args": "(window,install_callbacks)",
       "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_InitForVulkan",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
       "stname": ""
@@ -102,10 +99,9 @@
       "argsoriginal": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
       "call_args": "(window,key,scancode,action,mods)",
       "cimguiname": "ImGui_ImplGlfw_KeyCallback",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_KeyCallback",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int,int)",
       "stname": ""
@@ -135,10 +131,9 @@
       "argsoriginal": "(GLFWwindow* window,int button,int action,int mods)",
       "call_args": "(window,button,action,mods)",
       "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int)",
       "stname": ""
@@ -151,10 +146,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplGlfw_NewFrame",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_NewFrame",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -180,10 +174,9 @@
       "argsoriginal": "(GLFWwindow* window,double xoffset,double yoffset)",
       "call_args": "(window,xoffset,yoffset)",
       "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_ScrollCallback",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
       "stname": ""
@@ -196,10 +189,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplGlfw_Shutdown",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplGlfw_Shutdown",
-      "location": "imgui_impl_glfw",
+      "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -212,10 +204,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
       "stname": ""
@@ -228,10 +219,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
       "stname": ""
@@ -244,10 +234,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -260,10 +249,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -276,10 +264,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_Init",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_Init",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
       "ret": "bool",
       "signature": "()",
       "stname": ""
@@ -292,10 +279,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_NewFrame",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -313,10 +299,9 @@
       "argsoriginal": "(ImDrawData* draw_data)",
       "call_args": "(draw_data)",
       "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
       "stname": ""
@@ -329,10 +314,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL2_Shutdown",
-      "location": "imgui_impl_opengl2",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -345,10 +329,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
       "stname": ""
@@ -361,10 +344,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
       "ret": "bool",
       "signature": "()",
       "stname": ""
@@ -377,10 +359,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -393,10 +374,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -414,12 +394,11 @@
       "argsoriginal": "(const char* glsl_version=NULL)",
       "call_args": "(glsl_version)",
       "cimguiname": "ImGui_ImplOpenGL3_Init",
-      "comment": "",
       "defaults": {
         "glsl_version": "NULL"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
       "ret": "bool",
       "signature": "(const char*)",
       "stname": ""
@@ -432,10 +411,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_NewFrame",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "ret": "void",
       "signature": "()",
       "stname": ""
@@ -453,10 +431,9 @@
       "argsoriginal": "(ImDrawData* draw_data)",
       "call_args": "(draw_data)",
       "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
       "stname": ""
@@ -469,15 +446,34 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplOpenGL3_Shutdown",
-      "location": "imgui_impl_opengl3",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
+  "ImGui_ImplSDL2_InitForD3D": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForD3D",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplSDL2_InitForOpenGL": [
     {
       "args": "(SDL_Window* window,void* sdl_gl_context)",
@@ -494,10 +490,9 @@
       "argsoriginal": "(SDL_Window* window,void* sdl_gl_context)",
       "call_args": "(window,sdl_gl_context)",
       "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplSDL2_InitForOpenGL",
-      "location": "imgui_impl_sdl",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
       "ret": "bool",
       "signature": "(SDL_Window*,void*)",
       "stname": ""
@@ -515,10 +510,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplSDL2_InitForVulkan",
-      "location": "imgui_impl_sdl",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
       "ret": "bool",
       "signature": "(SDL_Window*)",
       "stname": ""
@@ -536,10 +530,9 @@
       "argsoriginal": "(SDL_Window* window)",
       "call_args": "(window)",
       "cimguiname": "ImGui_ImplSDL2_NewFrame",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplSDL2_NewFrame",
-      "location": "imgui_impl_sdl",
+      "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
       "ret": "void",
       "signature": "(SDL_Window*)",
       "stname": ""
@@ -557,10 +550,9 @@
       "argsoriginal": "(const SDL_Event* event)",
       "call_args": "(event)",
       "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplSDL2_ProcessEvent",
-      "location": "imgui_impl_sdl",
+      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
       "ret": "bool",
       "signature": "(const SDL_Event*)",
       "stname": ""
@@ -573,10 +565,9 @@
       "argsoriginal": "()",
       "call_args": "()",
       "cimguiname": "ImGui_ImplSDL2_Shutdown",
-      "comment": "",
       "defaults": [],
       "funcname": "ImGui_ImplSDL2_Shutdown",
-      "location": "imgui_impl_sdl",
+      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""

generator/output/impl_definitions.lua

@@ -12,10 +12,9 @@ defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][2]["type"] = "unsigned int"
 defs["ImGui_ImplGlfw_CharCallback"][1]["argsoriginal"] = "(GLFWwindow* window,unsigned int c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["call_args"] = "(window,c)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_CharCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_CharCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CharCallback"
 defs["ImGui_ImplGlfw_CharCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_CharCallback"][1]["signature"] = "(GLFWwindow*,unsigned int)"
 defs["ImGui_ImplGlfw_CharCallback"][1]["stname"] = ""
@@ -33,10 +32,9 @@ defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][2]["type"] = "bool"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["call_args"] = "(window,install_callbacks)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ret"] = "bool"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["signature"] = "(GLFWwindow*,bool)"
 defs["ImGui_ImplGlfw_InitForOpenGL"][1]["stname"] = ""
@@ -54,10 +52,9 @@ defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][2]["type"] = "bool"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["call_args"] = "(window,install_callbacks)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["ret"] = "bool"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["signature"] = "(GLFWwindow*,bool)"
 defs["ImGui_ImplGlfw_InitForVulkan"][1]["stname"] = ""
@@ -84,10 +81,9 @@ defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][5]["type"] = "int"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["call_args"] = "(window,key,scancode,action,mods)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_KeyCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["signature"] = "(GLFWwindow*,int,int,int,int)"
 defs["ImGui_ImplGlfw_KeyCallback"][1]["stname"] = ""
@@ -111,10 +107,9 @@ defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][4]["type"] = "int"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int button,int action,int mods)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["call_args"] = "(window,button,action,mods)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["signature"] = "(GLFWwindow*,int,int,int)"
 defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["stname"] = ""
@@ -126,10 +121,9 @@ defs["ImGui_ImplGlfw_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["cimguiname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_NewFrame"
 defs["ImGui_ImplGlfw_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplGlfw_NewFrame"][1]["stname"] = ""
@@ -150,10 +144,9 @@ defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][3]["type"] = "double"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsoriginal"] = "(GLFWwindow* window,double xoffset,double yoffset)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["call_args"] = "(window,xoffset,yoffset)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
 defs["ImGui_ImplGlfw_ScrollCallback"][1]["stname"] = ""
@@ -165,10 +158,9 @@ defs["ImGui_ImplGlfw_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["cimguiname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplGlfw_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw"
+defs["ImGui_ImplGlfw_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_Shutdown"
 defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplGlfw_Shutdown"][1]["stname"] = ""
@@ -180,10 +172,9 @@ defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["stname"] = ""
@@ -195,10 +186,9 @@ defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["stname"] = ""
@@ -210,10 +200,9 @@ defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["stname"] = ""
@@ -225,10 +214,9 @@ defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["stname"] = ""
@@ -240,10 +228,9 @@ defs["ImGui_ImplOpenGL2_Init"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Init"
 defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_Init"][1]["stname"] = ""
@@ -255,10 +242,9 @@ defs["ImGui_ImplOpenGL2_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_NewFrame"][1]["stname"] = ""
@@ -273,10 +259,9 @@ defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsT"][1]["type"] = "ImDrawData*"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
 defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["stname"] = ""
@@ -288,10 +273,9 @@ defs["ImGui_ImplOpenGL2_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL2_Shutdown"][1]["stname"] = ""
@@ -303,10 +287,9 @@ defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["stname"] = ""
@@ -318,10 +301,9 @@ defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["stname"] = ""
@@ -333,10 +315,9 @@ defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["stname"] = ""
@@ -348,10 +329,9 @@ defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["stname"] = ""
@@ -366,11 +346,10 @@ defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["type"] = "const char*"
 defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=NULL)"
 defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
 defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "NULL"
 defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["ret"] = "bool"
 defs["ImGui_ImplOpenGL3_Init"][1]["signature"] = "(const char*)"
 defs["ImGui_ImplOpenGL3_Init"][1]["stname"] = ""
@@ -382,10 +361,9 @@ defs["ImGui_ImplOpenGL3_NewFrame"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_NewFrame"][1]["stname"] = ""
@@ -400,10 +378,9 @@ defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsT"][1]["type"] = "ImDrawData*"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["call_args"] = "(draw_data)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
 defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["stname"] = ""
@@ -415,14 +392,30 @@ defs["ImGui_ImplOpenGL3_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["stname"] = ""
 defs["ImGui_ImplOpenGL3_Shutdown"]["()"] = defs["ImGui_ImplOpenGL3_Shutdown"][1]
+defs["ImGui_ImplSDL2_InitForD3D"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["funcname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForD3D"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForD3D"][1]
 defs["ImGui_ImplSDL2_InitForOpenGL"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["args"] = "(SDL_Window* window,void* sdl_gl_context)"
@@ -436,10 +429,9 @@ defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][2]["type"] = "void*"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsoriginal"] = "(SDL_Window* window,void* sdl_gl_context)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["call_args"] = "(window,sdl_gl_context)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["signature"] = "(SDL_Window*,void*)"
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["stname"] = ""
@@ -454,10 +446,9 @@ defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsT"][1]["type"] = "SDL_Window*"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsoriginal"] = "(SDL_Window* window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["signature"] = "(SDL_Window*)"
 defs["ImGui_ImplSDL2_InitForVulkan"][1]["stname"] = ""
@@ -472,10 +463,9 @@ defs["ImGui_ImplSDL2_NewFrame"][1]["argsT"][1]["type"] = "SDL_Window*"
 defs["ImGui_ImplSDL2_NewFrame"][1]["argsoriginal"] = "(SDL_Window* window)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "(window)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_NewFrame"
 defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "(SDL_Window*)"
 defs["ImGui_ImplSDL2_NewFrame"][1]["stname"] = ""
@@ -490,10 +480,9 @@ defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["type"] = "const SDL_Event*"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsoriginal"] = "(const SDL_Event* event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["call_args"] = "(event)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(const SDL_Event*)"
 defs["ImGui_ImplSDL2_ProcessEvent"][1]["stname"] = ""
@@ -505,10 +494,9 @@ defs["ImGui_ImplSDL2_Shutdown"][1]["argsT"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["argsoriginal"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["call_args"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["comment"] = ""
 defs["ImGui_ImplSDL2_Shutdown"][1]["defaults"] = {}
 defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl"
+defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
 defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplSDL2_Shutdown"][1]["stname"] = ""

generator/output/overloads.txt

@@ -1,8 +1,7 @@
 ----------------overloadings---------------------------
-igCombo	3
-1	bool	igCombo (const char*,int*,const char* const[],int,int)
-2	bool	igComboStr (const char*,int*,const char*,int)
-3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+ImVector_resize	2
+1	void	ImVector_resize (int)
+2	void	ImVector_resizeT (int,const T)
 ImVec4_ImVec4	2
 1	nil	ImVec4_ImVec4 ()
 2	nil	ImVec4_ImVec4Float (float,float,float,float)
@@ -11,101 +10,126 @@ igValue	4
 2	void	igValueInt (const char*,int)
 3	void	igValueUint (const char*,unsigned int)
 4	void	igValueFloat (const char*,float,const char*)
-igPushStyleVar	2
-1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
-2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
 igIsRectVisible	2
 1	bool	igIsRectVisible (const ImVec2)
 2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
 igRadioButton	2
 1	bool	igRadioButtonBool (const char*,bool)
 2	bool	igRadioButtonIntPtr (const char*,int*,int)
-igTreePush	2
-1	void	igTreePushStr (const char*)
-2	void	igTreePushPtr (const void*)
+ImGuiTextRange_ImGuiTextRange	2
+1	nil	ImGuiTextRange_ImGuiTextRange ()
+2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
+ImVector_back	2
+1	T*	ImVector_back ()
+2	const T*	ImVector_back_const ()const
+igPlotHistogram	2
+1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotHistogramFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igGetID	3
+1	ImGuiID	igGetIDStr (const char*)
+2	ImGuiID	igGetIDRange (const char*,const char*)
+3	ImGuiID	igGetIDPtr (const void*)
+igSetWindowPos	2
+1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
+igBeginChild	2
+1	bool	igBeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags)
+2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+igPushID	4
+1	void	igPushIDStr (const char*)
+2	void	igPushIDRange (const char*,const char*)
+3	void	igPushIDPtr (const void*)
+4	void	igPushIDInt (int)
+ImGuiStoragePair_ImGuiStoragePair	3
+1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
+2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
+3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
+igTreeNode	3
+1	bool	igTreeNodeStr (const char*)
+2	bool	igTreeNodeStrStr (const char*,const char*,...)
+3	bool	igTreeNodePtr (const void*,const char*,...)
+igCombo	3
+1	bool	igCombo (const char*,int*,const char* const[],int,int)
+2	bool	igComboStr (const char*,int*,const char*,int)
+3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+ImVector_erase	2
+1	T*	ImVector_erase (const T*)
+2	T*	ImVector_eraseTPtr (const T*,const T*)
+ImDrawList_AddText	2
+1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
+2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+igPushStyleVar	2
+1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
+2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
+igSetWindowFocus	2
+1	void	igSetWindowFocus ()
+2	void	igSetWindowFocusStr (const char*)
+ImVector_end	2
+1	T*	ImVector_end ()
+2	const T*	ImVector_end_const ()const
 igSetWindowSize	2
 1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
 2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
+ImVector_ImVector	2
+1	nil	ImVector_ImVector ()
+2	nil	ImVector_ImVectorVector (const ImVector)
 igSetWindowCollapsed	2
 1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
 2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
 igPlotLines	2
 1	void	igPlotLines (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)
-ImVec2_ImVec2	2
-1	nil	ImVec2_ImVec2 ()
-2	nil	ImVec2_ImVec2Float (float,float)
-igPlotHistogram	2
-1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotHistogramFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
-igTreeNodeExV	2
-1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
-2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
 igPushStyleColor	2
 1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
 2	void	igPushStyleColor (ImGuiCol,const ImVec4)
-igGetID	3
-1	ImGuiID	igGetIDStr (const char*)
-2	ImGuiID	igGetIDRange (const char*,const char*)
-3	ImGuiID	igGetIDPtr (const void*)
-igBeginChild	2
-1	bool	igBeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags)
-2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
-ImDrawList_AddText	2
-1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
-igSelectable	2
-1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+igTreeNodeExV	2
+1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
+2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
 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)
-igPushID	4
-1	void	igPushIDStr (const char*)
-2	void	igPushIDRange (const char*,const char*)
-3	void	igPushIDPtr (const void*)
-4	void	igPushIDInt (int)
-Pair_Pair	3
-1	nil	Pair_PairInt (ImGuiID,int)
-2	nil	Pair_PairFloat (ImGuiID,float)
-3	nil	Pair_PairPtr (ImGuiID,void*)
-TextRange_TextRange	2
-1	nil	TextRange_TextRange ()
-2	nil	TextRange_TextRangeStr (const char*,const char*)
+ImVec2_ImVec2	2
+1	nil	ImVec2_ImVec2 ()
+2	nil	ImVec2_ImVec2Float (float,float)
+igCollapsingHeader	2
+1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
+2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+igTreePush	2
+1	void	igTreePushStr (const char*)
+2	void	igTreePushPtr (const void*)
+igGetColorU32	3
+1	ImU32	igGetColorU32 (ImGuiCol,float)
+2	ImU32	igGetColorU32Vec4 (const ImVec4)
+3	ImU32	igGetColorU32U32 (ImU32)
 ImColor_ImColor	5
 1	nil	ImColor_ImColor ()
 2	nil	ImColor_ImColorInt (int,int,int,int)
 3	nil	ImColor_ImColorU32 (ImU32)
 4	nil	ImColor_ImColorFloat (float,float,float,float)
 5	nil	ImColor_ImColorVec4 (const ImVec4)
-igCollapsingHeader	2
-1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
-2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
-igMenuItem	2
-1	bool	igMenuItemBool (const char*,const char*,bool,bool)
-2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
-igSetWindowPos	2
-1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
-igSetWindowFocus	2
-1	void	igSetWindowFocus ()
-2	void	igSetWindowFocusStr (const char*)
+igSelectable	2
+1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+ImVector_begin	2
+1	T*	ImVector_begin ()
+2	const T*	ImVector_begin_const ()const
+ImVector_front	2
+1	T*	ImVector_front ()
+2	const T*	ImVector_front_const ()const
+ImVector_find	2
+1	T*	ImVector_find (const T)
+2	const T*	ImVector_find_const (const T)const
 igTreeNodeEx	3
 1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
 2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
 3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
+igMenuItem	2
+1	bool	igMenuItemBool (const char*,const char*,bool,bool)
+2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
 igListBoxHeader	2
 1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
 2	bool	igListBoxHeaderInt (const char*,int,int)
-igGetColorU32	3
-1	ImU32	igGetColorU32 (ImGuiCol,float)
-2	ImU32	igGetColorU32Vec4 (const ImVec4)
-3	ImU32	igGetColorU32U32 (ImU32)
-igTreeNode	3
-1	bool	igTreeNodeStr (const char*)
-2	bool	igTreeNodeStrStr (const char*,const char*,...)
-3	bool	igTreeNodePtr (const void*,const char*,...)
 igTreeNodeV	2
 1	bool	igTreeNodeVStr (const char*,const char*,va_list)
 2	bool	igTreeNodeVPtr (const void*,const char*,va_list)
-77 overloaded
+93 overloaded

generator/output/structs_and_enums.json

@@ -1,6 +1,11 @@
 {
   "enums": {
     "ImDrawCornerFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImDrawCornerFlags_None",
+        "value": "0"
+      },
       {
         "calc_value": 1,
         "name": "ImDrawCornerFlags_TopLeft",
@@ -62,6 +67,11 @@
         "calc_value": 2,
         "name": "ImDrawListFlags_AntiAliasedFill",
         "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImDrawListFlags_AllowVtxOffset",
+        "value": "1 << 2"
       }
     ],
     "ImFontAtlasFlags_": [
@@ -101,6 +111,11 @@
         "calc_value": 4,
         "name": "ImGuiBackendFlags_HasSetMousePos",
         "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiBackendFlags_RendererHasVtxOffset",
+        "value": "1 << 3"
       }
     ],
     "ImGuiCol_": [
@@ -423,17 +438,17 @@
       },
       {
         "calc_value": 1048576,
-        "name": "ImGuiColorEditFlags_RGB",
+        "name": "ImGuiColorEditFlags_DisplayRGB",
         "value": "1 << 20"
       },
       {
         "calc_value": 2097152,
-        "name": "ImGuiColorEditFlags_HSV",
+        "name": "ImGuiColorEditFlags_DisplayHSV",
         "value": "1 << 21"
       },
       {
         "calc_value": 4194304,
-        "name": "ImGuiColorEditFlags_HEX",
+        "name": "ImGuiColorEditFlags_DisplayHex",
         "value": "1 << 22"
       },
       {
@@ -456,10 +471,25 @@
         "name": "ImGuiColorEditFlags_PickerHueWheel",
         "value": "1 << 26"
       },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiColorEditFlags_InputRGB",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiColorEditFlags_InputHSV",
+        "value": "1 << 28"
+      },
+      {
+        "calc_value": 177209344,
+        "name": "ImGuiColorEditFlags__OptionsDefault",
+        "value": "ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_PickerHueBar"
+      },
       {
         "calc_value": 7340032,
-        "name": "ImGuiColorEditFlags__InputsMask",
-        "value": "ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_HSV|ImGuiColorEditFlags_HEX"
+        "name": "ImGuiColorEditFlags__DisplayMask",
+        "value": "ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_DisplayHSV|ImGuiColorEditFlags_DisplayHex"
       },
       {
         "calc_value": 25165824,
@@ -472,9 +502,9 @@
         "value": "ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar"
       },
       {
-        "calc_value": 42991616,
-        "name": "ImGuiColorEditFlags__OptionsDefault",
-        "value": "ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_PickerHueBar"
+        "calc_value": 402653184,
+        "name": "ImGuiColorEditFlags__InputMask",
+        "value": "ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_InputHSV"
       }
     ],
     "ImGuiComboFlags_": [
@@ -596,38 +626,58 @@
     "ImGuiDataType_": [
       {
         "calc_value": 0,
-        "name": "ImGuiDataType_S32",
+        "name": "ImGuiDataType_S8",
         "value": 0
       },
       {
         "calc_value": 1,
-        "name": "ImGuiDataType_U32",
+        "name": "ImGuiDataType_U8",
         "value": 1
       },
       {
         "calc_value": 2,
-        "name": "ImGuiDataType_S64",
+        "name": "ImGuiDataType_S16",
         "value": 2
       },
       {
         "calc_value": 3,
-        "name": "ImGuiDataType_U64",
+        "name": "ImGuiDataType_U16",
         "value": 3
       },
       {
         "calc_value": 4,
-        "name": "ImGuiDataType_Float",
+        "name": "ImGuiDataType_S32",
         "value": 4
       },
       {
         "calc_value": 5,
-        "name": "ImGuiDataType_Double",
+        "name": "ImGuiDataType_U32",
         "value": 5
       },
       {
         "calc_value": 6,
-        "name": "ImGuiDataType_COUNT",
+        "name": "ImGuiDataType_S64",
         "value": 6
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiDataType_U64",
+        "value": 7
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiDataType_Float",
+        "value": 8
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiDataType_Double",
+        "value": 9
+      },
+      {
+        "calc_value": 10,
+        "name": "ImGuiDataType_COUNT",
+        "value": 10
       }
     ],
     "ImGuiDir_": [
@@ -903,6 +953,11 @@
         "calc_value": 1048576,
         "name": "ImGuiInputTextFlags_Multiline",
         "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiInputTextFlags_NoMarkEdited",
+        "value": "1 << 21"
       }
     ],
     "ImGuiKey_": [
@@ -983,38 +1038,65 @@
       },
       {
         "calc_value": 15,
-        "name": "ImGuiKey_A",
+        "name": "ImGuiKey_KeyPadEnter",
         "value": 15
       },
       {
         "calc_value": 16,
-        "name": "ImGuiKey_C",
+        "name": "ImGuiKey_A",
         "value": 16
       },
       {
         "calc_value": 17,
-        "name": "ImGuiKey_V",
+        "name": "ImGuiKey_C",
         "value": 17
       },
       {
         "calc_value": 18,
-        "name": "ImGuiKey_X",
+        "name": "ImGuiKey_V",
         "value": 18
       },
       {
         "calc_value": 19,
-        "name": "ImGuiKey_Y",
+        "name": "ImGuiKey_X",
         "value": 19
       },
       {
         "calc_value": 20,
-        "name": "ImGuiKey_Z",
+        "name": "ImGuiKey_Y",
         "value": 20
       },
       {
         "calc_value": 21,
-        "name": "ImGuiKey_COUNT",
+        "name": "ImGuiKey_Z",
         "value": 21
+      },
+      {
+        "calc_value": 22,
+        "name": "ImGuiKey_COUNT",
+        "value": 22
+      }
+    ],
+    "ImGuiMouseButton_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiMouseButton_Left",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiMouseButton_Right",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiMouseButton_Middle",
+        "value": "2"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiMouseButton_COUNT",
+        "value": "5"
       }
     ],
     "ImGuiMouseCursor_": [
@@ -1065,8 +1147,13 @@
       },
       {
         "calc_value": 8,
-        "name": "ImGuiMouseCursor_COUNT",
+        "name": "ImGuiMouseCursor_NotAllowed",
         "value": 8
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiMouseCursor_COUNT",
+        "value": 9
       }
     ],
     "ImGuiNavInput_": [
@@ -1211,6 +1298,11 @@
         "calc_value": 8,
         "name": "ImGuiSelectableFlags_Disabled",
         "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiSelectableFlags_AllowItemOverlap",
+        "value": "1 << 4"
       }
     ],
     "ImGuiStyleVar_": [
@@ -1326,8 +1418,13 @@
       },
       {
         "calc_value": 22,
-        "name": "ImGuiStyleVar_COUNT",
+        "name": "ImGuiStyleVar_SelectableTextAlign",
         "value": 22
+      },
+      {
+        "calc_value": 23,
+        "name": "ImGuiStyleVar_COUNT",
+        "value": 23
       }
     ],
     "ImGuiTabBarFlags_": [
@@ -1348,12 +1445,12 @@
       },
       {
         "calc_value": 4,
-        "name": "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton",
+        "name": "ImGuiTabBarFlags_TabListPopupButton",
         "value": "1 << 2"
       },
       {
         "calc_value": 8,
-        "name": "ImGuiTabBarFlags_NoTabListPopupButton",
+        "name": "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton",
         "value": "1 << 3"
       },
       {
@@ -1475,6 +1572,16 @@
         "name": "ImGuiTreeNodeFlags_FramePadding",
         "value": "1 << 10"
       },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiTreeNodeFlags_SpanAvailWidth",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiTreeNodeFlags_SpanFullWidth",
+        "value": "1 << 12"
+      },
       {
         "calc_value": 8192,
         "name": "ImGuiTreeNodeFlags_NavLeftJumpsBackHere",
@@ -1640,40 +1747,6 @@
     ]
   },
   "structs": {
-    "CustomRect": [
-      {
-        "name": "ID",
-        "type": "unsigned int"
-      },
-      {
-        "name": "Width",
-        "type": "unsigned short"
-      },
-      {
-        "name": "Height",
-        "type": "unsigned short"
-      },
-      {
-        "name": "X",
-        "type": "unsigned short"
-      },
-      {
-        "name": "Y",
-        "type": "unsigned short"
-      },
-      {
-        "name": "GlyphAdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "GlyphOffset",
-        "type": "ImVec2"
-      },
-      {
-        "name": "Font",
-        "type": "ImFont*"
-      }
-    ],
     "ImColor": [
       {
         "name": "Value",
@@ -1682,12 +1755,12 @@
     ],
     "ImDrawChannel": [
       {
-        "name": "CmdBuffer",
+        "name": "_CmdBuffer",
         "template_type": "ImDrawCmd",
         "type": "ImVector_ImDrawCmd"
       },
       {
-        "name": "IdxBuffer",
+        "name": "_IdxBuffer",
         "template_type": "ImDrawIdx",
         "type": "ImVector_ImDrawIdx"
       }
@@ -1705,6 +1778,14 @@
         "name": "TextureId",
         "type": "ImTextureID"
       },
+      {
+        "name": "VtxOffset",
+        "type": "unsigned int"
+      },
+      {
+        "name": "IdxOffset",
+        "type": "unsigned int"
+      },
       {
         "name": "UserCallback",
         "type": "ImDrawCallback"
@@ -1742,6 +1823,10 @@
       {
         "name": "DisplaySize",
         "type": "ImVec2"
+      },
+      {
+        "name": "FramebufferScale",
+        "type": "ImVec2"
       }
     ],
     "ImDrawList": [
@@ -1772,6 +1857,10 @@
         "name": "_OwnerName",
         "type": "const char*"
       },
+      {
+        "name": "_VtxCurrentOffset",
+        "type": "unsigned int"
+      },
       {
         "name": "_VtxCurrentIdx",
         "type": "unsigned int"
@@ -1800,11 +1889,17 @@
         "type": "ImVector_ImVec2"
       },
       {
-        "name": "_ChannelsCurrent",
+        "name": "_Splitter",
+        "type": "ImDrawListSplitter"
+      }
+    ],
+    "ImDrawListSplitter": [
+      {
+        "name": "_Current",
         "type": "int"
       },
       {
-        "name": "_ChannelsCount",
+        "name": "_Count",
         "type": "int"
       },
       {
@@ -1828,56 +1923,64 @@
       }
     ],
     "ImFont": [
-      {
-        "name": "FontSize",
-        "type": "float"
-      },
-      {
-        "name": "Scale",
-        "type": "float"
-      },
-      {
-        "name": "DisplayOffset",
-        "type": "ImVec2"
-      },
-      {
-        "name": "Glyphs",
-        "template_type": "ImFontGlyph",
-        "type": "ImVector_ImFontGlyph"
-      },
       {
         "name": "IndexAdvanceX",
         "template_type": "float",
         "type": "ImVector_float"
       },
+      {
+        "name": "FallbackAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "FontSize",
+        "type": "float"
+      },
       {
         "name": "IndexLookup",
         "template_type": "ImWchar",
         "type": "ImVector_ImWchar"
       },
+      {
+        "name": "Glyphs",
+        "template_type": "ImFontGlyph",
+        "type": "ImVector_ImFontGlyph"
+      },
       {
         "name": "FallbackGlyph",
         "type": "const ImFontGlyph*"
       },
       {
-        "name": "FallbackAdvanceX",
-        "type": "float"
+        "name": "DisplayOffset",
+        "type": "ImVec2"
       },
       {
-        "name": "FallbackChar",
-        "type": "ImWchar"
+        "name": "ContainerAtlas",
+        "type": "ImFontAtlas*"
+      },
+      {
+        "name": "ConfigData",
+        "type": "const ImFontConfig*"
       },
       {
         "name": "ConfigDataCount",
         "type": "short"
       },
       {
-        "name": "ConfigData",
-        "type": "ImFontConfig*"
+        "name": "FallbackChar",
+        "type": "ImWchar"
       },
       {
-        "name": "ContainerAtlas",
-        "type": "ImFontAtlas*"
+        "name": "EllipsisChar",
+        "type": "ImWchar"
+      },
+      {
+        "name": "DirtyLookupTables",
+        "type": "bool"
+      },
+      {
+        "name": "Scale",
+        "type": "float"
       },
       {
         "name": "Ascent",
@@ -1887,10 +1990,6 @@
         "name": "Descent",
         "type": "float"
       },
-      {
-        "name": "DirtyLookupTables",
-        "type": "bool"
-      },
       {
         "name": "MetricsTotalSurface",
         "type": "int"
@@ -1948,8 +2047,8 @@
       },
       {
         "name": "CustomRects",
-        "template_type": "CustomRect",
-        "type": "ImVector_CustomRect"
+        "template_type": "ImFontAtlasCustomRect",
+        "type": "ImVector_ImFontAtlasCustomRect"
       },
       {
         "name": "ConfigData",
@@ -1962,6 +2061,40 @@
         "type": "int"
       }
     ],
+    "ImFontAtlasCustomRect": [
+      {
+        "name": "ID",
+        "type": "unsigned int"
+      },
+      {
+        "name": "Width",
+        "type": "unsigned short"
+      },
+      {
+        "name": "Height",
+        "type": "unsigned short"
+      },
+      {
+        "name": "X",
+        "type": "unsigned short"
+      },
+      {
+        "name": "Y",
+        "type": "unsigned short"
+      },
+      {
+        "name": "GlyphAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "GlyphOffset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Font",
+        "type": "ImFont*"
+      }
+    ],
     "ImFontConfig": [
       {
         "name": "FontData",
@@ -2027,6 +2160,10 @@
         "name": "RasterizerMultiply",
         "type": "float"
       },
+      {
+        "name": "EllipsisChar",
+        "type": "ImWchar"
+      },
       {
         "name": "Name[40]",
         "size": 40,
@@ -2082,8 +2219,8 @@
     "ImFontGlyphRangesBuilder": [
       {
         "name": "UsedChars",
-        "template_type": "int",
-        "type": "ImVector_int"
+        "template_type": "ImU32",
+        "type": "ImVector_ImU32"
       }
     ],
     "ImGuiIO": [
@@ -2129,7 +2266,7 @@
       },
       {
         "name": "KeyMap[ImGuiKey_COUNT]",
-        "size": 21,
+        "size": 22,
         "type": "int"
       },
       {
@@ -2164,14 +2301,6 @@
         "name": "DisplayFramebufferScale",
         "type": "ImVec2"
       },
-      {
-        "name": "DisplayVisibleMin",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplayVisibleMax",
-        "type": "ImVec2"
-      },
       {
         "name": "MouseDrawCursor",
         "type": "bool"
@@ -2192,6 +2321,10 @@
         "name": "ConfigWindowsMoveFromTitleBarOnly",
         "type": "bool"
       },
+      {
+        "name": "ConfigWindowsMemoryCompactTimer",
+        "type": "float"
+      },
       {
         "name": "BackendPlatformName",
         "type": "const char*"
@@ -2369,6 +2502,11 @@
         "size": 5,
         "type": "bool"
       },
+      {
+        "name": "MouseDownWasDoubleClick[5]",
+        "size": 5,
+        "type": "bool"
+      },
       {
         "name": "MouseDownDuration[5]",
         "size": 5,
@@ -2467,12 +2605,12 @@
     ],
     "ImGuiListClipper": [
       {
-        "name": "StartPosY",
-        "type": "float"
+        "name": "DisplayStart",
+        "type": "int"
       },
       {
-        "name": "ItemsHeight",
-        "type": "float"
+        "name": "DisplayEnd",
+        "type": "int"
       },
       {
         "name": "ItemsCount",
@@ -2483,12 +2621,12 @@
         "type": "int"
       },
       {
-        "name": "DisplayStart",
-        "type": "int"
+        "name": "ItemsHeight",
+        "type": "float"
       },
       {
-        "name": "DisplayEnd",
-        "type": "int"
+        "name": "StartPosY",
+        "type": "float"
       }
     ],
     "ImGuiOnceUponAFrame": [
@@ -2553,8 +2691,18 @@
     "ImGuiStorage": [
       {
         "name": "Data",
-        "template_type": "Pair",
-        "type": "ImVector_Pair"
+        "template_type": "ImGuiStoragePair",
+        "type": "ImVector_ImGuiStoragePair"
+      }
+    ],
+    "ImGuiStoragePair": [
+      {
+        "name": "key",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "",
+        "type": "union { int val_i; float val_f; void* val_p;}"
       }
     ],
     "ImGuiStyle": [
@@ -2582,6 +2730,10 @@
         "name": "WindowTitleAlign",
         "type": "ImVec2"
       },
+      {
+        "name": "WindowMenuButtonPosition",
+        "type": "ImGuiDir"
+      },
       {
         "name": "ChildRounding",
         "type": "float"
@@ -2654,10 +2806,18 @@
         "name": "TabBorderSize",
         "type": "float"
       },
+      {
+        "name": "ColorButtonPosition",
+        "type": "ImGuiDir"
+      },
       {
         "name": "ButtonTextAlign",
         "type": "ImVec2"
       },
+      {
+        "name": "SelectableTextAlign",
+        "type": "ImVec2"
+      },
       {
         "name": "DisplayWindowPadding",
         "type": "ImVec2"
@@ -2682,6 +2842,10 @@
         "name": "CurveTessellationTol",
         "type": "float"
       },
+      {
+        "name": "CircleSegmentMaxError",
+        "type": "float"
+      },
       {
         "name": "Colors[ImGuiCol_COUNT]",
         "size": 48,
@@ -2703,14 +2867,24 @@
       },
       {
         "name": "Filters",
-        "template_type": "TextRange",
-        "type": "ImVector_TextRange"
+        "template_type": "ImGuiTextRange",
+        "type": "ImVector_ImGuiTextRange"
       },
       {
         "name": "CountGrep",
         "type": "int"
       }
     ],
+    "ImGuiTextRange": [
+      {
+        "name": "b",
+        "type": "const char*"
+      },
+      {
+        "name": "e",
+        "type": "const char*"
+      }
+    ],
     "ImVec2": [
       {
         "name": "x",
@@ -2738,27 +2912,6 @@
         "name": "w",
         "type": "float"
       }
-    ],
-    "ImVector": [],
-    "Pair": [
-      {
-        "name": "key",
-        "type": "ImGuiID"
-      },
-      {
-        "name": "}",
-        "type": "union { int val_i; float val_f; void* val_p;"
-      }
-    ],
-    "TextRange": [
-      {
-        "name": "b",
-        "type": "const char*"
-      },
-      {
-        "name": "e",
-        "type": "const char*"
-      }
     ]
   }
 }

generator/output/typedefs_dict.json

@@ -1,5 +1,4 @@
 {
-  "CustomRect": "struct CustomRect",
   "ImColor": "struct ImColor",
   "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
   "ImDrawChannel": "struct ImDrawChannel",
@@ -10,9 +9,11 @@
   "ImDrawList": "struct ImDrawList",
   "ImDrawListFlags": "int",
   "ImDrawListSharedData": "struct ImDrawListSharedData",
+  "ImDrawListSplitter": "struct ImDrawListSplitter",
   "ImDrawVert": "struct ImDrawVert",
   "ImFont": "struct ImFont",
   "ImFontAtlas": "struct ImFontAtlas",
+  "ImFontAtlasCustomRect": "struct ImFontAtlasCustomRect",
   "ImFontAtlasFlags": "int",
   "ImFontConfig": "struct ImFontConfig",
   "ImFontGlyph": "struct ImFontGlyph",
@@ -20,7 +21,6 @@
   "ImGuiBackendFlags": "int",
   "ImGuiCol": "int",
   "ImGuiColorEditFlags": "int",
-  "ImGuiColumnsFlags": "int",
   "ImGuiComboFlags": "int",
   "ImGuiCond": "int",
   "ImGuiConfigFlags": "int",
@@ -37,6 +37,7 @@
   "ImGuiInputTextFlags": "int",
   "ImGuiKey": "int",
   "ImGuiListClipper": "struct ImGuiListClipper",
+  "ImGuiMouseButton": "int",
   "ImGuiMouseCursor": "int",
   "ImGuiNavInput": "int",
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
@@ -45,24 +46,28 @@
   "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
   "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
   "ImGuiStorage": "struct ImGuiStorage",
+  "ImGuiStoragePair": "struct ImGuiStoragePair",
   "ImGuiStyle": "struct ImGuiStyle",
   "ImGuiStyleVar": "int",
   "ImGuiTabBarFlags": "int",
   "ImGuiTabItemFlags": "int",
   "ImGuiTextBuffer": "struct ImGuiTextBuffer",
   "ImGuiTextFilter": "struct ImGuiTextFilter",
+  "ImGuiTextRange": "struct ImGuiTextRange",
   "ImGuiTreeNodeFlags": "int",
   "ImGuiWindowFlags": "int",
+  "ImS16": "signed short",
   "ImS32": "signed int",
   "ImS64": "int64_t",
+  "ImS8": "signed char",
   "ImTextureID": "void*",
+  "ImU16": "unsigned short",
   "ImU32": "unsigned int",
   "ImU64": "uint64_t",
+  "ImU8": "unsigned char",
   "ImVec2": "struct ImVec2",
   "ImVec4": "struct ImVec4",
   "ImWchar": "unsigned short",
-  "Pair": "struct Pair",
-  "TextRange": "struct TextRange",
   "const_iterator": "const value_type*",
   "iterator": "value_type*",
   "value_type": "T"

generator/output/typedefs_dict.lua

@@ -1,5 +1,4 @@
 local defs = {}
-defs["CustomRect"] = "struct CustomRect"
 defs["ImColor"] = "struct ImColor"
 defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
 defs["ImDrawChannel"] = "struct ImDrawChannel"
@@ -10,9 +9,11 @@ defs["ImDrawIdx"] = "unsigned short"
 defs["ImDrawList"] = "struct ImDrawList"
 defs["ImDrawListFlags"] = "int"
 defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
+defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
 defs["ImDrawVert"] = "struct ImDrawVert"
 defs["ImFont"] = "struct ImFont"
 defs["ImFontAtlas"] = "struct ImFontAtlas"
+defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
 defs["ImFontAtlasFlags"] = "int"
 defs["ImFontConfig"] = "struct ImFontConfig"
 defs["ImFontGlyph"] = "struct ImFontGlyph"
@@ -20,7 +21,6 @@ defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
 defs["ImGuiBackendFlags"] = "int"
 defs["ImGuiCol"] = "int"
 defs["ImGuiColorEditFlags"] = "int"
-defs["ImGuiColumnsFlags"] = "int"
 defs["ImGuiComboFlags"] = "int"
 defs["ImGuiCond"] = "int"
 defs["ImGuiConfigFlags"] = "int"
@@ -37,6 +37,7 @@ defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
 defs["ImGuiInputTextFlags"] = "int"
 defs["ImGuiKey"] = "int"
 defs["ImGuiListClipper"] = "struct ImGuiListClipper"
+defs["ImGuiMouseButton"] = "int"
 defs["ImGuiMouseCursor"] = "int"
 defs["ImGuiNavInput"] = "int"
 defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
@@ -45,24 +46,28 @@ defs["ImGuiSelectableFlags"] = "int"
 defs["ImGuiSizeCallback"] = "void(*)(ImGuiSizeCallbackData* data);"
 defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
 defs["ImGuiStorage"] = "struct ImGuiStorage"
+defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
 defs["ImGuiStyle"] = "struct ImGuiStyle"
 defs["ImGuiStyleVar"] = "int"
 defs["ImGuiTabBarFlags"] = "int"
 defs["ImGuiTabItemFlags"] = "int"
 defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
 defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
+defs["ImGuiTextRange"] = "struct ImGuiTextRange"
 defs["ImGuiTreeNodeFlags"] = "int"
 defs["ImGuiWindowFlags"] = "int"
+defs["ImS16"] = "signed short"
 defs["ImS32"] = "signed int"
 defs["ImS64"] = "int64_t"
+defs["ImS8"] = "signed char"
 defs["ImTextureID"] = "void*"
+defs["ImU16"] = "unsigned short"
 defs["ImU32"] = "unsigned int"
 defs["ImU64"] = "uint64_t"
+defs["ImU8"] = "unsigned char"
 defs["ImVec2"] = "struct ImVec2"
 defs["ImVec4"] = "struct ImVec4"
 defs["ImWchar"] = "unsigned short"
-defs["Pair"] = "struct Pair"
-defs["TextRange"] = "struct TextRange"
 defs["const_iterator"] = "const value_type*"
 defs["iterator"] = "value_type*"
 defs["value_type"] = "T"

test/CMakeLists.txt

@@ -0,0 +1,11 @@
+file(GLOB CIMGUI_TEST_SOURCES
+    main.c
+)
+
+add_executable(cimgui_test ${CIMGUI_TEST_SOURCES})
+
+set_target_properties(cimgui_test PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set_property(TARGET cimgui_test PROPERTY C_STANDARD 99)
+
+target_compile_definitions(cimgui_test PRIVATE CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1)
+target_link_libraries(cimgui_test PRIVATE cimgui)

test/main.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <assert.h>
+#include "../cimgui.h"
+
+int main(void)
+{
+  assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
+                                          sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert),
+                                          sizeof(ImDrawIdx)));
+  printf("CreateContext() - v%s\n", igGetVersion());
+  igCreateContext(NULL);
+  ImGuiIO *io = igGetIO();
+
+  unsigned char *text_pixels = NULL;
+  int text_w, text_h;
+  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+
+  for (int n = 0; n < 20; n++) {
+    printf("NewFrame() %d\n", n);
+
+    ImVec2 display_size;
+    display_size.x = 1920;
+    display_size.y = 1080;
+    io->DisplaySize = display_size;
+    io->DeltaTime = 1.0f / 60.0f;
+    igNewFrame();
+
+    static float f = 0.0f;
+    igText("Hello World!");
+    igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 1.0f);
+    igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+    igShowDemoWindow(NULL);
+
+    igRender();
+  }
+
+  printf("DestroyContext()\n");
+  igDestroyContext(NULL);
+
+  return 0;
+}

testbuildc/build.bat

@@ -1,6 +0,0 @@
-set PATH=%PATH%;C:\mingw32\bin;
-::set PATH=%PATH%;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
-::gcc -std=c99 -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-::gcc  -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-gcc  -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k

testbuildc/cimguitest.c

@@ -1,5 +0,0 @@
-#include "../cimgui.h"
-
-void main(void)
-{
-}

testbuildc/testcl.bat

@@ -1,13 +0,0 @@
-::set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
-::gcc -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h > 11.txt
-
-::set PATH=%PATH%;C:\luaGL;
-::set PATH=%PATH%;C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\bin\Hostx64\x64;
-
-::ejecutar en cmd esto 
-::"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-::cl /P /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ../imgui/imgui.h 
-:: > clout.txt
-cl  /P /DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k