Merge branch 'docking_inter'

Added raylib-cimgui to the README

.github/workflows/build.yml

@@ -0,0 +1,77 @@
+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:x64-windows
+          echo "/C/vcpkg/installed/x64-windows/tools/luajit" >> $GITHUB_PATH
+          echo "/C/vcpkg/installed/x64-windows/bin"   >> $GITHUB_PATH
+        fi
+
+    - name: Download Submodules
+      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: |
+        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/

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "imgui"]
 	path = imgui
 	url = https://github.com/ocornut/imgui.git
+	branch = docking

.travis.yml

@@ -1,12 +1,23 @@
 language: cpp
+dist: focal
 
 os:
   - linux
+  - osx
+  - windows
 
 compiler:
   - gcc
   - clang
 
 script:
-  - make -C cimgui
-  - $CC cimgui.h    # Make sure we can include in a plain C compiler
+  - mkdir bld
+  - cd bld
+  - cmake -D CIMGUI_TEST=1 ..
+  - cmake --build .
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      ./Debug/cimgui_test.exe
+    else
+      ./cimgui_test
+    fi

CMakeLists.txt

@@ -0,0 +1,67 @@
+cmake_minimum_required(VERSION 3.15)
+cmake_policy(SET CMP0091 NEW)
+project(cimgui)
+
+set (CMAKE_CXX_STANDARD 11)
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+
+#general settings
+file(GLOB IMGUI_SOURCES
+    cimgui.cpp
+    imgui/imgui.cpp
+    imgui/imgui_draw.cpp
+    imgui/imgui_demo.cpp
+    imgui/imgui_widgets.cpp
+	${TABLES_SOURCE}
+)
+
+set(IMGUI_STATIC "no" CACHE STRING "Build as a static library")
+set(IMGUI_FREETYPE "no" CACHE STRING "Build with freetype library")
+set(IMGUI_LIBRARIES )
+
+if(IMGUI_FREETYPE)
+	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
+	list(APPEND IMGUI_LIBRARIES freetype)
+	list(APPEND IMGUI_SOURCES imgui/misc/freetype/imgui_freetype.cpp)
+	add_definitions("-DCIMGUI_FREETYPE=1")
+endif(IMGUI_FREETYPE)
+
+#add library and link
+if (IMGUI_STATIC)
+    add_library(cimgui STATIC ${IMGUI_SOURCES})
+else (IMGUI_STATIC)
+    add_library(cimgui SHARED ${IMGUI_SOURCES})
+endif (IMGUI_STATIC)
+
+target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
+if (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t__declspec\(dllexport\))
+    list(APPEND IMGUI_LIBRARIES imm32)
+else (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t)
+endif (WIN32)
+
+target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/imgui)
+set_target_properties(cimgui PROPERTIES PREFIX "")
+target_link_libraries(cimgui ${IMGUI_LIBRARIES})
+
+#install
+install(TARGETS cimgui
+    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

@@ -1,29 +1,35 @@
 #
 # Cross Platform Makefile
-# Compatible with Ubuntu 14.04.1 and Mac OS X
+# Compatible with Ubuntu 14.04.1 and macOS
 
 OBJS = cimgui.o
-OBJS += ../imgui/imgui.o
-OBJS += ../imgui/imgui_draw.o
-OBJS += ../imgui/imgui_demo.o
+OBJS += ./imgui/imgui.o
+OBJS += ./imgui/imgui_draw.o
+OBJS += ./imgui/imgui_demo.o
+OBJS += ./imgui/imgui_tables.o
+OBJS += ./imgui/imgui_widgets.o
+
+CXXFLAGS=-O2 -fno-exceptions -fno-rtti
 
 UNAME_S := $(shell uname -s)
 
+AR := ar -rc
+
 ifeq ($(UNAME_S), Linux) #LINUX
 	ECHO_MESSAGE = "Linux"
 
 	OUTPUTNAME = cimgui.so
-	CXXFLAGS = -I../../
+	CXXFLAGS += -I./imgui/
 	CXXFLAGS += -Wall
 	CXXFLAGS += -shared -fPIC
 	CFLAGS = $(CXXFLAGS)
 endif
 
 ifeq ($(UNAME_S), Darwin) #APPLE
-	ECHO_MESSAGE = "Mac OS X"
+	ECHO_MESSAGE = "macOS"
 
 	OUTPUTNAME = cimgui.dylib
-	CXXFLAGS = -I/usr/local/include
+	CXXFLAGS += -I/usr/local/include
 	CXXFLAGS += -Wall
 	LINKFLAGS = -dynamiclib
 	CFLAGS = $(CXXFLAGS)
@@ -33,7 +39,7 @@ ifeq ($(OS), Windows_NT)
 	ECHO_MESSAGE = "Windows"
 
 	OUTPUTNAME = cimgui.dll
-	CXXFLAGS = -I../../
+	CXXFLAGS += -I./imgui/
 	CXXFLAGS += -Wall
 	CXXFLAGS += -shared
 	LINKFLAGS = -limm32
@@ -43,11 +49,29 @@ endif
 .cpp.o:
 	$(CXX) $(CXXFLAGS) -c -o $@ $<
 
-all:imgui_example
+all:$(OUTPUTNAME)
 	@echo Build complete for $(ECHO_MESSAGE)
 
-imgui_example:$(OBJS)
+static:$(OBJS)
+	$(AR) libcimgui.a $(OBJS)
+
+$(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
 
 clean:
-	rm $(OBJS)
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OBJS))
+else
+	rm -f $(OBJS)
+endif
+
+fclean: clean
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OUTPUTNAME))
+else
+	rm -f $(OUTPUTNAME)
+endif
+
+re: fclean all
+
+.PHONY: all clean fclean re static

README.md

@@ -1,36 +1,121 @@
-# cimgui [![Build Status](https://travis-ci.org/Extrawurst/cimgui.svg)](https://travis-ci.org/Extrawurst/cimgui)
+# cimgui [![Build Status](https://travis-ci.org/cimgui/cimgui.svg?branch=master)](https://travis-ci.org/cimgui/cimgui)
 
-![sample](screenshot.png)
 
-This is a thin c-api wrapper programmatically generated for the excellent C++ intermediate gui [imgui](https://github.com/ocornut/imgui).
-All functions are programmatically wrapped except contructors, destructors and ImVector.(Unless someone find a use case for them)
-Generated files are: cimgui.cpp, cimgui.h for C compilation. Also for helping in bindings creation, definitions.lua with function definitions information and structs_and_enums.lua.
-This library is intended as a intermediate layer to be able to use imgui from other languages that can interface with C (like D - see [D-binding](https://github.com/Extrawurst/DerelictImgui))
+This is a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui [Dear ImGui](https://github.com/ocornut/imgui).
+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))
+
+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.62 of imgui](https://github.com/ocornut/imgui/tree/v1.62)
-* 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/sonoro1234/cimgui/blob/cimgui_auto_implementations/generator/generator.lua#L40). Until the comunity finish with defining this table tag will be 1.62beta. Current overloaded function names can be found in (https://github.com/sonoro1234/cimgui/tree/cimgui_auto_implementations/generator/generated/overloads.txt)
+* currently this wrapper is based on version [1.90.6 of Dear ImGui with internal api]
+* only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
+* if you are interested in imgui backends you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
+* All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
+* Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)
 
-# auto binding generation
+# compilation
 
-* update imgui folder to the version you desire.
-* run imgui/generator/generator.bat (or make a .sh version and please PR) with gcc and Lua on your PATH.
-* build as shown in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master_auto_implementations/build
-* generate binding as done in https://github.com/sonoro1234/LuaJIT-ImGui/blob/master_auto_implementations/lua/build.bat
+* clone 
+  * `git clone --recursive https://github.com/cimgui/cimgui.git`
+  * `git submodule update --init --recursive` (If already cloned)
+* compile 
+  * using makefile on linux/macOS/mingw (Or use CMake to generate project)
+  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location) (only if cimgui is generated with freetype option)
+  * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
+  
+  For compiling with backends there are now examples with SDL2 and opengl3/vulkan in folder backend_test.
+  They'll generate a cimgui_sdl module and a test_sdl executable.
 
+# using generator
+
+
+* 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 need to use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC). (this repo was done with gcc)
+* update `imgui` folder to the version you desire.
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired backends and whether imgui_internal is generated or not, Freetype2 is used or not and comments are generated or not
+* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, vulkan, opengl2 and opengl3 as backends.
+* edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
+* Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
+* as a result some files are generated: `cimgui.cpp`, `cimgui.h` and `cimgui_impl.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the backends info. 
+* You can pass compiler flags to generator.sh or generator.bat by editing them at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+* You are able to pass any extra argument to generator.sh (.bat) in the command-line.
+* If you are using different options than cimgui repo and if you want to keep them after a cimgui update, you can keep them in a copy of generator.sh (.bat) outside of cimgui folder where `cd cimgui/generator` is used before luajit call. See https://github.com/cimgui/cimgui/issues/232#issuecomment-1497059497
+# generate binding
+* C interface is exposed by cimgui.h when you define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+* with your prefered language you can use the lua or json files generated as in:
+  * https://github.com/sonoro1234/LuaJIT-ImGui/blob/master/lua/build.bat (with lua code generation in https://github.com/sonoro1234/LuaJIT-ImGui/blob/master/lua/class_gen.lua)
+  * https://github.com/mellinoe/ImGui.NET/tree/autogen/src/CodeGenerator
+### 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 (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, when the argument is a function pointer also ret: return type and signature: the function signature)
+  * args : a string of argsT concatenated and separated by commas
+  * call_args : a string with the argument names separated by commas for calling imgui function
+  * defaults : a collection in which key is argument name and value is the default value.
+  * manual : will be true if this function is hand-written (not generated)
+  * skipped : will be true if this function is not generated (and not hand-written)
+  * isvararg : is set if some argument is a vararg
+  * constructor : is set if the function is a constructor for a class.
+  * destructor : is set if the function is a destructor for a class but not just a default destructor.
+  * realdestructor : is set if the function is a destructor for a class
+  * templated : is set if the function belongs to a templated class (ImVector)
+  * templatedgen: is set if the function belongs to a struct generated from template (ImVector_ImWchar)
+  * nonUDT : if present the original function was returning a user defined type so that signature has been changed to accept a pointer to the UDT as first argument.
+  * location : name of the header file and linenumber this function comes from. (imgui:000, internal:123, imgui_impl_xxx:123)
+  * is_static_function : is setted when it is an struct static function.
+### structs_and_enums description
+* Is is a collection with three items:
+  * under key enums we get the enums collection in which each key is the enum tagname and the value is an array of the ordered values represented as a collection with keys
+    * name : the name of this enum value
+    * value : the C string
+    * calc_value : the numeric value corresponding to value
+  * under key structs we get the structs collection in which the key is the struct name and the value is an array of the struct members. Each one given as a collection with keys
+    * type : the type of the struct member
+    * template_type : if type has a template argument (as ImVector) here will be
+    * name : the name of the struct member
+    * size : the number of array elements (when it is an array)
+    * bitfield : the bitfield width (in case it is a bitfield)
+  * under key locations we get the locations collection in which each key is the enum tagname or the struct name and the value is the name of the header file and line number this comes from.
 # usage
 
-* clone
-* make using makefile on linux/osx
 * use whatever method is in ImGui c++ namespace in the original [imgui.h](https://github.com/ocornut/imgui/blob/master/imgui.h) by prepending `ig`
 * methods have the same parameter list and return values (where possible)
+* functions that belong to a struct have an extra first argument with a pointer to the struct.
+* where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
+
+# usage with backends
+
+* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan
+* read [How can cimgui backends be used](https://github.com/cimgui/cimgui/issues/157)
 
 # example bindings based on cimgui
 
-* [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
+* [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
 * [ImGui.NET](https://github.com/mellinoe/ImGui.NET)
-* [ImGuiCS](https://github.com/0x0ade/ImGuiCS)
+* [nimgl/imgui](https://github.com/nimgl/imgui)
+* [kotlin-imgui](https://github.com/Dominaezzz/kotlin-imgui)
+* [CImGui.jl](https://github.com/Gnimuc/CImGui.jl)
+* [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
+* [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
+* [BindBC-CimGui](https://github.com/MrcSnm/bindbc-cimgui)
 * [imgui-rs](https://github.com/Gekkio/imgui-rs)
 * [imgui-pas](https://github.com/dpethes/imgui-pas)
-* [odin-dear_imgui](https://github.com/ThisDrunkDane/odin-dear_imgui)
-* [LuaJIT-imgui](https://github.com/sonoro1234/LuaJIT-ImGui)
+* [crystal-imgui](https://github.com/oprypin/crystal-imgui)
+
+# C examples based on cimgui
+
+* [sdl2_opengl3](https://github.com/cimgui/cimgui/tree/docking_inter/backend_test)
+* [sdl2-cimgui-demo](https://github.com/haxpor/sdl2-cimgui-demo)
+* [cimgui_c_sdl2_example](https://github.com/canoi12/cimgui_c_sdl2_example/)
+* [cimgui-c-example](https://github.com/peko/cimgui-c-example) with GLFW
+* [raylib-cimgui](https://github.com/alfredbaudisch/raylib-cimgui)

TODO.txt

@@ -0,0 +1,5 @@
+
+
+ - Being able to use a prefix for structs and enums. Could be a manual dictionary or an option to take parent namespace and struct (https://github.com/rokups/ImNodes/pull/20#issuecomment-719713982)
+ 
+ - Being able to generate separate headers for imgui and imgui_internal. (https://github.com/cimgui/cimgui/pull/126#issuecomment-735674105)

backend_test/example_glfw_opengl3/CMakeLists.txt

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

backend_test/example_glfw_opengl3/main.c

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

backend_test/example_sdl_opengl3/CMakeLists.txt

@@ -0,0 +1,111 @@
+Project(cimgui_sdl)
+cmake_minimum_required(VERSION 2.8)
+if(WIN32) #to mingw work as all the others
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+
+set (CMAKE_CXX_STANDARD 11)
+
+#general settings
+
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
+	set(BAKENDS_FOLDER "../../imgui/backends/")
+else()
+	set(BAKENDS_FOLDER "../../imgui/examples/")
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+include_directories(../../imgui)
+add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+
+include_directories(../../)
+set(IMGUI_SOURCES 
+../../cimgui.cpp 
+../../imgui/imgui.cpp 
+../../imgui/imgui_draw.cpp 
+../../imgui/imgui_demo.cpp 
+../../imgui/imgui_widgets.cpp
+${TABLES_SOURCE} 
+)
+
+set(IMGUI_SOURCES_sdl)
+set(IMGUI_LIBRARIES )
+
+if (WIN32)
+    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+
+add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
+
+#optional adding freetype
+option(IMGUI_FREETYPE "add Freetype2" OFF)
+
+if(IMGUI_FREETYPE)
+	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
+	list(APPEND IMGUI_LIBRARIES freetype)
+	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
+	add_definitions("-DCIMGUI_FREETYPE=1")
+endif(IMGUI_FREETYPE)
+
+#opengl3
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp)
+include_directories(../../imgui/examples/libs/gl3w)
+if(WIN32)
+       list(APPEND IMGUI_LIBRARIES opengl32)
+else(WIN32)#Unix
+       list(APPEND IMGUI_LIBRARIES GL)
+endif(WIN32)
+
+
+#sdl2
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
+if(DEFINED SDL_PATH)
+	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
+else(DEFINED SDL_PATH)
+	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
+	find_package(SDL2)
+endif(DEFINED SDL_PATH)
+
+if(SDL2_FOUND)
+	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
+	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
+		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
+		include_directories(${SDL2_INCLUDE_DIRS})
+		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
+	else()#use new one SDL2 config
+		include_directories(${SDL_INCLUDE})
+		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
+		set(SDL_MAIN SDL2::SDL2main)
+		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
+	endif()
+else(SDL2_FOUND)
+	if(DEFINED SDL_PATH)
+		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
+	else(DEFINED SDL_PATH)
+		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
+	endif(DEFINED SDL_PATH)
+endif(SDL2_FOUND)
+
+add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
+target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+
+#using library
+include_directories(../../generator/output/)
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL2)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+

backend_test/example_sdl_opengl3/main.c

@@ -0,0 +1,195 @@
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_impl.h"
+#include <stdio.h>
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+SDL_Window *window = NULL;
+
+int main(int argc, char* argv[])
+{
+
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    SDL_Log("failed to init: %s", SDL_GetError());
+    return -1;
+  }
+ 
+  // Decide GL+GLSL versions
+#if __APPLE__
+    // GL 3.2 Core + GLSL 150
+    const char* glsl_version = "#version 150";
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); // Always required on Mac
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
+#else
+    // GL 3.0 + GLSL 130
+    const char* glsl_version = "#version 130";
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+#endif
+
+  // and prepare OpenGL stuff
+  SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
+  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+  SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+  SDL_DisplayMode current;
+  SDL_GetCurrentDisplayMode(0, &current);
+  
+  window = SDL_CreateWindow(
+      "Hello", 0, 0, 1024, 768,
+      SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
+      );
+  if (window == NULL) {
+    SDL_Log("Failed to create window: %s", SDL_GetError());
+    return -1;
+  }
+
+  SDL_GLContext gl_context = SDL_GL_CreateContext(window);
+  SDL_GL_SetSwapInterval(1);  // enable vsync
+
+
+  // check opengl version sdl uses
+  SDL_Log("opengl version: %s", (char*)glGetString(GL_VERSION));
+
+  // setup imgui
+  igCreateContext(NULL);
+  
+  //set docking
+  ImGuiIO* ioptr = igGetIO();
+  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;       // Enable Keyboard Controls
+  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+#ifdef IMGUI_HAS_DOCK
+  ioptr->ConfigFlags |= ImGuiConfigFlags_DockingEnable;           // Enable Docking
+  ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;         // Enable Multi-Viewport / Platform Windows
+#endif
+  
+  ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
+  ImGui_ImplOpenGL3_Init(glsl_version);
+
+  igStyleColorsDark(NULL);
+  //ImFontAtlas_AddFontDefault(io.Fonts, NULL);
+
+
+  bool showDemoWindow = true;
+  bool showAnotherWindow = false;
+  ImVec4 clearColor;
+  clearColor.x = 0.45f;
+  clearColor.y = 0.55f;
+  clearColor.z = 0.60f;
+  clearColor.w = 1.00f;
+
+  bool quit = false;
+  while (!quit)
+  {
+    SDL_Event e;
+
+    // we need to call SDL_PollEvent to let window rendered, otherwise
+    // no window will be shown
+    while (SDL_PollEvent(&e) != 0)
+    {
+      ImGui_ImplSDL2_ProcessEvent(&e);
+      if (e.type == SDL_QUIT)
+        quit = true;
+      if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_CLOSE && e.window.windowID == SDL_GetWindowID(window))
+        quit = true;
+    }
+    
+    // start imgui frame
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    igNewFrame();
+
+    if (showDemoWindow)
+      igShowDemoWindow(&showDemoWindow);
+
+    // show a simple window that we created ourselves.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      igBegin("Hello, world!", NULL, 0);
+      igText("This is some useful text");
+      igCheckbox("Demo window", &showDemoWindow);
+      igCheckbox("Another window", &showAnotherWindow);
+
+      igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+      igColorEdit3("clear color", (float*)&clearColor, 0);
+
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Button", buttonSize))
+        counter++;
+      igSameLine(0.0f, -1.0f);
+      igText("counter = %d", counter);
+
+      igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / igGetIO()->Framerate, igGetIO()->Framerate);
+      igEnd();
+    }
+
+    if (showAnotherWindow)
+    {
+      igBegin("imgui Another Window", &showAnotherWindow, 0);
+      igText("Hello from imgui");
+      ImVec2 buttonSize;
+      buttonSize.x = 0; buttonSize.y = 0;
+      if (igButton("Close me", buttonSize))
+      {
+        showAnotherWindow = false;
+      }
+      igEnd();
+    }
+
+    // render
+    igRender();
+    SDL_GL_MakeCurrent(window, gl_context);
+    glViewport(0, 0, (int)ioptr->DisplaySize.x, (int)ioptr->DisplaySize.y);
+    glClearColor(clearColor.x, clearColor.y, clearColor.z, clearColor.w);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(igGetDrawData());
+#ifdef IMGUI_HAS_DOCK
+	if (ioptr->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+        {
+            SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
+            SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
+            igUpdatePlatformWindows();
+            igRenderPlatformWindowsDefault(NULL,NULL);
+            SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
+        }
+#endif
+    SDL_GL_SwapWindow(window);
+  }
+
+  // clean up
+  ImGui_ImplOpenGL3_Shutdown();
+  ImGui_ImplSDL2_Shutdown();
+  igDestroyContext(NULL);
+
+  SDL_GL_DeleteContext(gl_context);
+  if (window != NULL)
+  {
+    SDL_DestroyWindow(window);
+    window = NULL;
+  }
+  SDL_Quit();
+
+  return 0;
+}

backend_test/example_sdl_vulkan/CMakeLists.txt

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

backend_test/example_sdl_vulkan/main.c

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

generator/cimgui_template.cpp

@@ -1,11 +1,24 @@
-
-#include "../imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#ifndef CIMGUI_FREETYPE
+#error "IMGUI_FREETYPE should be defined for Freetype linking"
+#endif
+#else
+#ifdef CIMGUI_FREETYPE
+#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
+#endif
+#endif
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#include "../imgui/imgui_internal.h"
+
 
 #include "auto_funcs.cpp"
 
+
 /////////////////////////////manual written functions
 CIMGUI_API void igLogText(CONST char *fmt, ...)
 {
@@ -24,11 +37,94 @@ CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const ch
     buffer->appendfv(fmt, args);
     va_end(args);
 }
-CIMGUI_API void ImFontConfig_DefaultConstructor(ImFontConfig *config)
-{
-    *config = ImFontConfig();
-}
+
 CIMGUI_API float igGET_FLT_MAX()
 {
     return FLT_MAX;
 }
+
+CIMGUI_API float igGET_FLT_MIN()
+{
+    return FLT_MIN;
+}
+
+
+CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
+{
+	return IM_NEW(ImVector<ImWchar>) ();
+}
+
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
+{
+    IM_DELETE(self);
+}
+
+CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
+{
+	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
+}
+CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p)
+{
+	p->~ImVector<ImWchar>();
+}
+
+
+#ifdef IMGUI_HAS_DOCK
+
+// NOTE: Some function pointers in the ImGuiPlatformIO structure are not C-compatible because of their
+// use of a complex return type. To work around this, we store a custom CimguiStorage object inside
+// ImGuiIO::BackendLanguageUserData, which contains C-compatible function pointer variants for these
+// functions. When a user function pointer is provided, we hook up the underlying ImGuiPlatformIO
+// function pointer to a thunk which accesses the user function pointer through CimguiStorage.
+
+struct CimguiStorage
+{
+    void(*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
+    void(*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
+};
+
+// Gets a reference to the CimguiStorage object stored in the current ImGui context's BackendLanguageUserData.
+CimguiStorage& GetCimguiStorage()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if (io.BackendLanguageUserData == NULL)
+    {
+        io.BackendLanguageUserData = new CimguiStorage();
+    }
+
+    return *(CimguiStorage*)io.BackendLanguageUserData;
+}
+
+// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
+ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp)
+{
+    ImVec2 pos;
+    GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
+    return pos;
+};
+
+// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowPos.
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos))
+{
+    CimguiStorage& storage = GetCimguiStorage();
+    storage.Platform_GetWindowPos = user_callback;
+    platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
+}
+
+// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
+ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp)
+{
+    ImVec2 size;
+    GetCimguiStorage().Platform_GetWindowSize(vp, &size);
+    return size;
+};
+
+// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowSize.
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size))
+{
+    CimguiStorage& storage = GetCimguiStorage();
+    storage.Platform_GetWindowSize = user_callback;
+    platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
+}
+
+#endif

generator/cimgui_template.h

@@ -1,17 +1,19 @@
-
+#ifndef CIMGUI_INCLUDED
+#define CIMGUI_INCLUDED
 #include <stdio.h>
-
+#include <stdint.h>
 #if defined _WIN32 || defined __CYGWIN__
     #ifdef CIMGUI_NO_EXPORT
         #define API
     #else
         #define API __declspec(dllexport)
     #endif
-    #ifndef __GNUC__
-    #define snprintf sprintf_s
-    #endif
 #else
-    #define API
+    #ifdef __GNUC__
+        #define API  __attribute__((__visibility__("default")))
+    #else
+        #define API
+    #endif
 #endif
 
 #if defined __cplusplus
@@ -29,11 +31,9 @@
 #ifdef _MSC_VER
 typedef unsigned __int64 ImU64;
 #else
-typedef unsigned long long ImU64;
+//typedef unsigned long long ImU64;
 #endif
 
-//struct GLFWwindow;
-//struct SDL_Window;
 
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "imgui_structs.h"
@@ -50,8 +50,20 @@ typedef union SDL_Event SDL_Event;
 CIMGUI_API void igLogText(CONST char *fmt, ...);
 //no appendfV
 CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
-CIMGUI_API void ImFontConfig_DefaultConstructor(ImFontConfig *config);
 //for getting FLT_MAX in bindings
-CIMGUI_API float igGET_FLT_MAX();
+CIMGUI_API float igGET_FLT_MAX(void);
+//for getting FLT_MIN in bindings
+CIMGUI_API float igGET_FLT_MIN(void);
+
+
+CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create(void);
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
+CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
+CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
+
+
+#endif //CIMGUI_INCLUDED
+
+
 
 

generator/config_generator.lua

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

generator/generated/cimgui_impl.h

@@ -1,34 +0,0 @@
-struct GLFWwindow;
-typedef struct SDL_Window SDL_Window;
-typedef struct GLFWwindow GLFWwindow;
-struct SDL_Window;
-typedef union SDL_Event SDL_Event;
-CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown();
-CIMGUI_API void ImGui_ImplGlfw_NewFrame();
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
-CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
-CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
-CIMGUI_API void ImGui_ImplOpenGL3_Shutdown();
-CIMGUI_API void ImGui_ImplOpenGL3_NewFrame();
-CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplOpenGL2_Init();
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown();
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame();
-CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown();
-CIMGUI_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(SDL_Event* event);

generator/generated/impl_definitions.lua

@@ -1,409 +0,0 @@
-local defs = {}
-defs["ImGui_ImplOpenGL3_NewFrame"] = {}
-defs["ImGui_ImplOpenGL3_NewFrame"][1] = {}
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
-defs["ImGui_ImplOpenGL3_NewFrame"]["()"] = defs["ImGui_ImplOpenGL3_NewFrame"][1]
-defs["ImGui_ImplSDL2_Shutdown"] = {}
-defs["ImGui_ImplSDL2_Shutdown"][1] = {}
-defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"][1]["args"] = "()"
-defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
-defs["ImGui_ImplSDL2_Shutdown"][1]["call_args"] = "()"
-defs["ImGui_ImplSDL2_Shutdown"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplSDL2_Shutdown"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_Shutdown"][1]["comment"] = ""
-defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl"
-defs["ImGui_ImplSDL2_Shutdown"][1]["defaults"] = {}
-defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"
-defs["ImGui_ImplSDL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplSDL2_Shutdown"
-defs["ImGui_ImplSDL2_Shutdown"]["()"] = defs["ImGui_ImplSDL2_Shutdown"][1]
-defs["ImGui_ImplGlfw_KeyCallback"] = {}
-defs["ImGui_ImplGlfw_KeyCallback"][1] = {}
-defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["args"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["call_args"] = "(window,key,scancode,action,mods)"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_KeyCallback"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_KeyCallback"][1]["signature"] = "(GLFWwindow*,int,int,int,int)"
-defs["ImGui_ImplGlfw_KeyCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
-defs["ImGui_ImplGlfw_KeyCallback"]["(GLFWwindow*,int,int,int,int)"] = defs["ImGui_ImplGlfw_KeyCallback"][1]
-defs["ImGui_ImplGlfw_InitForVulkan"] = {}
-defs["ImGui_ImplGlfw_InitForVulkan"][1] = {}
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["ret"] = "bool"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["call_args"] = "(window,install_callbacks)"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["signature"] = "(GLFWwindow*,bool)"
-defs["ImGui_ImplGlfw_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
-defs["ImGui_ImplGlfw_InitForVulkan"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForVulkan"][1]
-defs["ImGui_ImplSDL2_NewFrame"] = {}
-defs["ImGui_ImplSDL2_NewFrame"][1] = {}
-defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"][1]["args"] = "(SDL_Window* window)"
-defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
-defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "(window)"
-defs["ImGui_ImplSDL2_NewFrame"][1]["argsoriginal"] = "(SDL_Window* window)"
-defs["ImGui_ImplSDL2_NewFrame"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_NewFrame"][1]["comment"] = ""
-defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl"
-defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
-defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "(SDL_Window*)"
-defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
-defs["ImGui_ImplSDL2_NewFrame"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_NewFrame"][1]
-defs["ImGui_ImplSDL2_InitForVulkan"] = {}
-defs["ImGui_ImplSDL2_InitForVulkan"][1] = {}
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["args"] = "(SDL_Window* window)"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["ret"] = "bool"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["call_args"] = "(window)"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsoriginal"] = "(SDL_Window* window)"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["comment"] = ""
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["defaults"] = {}
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["signature"] = "(SDL_Window*)"
-defs["ImGui_ImplSDL2_InitForVulkan"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
-defs["ImGui_ImplSDL2_InitForVulkan"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForVulkan"][1]
-defs["ImGui_ImplGlfw_ScrollCallback"] = {}
-defs["ImGui_ImplGlfw_ScrollCallback"][1] = {}
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["args"] = "(GLFWwindow* window,double xoffset,double yoffset)"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["call_args"] = "(window,xoffset,yoffset)"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsoriginal"] = "(GLFWwindow* window,double xoffset,double yoffset)"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
-defs["ImGui_ImplGlfw_ScrollCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
-defs["ImGui_ImplGlfw_ScrollCallback"]["(GLFWwindow*,double,double)"] = defs["ImGui_ImplGlfw_ScrollCallback"][1]
-defs["ImGui_ImplOpenGL3_Init"] = {}
-defs["ImGui_ImplOpenGL3_Init"][1] = {}
-defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"][1]["args"] = "(const char* glsl_version)"
-defs["ImGui_ImplOpenGL3_Init"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
-defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=\"#version 150\")"
-defs["ImGui_ImplOpenGL3_Init"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_Init"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_Init"][1]["signature"] = "(const char*)"
-defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
-defs["ImGui_ImplOpenGL3_Init"]["(const char*)"] = defs["ImGui_ImplOpenGL3_Init"][1]
-defs["ImGui_ImplSDL2_InitForOpenGL"] = {}
-defs["ImGui_ImplSDL2_InitForOpenGL"][1] = {}
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["args"] = "(SDL_Window* window,void* sdl_gl_context)"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ret"] = "bool"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["call_args"] = "(window,sdl_gl_context)"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsoriginal"] = "(SDL_Window* window,void* sdl_gl_context)"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["comment"] = ""
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["defaults"] = {}
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["signature"] = "(SDL_Window*,void*)"
-defs["ImGui_ImplSDL2_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
-defs["ImGui_ImplSDL2_InitForOpenGL"]["(SDL_Window*,void*)"] = defs["ImGui_ImplSDL2_InitForOpenGL"][1]
-defs["ImGui_ImplGlfw_InitForOpenGL"] = {}
-defs["ImGui_ImplGlfw_InitForOpenGL"][1] = {}
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ret"] = "bool"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["call_args"] = "(window,install_callbacks)"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["signature"] = "(GLFWwindow*,bool)"
-defs["ImGui_ImplGlfw_InitForOpenGL"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
-defs["ImGui_ImplGlfw_InitForOpenGL"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForOpenGL"][1]
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"] = {}
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1] = {}
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"] = {}
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1] = {}
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL2_DestroyFontsTexture"]["()"] = defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"] = {}
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1] = {}
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL2_CreateDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"] = {}
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1] = {}
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
-defs["ImGui_ImplOpenGL3_CreateFontsTexture"]["()"] = defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]
-defs["ImGui_ImplGlfw_Shutdown"] = {}
-defs["ImGui_ImplGlfw_Shutdown"][1] = {}
-defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"][1]["args"] = "()"
-defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_Shutdown"][1]["call_args"] = "()"
-defs["ImGui_ImplGlfw_Shutdown"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplGlfw_Shutdown"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_Shutdown"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_Shutdown"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
-defs["ImGui_ImplGlfw_Shutdown"][1]["cimguiname"] = "ImGui_ImplGlfw_Shutdown"
-defs["ImGui_ImplGlfw_Shutdown"]["()"] = defs["ImGui_ImplGlfw_Shutdown"][1]
-defs["ImGui_ImplOpenGL2_RenderDrawData"] = {}
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1] = {}
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["args"] = "(ImDrawData* draw_data)"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["call_args"] = "(draw_data)"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
-defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
-defs["ImGui_ImplOpenGL2_RenderDrawData"]["(ImDrawData*)"] = defs["ImGui_ImplOpenGL2_RenderDrawData"][1]
-defs["ImGui_ImplOpenGL2_NewFrame"] = {}
-defs["ImGui_ImplOpenGL2_NewFrame"][1] = {}
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
-defs["ImGui_ImplOpenGL2_NewFrame"]["()"] = defs["ImGui_ImplOpenGL2_NewFrame"][1]
-defs["ImGui_ImplOpenGL2_Shutdown"] = {}
-defs["ImGui_ImplOpenGL2_Shutdown"][1] = {}
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
-defs["ImGui_ImplOpenGL2_Shutdown"]["()"] = defs["ImGui_ImplOpenGL2_Shutdown"][1]
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"] = {}
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1] = {}
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
-defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]
-defs["ImGui_ImplGlfw_NewFrame"] = {}
-defs["ImGui_ImplGlfw_NewFrame"][1] = {}
-defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"][1]["args"] = "()"
-defs["ImGui_ImplGlfw_NewFrame"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_NewFrame"][1]["call_args"] = "()"
-defs["ImGui_ImplGlfw_NewFrame"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplGlfw_NewFrame"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_NewFrame"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_NewFrame"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_NewFrame"][1]["signature"] = "()"
-defs["ImGui_ImplGlfw_NewFrame"][1]["cimguiname"] = "ImGui_ImplGlfw_NewFrame"
-defs["ImGui_ImplGlfw_NewFrame"]["()"] = defs["ImGui_ImplGlfw_NewFrame"][1]
-defs["ImGui_ImplOpenGL3_Shutdown"] = {}
-defs["ImGui_ImplOpenGL3_Shutdown"][1] = {}
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_Shutdown"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
-defs["ImGui_ImplOpenGL3_Shutdown"]["()"] = defs["ImGui_ImplOpenGL3_Shutdown"][1]
-defs["ImGui_ImplOpenGL2_Init"] = {}
-defs["ImGui_ImplOpenGL2_Init"][1] = {}
-defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL2_Init"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_Init"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_Init"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_Init"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_Init"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL2_Init"
-defs["ImGui_ImplOpenGL2_Init"]["()"] = defs["ImGui_ImplOpenGL2_Init"][1]
-defs["ImGui_ImplSDL2_ProcessEvent"] = {}
-defs["ImGui_ImplSDL2_ProcessEvent"][1] = {}
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["args"] = "(SDL_Event* event)"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["call_args"] = "(event)"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsoriginal"] = "(SDL_Event* event)"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["stname"] = ""
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["comment"] = ""
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["defaults"] = {}
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(SDL_Event*)"
-defs["ImGui_ImplSDL2_ProcessEvent"][1]["cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
-defs["ImGui_ImplSDL2_ProcessEvent"]["(SDL_Event*)"] = defs["ImGui_ImplSDL2_ProcessEvent"][1]
-defs["ImGui_ImplGlfw_MouseButtonCallback"] = {}
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1] = {}
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["args"] = "(GLFWwindow* window,int button,int action,int mods)"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["call_args"] = "(window,button,action,mods)"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int button,int action,int mods)"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["signature"] = "(GLFWwindow*,int,int,int)"
-defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
-defs["ImGui_ImplGlfw_MouseButtonCallback"]["(GLFWwindow*,int,int,int)"] = defs["ImGui_ImplGlfw_MouseButtonCallback"][1]
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"] = {}
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1] = {}
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
-defs["ImGui_ImplOpenGL2_CreateFontsTexture"]["()"] = defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"] = {}
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1] = {}
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
-defs["ImGui_ImplOpenGL3_DestroyFontsTexture"]["()"] = defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]
-defs["ImGui_ImplGlfw_CharCallback"] = {}
-defs["ImGui_ImplGlfw_CharCallback"][1] = {}
-defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"][1]["args"] = "(GLFWwindow* window,unsigned int c)"
-defs["ImGui_ImplGlfw_CharCallback"][1]["ret"] = "void"
-defs["ImGui_ImplGlfw_CharCallback"][1]["call_args"] = "(window,c)"
-defs["ImGui_ImplGlfw_CharCallback"][1]["argsoriginal"] = "(GLFWwindow* window,unsigned int c)"
-defs["ImGui_ImplGlfw_CharCallback"][1]["stname"] = ""
-defs["ImGui_ImplGlfw_CharCallback"][1]["comment"] = ""
-defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw"
-defs["ImGui_ImplGlfw_CharCallback"][1]["defaults"] = {}
-defs["ImGui_ImplGlfw_CharCallback"][1]["signature"] = "(GLFWwindow*,unsigned int)"
-defs["ImGui_ImplGlfw_CharCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CharCallback"
-defs["ImGui_ImplGlfw_CharCallback"]["(GLFWwindow*,unsigned int)"] = defs["ImGui_ImplGlfw_CharCallback"][1]
-defs["ImGui_ImplOpenGL3_RenderDrawData"] = {}
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1] = {}
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["args"] = "(ImDrawData* draw_data)"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["call_args"] = "(draw_data)"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsoriginal"] = "(ImDrawData* draw_data)"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
-defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
-defs["ImGui_ImplOpenGL3_RenderDrawData"]["(ImDrawData*)"] = defs["ImGui_ImplOpenGL3_RenderDrawData"][1]
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"] = {}
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1] = {}
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["args"] = "()"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["call_args"] = "()"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["argsoriginal"] = "()"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["stname"] = ""
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["comment"] = ""
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
-defs["ImGui_ImplOpenGL3_CreateDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]
-
-return defs

generator/generated/overloads.txt

@@ -1,111 +0,0 @@
-----------------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)
-ImVec4_ImVec4	2
-1	nil	ImVec4_ImVec4 ()
-2	nil	ImVec4_ImVec4Float (float,float,float,float)
-igValue	4
-1	void	igValueBool (const char*,bool)
-2	void	igValueInt (const char*,int)
-3	void	igValueUint (const char*,unsigned int)
-4	void	igValueFloat (const char*,float,const char*)
-igPushStyleVar	2
-1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
-2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
-igIsRectVisible	2
-1	bool	igIsRectVisible (const ImVec2)
-2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
-igRadioButton	2
-1	bool	igRadioButtonBool (const char*,bool)
-2	bool	igRadioButtonIntPtr (const char*,int*,int)
-igSetWindowSize	2
-1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
-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)
-igGetID	3
-1	ImGuiID	igGetIDStr (const char*)
-2	ImGuiID	igGetIDStrStr (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)
-igSetWindowFocus	2
-1	void	igSetWindowFocus ()
-2	void	igSetWindowFocusStr (const char*)
-ImDrawList_AddText	2
-1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
-igSelectable	2
-1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
-igListBox	2
-1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
-2	bool	igListBoxFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
-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*)
-igTreePush	2
-1	void	igTreePushStr (const char*)
-2	void	igTreePushPtr (const void*)
-TextRange_TextRange	2
-1	nil	TextRange_TextRange ()
-2	nil	TextRange_TextRangeStr (const char*,const char*)
-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)
-igPushStyleColor	2
-1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
-2	void	igPushStyleColor (ImGuiCol,const ImVec4)
-igCollapsingHeader	2
-1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
-2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
-igListBoxHeader	2
-1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
-2	bool	igListBoxHeaderInt (const char*,int,int)
-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)
-igTreeNodeEx	3
-1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
-2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
-3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
-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

generator/generator.bat

@@ -1,8 +1,8 @@
 :: this script must be executed in this directory
-:: all the output goes to generated folder
+:: all the output goes to generator/output folder
 :: .cpp and .h files:
-:: cimgui.h and cimgui.cpp generated without preprocess
-:: cimgui_auto.h and cimgui_auto.cpp with gcc preprocess
+:: 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
@@ -10,15 +10,15 @@
 :: 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:\mingws\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..n] name of implementations to generate
-luajit.exe ./generator.lua glfw opengl3 opengl2 sdl
-
-::copy cimgui.h and cimgui.cpp
-copy .\generated\cimgui_auto.h ..\cimgui_auto.h
-copy .\generated\cimgui_auto.cpp ..\cimgui_auto.cpp
+:: arg[1] compiler name gcc, clang or cl
+:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+:: examples: "" "internal" "internal freetype comments"
+:: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 %*
 
 ::leave console open
 cmd /k

generator/generator.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+
+# 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, or cl
+# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
+# examples: "" "internal" "internal freetype" "comments internal"
+# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+#
+
+# parse command line arguments
+# ref: https://stackoverflow.com/questions/192249/how-do-i-parse-command-line-arguments-in-bash
+POSITIONAL_ARGS=()
+
+TARGETS="internal noimstrv"
+CFLAGS="glfw opengl3 opengl2 sdl2"
+
+help() {
+        cat <<EOF
+Usage of generator.sh:
+   -t --target    specify which imgui features should be generated
+                  (default: $TARGETS)
+   -c --cflags    specify additional gcc flags
+                  (default: $CFLAGS
+   -h --help      show this message and exit
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    -c|--cflags)
+      CFLAGS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -t|--target)
+      TARGETS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -h|--help)
+      help
+      exit 0
+      ;;
+    -*|--*)
+      echo "Unknown option $1"
+      help
+      exit 1
+      ;;
+    *)
+      POSITIONAL_ARGS+=("$1") # save positional arg
+      shift # past argument
+      ;;
+  esac
+done
+
+set -- "${POSITIONAL_ARGS[@]}" # restore positional parameters
+
+# if [[ "$OSTYPE" == "cygwin" || "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]];
+# then
+#   suffix='.exe'
+# fi
+
+echo "CFLAGS: " $CFLAGS
+echo "TARGETS: " $TARGETS
+
+luajit$suffix ./generator.lua gcc "$TARGETS" $CFLAGS

generator/json.lua

@@ -21,14 +21,19 @@
 -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 -- SOFTWARE.
 --
-
+--changes---------------------------------------------------------------------
+--prettify: adding carriage return, indentation, dictionaries sorted by key
+--dict_on_empty: table to json.encode to make empty table a dictionary instead of array
+------------------------------------------------------------------------------
 local json = { _version = "0.1.1" }
 
 -------------------------------------------------------------------------------
 -- Encode
 -------------------------------------------------------------------------------
-
+local TAB = "  "
+local rep = string.rep
 local encode
+local dict_on_empty = {}
 
 local escape_char_map = {
   [ "\\" ] = "\\\\",
@@ -56,10 +61,10 @@ local function encode_nil(val)
 end
 
 
-local function encode_table(val, stack)
+local function encode_table(val, stack,level,isvalue)
   local res = {}
   stack = stack or {}
-
+  level = level or 0
   -- Circular reference?
   if stack[val] then error("circular reference") end
 
@@ -77,38 +82,55 @@ local function encode_table(val, stack)
     if n ~= #val then
       error("invalid table: sparse array")
     end
+
     -- Encode
     for i, v in ipairs(val) do
-      table.insert(res, encode(v, stack))
+      table.insert(res, encode(v, stack,level+1))
     end
+
     stack[val] = nil
-    return "[" .. table.concat(res, ",") .. "]"
+    local inner = table.concat(res, ",\n")
+    if #inner > 0 then inner = "\n"..inner.."\n"..rep(TAB,level) end
+    return rep(isvalue and "" or TAB,level).."[" .. inner .. "]"
 
   else
+    local ordered_keys = {}
+    for k,v in pairs(val) do
+        table.insert(ordered_keys,k)
+    end
+    table.sort(ordered_keys)
     -- Treat as an object
-    for k, v in pairs(val) do
+    for _,k in ipairs(ordered_keys) do
+      local v = val[k]
+
       if type(k) ~= "string" then
         error("invalid table: mixed or invalid key types")
       end
-      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+      if type(v) == "table" and next(v) == nil and dict_on_empty[k] then
+          table.insert(res, encode(k, stack,level+1) .. ": {}")
+      else
+          table.insert(res, encode(k, stack,level+1) .. ": " .. encode(v, stack,level+1,true))
+      end
     end
     stack[val] = nil
-    return "{" .. table.concat(res, ",") .. "}"
+    local inner = table.concat(res, ",\n")
+    if #inner > 0 then inner = "\n"..inner.."\n"..rep(TAB,level) end
+    return rep(isvalue and "" or TAB,level).."{" .. inner .. "}"
   end
 end
 
 
-local function encode_string(val)
-  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+local function encode_string(val,stack,level,isvalue)
+  return rep(isvalue and "" or TAB,level)..'"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
 end
 
 
-local function encode_number(val)
+local function encode_number(val,stack,level,isvalue)
   -- Check for NaN, -inf and inf
   if val ~= val or val <= -math.huge or val >= math.huge then
     error("unexpected number value '" .. tostring(val) .. "'")
   end
-  return string.format("%.14g", val)
+  return rep(isvalue and "" or TAB,level)..string.format("%.14g", val)
 end
 
 
@@ -121,17 +143,18 @@ local type_func_map = {
 }
 
 
-encode = function(val, stack)
+encode = function(val, stack,level,isvalue)
   local t = type(val)
   local f = type_func_map[t]
   if f then
-    return f(val, stack)
+    return f(val, stack,level,isvalue)
   end
   error("unexpected type '" .. t .. "'")
 end
 
 
-function json.encode(val)
+function json.encode(val,opts)
+  dict_on_empty = opts and opts.dict_on_empty or {}
   return ( encode(val) )
 end
 
@@ -396,5 +419,4 @@ function json.decode(str)
   return res
 end
 
-
 return json

generator/output/cimgui_impl.h

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

generator/output/impl_definitions.json

@@ -0,0 +1,892 @@
+{
+  "ImGui_ImplGlfw_CharCallback": [
+    {
+      "args": "(GLFWwindow* window,unsigned int c)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,unsigned int c)",
+      "call_args": "(window,c)",
+      "cimguiname": "ImGui_ImplGlfw_CharCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_CharCallback",
+      "location": "imgui_impl_glfw:55",
+      "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,unsigned int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_CursorEnterCallback": [
+    {
+      "args": "(GLFWwindow* window,int entered)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "entered",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int entered)",
+      "call_args": "(window,entered)",
+      "cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_CursorEnterCallback",
+      "location": "imgui_impl_glfw:50",
+      "ov_cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_CursorPosCallback": [
+    {
+      "args": "(GLFWwindow* window,double x,double y)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,double x,double y)",
+      "call_args": "(window,x,y)",
+      "cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_CursorPosCallback",
+      "location": "imgui_impl_glfw:51",
+      "ov_cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForOpenGL": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InitForOpenGL",
+      "location": "imgui_impl_glfw:27",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForOther": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForOther",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InitForOther",
+      "location": "imgui_impl_glfw:29",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForOther",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForVulkan": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InitForVulkan",
+      "location": "imgui_impl_glfw:28",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InstallCallbacks": [
+    {
+      "args": "(GLFWwindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InstallCallbacks",
+      "location": "imgui_impl_glfw:41",
+      "ov_cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
+      "ret": "void",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_KeyCallback": [
+    {
+      "args": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "key",
+          "type": "int"
+        },
+        {
+          "name": "scancode",
+          "type": "int"
+        },
+        {
+          "name": "action",
+          "type": "int"
+        },
+        {
+          "name": "mods",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "call_args": "(window,key,scancode,action,mods)",
+      "cimguiname": "ImGui_ImplGlfw_KeyCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_KeyCallback",
+      "location": "imgui_impl_glfw:54",
+      "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_MonitorCallback": [
+    {
+      "args": "(GLFWmonitor* monitor,int event)",
+      "argsT": [
+        {
+          "name": "monitor",
+          "type": "GLFWmonitor*"
+        },
+        {
+          "name": "event",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWmonitor* monitor,int event)",
+      "call_args": "(monitor,event)",
+      "cimguiname": "ImGui_ImplGlfw_MonitorCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_MonitorCallback",
+      "location": "imgui_impl_glfw:56",
+      "ov_cimguiname": "ImGui_ImplGlfw_MonitorCallback",
+      "ret": "void",
+      "signature": "(GLFWmonitor*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_MouseButtonCallback": [
+    {
+      "args": "(GLFWwindow* window,int button,int action,int mods)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "button",
+          "type": "int"
+        },
+        {
+          "name": "action",
+          "type": "int"
+        },
+        {
+          "name": "mods",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int button,int action,int mods)",
+      "call_args": "(window,button,action,mods)",
+      "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "location": "imgui_impl_glfw:52",
+      "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplGlfw_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_NewFrame",
+      "location": "imgui_impl_glfw:31",
+      "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_RestoreCallbacks": [
+    {
+      "args": "(GLFWwindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "location": "imgui_impl_glfw:42",
+      "ov_cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
+      "ret": "void",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_ScrollCallback": [
+    {
+      "args": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "xoffset",
+          "type": "double"
+        },
+        {
+          "name": "yoffset",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "call_args": "(window,xoffset,yoffset)",
+      "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_ScrollCallback",
+      "location": "imgui_impl_glfw:53",
+      "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_SetCallbacksChainForAllWindows": [
+    {
+      "args": "(bool chain_for_all_windows)",
+      "argsT": [
+        {
+          "name": "chain_for_all_windows",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool chain_for_all_windows)",
+      "call_args": "(chain_for_all_windows)",
+      "cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "location": "imgui_impl_glfw:46",
+      "ov_cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplGlfw_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_Shutdown",
+      "location": "imgui_impl_glfw:30",
+      "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_WindowFocusCallback": [
+    {
+      "args": "(GLFWwindow* window,int focused)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "focused",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int focused)",
+      "call_args": "(window,focused)",
+      "cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_WindowFocusCallback",
+      "location": "imgui_impl_glfw:49",
+      "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_CreateDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "location": "imgui_impl_opengl2:35",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_CreateFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "location": "imgui_impl_opengl2:33",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_DestroyDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "location": "imgui_impl_opengl2:36",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_DestroyFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "location": "imgui_impl_opengl2:34",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_Init": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_Init",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_Init",
+      "location": "imgui_impl_opengl2:27",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_NewFrame",
+      "location": "imgui_impl_opengl2:29",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data)",
+      "call_args": "(draw_data)",
+      "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "location": "imgui_impl_opengl2:30",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL2_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_Shutdown",
+      "location": "imgui_impl_opengl2:28",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_CreateDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "location": "imgui_impl_opengl3:41",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_CreateFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "location": "imgui_impl_opengl3:39",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_DestroyDeviceObjects": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "location": "imgui_impl_opengl3:42",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_DestroyFontsTexture": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "location": "imgui_impl_opengl3:40",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_Init": [
+    {
+      "args": "(const char* glsl_version)",
+      "argsT": [
+        {
+          "name": "glsl_version",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* glsl_version=nullptr)",
+      "call_args": "(glsl_version)",
+      "cimguiname": "ImGui_ImplOpenGL3_Init",
+      "defaults": {
+        "glsl_version": "nullptr"
+      },
+      "funcname": "ImGui_ImplOpenGL3_Init",
+      "location": "imgui_impl_opengl3:33",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_NewFrame",
+      "location": "imgui_impl_opengl3:35",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data)",
+      "call_args": "(draw_data)",
+      "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "location": "imgui_impl_opengl3:36",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplOpenGL3_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_Shutdown",
+      "location": "imgui_impl_opengl3:34",
+      "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",
+      "location": "imgui_impl_sdl2:32",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForMetal": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForMetal",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForMetal",
+      "location": "imgui_impl_sdl2:33",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForOpenGL": [
+    {
+      "args": "(SDL_Window* window,void* sdl_gl_context)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        },
+        {
+          "name": "sdl_gl_context",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window,void* sdl_gl_context)",
+      "call_args": "(window,sdl_gl_context)",
+      "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForOpenGL",
+      "location": "imgui_impl_sdl2:30",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
+      "ret": "bool",
+      "signature": "(SDL_Window*,void*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForOther": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForOther",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForOther",
+      "location": "imgui_impl_sdl2:35",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOther",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForSDLRenderer": [
+    {
+      "args": "(SDL_Window* window,SDL_Renderer* renderer)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        },
+        {
+          "name": "renderer",
+          "type": "SDL_Renderer*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window,SDL_Renderer* renderer)",
+      "call_args": "(window,renderer)",
+      "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "location": "imgui_impl_sdl2:34",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "ret": "bool",
+      "signature": "(SDL_Window*,SDL_Renderer*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForVulkan": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForVulkan",
+      "location": "imgui_impl_sdl2:31",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplSDL2_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_NewFrame",
+      "location": "imgui_impl_sdl2:37",
+      "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_ProcessEvent": [
+    {
+      "args": "(const SDL_Event* event)",
+      "argsT": [
+        {
+          "name": "event",
+          "type": "const SDL_Event*"
+        }
+      ],
+      "argsoriginal": "(const SDL_Event* event)",
+      "call_args": "(event)",
+      "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_ProcessEvent",
+      "location": "imgui_impl_sdl2:38",
+      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
+      "ret": "bool",
+      "signature": "(const SDL_Event*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_SetGamepadMode": [
+    {
+      "args": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count)",
+      "argsT": [
+        {
+          "name": "mode",
+          "type": "ImGui_ImplSDL2_GamepadMode"
+        },
+        {
+          "name": "manual_gamepads_array",
+          "type": "struct _SDL_GameController**"
+        },
+        {
+          "name": "manual_gamepads_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)",
+      "call_args": "(mode,manual_gamepads_array,manual_gamepads_count)",
+      "cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
+      "defaults": {
+        "manual_gamepads_array": "NULL",
+        "manual_gamepads_count": "-1"
+      },
+      "funcname": "ImGui_ImplSDL2_SetGamepadMode",
+      "location": "imgui_impl_sdl2:43",
+      "ov_cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
+      "ret": "void",
+      "signature": "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_Shutdown",
+      "location": "imgui_impl_sdl2:36",
+      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ]
+}

generator/output/impl_definitions.lua

@@ -0,0 +1,777 @@
+local defs = {}
+defs["ImGui_ImplGlfw_CharCallback"] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1]["args"] = "(GLFWwindow* window,unsigned int c)"
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1]["argsT"][2]["name"] = "c"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_CharCallback"][1]["funcname"] = "ImGui_ImplGlfw_CharCallback"
+defs["ImGui_ImplGlfw_CharCallback"][1]["location"] = "imgui_impl_glfw:55"
+defs["ImGui_ImplGlfw_CharCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CharCallback"
+defs["ImGui_ImplGlfw_CharCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_CharCallback"][1]["signature"] = "(GLFWwindow*,unsigned int)"
+defs["ImGui_ImplGlfw_CharCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_CharCallback"]["(GLFWwindow*,unsigned int)"] = defs["ImGui_ImplGlfw_CharCallback"][1]
+defs["ImGui_ImplGlfw_CursorEnterCallback"] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["args"] = "(GLFWwindow* window,int entered)"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][2]["name"] = "entered"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsT"][2]["type"] = "int"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int entered)"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["call_args"] = "(window,entered)"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CursorEnterCallback"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["funcname"] = "ImGui_ImplGlfw_CursorEnterCallback"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["location"] = "imgui_impl_glfw:50"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CursorEnterCallback"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["signature"] = "(GLFWwindow*,int)"
+defs["ImGui_ImplGlfw_CursorEnterCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_CursorEnterCallback"]["(GLFWwindow*,int)"] = defs["ImGui_ImplGlfw_CursorEnterCallback"][1]
+defs["ImGui_ImplGlfw_CursorPosCallback"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["args"] = "(GLFWwindow* window,double x,double y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2]["name"] = "x"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][2]["type"] = "double"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3]["name"] = "y"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsT"][3]["type"] = "double"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["argsoriginal"] = "(GLFWwindow* window,double x,double y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["call_args"] = "(window,x,y)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["funcname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["location"] = "imgui_impl_glfw:51"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_CursorPosCallback"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
+defs["ImGui_ImplGlfw_CursorPosCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_CursorPosCallback"]["(GLFWwindow*,double,double)"] = defs["ImGui_ImplGlfw_CursorPosCallback"][1]
+defs["ImGui_ImplGlfw_InitForOpenGL"] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["argsT"][2]["name"] = "install_callbacks"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["funcname"] = "ImGui_ImplGlfw_InitForOpenGL"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["location"] = "imgui_impl_glfw:27"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForOpenGL"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["ret"] = "bool"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["signature"] = "(GLFWwindow*,bool)"
+defs["ImGui_ImplGlfw_InitForOpenGL"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_InitForOpenGL"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForOpenGL"][1]
+defs["ImGui_ImplGlfw_InitForOther"] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][2]["name"] = "install_callbacks"
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsT"][2]["type"] = "bool"
+defs["ImGui_ImplGlfw_InitForOther"][1]["argsoriginal"] = "(GLFWwindow* window,bool install_callbacks)"
+defs["ImGui_ImplGlfw_InitForOther"][1]["call_args"] = "(window,install_callbacks)"
+defs["ImGui_ImplGlfw_InitForOther"][1]["cimguiname"] = "ImGui_ImplGlfw_InitForOther"
+defs["ImGui_ImplGlfw_InitForOther"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_InitForOther"][1]["funcname"] = "ImGui_ImplGlfw_InitForOther"
+defs["ImGui_ImplGlfw_InitForOther"][1]["location"] = "imgui_impl_glfw:29"
+defs["ImGui_ImplGlfw_InitForOther"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForOther"
+defs["ImGui_ImplGlfw_InitForOther"][1]["ret"] = "bool"
+defs["ImGui_ImplGlfw_InitForOther"][1]["signature"] = "(GLFWwindow*,bool)"
+defs["ImGui_ImplGlfw_InitForOther"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_InitForOther"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForOther"][1]
+defs["ImGui_ImplGlfw_InitForVulkan"] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["args"] = "(GLFWwindow* window,bool install_callbacks)"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["argsT"][2]["name"] = "install_callbacks"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["funcname"] = "ImGui_ImplGlfw_InitForVulkan"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["location"] = "imgui_impl_glfw:28"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InitForVulkan"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["ret"] = "bool"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["signature"] = "(GLFWwindow*,bool)"
+defs["ImGui_ImplGlfw_InitForVulkan"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_InitForVulkan"]["(GLFWwindow*,bool)"] = defs["ImGui_ImplGlfw_InitForVulkan"][1]
+defs["ImGui_ImplGlfw_InstallCallbacks"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["args"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["argsoriginal"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["call_args"] = "(window)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["cimguiname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["funcname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["location"] = "imgui_impl_glfw:41"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_InstallCallbacks"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["signature"] = "(GLFWwindow*)"
+defs["ImGui_ImplGlfw_InstallCallbacks"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_InstallCallbacks"]["(GLFWwindow*)"] = defs["ImGui_ImplGlfw_InstallCallbacks"][1]
+defs["ImGui_ImplGlfw_KeyCallback"] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["args"] = "(GLFWwindow* window,int key,int scancode,int action,int mods)"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][2]["name"] = "key"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][2]["type"] = "int"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][3] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][3]["name"] = "scancode"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][3]["type"] = "int"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][4] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][4]["name"] = "action"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][4]["type"] = "int"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][5] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["argsT"][5]["name"] = "mods"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_KeyCallback"][1]["funcname"] = "ImGui_ImplGlfw_KeyCallback"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["location"] = "imgui_impl_glfw:54"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_KeyCallback"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["signature"] = "(GLFWwindow*,int,int,int,int)"
+defs["ImGui_ImplGlfw_KeyCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_KeyCallback"]["(GLFWwindow*,int,int,int,int)"] = defs["ImGui_ImplGlfw_KeyCallback"][1]
+defs["ImGui_ImplGlfw_MonitorCallback"] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["args"] = "(GLFWmonitor* monitor,int event)"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][1]["name"] = "monitor"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][1]["type"] = "GLFWmonitor*"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][2]["name"] = "event"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsT"][2]["type"] = "int"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["argsoriginal"] = "(GLFWmonitor* monitor,int event)"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["call_args"] = "(monitor,event)"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_MonitorCallback"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["funcname"] = "ImGui_ImplGlfw_MonitorCallback"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["location"] = "imgui_impl_glfw:56"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_MonitorCallback"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["signature"] = "(GLFWmonitor*,int)"
+defs["ImGui_ImplGlfw_MonitorCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_MonitorCallback"]["(GLFWmonitor*,int)"] = defs["ImGui_ImplGlfw_MonitorCallback"][1]
+defs["ImGui_ImplGlfw_MouseButtonCallback"] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["args"] = "(GLFWwindow* window,int button,int action,int mods)"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][2]["name"] = "button"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][2]["type"] = "int"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][3] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][3]["name"] = "action"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][3]["type"] = "int"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][4] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["argsT"][4]["name"] = "mods"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["funcname"] = "ImGui_ImplGlfw_MouseButtonCallback"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["location"] = "imgui_impl_glfw:52"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_MouseButtonCallback"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["signature"] = "(GLFWwindow*,int,int,int)"
+defs["ImGui_ImplGlfw_MouseButtonCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_MouseButtonCallback"]["(GLFWwindow*,int,int,int)"] = defs["ImGui_ImplGlfw_MouseButtonCallback"][1]
+defs["ImGui_ImplGlfw_NewFrame"] = {}
+defs["ImGui_ImplGlfw_NewFrame"][1] = {}
+defs["ImGui_ImplGlfw_NewFrame"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_NewFrame"][1]["funcname"] = "ImGui_ImplGlfw_NewFrame"
+defs["ImGui_ImplGlfw_NewFrame"][1]["location"] = "imgui_impl_glfw:31"
+defs["ImGui_ImplGlfw_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_NewFrame"
+defs["ImGui_ImplGlfw_NewFrame"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_NewFrame"][1]["signature"] = "()"
+defs["ImGui_ImplGlfw_NewFrame"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_NewFrame"]["()"] = defs["ImGui_ImplGlfw_NewFrame"][1]
+defs["ImGui_ImplGlfw_RestoreCallbacks"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["args"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["argsoriginal"] = "(GLFWwindow* window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["call_args"] = "(window)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["cimguiname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["funcname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["location"] = "imgui_impl_glfw:42"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_RestoreCallbacks"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["signature"] = "(GLFWwindow*)"
+defs["ImGui_ImplGlfw_RestoreCallbacks"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_RestoreCallbacks"]["(GLFWwindow*)"] = defs["ImGui_ImplGlfw_RestoreCallbacks"][1]
+defs["ImGui_ImplGlfw_ScrollCallback"] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["args"] = "(GLFWwindow* window,double xoffset,double yoffset)"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][2]["name"] = "xoffset"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][2]["type"] = "double"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][3] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["argsT"][3]["name"] = "yoffset"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["funcname"] = "ImGui_ImplGlfw_ScrollCallback"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["location"] = "imgui_impl_glfw:53"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_ScrollCallback"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["signature"] = "(GLFWwindow*,double,double)"
+defs["ImGui_ImplGlfw_ScrollCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_ScrollCallback"]["(GLFWwindow*,double,double)"] = defs["ImGui_ImplGlfw_ScrollCallback"][1]
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["args"] = "(bool chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1]["name"] = "chain_for_all_windows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsT"][1]["type"] = "bool"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["argsoriginal"] = "(bool chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["call_args"] = "(chain_for_all_windows)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["cimguiname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["funcname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["location"] = "imgui_impl_glfw:46"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_SetCallbacksChainForAllWindows"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["signature"] = "(bool)"
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"]["(bool)"] = defs["ImGui_ImplGlfw_SetCallbacksChainForAllWindows"][1]
+defs["ImGui_ImplGlfw_Shutdown"] = {}
+defs["ImGui_ImplGlfw_Shutdown"][1] = {}
+defs["ImGui_ImplGlfw_Shutdown"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplGlfw_Shutdown"][1]["funcname"] = "ImGui_ImplGlfw_Shutdown"
+defs["ImGui_ImplGlfw_Shutdown"][1]["location"] = "imgui_impl_glfw:30"
+defs["ImGui_ImplGlfw_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_Shutdown"
+defs["ImGui_ImplGlfw_Shutdown"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_Shutdown"][1]["signature"] = "()"
+defs["ImGui_ImplGlfw_Shutdown"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_Shutdown"]["()"] = defs["ImGui_ImplGlfw_Shutdown"][1]
+defs["ImGui_ImplGlfw_WindowFocusCallback"] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["args"] = "(GLFWwindow* window,int focused)"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][1] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][1]["type"] = "GLFWwindow*"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][2] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][2]["name"] = "focused"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsT"][2]["type"] = "int"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["argsoriginal"] = "(GLFWwindow* window,int focused)"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["call_args"] = "(window,focused)"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["cimguiname"] = "ImGui_ImplGlfw_WindowFocusCallback"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["defaults"] = {}
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["funcname"] = "ImGui_ImplGlfw_WindowFocusCallback"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["location"] = "imgui_impl_glfw:49"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["ov_cimguiname"] = "ImGui_ImplGlfw_WindowFocusCallback"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["ret"] = "void"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["signature"] = "(GLFWwindow*,int)"
+defs["ImGui_ImplGlfw_WindowFocusCallback"][1]["stname"] = ""
+defs["ImGui_ImplGlfw_WindowFocusCallback"]["(GLFWwindow*,int)"] = defs["ImGui_ImplGlfw_WindowFocusCallback"][1]
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"] = {}
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1] = {}
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl2:35"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_CreateDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL2_CreateDeviceObjects"][1]
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"] = {}
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1] = {}
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl2:33"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_CreateFontsTexture"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_CreateFontsTexture"]["()"] = defs["ImGui_ImplOpenGL2_CreateFontsTexture"][1]
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"] = {}
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1] = {}
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl2:36"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL2_DestroyDeviceObjects"][1]
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"] = {}
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1] = {}
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl2:34"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_DestroyFontsTexture"]["()"] = defs["ImGui_ImplOpenGL2_DestroyFontsTexture"][1]
+defs["ImGui_ImplOpenGL2_Init"] = {}
+defs["ImGui_ImplOpenGL2_Init"][1] = {}
+defs["ImGui_ImplOpenGL2_Init"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_Init"][1]["funcname"] = "ImGui_ImplOpenGL2_Init"
+defs["ImGui_ImplOpenGL2_Init"][1]["location"] = "imgui_impl_opengl2:27"
+defs["ImGui_ImplOpenGL2_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Init"
+defs["ImGui_ImplOpenGL2_Init"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL2_Init"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_Init"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_Init"]["()"] = defs["ImGui_ImplOpenGL2_Init"][1]
+defs["ImGui_ImplOpenGL2_NewFrame"] = {}
+defs["ImGui_ImplOpenGL2_NewFrame"][1] = {}
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL2_NewFrame"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["location"] = "imgui_impl_opengl2:29"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_NewFrame"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_NewFrame"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_NewFrame"]["()"] = defs["ImGui_ImplOpenGL2_NewFrame"][1]
+defs["ImGui_ImplOpenGL2_RenderDrawData"] = {}
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1] = {}
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["args"] = "(ImDrawData* draw_data)"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsT"] = {}
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsT"][1] = {}
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["argsT"][1]["name"] = "draw_data"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL2_RenderDrawData"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["location"] = "imgui_impl_opengl2:30"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_RenderDrawData"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
+defs["ImGui_ImplOpenGL2_RenderDrawData"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_RenderDrawData"]["(ImDrawData*)"] = defs["ImGui_ImplOpenGL2_RenderDrawData"][1]
+defs["ImGui_ImplOpenGL2_Shutdown"] = {}
+defs["ImGui_ImplOpenGL2_Shutdown"][1] = {}
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL2_Shutdown"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["location"] = "imgui_impl_opengl2:28"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL2_Shutdown"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL2_Shutdown"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL2_Shutdown"]["()"] = defs["ImGui_ImplOpenGL2_Shutdown"][1]
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"] = {}
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1] = {}
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["location"] = "imgui_impl_opengl3:41"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateDeviceObjects"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_CreateDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL3_CreateDeviceObjects"][1]
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"] = {}
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1] = {}
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["location"] = "imgui_impl_opengl3:39"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_CreateFontsTexture"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_CreateFontsTexture"]["()"] = defs["ImGui_ImplOpenGL3_CreateFontsTexture"][1]
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"] = {}
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1] = {}
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["location"] = "imgui_impl_opengl3:42"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyDeviceObjects"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"]["()"] = defs["ImGui_ImplOpenGL3_DestroyDeviceObjects"][1]
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"] = {}
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1] = {}
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["funcname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["location"] = "imgui_impl_opengl3:40"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_DestroyFontsTexture"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_DestroyFontsTexture"]["()"] = defs["ImGui_ImplOpenGL3_DestroyFontsTexture"][1]
+defs["ImGui_ImplOpenGL3_Init"] = {}
+defs["ImGui_ImplOpenGL3_Init"][1] = {}
+defs["ImGui_ImplOpenGL3_Init"][1]["args"] = "(const char* glsl_version)"
+defs["ImGui_ImplOpenGL3_Init"][1]["argsT"] = {}
+defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1] = {}
+defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["name"] = "glsl_version"
+defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["type"] = "const char*"
+defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=nullptr)"
+defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
+defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "nullptr"
+defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3:33"
+defs["ImGui_ImplOpenGL3_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["ret"] = "bool"
+defs["ImGui_ImplOpenGL3_Init"][1]["signature"] = "(const char*)"
+defs["ImGui_ImplOpenGL3_Init"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_Init"]["(const char*)"] = defs["ImGui_ImplOpenGL3_Init"][1]
+defs["ImGui_ImplOpenGL3_NewFrame"] = {}
+defs["ImGui_ImplOpenGL3_NewFrame"][1] = {}
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["funcname"] = "ImGui_ImplOpenGL3_NewFrame"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["location"] = "imgui_impl_opengl3:35"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_NewFrame"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["signature"] = "()"
+defs["ImGui_ImplOpenGL3_NewFrame"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_NewFrame"]["()"] = defs["ImGui_ImplOpenGL3_NewFrame"][1]
+defs["ImGui_ImplOpenGL3_RenderDrawData"] = {}
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1] = {}
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["args"] = "(ImDrawData* draw_data)"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsT"] = {}
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsT"][1] = {}
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["argsT"][1]["name"] = "draw_data"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["funcname"] = "ImGui_ImplOpenGL3_RenderDrawData"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["location"] = "imgui_impl_opengl3:36"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_RenderDrawData"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["signature"] = "(ImDrawData*)"
+defs["ImGui_ImplOpenGL3_RenderDrawData"][1]["stname"] = ""
+defs["ImGui_ImplOpenGL3_RenderDrawData"]["(ImDrawData*)"] = defs["ImGui_ImplOpenGL3_RenderDrawData"][1]
+defs["ImGui_ImplOpenGL3_Shutdown"] = {}
+defs["ImGui_ImplOpenGL3_Shutdown"][1] = {}
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["funcname"] = "ImGui_ImplOpenGL3_Shutdown"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["location"] = "imgui_impl_opengl3:34"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Shutdown"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
+defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
+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]["location"] = "imgui_impl_sdl2:32"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForD3D"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForD3D"][1]
+defs["ImGui_ImplSDL2_InitForMetal"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["funcname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["location"] = "imgui_impl_sdl2:33"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForMetal"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForMetal"][1]
+defs["ImGui_ImplSDL2_InitForOpenGL"] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["args"] = "(SDL_Window* window,void* sdl_gl_context)"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][2] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["argsT"][2]["name"] = "sdl_gl_context"
+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]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["funcname"] = "ImGui_ImplSDL2_InitForOpenGL"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["location"] = "imgui_impl_sdl2:30"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForOpenGL"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["signature"] = "(SDL_Window*,void*)"
+defs["ImGui_ImplSDL2_InitForOpenGL"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForOpenGL"]["(SDL_Window*,void*)"] = defs["ImGui_ImplSDL2_InitForOpenGL"][1]
+defs["ImGui_ImplSDL2_InitForOther"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForOther"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForOther"][1]["funcname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["location"] = "imgui_impl_sdl2:35"
+defs["ImGui_ImplSDL2_InitForOther"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForOther"
+defs["ImGui_ImplSDL2_InitForOther"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForOther"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForOther"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForOther"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForOther"][1]
+defs["ImGui_ImplSDL2_InitForSDLRenderer"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["args"] = "(SDL_Window* window,SDL_Renderer* renderer)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2]["name"] = "renderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][2]["type"] = "SDL_Renderer*"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsoriginal"] = "(SDL_Window* window,SDL_Renderer* renderer)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["call_args"] = "(window,renderer)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["funcname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["location"] = "imgui_impl_sdl2:34"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["signature"] = "(SDL_Window*,SDL_Renderer*)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForSDLRenderer"]["(SDL_Window*,SDL_Renderer*)"] = defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]
+defs["ImGui_ImplSDL2_InitForVulkan"] = {}
+defs["ImGui_ImplSDL2_InitForVulkan"][1] = {}
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["argsT"][1]["name"] = "window"
+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]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["funcname"] = "ImGui_ImplSDL2_InitForVulkan"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["location"] = "imgui_impl_sdl2:31"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForVulkan"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForVulkan"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForVulkan"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForVulkan"][1]
+defs["ImGui_ImplSDL2_NewFrame"] = {}
+defs["ImGui_ImplSDL2_NewFrame"][1] = {}
+defs["ImGui_ImplSDL2_NewFrame"][1]["args"] = "()"
+defs["ImGui_ImplSDL2_NewFrame"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_NewFrame"][1]["argsoriginal"] = "()"
+defs["ImGui_ImplSDL2_NewFrame"][1]["call_args"] = "()"
+defs["ImGui_ImplSDL2_NewFrame"][1]["cimguiname"] = "ImGui_ImplSDL2_NewFrame"
+defs["ImGui_ImplSDL2_NewFrame"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_NewFrame"][1]["funcname"] = "ImGui_ImplSDL2_NewFrame"
+defs["ImGui_ImplSDL2_NewFrame"][1]["location"] = "imgui_impl_sdl2:37"
+defs["ImGui_ImplSDL2_NewFrame"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_NewFrame"
+defs["ImGui_ImplSDL2_NewFrame"][1]["ret"] = "void"
+defs["ImGui_ImplSDL2_NewFrame"][1]["signature"] = "()"
+defs["ImGui_ImplSDL2_NewFrame"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_NewFrame"]["()"] = defs["ImGui_ImplSDL2_NewFrame"][1]
+defs["ImGui_ImplSDL2_ProcessEvent"] = {}
+defs["ImGui_ImplSDL2_ProcessEvent"][1] = {}
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["args"] = "(const SDL_Event* event)"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["name"] = "event"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["argsT"][1]["type"] = "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]["defaults"] = {}
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["funcname"] = "ImGui_ImplSDL2_ProcessEvent"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["location"] = "imgui_impl_sdl2:38"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_ProcessEvent"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["signature"] = "(const SDL_Event*)"
+defs["ImGui_ImplSDL2_ProcessEvent"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_ProcessEvent"]["(const SDL_Event*)"] = defs["ImGui_ImplSDL2_ProcessEvent"][1]
+defs["ImGui_ImplSDL2_SetGamepadMode"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["args"] = "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1]["name"] = "mode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][1]["type"] = "ImGui_ImplSDL2_GamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2]["name"] = "manual_gamepads_array"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][2]["type"] = "struct _SDL_GameController**"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3]["name"] = "manual_gamepads_count"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsT"][3]["type"] = "int"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["argsoriginal"] = "(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array=((void*)0),int manual_gamepads_count=-1)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["call_args"] = "(mode,manual_gamepads_array,manual_gamepads_count)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["cimguiname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"]["manual_gamepads_array"] = "NULL"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["defaults"]["manual_gamepads_count"] = "-1"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["funcname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["location"] = "imgui_impl_sdl2:43"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_SetGamepadMode"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["ret"] = "void"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["signature"] = "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)"
+defs["ImGui_ImplSDL2_SetGamepadMode"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_SetGamepadMode"]["(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)"] = defs["ImGui_ImplSDL2_SetGamepadMode"][1]
+defs["ImGui_ImplSDL2_Shutdown"] = {}
+defs["ImGui_ImplSDL2_Shutdown"][1] = {}
+defs["ImGui_ImplSDL2_Shutdown"][1]["args"] = "()"
+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]["defaults"] = {}
+defs["ImGui_ImplSDL2_Shutdown"][1]["funcname"] = "ImGui_ImplSDL2_Shutdown"
+defs["ImGui_ImplSDL2_Shutdown"][1]["location"] = "imgui_impl_sdl2:36"
+defs["ImGui_ImplSDL2_Shutdown"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_Shutdown"
+defs["ImGui_ImplSDL2_Shutdown"][1]["ret"] = "void"
+defs["ImGui_ImplSDL2_Shutdown"][1]["signature"] = "()"
+defs["ImGui_ImplSDL2_Shutdown"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_Shutdown"]["()"] = defs["ImGui_ImplSDL2_Shutdown"][1]
+
+return defs

generator/output/overloads.txt

@@ -0,0 +1,290 @@
+----------------overloadings---------------------------
+ImColor_ImColor	5
+1	nil	ImColor_ImColor_Nil ()
+2	nil	ImColor_ImColor_Float (float,float,float,float)
+3	nil	ImColor_ImColor_Vec4 (const ImVec4)
+4	nil	ImColor_ImColor_Int (int,int,int,int)
+5	nil	ImColor_ImColor_U32 (ImU32)
+ImDrawList_AddText	2
+1	void	ImDrawList_AddText_Vec2 (const ImVec2,ImU32,const char*,const char*)
+2	void	ImDrawList_AddText_FontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
+1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr (void*)
+2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int (int)
+ImGuiStoragePair_ImGuiStoragePair	3
+1	nil	ImGuiStoragePair_ImGuiStoragePair_Int (ImGuiID,int)
+2	nil	ImGuiStoragePair_ImGuiStoragePair_Float (ImGuiID,float)
+3	nil	ImGuiStoragePair_ImGuiStoragePair_Ptr (ImGuiID,void*)
+ImGuiStyleMod_ImGuiStyleMod	3
+1	nil	ImGuiStyleMod_ImGuiStyleMod_Int (ImGuiStyleVar,int)
+2	nil	ImGuiStyleMod_ImGuiStyleMod_Float (ImGuiStyleVar,float)
+3	nil	ImGuiStyleMod_ImGuiStyleMod_Vec2 (ImGuiStyleVar,ImVec2)
+ImGuiTextRange_ImGuiTextRange	2
+1	nil	ImGuiTextRange_ImGuiTextRange_Nil ()
+2	nil	ImGuiTextRange_ImGuiTextRange_Str (const char*,const char*)
+ImGuiWindow_GetID	3
+1	ImGuiID	ImGuiWindow_GetID_Str (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetID_Ptr (const void*)
+3	ImGuiID	ImGuiWindow_GetID_Int (int)
+ImPool_Remove	2
+1	void	ImPool_Remove_TPtr (ImGuiID,const T*)
+2	void	ImPool_Remove_PoolIdx (ImGuiID,ImPoolIdx)
+ImRect_Add	2
+1	void	ImRect_Add_Vec2 (const ImVec2)
+2	void	ImRect_Add_Rect (const ImRect)
+ImRect_Contains	2
+1	bool	ImRect_Contains_Vec2 (const ImVec2)const
+2	bool	ImRect_Contains_Rect (const ImRect)const
+ImRect_Expand	2
+1	void	ImRect_Expand_Float (const float)
+2	void	ImRect_Expand_Vec2 (const ImVec2)
+ImRect_ImRect	4
+1	nil	ImRect_ImRect_Nil ()
+2	nil	ImRect_ImRect_Vec2 (const ImVec2,const ImVec2)
+3	nil	ImRect_ImRect_Vec4 (const ImVec4)
+4	nil	ImRect_ImRect_Float (float,float,float,float)
+ImSpan_ImSpan	3
+1	nil	ImSpan_ImSpan_Nil ()
+2	nil	ImSpan_ImSpan_TPtrInt (T*,int)
+3	nil	ImSpan_ImSpan_TPtrTPtr (T*,T*)
+ImSpan_begin	2
+1	T*	ImSpan_begin_Nil ()
+2	const T*	ImSpan_begin__const ()const
+ImSpan_end	2
+1	T*	ImSpan_end_Nil ()
+2	const T*	ImSpan_end__const ()const
+ImSpan_set	2
+1	void	ImSpan_set_Int (T*,int)
+2	void	ImSpan_set_TPtr (T*,T*)
+ImVec1_ImVec1	2
+1	nil	ImVec1_ImVec1_Nil ()
+2	nil	ImVec1_ImVec1_Float (float)
+ImVec2_ImVec2	2
+1	nil	ImVec2_ImVec2_Nil ()
+2	nil	ImVec2_ImVec2_Float (float,float)
+ImVec2ih_ImVec2ih	3
+1	nil	ImVec2ih_ImVec2ih_Nil ()
+2	nil	ImVec2ih_ImVec2ih_short (short,short)
+3	nil	ImVec2ih_ImVec2ih_Vec2 (const ImVec2)
+ImVec4_ImVec4	2
+1	nil	ImVec4_ImVec4_Nil ()
+2	nil	ImVec4_ImVec4_Float (float,float,float,float)
+ImVector_ImVector	2
+1	nil	ImVector_ImVector_Nil ()
+2	nil	ImVector_ImVector_Vector_T_ (const ImVector_T )
+ImVector_back	2
+1	T*	ImVector_back_Nil ()
+2	const T*	ImVector_back__const ()const
+ImVector_begin	2
+1	T*	ImVector_begin_Nil ()
+2	const T*	ImVector_begin__const ()const
+ImVector_end	2
+1	T*	ImVector_end_Nil ()
+2	const T*	ImVector_end__const ()const
+ImVector_erase	2
+1	T*	ImVector_erase_Nil (const T*)
+2	T*	ImVector_erase_TPtr (const T*,const T*)
+ImVector_find	2
+1	T*	ImVector_find_Nil (const T)
+2	const T*	ImVector_find__const (const T)const
+ImVector_front	2
+1	T*	ImVector_front_Nil ()
+2	const T*	ImVector_front__const ()const
+ImVector_resize	2
+1	void	ImVector_resize_Nil (int)
+2	void	ImVector_resize_T (int,const T)
+igBeginChild	2
+1	bool	igBeginChild_Str (const char*,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
+2	bool	igBeginChild_ID (ImGuiID,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
+igCheckboxFlags	4
+1	bool	igCheckboxFlags_IntPtr (const char*,int*,int)
+2	bool	igCheckboxFlags_UintPtr (const char*,unsigned int*,unsigned int)
+3	bool	igCheckboxFlags_S64Ptr (const char*,ImS64*,ImS64)
+4	bool	igCheckboxFlags_U64Ptr (const char*,ImU64*,ImU64)
+igCollapsingHeader	2
+1	bool	igCollapsingHeader_TreeNodeFlags (const char*,ImGuiTreeNodeFlags)
+2	bool	igCollapsingHeader_BoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+igCombo	3
+1	bool	igCombo_Str_arr (const char*,int*,const char* const[],int,int)
+2	bool	igCombo_Str (const char*,int*,const char*,int)
+3	bool	igCombo_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
+igGetBackgroundDrawList	2
+1	ImDrawList*	igGetBackgroundDrawList_Nil ()
+2	ImDrawList*	igGetBackgroundDrawList_ViewportPtr (ImGuiViewport*)
+igGetColorU32	3
+1	ImU32	igGetColorU32_Col (ImGuiCol,float)
+2	ImU32	igGetColorU32_Vec4 (const ImVec4)
+3	ImU32	igGetColorU32_U32 (ImU32,float)
+igGetForegroundDrawList	3
+1	ImDrawList*	igGetForegroundDrawList_Nil ()
+2	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
+3	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
+igGetID	3
+1	ImGuiID	igGetID_Str (const char*)
+2	ImGuiID	igGetID_StrStr (const char*,const char*)
+3	ImGuiID	igGetID_Ptr (const void*)
+igGetIDWithSeed	2
+1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
+2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
+igGetKeyData	2
+1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
+2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
+igImAbs	3
+1	int	igImAbs_Int (int)
+2	float	igImAbs_Float (float)
+3	double	igImAbs_double (double)
+igImFloor	2
+1	float	igImFloor_Float (float)
+2	ImVec2	igImFloor_Vec2 (const ImVec2)
+igImIsPowerOfTwo	2
+1	bool	igImIsPowerOfTwo_Int (int)
+2	bool	igImIsPowerOfTwo_U64 (ImU64)
+igImLengthSqr	2
+1	float	igImLengthSqr_Vec2 (const ImVec2)
+2	float	igImLengthSqr_Vec4 (const ImVec4)
+igImLerp	3
+1	ImVec2	igImLerp_Vec2Float (const ImVec2,const ImVec2,float)
+2	ImVec2	igImLerp_Vec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
+3	ImVec4	igImLerp_Vec4 (const ImVec4,const ImVec4,float)
+igImLog	2
+1	float	igImLog_Float (float)
+2	double	igImLog_double (double)
+igImPow	2
+1	float	igImPow_Float (float,float)
+2	double	igImPow_double (double,double)
+igImRsqrt	2
+1	float	igImRsqrt_Float (float)
+2	double	igImRsqrt_double (double)
+igImSign	2
+1	float	igImSign_Float (float)
+2	double	igImSign_double (double)
+igImTrunc	2
+1	float	igImTrunc_Float (float)
+2	ImVec2	igImTrunc_Vec2 (const ImVec2)
+igIsKeyChordPressed	2
+1	bool	igIsKeyChordPressed_Nil (ImGuiKeyChord)
+2	bool	igIsKeyChordPressed_ID (ImGuiKeyChord,ImGuiID,ImGuiInputFlags)
+igIsKeyDown	2
+1	bool	igIsKeyDown_Nil (ImGuiKey)
+2	bool	igIsKeyDown_ID (ImGuiKey,ImGuiID)
+igIsKeyPressed	2
+1	bool	igIsKeyPressed_Bool (ImGuiKey,bool)
+2	bool	igIsKeyPressed_ID (ImGuiKey,ImGuiID,ImGuiInputFlags)
+igIsKeyReleased	2
+1	bool	igIsKeyReleased_Nil (ImGuiKey)
+2	bool	igIsKeyReleased_ID (ImGuiKey,ImGuiID)
+igIsMouseClicked	2
+1	bool	igIsMouseClicked_Bool (ImGuiMouseButton,bool)
+2	bool	igIsMouseClicked_ID (ImGuiMouseButton,ImGuiID,ImGuiInputFlags)
+igIsMouseDoubleClicked	2
+1	bool	igIsMouseDoubleClicked_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDoubleClicked_ID (ImGuiMouseButton,ImGuiID)
+igIsMouseDown	2
+1	bool	igIsMouseDown_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDown_ID (ImGuiMouseButton,ImGuiID)
+igIsMouseReleased	2
+1	bool	igIsMouseReleased_Nil (ImGuiMouseButton)
+2	bool	igIsMouseReleased_ID (ImGuiMouseButton,ImGuiID)
+igIsPopupOpen	2
+1	bool	igIsPopupOpen_Str (const char*,ImGuiPopupFlags)
+2	bool	igIsPopupOpen_ID (ImGuiID,ImGuiPopupFlags)
+igIsRectVisible	2
+1	bool	igIsRectVisible_Nil (const ImVec2)
+2	bool	igIsRectVisible_Vec2 (const ImVec2,const ImVec2)
+igItemSize	2
+1	void	igItemSize_Vec2 (const ImVec2,float)
+2	void	igItemSize_Rect (const ImRect,float)
+igListBox	2
+1	bool	igListBox_Str_arr (const char*,int*,const char* const[],int,int)
+2	bool	igListBox_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
+igMarkIniSettingsDirty	2
+1	void	igMarkIniSettingsDirty_Nil ()
+2	void	igMarkIniSettingsDirty_WindowPtr (ImGuiWindow*)
+igMenuItem	2
+1	bool	igMenuItem_Bool (const char*,const char*,bool,bool)
+2	bool	igMenuItem_BoolPtr (const char*,const char*,bool*,bool)
+igOpenPopup	2
+1	void	igOpenPopup_Str (const char*,ImGuiPopupFlags)
+2	void	igOpenPopup_ID (ImGuiID,ImGuiPopupFlags)
+igPlotHistogram	2
+1	void	igPlotHistogram_FloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotHistogram_FnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igPlotLines	2
+1	void	igPlotLines_FloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotLines_FnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igPushID	4
+1	void	igPushID_Str (const char*)
+2	void	igPushID_StrStr (const char*,const char*)
+3	void	igPushID_Ptr (const void*)
+4	void	igPushID_Int (int)
+igPushStyleColor	2
+1	void	igPushStyleColor_U32 (ImGuiCol,ImU32)
+2	void	igPushStyleColor_Vec4 (ImGuiCol,const ImVec4)
+igPushStyleVar	2
+1	void	igPushStyleVar_Float (ImGuiStyleVar,float)
+2	void	igPushStyleVar_Vec2 (ImGuiStyleVar,const ImVec2)
+igRadioButton	2
+1	bool	igRadioButton_Bool (const char*,bool)
+2	bool	igRadioButton_IntPtr (const char*,int*,int)
+igSelectable	2
+1	bool	igSelectable_Bool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectable_BoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+igSetScrollFromPosX	2
+1	void	igSetScrollFromPosX_Float (float,float)
+2	void	igSetScrollFromPosX_WindowPtr (ImGuiWindow*,float,float)
+igSetScrollFromPosY	2
+1	void	igSetScrollFromPosY_Float (float,float)
+2	void	igSetScrollFromPosY_WindowPtr (ImGuiWindow*,float,float)
+igSetScrollX	2
+1	void	igSetScrollX_Float (float)
+2	void	igSetScrollX_WindowPtr (ImGuiWindow*,float)
+igSetScrollY	2
+1	void	igSetScrollY_Float (float)
+2	void	igSetScrollY_WindowPtr (ImGuiWindow*,float)
+igSetWindowCollapsed	3
+1	void	igSetWindowCollapsed_Bool (bool,ImGuiCond)
+2	void	igSetWindowCollapsed_Str (const char*,bool,ImGuiCond)
+3	void	igSetWindowCollapsed_WindowPtr (ImGuiWindow*,bool,ImGuiCond)
+igSetWindowFocus	2
+1	void	igSetWindowFocus_Nil ()
+2	void	igSetWindowFocus_Str (const char*)
+igSetWindowPos	3
+1	void	igSetWindowPos_Vec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowPos_Str (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowPos_WindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igSetWindowSize	3
+1	void	igSetWindowSize_Vec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowSize_Str (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowSize_WindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igTabItemCalcSize	2
+1	ImVec2	igTabItemCalcSize_Str (const char*,bool)
+2	ImVec2	igTabItemCalcSize_WindowPtr (ImGuiWindow*)
+igTableGcCompactTransientBuffers	2
+1	void	igTableGcCompactTransientBuffers_TablePtr (ImGuiTable*)
+2	void	igTableGcCompactTransientBuffers_TableTempDataPtr (ImGuiTableTempData*)
+igTableGetColumnName	2
+1	const char*	igTableGetColumnName_Int (int)
+2	const char*	igTableGetColumnName_TablePtr (const ImGuiTable*,int)
+igTreeNode	3
+1	bool	igTreeNode_Str (const char*)
+2	bool	igTreeNode_StrStr (const char*,const char*,...)
+3	bool	igTreeNode_Ptr (const void*,const char*,...)
+igTreeNodeEx	3
+1	bool	igTreeNodeEx_Str (const char*,ImGuiTreeNodeFlags)
+2	bool	igTreeNodeEx_StrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
+3	bool	igTreeNodeEx_Ptr (const void*,ImGuiTreeNodeFlags,const char*,...)
+igTreeNodeExV	2
+1	bool	igTreeNodeExV_Str (const char*,ImGuiTreeNodeFlags,const char*,va_list)
+2	bool	igTreeNodeExV_Ptr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
+igTreeNodeV	2
+1	bool	igTreeNodeV_Str (const char*,const char*,va_list)
+2	bool	igTreeNodeV_Ptr (const void*,const char*,va_list)
+igTreePush	2
+1	void	igTreePush_Str (const char*)
+2	void	igTreePush_Ptr (const void*)
+igValue	4
+1	void	igValue_Bool (const char*,bool)
+2	void	igValue_Int (const char*,int)
+3	void	igValue_Uint (const char*,unsigned int)
+4	void	igValue_Float (const char*,float,const char*)
+201 overloaded

generator/output/typedefs_dict.json

@@ -0,0 +1,193 @@
+{
+  "ImBitArrayForNamedKeys": "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>",
+  "ImBitArrayPtr": "ImU32*",
+  "ImBitVector": "struct ImBitVector",
+  "ImColor": "struct ImColor",
+  "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
+  "ImDrawChannel": "struct ImDrawChannel",
+  "ImDrawCmd": "struct ImDrawCmd",
+  "ImDrawCmdHeader": "struct ImDrawCmdHeader",
+  "ImDrawData": "struct ImDrawData",
+  "ImDrawDataBuilder": "struct ImDrawDataBuilder",
+  "ImDrawFlags": "int",
+  "ImDrawIdx": "unsigned short",
+  "ImDrawList": "struct ImDrawList",
+  "ImDrawListFlags": "int",
+  "ImDrawListSharedData": "struct ImDrawListSharedData",
+  "ImDrawListSplitter": "struct ImDrawListSplitter",
+  "ImDrawVert": "struct ImDrawVert",
+  "ImFileHandle": "FILE*",
+  "ImFont": "struct ImFont",
+  "ImFontAtlas": "struct ImFontAtlas",
+  "ImFontAtlasCustomRect": "struct ImFontAtlasCustomRect",
+  "ImFontAtlasFlags": "int",
+  "ImFontBuilderIO": "struct ImFontBuilderIO",
+  "ImFontConfig": "struct ImFontConfig",
+  "ImFontGlyph": "struct ImFontGlyph",
+  "ImFontGlyphRangesBuilder": "struct ImFontGlyphRangesBuilder",
+  "ImGuiActivateFlags": "int",
+  "ImGuiBackendFlags": "int",
+  "ImGuiButtonFlags": "int",
+  "ImGuiChildFlags": "int",
+  "ImGuiCol": "int",
+  "ImGuiColorEditFlags": "int",
+  "ImGuiColorMod": "struct ImGuiColorMod",
+  "ImGuiComboFlags": "int",
+  "ImGuiComboPreviewData": "struct ImGuiComboPreviewData",
+  "ImGuiCond": "int",
+  "ImGuiConfigFlags": "int",
+  "ImGuiContext": "struct ImGuiContext",
+  "ImGuiContextHook": "struct ImGuiContextHook",
+  "ImGuiContextHookCallback": "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);",
+  "ImGuiDataType": "int",
+  "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
+  "ImGuiDataTypeTempStorage": "struct ImGuiDataTypeTempStorage",
+  "ImGuiDataVarInfo": "struct ImGuiDataVarInfo",
+  "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
+  "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
+  "ImGuiDebugLogFlags": "int",
+  "ImGuiDir": "int",
+  "ImGuiDragDropFlags": "int",
+  "ImGuiErrorLogCallback": "void(*)(void* user_data,const char* fmt,...);",
+  "ImGuiFocusRequestFlags": "int",
+  "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
+  "ImGuiFocusedFlags": "int",
+  "ImGuiGroupData": "struct ImGuiGroupData",
+  "ImGuiHoveredFlags": "int",
+  "ImGuiID": "unsigned int",
+  "ImGuiIDStackTool": "struct ImGuiIDStackTool",
+  "ImGuiIO": "struct ImGuiIO",
+  "ImGuiInputEvent": "struct ImGuiInputEvent",
+  "ImGuiInputEventAppFocused": "struct ImGuiInputEventAppFocused",
+  "ImGuiInputEventKey": "struct ImGuiInputEventKey",
+  "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
+  "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
+  "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
+  "ImGuiInputEventText": "struct ImGuiInputEventText",
+  "ImGuiInputFlags": "int",
+  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
+  "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
+  "ImGuiInputTextDeactivateData": "struct ImGuiInputTextDeactivateData",
+  "ImGuiInputTextDeactivatedState": "struct ImGuiInputTextDeactivatedState",
+  "ImGuiInputTextFlags": "int",
+  "ImGuiInputTextState": "struct ImGuiInputTextState",
+  "ImGuiItemFlags": "int",
+  "ImGuiItemStatusFlags": "int",
+  "ImGuiKeyChord": "int",
+  "ImGuiKeyData": "struct ImGuiKeyData",
+  "ImGuiKeyOwnerData": "struct ImGuiKeyOwnerData",
+  "ImGuiKeyRoutingData": "struct ImGuiKeyRoutingData",
+  "ImGuiKeyRoutingIndex": "ImS16",
+  "ImGuiKeyRoutingTable": "struct ImGuiKeyRoutingTable",
+  "ImGuiLastItemData": "struct ImGuiLastItemData",
+  "ImGuiLayoutType": "int",
+  "ImGuiListClipper": "struct ImGuiListClipper",
+  "ImGuiListClipperData": "struct ImGuiListClipperData",
+  "ImGuiListClipperRange": "struct ImGuiListClipperRange",
+  "ImGuiLocEntry": "struct ImGuiLocEntry",
+  "ImGuiMemAllocFunc": "void*(*)(size_t sz,void* user_data);",
+  "ImGuiMemFreeFunc": "void(*)(void* ptr,void* user_data);",
+  "ImGuiMenuColumns": "struct ImGuiMenuColumns",
+  "ImGuiMetricsConfig": "struct ImGuiMetricsConfig",
+  "ImGuiMouseButton": "int",
+  "ImGuiMouseCursor": "int",
+  "ImGuiNavHighlightFlags": "int",
+  "ImGuiNavItemData": "struct ImGuiNavItemData",
+  "ImGuiNavMoveFlags": "int",
+  "ImGuiNavTreeNodeData": "struct ImGuiNavTreeNodeData",
+  "ImGuiNextItemData": "struct ImGuiNextItemData",
+  "ImGuiNextItemDataFlags": "int",
+  "ImGuiNextWindowData": "struct ImGuiNextWindowData",
+  "ImGuiNextWindowDataFlags": "int",
+  "ImGuiOldColumnData": "struct ImGuiOldColumnData",
+  "ImGuiOldColumnFlags": "int",
+  "ImGuiOldColumns": "struct ImGuiOldColumns",
+  "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
+  "ImGuiPayload": "struct ImGuiPayload",
+  "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
+  "ImGuiPopupData": "struct ImGuiPopupData",
+  "ImGuiPopupFlags": "int",
+  "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
+  "ImGuiScrollFlags": "int",
+  "ImGuiSelectableFlags": "int",
+  "ImGuiSelectionUserData": "ImS64",
+  "ImGuiSeparatorFlags": "int",
+  "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
+  "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
+  "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
+  "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
+  "ImGuiSliderFlags": "int",
+  "ImGuiSortDirection": "int",
+  "ImGuiStackLevelInfo": "struct ImGuiStackLevelInfo",
+  "ImGuiStackSizes": "struct ImGuiStackSizes",
+  "ImGuiStorage": "struct ImGuiStorage",
+  "ImGuiStoragePair": "struct ImGuiStoragePair",
+  "ImGuiStyle": "struct ImGuiStyle",
+  "ImGuiStyleMod": "struct ImGuiStyleMod",
+  "ImGuiStyleVar": "int",
+  "ImGuiTabBar": "struct ImGuiTabBar",
+  "ImGuiTabBarFlags": "int",
+  "ImGuiTabItem": "struct ImGuiTabItem",
+  "ImGuiTabItemFlags": "int",
+  "ImGuiTable": "struct ImGuiTable",
+  "ImGuiTableBgTarget": "int",
+  "ImGuiTableCellData": "struct ImGuiTableCellData",
+  "ImGuiTableColumn": "struct ImGuiTableColumn",
+  "ImGuiTableColumnFlags": "int",
+  "ImGuiTableColumnIdx": "ImS16",
+  "ImGuiTableColumnSettings": "struct ImGuiTableColumnSettings",
+  "ImGuiTableColumnSortSpecs": "struct ImGuiTableColumnSortSpecs",
+  "ImGuiTableColumnsSettings": "struct ImGuiTableColumnsSettings",
+  "ImGuiTableDrawChannelIdx": "ImU16",
+  "ImGuiTableFlags": "int",
+  "ImGuiTableHeaderData": "struct ImGuiTableHeaderData",
+  "ImGuiTableInstanceData": "struct ImGuiTableInstanceData",
+  "ImGuiTableRowFlags": "int",
+  "ImGuiTableSettings": "struct ImGuiTableSettings",
+  "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",
+  "ImGuiTableTempData": "struct ImGuiTableTempData",
+  "ImGuiTextBuffer": "struct ImGuiTextBuffer",
+  "ImGuiTextFilter": "struct ImGuiTextFilter",
+  "ImGuiTextFlags": "int",
+  "ImGuiTextIndex": "struct ImGuiTextIndex",
+  "ImGuiTextRange": "struct ImGuiTextRange",
+  "ImGuiTooltipFlags": "int",
+  "ImGuiTreeNodeFlags": "int",
+  "ImGuiTypingSelectFlags": "int",
+  "ImGuiTypingSelectRequest": "struct ImGuiTypingSelectRequest",
+  "ImGuiTypingSelectState": "struct ImGuiTypingSelectState",
+  "ImGuiViewport": "struct ImGuiViewport",
+  "ImGuiViewportFlags": "int",
+  "ImGuiViewportP": "struct ImGuiViewportP",
+  "ImGuiWindow": "struct ImGuiWindow",
+  "ImGuiWindowFlags": "int",
+  "ImGuiWindowRefreshFlags": "int",
+  "ImGuiWindowSettings": "struct ImGuiWindowSettings",
+  "ImGuiWindowStackData": "struct ImGuiWindowStackData",
+  "ImGuiWindowTempData": "struct ImGuiWindowTempData",
+  "ImPoolIdx": "int",
+  "ImRect": "struct ImRect",
+  "ImS16": "signed short",
+  "ImS32": "signed int",
+  "ImS64": "signed long long",
+  "ImS8": "signed char",
+  "ImTextureID": "void*",
+  "ImU16": "unsigned short",
+  "ImU32": "unsigned int",
+  "ImU64": "unsigned long long",
+  "ImU8": "unsigned char",
+  "ImVec1": "struct ImVec1",
+  "ImVec2": "struct ImVec2",
+  "ImVec2ih": "struct ImVec2ih",
+  "ImVec4": "struct ImVec4",
+  "ImWchar": "ImWchar16",
+  "ImWchar16": "unsigned short",
+  "ImWchar32": "unsigned int",
+  "STB_TexteditState": "struct STB_TexteditState",
+  "StbTexteditRow": "struct StbTexteditRow",
+  "StbUndoRecord": "struct StbUndoRecord",
+  "StbUndoState": "struct StbUndoState",
+  "const_iterator": "const value_type*",
+  "iterator": "value_type*",
+  "value_type": "T"
+}

generator/output/typedefs_dict.lua

@@ -0,0 +1,194 @@
+local defs = {}
+defs["ImBitArrayForNamedKeys"] = "ImBitArray<ImGuiKey_NamedKey_COUNT,-ImGuiKey_NamedKey_BEGIN>"
+defs["ImBitArrayPtr"] = "ImU32*"
+defs["ImBitVector"] = "struct ImBitVector"
+defs["ImColor"] = "struct ImColor"
+defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
+defs["ImDrawChannel"] = "struct ImDrawChannel"
+defs["ImDrawCmd"] = "struct ImDrawCmd"
+defs["ImDrawCmdHeader"] = "struct ImDrawCmdHeader"
+defs["ImDrawData"] = "struct ImDrawData"
+defs["ImDrawDataBuilder"] = "struct ImDrawDataBuilder"
+defs["ImDrawFlags"] = "int"
+defs["ImDrawIdx"] = "unsigned short"
+defs["ImDrawList"] = "struct ImDrawList"
+defs["ImDrawListFlags"] = "int"
+defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
+defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
+defs["ImDrawVert"] = "struct ImDrawVert"
+defs["ImFileHandle"] = "FILE*"
+defs["ImFont"] = "struct ImFont"
+defs["ImFontAtlas"] = "struct ImFontAtlas"
+defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
+defs["ImFontAtlasFlags"] = "int"
+defs["ImFontBuilderIO"] = "struct ImFontBuilderIO"
+defs["ImFontConfig"] = "struct ImFontConfig"
+defs["ImFontGlyph"] = "struct ImFontGlyph"
+defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
+defs["ImGuiActivateFlags"] = "int"
+defs["ImGuiBackendFlags"] = "int"
+defs["ImGuiButtonFlags"] = "int"
+defs["ImGuiChildFlags"] = "int"
+defs["ImGuiCol"] = "int"
+defs["ImGuiColorEditFlags"] = "int"
+defs["ImGuiColorMod"] = "struct ImGuiColorMod"
+defs["ImGuiComboFlags"] = "int"
+defs["ImGuiComboPreviewData"] = "struct ImGuiComboPreviewData"
+defs["ImGuiCond"] = "int"
+defs["ImGuiConfigFlags"] = "int"
+defs["ImGuiContext"] = "struct ImGuiContext"
+defs["ImGuiContextHook"] = "struct ImGuiContextHook"
+defs["ImGuiContextHookCallback"] = "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);"
+defs["ImGuiDataType"] = "int"
+defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
+defs["ImGuiDataTypeTempStorage"] = "struct ImGuiDataTypeTempStorage"
+defs["ImGuiDataVarInfo"] = "struct ImGuiDataVarInfo"
+defs["ImGuiDebugAllocEntry"] = "struct ImGuiDebugAllocEntry"
+defs["ImGuiDebugAllocInfo"] = "struct ImGuiDebugAllocInfo"
+defs["ImGuiDebugLogFlags"] = "int"
+defs["ImGuiDir"] = "int"
+defs["ImGuiDragDropFlags"] = "int"
+defs["ImGuiErrorLogCallback"] = "void(*)(void* user_data,const char* fmt,...);"
+defs["ImGuiFocusRequestFlags"] = "int"
+defs["ImGuiFocusScopeData"] = "struct ImGuiFocusScopeData"
+defs["ImGuiFocusedFlags"] = "int"
+defs["ImGuiGroupData"] = "struct ImGuiGroupData"
+defs["ImGuiHoveredFlags"] = "int"
+defs["ImGuiID"] = "unsigned int"
+defs["ImGuiIDStackTool"] = "struct ImGuiIDStackTool"
+defs["ImGuiIO"] = "struct ImGuiIO"
+defs["ImGuiInputEvent"] = "struct ImGuiInputEvent"
+defs["ImGuiInputEventAppFocused"] = "struct ImGuiInputEventAppFocused"
+defs["ImGuiInputEventKey"] = "struct ImGuiInputEventKey"
+defs["ImGuiInputEventMouseButton"] = "struct ImGuiInputEventMouseButton"
+defs["ImGuiInputEventMousePos"] = "struct ImGuiInputEventMousePos"
+defs["ImGuiInputEventMouseWheel"] = "struct ImGuiInputEventMouseWheel"
+defs["ImGuiInputEventText"] = "struct ImGuiInputEventText"
+defs["ImGuiInputFlags"] = "int"
+defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
+defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
+defs["ImGuiInputTextDeactivateData"] = "struct ImGuiInputTextDeactivateData"
+defs["ImGuiInputTextDeactivatedState"] = "struct ImGuiInputTextDeactivatedState"
+defs["ImGuiInputTextFlags"] = "int"
+defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
+defs["ImGuiItemFlags"] = "int"
+defs["ImGuiItemStatusFlags"] = "int"
+defs["ImGuiKeyChord"] = "int"
+defs["ImGuiKeyData"] = "struct ImGuiKeyData"
+defs["ImGuiKeyOwnerData"] = "struct ImGuiKeyOwnerData"
+defs["ImGuiKeyRoutingData"] = "struct ImGuiKeyRoutingData"
+defs["ImGuiKeyRoutingIndex"] = "ImS16"
+defs["ImGuiKeyRoutingTable"] = "struct ImGuiKeyRoutingTable"
+defs["ImGuiLastItemData"] = "struct ImGuiLastItemData"
+defs["ImGuiLayoutType"] = "int"
+defs["ImGuiListClipper"] = "struct ImGuiListClipper"
+defs["ImGuiListClipperData"] = "struct ImGuiListClipperData"
+defs["ImGuiListClipperRange"] = "struct ImGuiListClipperRange"
+defs["ImGuiLocEntry"] = "struct ImGuiLocEntry"
+defs["ImGuiMemAllocFunc"] = "void*(*)(size_t sz,void* user_data);"
+defs["ImGuiMemFreeFunc"] = "void(*)(void* ptr,void* user_data);"
+defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
+defs["ImGuiMetricsConfig"] = "struct ImGuiMetricsConfig"
+defs["ImGuiMouseButton"] = "int"
+defs["ImGuiMouseCursor"] = "int"
+defs["ImGuiNavHighlightFlags"] = "int"
+defs["ImGuiNavItemData"] = "struct ImGuiNavItemData"
+defs["ImGuiNavMoveFlags"] = "int"
+defs["ImGuiNavTreeNodeData"] = "struct ImGuiNavTreeNodeData"
+defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
+defs["ImGuiNextItemDataFlags"] = "int"
+defs["ImGuiNextWindowData"] = "struct ImGuiNextWindowData"
+defs["ImGuiNextWindowDataFlags"] = "int"
+defs["ImGuiOldColumnData"] = "struct ImGuiOldColumnData"
+defs["ImGuiOldColumnFlags"] = "int"
+defs["ImGuiOldColumns"] = "struct ImGuiOldColumns"
+defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
+defs["ImGuiPayload"] = "struct ImGuiPayload"
+defs["ImGuiPlatformImeData"] = "struct ImGuiPlatformImeData"
+defs["ImGuiPopupData"] = "struct ImGuiPopupData"
+defs["ImGuiPopupFlags"] = "int"
+defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
+defs["ImGuiScrollFlags"] = "int"
+defs["ImGuiSelectableFlags"] = "int"
+defs["ImGuiSelectionUserData"] = "ImS64"
+defs["ImGuiSeparatorFlags"] = "int"
+defs["ImGuiSettingsHandler"] = "struct ImGuiSettingsHandler"
+defs["ImGuiShrinkWidthItem"] = "struct ImGuiShrinkWidthItem"
+defs["ImGuiSizeCallback"] = "void(*)(ImGuiSizeCallbackData* data);"
+defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
+defs["ImGuiSliderFlags"] = "int"
+defs["ImGuiSortDirection"] = "int"
+defs["ImGuiStackLevelInfo"] = "struct ImGuiStackLevelInfo"
+defs["ImGuiStackSizes"] = "struct ImGuiStackSizes"
+defs["ImGuiStorage"] = "struct ImGuiStorage"
+defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
+defs["ImGuiStyle"] = "struct ImGuiStyle"
+defs["ImGuiStyleMod"] = "struct ImGuiStyleMod"
+defs["ImGuiStyleVar"] = "int"
+defs["ImGuiTabBar"] = "struct ImGuiTabBar"
+defs["ImGuiTabBarFlags"] = "int"
+defs["ImGuiTabItem"] = "struct ImGuiTabItem"
+defs["ImGuiTabItemFlags"] = "int"
+defs["ImGuiTable"] = "struct ImGuiTable"
+defs["ImGuiTableBgTarget"] = "int"
+defs["ImGuiTableCellData"] = "struct ImGuiTableCellData"
+defs["ImGuiTableColumn"] = "struct ImGuiTableColumn"
+defs["ImGuiTableColumnFlags"] = "int"
+defs["ImGuiTableColumnIdx"] = "ImS16"
+defs["ImGuiTableColumnSettings"] = "struct ImGuiTableColumnSettings"
+defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
+defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
+defs["ImGuiTableDrawChannelIdx"] = "ImU16"
+defs["ImGuiTableFlags"] = "int"
+defs["ImGuiTableHeaderData"] = "struct ImGuiTableHeaderData"
+defs["ImGuiTableInstanceData"] = "struct ImGuiTableInstanceData"
+defs["ImGuiTableRowFlags"] = "int"
+defs["ImGuiTableSettings"] = "struct ImGuiTableSettings"
+defs["ImGuiTableSortSpecs"] = "struct ImGuiTableSortSpecs"
+defs["ImGuiTableTempData"] = "struct ImGuiTableTempData"
+defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
+defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
+defs["ImGuiTextFlags"] = "int"
+defs["ImGuiTextIndex"] = "struct ImGuiTextIndex"
+defs["ImGuiTextRange"] = "struct ImGuiTextRange"
+defs["ImGuiTooltipFlags"] = "int"
+defs["ImGuiTreeNodeFlags"] = "int"
+defs["ImGuiTypingSelectFlags"] = "int"
+defs["ImGuiTypingSelectRequest"] = "struct ImGuiTypingSelectRequest"
+defs["ImGuiTypingSelectState"] = "struct ImGuiTypingSelectState"
+defs["ImGuiViewport"] = "struct ImGuiViewport"
+defs["ImGuiViewportFlags"] = "int"
+defs["ImGuiViewportP"] = "struct ImGuiViewportP"
+defs["ImGuiWindow"] = "struct ImGuiWindow"
+defs["ImGuiWindowFlags"] = "int"
+defs["ImGuiWindowRefreshFlags"] = "int"
+defs["ImGuiWindowSettings"] = "struct ImGuiWindowSettings"
+defs["ImGuiWindowStackData"] = "struct ImGuiWindowStackData"
+defs["ImGuiWindowTempData"] = "struct ImGuiWindowTempData"
+defs["ImPoolIdx"] = "int"
+defs["ImRect"] = "struct ImRect"
+defs["ImS16"] = "signed short"
+defs["ImS32"] = "signed int"
+defs["ImS64"] = "signed long long"
+defs["ImS8"] = "signed char"
+defs["ImTextureID"] = "void*"
+defs["ImU16"] = "unsigned short"
+defs["ImU32"] = "unsigned int"
+defs["ImU64"] = "unsigned long long"
+defs["ImU8"] = "unsigned char"
+defs["ImVec1"] = "struct ImVec1"
+defs["ImVec2"] = "struct ImVec2"
+defs["ImVec2ih"] = "struct ImVec2ih"
+defs["ImVec4"] = "struct ImVec4"
+defs["ImWchar"] = "ImWchar16"
+defs["ImWchar16"] = "unsigned short"
+defs["ImWchar32"] = "unsigned int"
+defs["STB_TexteditState"] = "struct STB_TexteditState"
+defs["StbTexteditRow"] = "struct StbTexteditRow"
+defs["StbUndoRecord"] = "struct StbUndoRecord"
+defs["StbUndoState"] = "struct StbUndoState"
+defs["const_iterator"] = "const value_type*"
+defs["iterator"] = "value_type*"
+defs["value_type"] = "T"
+
+return defs

generator/print_defines.cpp

@@ -0,0 +1,33 @@
+#include "imgui.h"
+
+#define CIMGUI_STRINGIZE_(x) #x
+#define CIMGUI_STRINGIZE(x) CIMGUI_STRINGIZE_(x)
+#define CIMGUI_DEFSTRING(x) "#define " #x " " CIMGUI_STRINGIZE(x)
+
+#ifdef IMGUI_VERSION
+#pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION))
+#endif
+
+#ifdef IMGUI_VERSION_NUM
+#pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION_NUM))
+#endif
+
+#ifdef IMGUI_HAS_DOCK
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_DOCK))
+#endif
+
+#ifdef IMGUI_HAS_IMSTR
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_IMSTR))
+#endif
+
+#ifdef FLT_MIN
+#pragma message(CIMGUI_DEFSTRING(FLT_MIN))
+#endif
+
+#ifdef FLT_MAX
+#pragma message(CIMGUI_DEFSTRING(FLT_MAX))
+#endif
+
+#ifdef ImDrawCallback_ResetRenderState
+#pragma message(CIMGUI_DEFSTRING(ImDrawCallback_ResetRenderState))
+#endif

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,53 @@
+#include <stdio.h>
+#include <assert.h>
+#include "../cimgui.h"
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#define igDebugCheckVersionAndDataLayout igDebugCheckVersionAndDataLayout_Str
+#endif
+
+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();
+    
+    igBegin("mainwindow",NULL,ImGuiWindowFlags_NoTitleBar);
+    static float f = 0.0f;
+    igText("Hello World!");
+    igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 0);
+    igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+    igEnd();
+    igShowDemoWindow(NULL);
+
+    igRender();
+  }
+  printf("%llu\n",ImGuiWindowFlags_NoTitleBar);
+  printf("size: %d\n",sizeof(ImGuiWindowFlags_NoTitleBar));
+  printf("DestroyContext()\n");
+  igDestroyContext(NULL);
+
+  return 0;
+}