Merge branch 'docking_inter'

Fix generation with MSVC

.github/workflows/build.yml

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

.gitignore

@@ -31,3 +31,11 @@ cimgui/cimgui.opensdf
 cimgui/cimgui.sdf
 cimgui/cimgui.v12.suo
 cimgui/Release/
+.idea
+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 = master

.travis.yml

@@ -1,11 +1,23 @@
 language: cpp
+dist: focal
 
 os:
   - linux
+  - osx
+  - windows
 
 compiler:
   - gcc
   - clang
 
-script: 
-  - make -C cimgui
+script:
+  - 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,65 @@
+cmake_minimum_required(VERSION 3.1)
+
+project(cimgui)
+
+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

@@ -0,0 +1,69 @@
+#
+# Cross Platform Makefile
+# 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_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./imgui/
+	CXXFLAGS += -Wall
+	CXXFLAGS += -shared -fPIC
+	CFLAGS = $(CXXFLAGS)
+endif
+
+ifeq ($(UNAME_S), Darwin) #APPLE
+	ECHO_MESSAGE = "macOS"
+
+	OUTPUTNAME = cimgui.dylib
+	CXXFLAGS += -I/usr/local/include
+	CXXFLAGS += -Wall
+	LINKFLAGS = -dynamiclib
+	CFLAGS = $(CXXFLAGS)
+endif
+
+ifeq ($(OS), Windows_NT)
+	ECHO_MESSAGE = "Windows"
+
+	OUTPUTNAME = cimgui.dll
+	CXXFLAGS += -I./imgui/
+	CXXFLAGS += -Wall
+	CXXFLAGS += -shared
+	LINKFLAGS = -limm32
+	CFLAGS = $(CXXFLAGS)
+endif
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) -c -o $@ $<
+
+all:$(OUTPUTNAME)
+	@echo Build complete for $(ECHO_MESSAGE)
+
+static:$(OBJS)
+	$(AR) libcimgui.a $(OBJS)
+
+$(OUTPUTNAME):$(OBJS)
+	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
+
+clean:
+	rm -f $(OBJS)
+
+fclean: clean
+	rm -f $(OUTPUTNAME)
+
+re: fclean all
+
+.PHONY: all clean fclean re static

README.md

@@ -1,19 +1,117 @@
-# 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](https://raw.github.com/extrawurst/cimgui/master/Screen Shot 2015-04-09.png)
-![new menus api](https://raw.github.com/extrawurst/cimgui/master/menus-api.gif)
 
-This is a thin c-api wrapper for the excellent C++ intermediate gui [imgui](https://github.com/ocornut/imgui).
-Most of the functions have wrapper counterparts now, missing stuff is added on a as-needed basis (PR welcome).
-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.40 of imgui](https://github.com/ocornut/imgui/releases/tag/v1.40)
-* does not compile with pure C compiler yet (for writing bindings in languages that are able to use C-ABI it is enough though, see D-bindings)
+* currently this wrapper is based on version [1.85 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)
 
+# compilation
+
+* 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)
+  * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
+  
+  For compiling with backends there is now an example with SDL2 and opengl3 in folder backend_test. It will generate a cimgui_sdl module and a test_sdl executable. You only need to provide SDL_PATH telling cmake where to look for SDL2 cmake installation.
+
+# 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 and Freetype2 is used or not. 
+* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, opengl2 and opengl3 as backends.
+* edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
+* Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
+* as a result some files are generated: `cimgui.cpp`, `cimgui.h` and `cimgui_impl.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the backends info. 
+* You can pass compiler flags to generator.sh or generator.bat at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+
+# 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 (linux makefile not tested)
-* 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_` (most of the time)
+* 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.
+
+# example bindings based on cimgui
+
+* [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
+* [ImGui.NET](https://github.com/mellinoe/ImGui.NET)
+* [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)
+* [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

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/CMakeLists.txt

@@ -0,0 +1,98 @@
+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)
+#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)
+list(APPEND IMGUI_SOURCES ./cimgui_extras.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_sdl.cpp)
+if(DEFINED SDL_PATH)
+	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
+	FIND_PACKAGE(SDL2 REQUIRED PATHS ${SDL_PATH})
+	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(DEFINED SDL_PATH)
+	message(STATUS "SDL_PATH not defined")
+	set(IMGUI_SDL_LIBRARY SDL2)
+endif(DEFINED SDL_PATH)
+
+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)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+

backend_test/cimgui_extras.cpp

@@ -0,0 +1,10 @@
+#include "../imgui/imgui.h"
+
+#include "../imgui/backends/imgui_impl_opengl3_loader.h"
+
+//making it accesible for luajit
+#ifdef _WIN32
+extern "C" __declspec( dllexport ) int Do_gl3wInit(void){ return imgl3wInit();};
+#else
+extern "C"	int Do_gl3wInit(void){ return imgl3wInit();};
+#endif

backend_test/cimgui_extras.h

@@ -0,0 +1,8 @@
+
+
+//making it accesible for main
+#ifdef _WIN32
+__declspec( dllexport ) int Do_gl3wInit(void);
+#else
+int Do_gl3wInit(void);
+#endif

backend_test/main.c

@@ -0,0 +1,203 @@
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_extras.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
+
+  // Initialize OpenGL loader for cimgui_sdl
+  bool err = Do_gl3wInit() != 0;
+  if (err)
+  {
+    SDL_Log("Failed to initialize OpenGL loader for cimgui_sdl!");
+    return 1;
+  }
+
+  // check opengl version sdl uses
+  SDL_Log("opengl version: %s", (char*)glGetString(GL_VERSION));
+
+  // 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(window);
+    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;
+}

cimgui/Makefile

@@ -1,43 +0,0 @@
-#
-# Cross Platform Makefile
-# Compatible with Ubuntu 14.04.1 and Mac OS X
-
-OBJS = cimgui.o
-OBJS += fontAtlas.o 
-OBJS += drawList.o
-#OBJS += test.o
-OBJS += ../imgui/imgui.o
-
-UNAME_S := $(shell uname -s)
-
-ifeq ($(UNAME_S), Linux) #LINUX
-	ECHO_MESSAGE = "Linux"
-
-	OUTPUTNAME = cimgui.so
-	CXXFLAGS = -I../../
-	CXXFLAGS += -Wall
-	CXXFLAGS += -shared -fPIC
-	CFLAGS = $(CXXFLAGS)
-endif
-
-ifeq ($(UNAME_S), Darwin) #APPLE
-	ECHO_MESSAGE = "Mac OS X"
-
-	OUTPUTNAME = cimgui.dylib
-	CXXFLAGS = -I/usr/local/include
-	CXXFLAGS += -Wall
-	LINKFLAGS = -dynamiclib
-	CFLAGS = $(CXXFLAGS)
-endif
-
-.cpp.o:
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-all:imgui_example
-	@echo Build complete for $(ECHO_MESSAGE)
-
-imgui_example:$(OBJS)
-	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
-
-clean:
-	rm $(OBJS)

cimgui/cimgui.h

@@ -1,334 +0,0 @@
-
-#include <stdio.h>
-
-#if defined _WIN32 || defined __CYGWIN__
-#define API __declspec(dllexport)
-#define snprintf sprintf_s
-#else
-#define API
-#endif
-
-#if defined __cplusplus
-#define EXTERN extern "C"
-#else
-#include <stdarg.h>
-#include <stdbool.h>
-#define EXTERN extern
-#endif
-
-#define CIMGUI_API EXTERN API
-#define CONST const
-
-typedef int ImGuiWindowFlags;
-typedef int ImGuiSetCond;
-typedef int ImGuiColorEditMode;
-
-CIMGUI_API ImGuiIO*         ig_GetIO();
-CIMGUI_API ImGuiStyle*      ig_GetStyle();
-CIMGUI_API void             ig_NewFrame();
-CIMGUI_API void             ig_Render();
-CIMGUI_API void             ig_Shutdown();
-CIMGUI_API void             ig_ShowUserGuide();
-CIMGUI_API void             ig_ShowStyleEditor(ImGuiStyle* ref);
-CIMGUI_API void             ig_ShowTestWindow(bool* opened);
-CIMGUI_API void             ig_ShowMetricsWindow(bool* opened);
-
-// Window
-CIMGUI_API bool             ig_Begin(CONST char* name, bool* p_opened, ImGuiWindowFlags flags);
-CIMGUI_API bool             ig_Begin2(CONST char* name, bool* p_opened, CONST struct ImVec2 size_on_first_use, float bg_alpha, ImGuiWindowFlags flags);
-CIMGUI_API void             ig_End();
-CIMGUI_API bool             ig_BeginChild(CONST char* str_id, CONST struct ImVec2 size, bool border, ImGuiWindowFlags extra_flags);
-CIMGUI_API bool             ig_BeginChildEx(ImGuiID id, CONST struct ImVec2 size, bool border, ImGuiWindowFlags extra_flags);
-CIMGUI_API void             ig_EndChild();
-CIMGUI_API void             ig_GetContentRegionMax(struct ImVec2* out);
-CIMGUI_API void             ig_GetWindowContentRegionMin(struct ImVec2* out);
-CIMGUI_API void             ig_GetWindowContentRegionMax(struct ImVec2* out);
-CIMGUI_API ImDrawList*      ig_GetWindowDrawList();
-CIMGUI_API ImFont*          ig_GetWindowFont();
-CIMGUI_API float            ig_GetWindowFontSize(); 
-CIMGUI_API void             ig_SetWindowFontScale(float scale);
-CIMGUI_API void             ig_GetWindowPos(struct ImVec2* out);
-CIMGUI_API void             ig_GetWindowSize(struct ImVec2* out);
-CIMGUI_API float            ig_GetWindowWidth();
-CIMGUI_API bool             ig_IsWindowCollapsed();
-
-CIMGUI_API void             ig_SetNextWindowPos(CONST struct ImVec2 pos, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetNextWindowPosCenter(ImGuiSetCond cond);
-CIMGUI_API void             ig_SetNextWindowSize(CONST struct ImVec2 size, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetNextWindowFocus();
-CIMGUI_API void             ig_SetWindowPos(CONST struct ImVec2 pos, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowSize(CONST struct ImVec2 size, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowCollapsed(bool collapsed, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowFocus();
-CIMGUI_API void             ig_SetWindowPosByName(CONST char* name, CONST struct ImVec2 pos, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowSize2(CONST char* name, CONST struct ImVec2 size, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowCollapsed2(CONST char* name, bool collapsed, ImGuiSetCond cond);
-CIMGUI_API void             ig_SetWindowFocus2(CONST char* name);
-
-CIMGUI_API float            ig_GetScrollPosY();
-CIMGUI_API float            ig_GetScrollMaxY();
-CIMGUI_API void             ig_SetScrollPosHere();
-CIMGUI_API void             ig_SetKeyboardFocusHere(int offset);
-CIMGUI_API void             ig_SetStateStorage(ImGuiStorage* tree);
-CIMGUI_API ImGuiStorage*    ig_GetStateStorage();
-
-// Parameters stacks (shared)
-CIMGUI_API void             ig_PushFont(ImFont* font);
-CIMGUI_API void             ig_PopFont();
-CIMGUI_API void             ig_PushStyleColor(ImGuiCol idx, CONST struct ImVec4 col);
-CIMGUI_API void             ig_PopStyleColor(int count);
-CIMGUI_API void             ig_PushStyleVar(ImGuiStyleVar idx, float val);
-CIMGUI_API void             ig_PushStyleVarVec(ImGuiStyleVar idx, CONST struct ImVec2 val);
-CIMGUI_API void             ig_PopStyleVar(int count);
-
-// Parameters stacks (current window)
-CIMGUI_API void             ig_PushItemWidth(float item_width);
-CIMGUI_API void             ig_PopItemWidth();
-CIMGUI_API float            ig_CalcItemWidth();
-CIMGUI_API void             ig_PushAllowKeyboardFocus(bool v);
-CIMGUI_API void             ig_PopAllowKeyboardFocus();
-CIMGUI_API void             ig_PushTextWrapPos(float wrap_pos_x);
-CIMGUI_API void             ig_PopTextWrapPos();
-CIMGUI_API void             ig_PushButtonRepeat(bool repeat);
-CIMGUI_API void             ig_PopButtonRepeat();
-
-
-// Tooltip
-CIMGUI_API void             ig_SetTooltip(CONST char* fmt, ...);
-CIMGUI_API void             ig_SetTooltipV(CONST char* fmt, va_list args);
-CIMGUI_API void             ig_BeginTooltip();
-CIMGUI_API void             ig_EndTooltip();
-
-// Popup
-CIMGUI_API void             ig_OpenPopup(CONST char* str_id);
-CIMGUI_API bool             ig_BeginPopup(CONST char* str_id);
-CIMGUI_API bool             ig_BeginPopupModal(CONST char* name, bool* p_opened, ImGuiWindowFlags extra_flags);
-CIMGUI_API bool             ig_BeginPopupContextItem(CONST char* str_id, int mouse_button);
-CIMGUI_API bool             ig_BeginPopupContextWindow(bool also_over_items, CONST char* str_id, int mouse_button);
-CIMGUI_API bool             ig_BeginPopupContextVoid(CONST char* str_id, int mouse_button);
-CIMGUI_API void             ig_EndPopup();
-CIMGUI_API void             ig_CloseCurrentPopup();
-
-// Layout
-CIMGUI_API void             ig_BeginGroup();
-CIMGUI_API void             ig_EndGroup();
-CIMGUI_API void             ig_Separator();
-CIMGUI_API void             ig_SameLine(int column_x, int spacing_w);
-CIMGUI_API void             ig_Spacing();
-CIMGUI_API void             ig_Dummy(CONST ImVec2* size);
-CIMGUI_API void             ig_Indent();
-CIMGUI_API void             ig_Unindent();
-CIMGUI_API void             ig_Columns(int count, CONST char* id, bool border);
-CIMGUI_API void             ig_NextColumn();
-CIMGUI_API int              ig_GetColumnIndex();
-CIMGUI_API float            ig_GetColumnOffset(int column_index);
-CIMGUI_API void             ig_SetColumnOffset(int column_index, float offset_x);
-CIMGUI_API float            ig_GetColumnWidth(int column_index);
-CIMGUI_API int              ig_GetColumnsCount();
-CIMGUI_API void             ig_GetCursorPos(struct ImVec2* pOut);
-CIMGUI_API float            ig_GetCursorPosX();
-CIMGUI_API float            ig_GetCursorPosY();
-CIMGUI_API void             ig_SetCursorPos(CONST struct ImVec2 pos);
-CIMGUI_API void             ig_SetCursorPosX(float x);
-CIMGUI_API void             ig_SetCursorPosY(float y);
-CIMGUI_API void             ig_GetCursorScreenPos(struct ImVec2* pOut);
-CIMGUI_API void             ig_SetCursorScreenPos(CONST struct ImVec2 pos);
-CIMGUI_API void             ig_AlignFirstTextHeightToWidgets();
-CIMGUI_API float            ig_GetTextLineHeight();
-CIMGUI_API float            ig_GetTextLineHeightWithSpacing();
-CIMGUI_API float            ig_GetItemsLineHeightWithSpacing();
-
-// ID scopes
-// If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them
-// You can also use "##extra" within your widget name to distinguish them from each others (see 'Programmer Guide')
-CIMGUI_API void             ig_PushIdStr(CONST char* str_id);
-CIMGUI_API void             ig_PushIdStrRange(CONST char* str_begin, CONST char* str_end);
-CIMGUI_API void             ig_PushIdPtr(CONST void* ptr_id);
-CIMGUI_API void             ig_PushIdInt(CONST int int_id);
-CIMGUI_API void             ig_PopId();
-CIMGUI_API ImGuiID          ig_GetIdStr(CONST char* str_id);
-CIMGUI_API ImGuiID          ig_GetIdStrRange(CONST char* str_begin,CONST char* str_end);
-CIMGUI_API ImGuiID          ig_GetIdPtr(CONST void* ptr_id);
-
-// Widgets
-CIMGUI_API void             ig_Text(CONST char* fmt, ...);
-CIMGUI_API void             ig_TextV(CONST char* fmt, va_list args);
-CIMGUI_API void             ig_TextColored(CONST struct ImVec4 col, CONST char* fmt, ...);
-CIMGUI_API void             ig_TextColoredV(CONST struct ImVec4 col, CONST char* fmt, va_list args);
-CIMGUI_API void             ig_TextDisabled(CONST char* fmt, ...);
-CIMGUI_API void             ig_TextDisabledV(CONST char* fmt, va_list args);
-CIMGUI_API void             ig_TextWrapped(CONST char* fmt, ...);
-CIMGUI_API void             ig_TextWrappedV(CONST char* fmt, va_list args);
-CIMGUI_API void             ig_TextUnformatted(CONST char* text, CONST char* text_end);
-CIMGUI_API void             ig_LabelText(CONST char* label, CONST char* fmt, ...);
-CIMGUI_API void             ig_LabelTextV(CONST char* label, CONST char* fmt, va_list args);
-CIMGUI_API void             ig_Bullet();
-CIMGUI_API void             ig_BulletText(CONST char* fmt, ...);
-CIMGUI_API void             ig_BulletTextV(CONST char* fmt, va_list args);
-CIMGUI_API bool             ig_Button(CONST char* label, CONST struct ImVec2 size);
-CIMGUI_API bool             ig_SmallButton(CONST char* label);
-CIMGUI_API bool             ig_InvisibleButton(CONST char* str_id, CONST struct ImVec2 size);
-CIMGUI_API void             ig_Image(ImTextureID user_texture_id, CONST struct ImVec2 size, CONST struct ImVec2 uv0, CONST struct ImVec2 uv1, CONST struct ImVec4 tint_col, CONST struct ImVec4 border_col);
-CIMGUI_API bool             ig_ImageButton(ImTextureID user_texture_id, CONST struct ImVec2 size, CONST struct ImVec2 uv0, CONST struct ImVec2 uv1, int frame_padding, CONST struct ImVec4 bg_col, CONST struct ImVec4 tint_col);
-CIMGUI_API bool             ig_CollapsingHeader(CONST char* label, CONST char* str_id, bool display_frame, bool default_open);
-CIMGUI_API bool             ig_Checkbox(CONST char* label, bool* v);
-CIMGUI_API bool             ig_CheckboxFlags(CONST char* label, unsigned int* flags, unsigned int flags_value);
-CIMGUI_API bool             ig_RadioButtonBool(CONST char* label, bool active);
-CIMGUI_API bool             ig_RadioButton(CONST char* label, int* v, int v_button);
-CIMGUI_API bool             ig_Combo(CONST char* label, int* current_item, CONST char** items, int items_count, int height_in_items);
-CIMGUI_API bool             ig_Combo2(CONST char* label, int* current_item, CONST char* items_separated_by_zeros, int height_in_items);
-CIMGUI_API bool             ig_Combo3(CONST char* label, int* current_item, bool(*items_getter)(void* data, int idx, CONST char** out_text), void* data, int items_count, int height_in_items);
-CIMGUI_API bool             ig_ColorButton(CONST struct ImVec4 col, bool small_height, bool outline_border);
-CIMGUI_API bool             ig_ColorEdit3(CONST char* label, float col[3]);
-CIMGUI_API bool             ig_ColorEdit4(CONST char* label, float col[4], bool show_alpha);
-CIMGUI_API void             ig_ColorEditMode(ImGuiColorEditMode mode);
-CIMGUI_API void             ig_PlotLines(CONST char* label, CONST float* values, int values_count, int values_offset, CONST char* overlay_text, float scale_min, float scale_max, struct ImVec2 graph_size, size_t stride);
-CIMGUI_API void             ig_PlotLines2(CONST char* label, float(*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, CONST char* overlay_text, float scale_min, float scale_max, struct ImVec2 graph_size);
-CIMGUI_API void             ig_PlotHistogram(CONST char* label, CONST float* values, int values_count, int values_offset, CONST char* overlay_text, float scale_min, float scale_max, struct ImVec2 graph_size, size_t stride);
-CIMGUI_API void             ig_PlotHistogram2(CONST char* label, float(*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, CONST char* overlay_text, float scale_min, float scale_max, struct ImVec2 graph_size);
-
-// Widgets: Sliders (tip: ctrl+click on a slider to input text)
-CIMGUI_API bool             ig_SliderFloat(CONST char* label, float* v, float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_SliderFloat2(CONST char* label, float v[2], float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_SliderFloat3(CONST char* label, float v[3], float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_SliderFloat4(CONST char* label, float v[4], float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_SliderAngle(CONST char* label, float* v_rad, float v_degrees_min, float v_degrees_max);
-CIMGUI_API bool             ig_SliderInt(CONST char* label, int* v, int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_SliderInt2(CONST char* label, int v[2], int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_SliderInt3(CONST char* label, int v[3], int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_SliderInt4(CONST char* label, int v[4], int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_VSliderFloat(CONST char* label, CONST struct ImVec2 size, float* v, float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_VSliderInt(CONST char* label, CONST struct ImVec2 size, int* v, int v_min, int v_max, CONST char* display_format);
-
-// Widgets: Drags (tip: ctrl+click on a drag box to input text)
-CIMGUI_API bool             ig_DragFloat(CONST char* label, float* v, float v_speed, float v_min, float v_max, CONST char* display_format, float power);     // If v_max >= v_max we have no bound
-CIMGUI_API bool             ig_DragFloat2(CONST char* label, float v[2], float v_speed, float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_DragFloat3(CONST char* label, float v[3], float v_speed, float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_DragFloat4(CONST char* label, float v[4], float v_speed, float v_min, float v_max, CONST char* display_format, float power);
-CIMGUI_API bool             ig_DragInt(CONST char* label, int* v, float v_speed, int v_min, int v_max, CONST char* display_format);                                       // If v_max >= v_max we have no bound
-CIMGUI_API bool             ig_DragInt2(CONST char* label, int v[2], float v_speed, int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_DragInt3(CONST char* label, int v[3], float v_speed, int v_min, int v_max, CONST char* display_format);
-CIMGUI_API bool             ig_DragInt4(CONST char* label, int v[4], float v_speed, int v_min, int v_max, CONST char* display_format);
-
-
-// Widgets: Input
-CIMGUI_API bool             ig_InputText(CONST char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data);
-CIMGUI_API bool             ig_InputTextMultiline(CONST char* label, char* buf, size_t buf_size, CONST ImVec2 size, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data);
-CIMGUI_API bool             ig_InputFloat(CONST char* label, float* v, float step, float step_fast, int decimal_precision, ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputFloat2(CONST char* label, float v[2], int decimal_precision, ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputFloat3(CONST char* label, float v[3], int decimal_precision, ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputFloat4(CONST char* label, float v[4], int decimal_precision, ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputInt(CONST char* label, int* v, int step, int step_fast, ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputInt2(CONST char* label, int v[2], ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputInt3(CONST char* label, int v[3], ImGuiInputTextFlags extra_flags);
-CIMGUI_API bool             ig_InputInt4(CONST char* label, int v[4], ImGuiInputTextFlags extra_flags);
-
-// Widgets: Trees
-CIMGUI_API bool             ig_TreeNode(CONST char* str_label_id);
-CIMGUI_API bool             ig_TreeNodeStr(CONST char* str_id, CONST char* fmt, ...);
-CIMGUI_API bool             ig_TreeNodePtr(CONST void* ptr_id, CONST char* fmt, ...);
-CIMGUI_API bool             ig_TreeNodeStrV(CONST char* str_id, CONST char* fmt, va_list args);
-CIMGUI_API bool             ig_TreeNodePtrV(CONST void* ptr_id, CONST char* fmt, va_list args);
-CIMGUI_API void             ig_TreePushStr(CONST char* str_id);
-CIMGUI_API void             ig_TreePushPtr(CONST void* ptr_id);
-CIMGUI_API void             ig_TreePop();
-CIMGUI_API void             ig_SetNextTreeNodeOpened(bool opened, ImGuiSetCond cond);
-
-// Widgets: Selectable / Lists
-CIMGUI_API bool             ig_Selectable(CONST char* label, bool selected, ImGuiSelectableFlags flags, CONST ImVec2 size);
-CIMGUI_API bool             ig_SelectableEx(CONST char* label, bool* p_selected, ImGuiSelectableFlags flags, CONST ImVec2 size);
-CIMGUI_API bool             ig_ListBox(CONST char* label, int* current_item, CONST char** items, int items_count, int height_in_items);
-CIMGUI_API bool             ig_ListBox2(CONST char* label, int* current_item, bool(*items_getter)(void* data, int idx, CONST char** out_text), void* data, int items_count, int height_in_items);
-CIMGUI_API bool             ig_ListBoxHeader(CONST char* label, CONST struct ImVec2 size);
-CIMGUI_API bool             ig_ListBoxHeader2(CONST char* label, int items_count, int height_in_items);
-CIMGUI_API void             ig_ListBoxFooter();
-
-// Widgets: Menus
-CIMGUI_API bool             ig_BeginMainMenuBar();
-CIMGUI_API void             ig_EndMainMenuBar();
-CIMGUI_API bool             ig_BeginMenuBar();
-CIMGUI_API void             ig_EndMenuBar();
-CIMGUI_API bool             ig_BeginMenu(CONST char* label, bool enabled);
-CIMGUI_API void             ig_EndMenu();
-CIMGUI_API bool             ig_MenuItem(CONST char* label, CONST char* shortcut, bool selected, bool enabled);
-CIMGUI_API bool             ig_MenuItemPtr(CONST char* label, CONST char* shortcut, bool* p_selected, bool enabled);
-
-
-// Widgets: Value() Helpers. Output single value in "name: value" format (tip: freely declare your own within the ImGui namespace!)
-CIMGUI_API void             ig_ValueBool(CONST char* prefix, bool b);
-CIMGUI_API void             ig_ValueInt(CONST char* prefix, int v);
-CIMGUI_API void             ig_ValueUInt(CONST char* prefix, unsigned int v);
-CIMGUI_API void             ig_ValueFloat(CONST char* prefix, float v, CONST char* float_format);
-CIMGUI_API void             ig_Color(CONST char* prefix, CONST struct ImVec4 v);
-CIMGUI_API void             ig_Color2(CONST char* prefix, unsigned int v);
-
-// Logging: all text output from interface is redirected to tty/file/clipboard. Tree nodes are automatically opened.
-CIMGUI_API void             ig_LogToTTY(int max_depth);
-CIMGUI_API void             ig_LogToFile(int max_depth, CONST char* filename);
-CIMGUI_API void             ig_LogToClipboard(int max_depth);
-CIMGUI_API void             ig_LogFinish();
-CIMGUI_API void             ig_LogButtons();
-CIMGUI_API void             ig_LogText(CONST char* fmt, ...);
-
-// Utilities
-CIMGUI_API bool             ig_IsItemHovered();
-CIMGUI_API bool             ig_IsItemHoveredRect();
-CIMGUI_API bool             ig_IsItemActive();
-CIMGUI_API bool             ig_IsItemVisible();
-CIMGUI_API bool             ig_IsAnyItemHovered();
-CIMGUI_API bool             ig_IsAnyItemActive();
-CIMGUI_API void             ig_GetItemRectMin(struct ImVec2* pOut);
-CIMGUI_API void             ig_GetItemRectMax(struct ImVec2* pOut);
-CIMGUI_API void             ig_GetItemRectSize(struct ImVec2* pOut);
-CIMGUI_API bool             ig_IsWindowHovered();
-CIMGUI_API bool             ig_IsWindowFocused();
-CIMGUI_API bool             ig_IsRootWindowFocused();
-CIMGUI_API bool             ig_IsRootWindowOrAnyChildFocused();
-CIMGUI_API bool             ig_IsRectVisible(CONST struct ImVec2 item_size);
-CIMGUI_API bool             ig_IsKeyDown(int key_index);
-CIMGUI_API bool             ig_IsKeyPressed(int key_index, bool repeat);
-CIMGUI_API bool             ig_IsKeyReleased(int key_index);
-CIMGUI_API bool             ig_IsMouseDown(int button);
-CIMGUI_API bool             ig_IsMouseClicked(int button, bool repeat);
-CIMGUI_API bool             ig_IsMouseDoubleClicked(int button);
-CIMGUI_API bool             ig_IsMouseReleased(int button);
-CIMGUI_API bool             ig_IsMouseHoveringWindow();
-CIMGUI_API bool             ig_IsMouseHoveringAnyWindow();
-CIMGUI_API bool             ig_IsMouseHoveringRect(CONST struct ImVec2 rect_min, CONST struct ImVec2 rect_max);
-CIMGUI_API bool             ig_IsMouseDragging(int button, float lock_threshold);
-CIMGUI_API bool             ig_IsPosHoveringAnyWindow(CONST struct ImVec2 pos);
-CIMGUI_API void             ig_GetMousePos(struct ImVec2* pOut);
-CIMGUI_API void             ig_GetMouseDragDelta(struct ImVec2* pOut, int button, float lock_threshold);
-CIMGUI_API void             ig_ResetMouseDragDelta(int button);
-CIMGUI_API ImGuiMouseCursor ig_GetMouseCursor();
-CIMGUI_API void             ig_SetMouseCursor(ImGuiMouseCursor type);
-CIMGUI_API float            ig_GetTime();
-CIMGUI_API int              ig_GetFrameCount();
-CIMGUI_API CONST char*      ig_GetStyleColName(ImGuiCol idx);
-CIMGUI_API void             ig_CalcItemRectClosestPoint(struct ImVec2* pOut, CONST struct ImVec2 pos, bool on_edge, float outward);
-CIMGUI_API void             ig_CalcTextSize(struct ImVec2* pOut, CONST char* text, CONST char* text_end, bool hide_text_after_double_hash, float wrap_width);
-CIMGUI_API void             ig_CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);
-
-CIMGUI_API bool             ig_BeginChildFrame(ImGuiID id, CONST struct ImVec2 size);
-CIMGUI_API void             ig_EndChildFrame();
-
-CIMGUI_API ImU32            ig_ColorConvertFloat4ToU32(CONST struct ImVec4 in);
-CIMGUI_API void             ig_ColorConvertRGBtoHSV(float r, float g, float b, float* out_h, float* out_s, float* out_v);
-CIMGUI_API void             ig_ColorConvertHSVtoRGB(float h, float s, float v, float* out_r, float* out_g, float* out_b);
-
-// Internal state access - if you want to share ImGui state between modules (e.g. DLL) or allocate it yourself
-CIMGUI_API CONST char*      ig_GetVersion();
-CIMGUI_API void*            ig_GetInternalState();
-CIMGUI_API size_t           ig_GetInternalStateSize();
-CIMGUI_API void             ig_SetInternalState(void* state, bool construct);
-
-CIMGUI_API void             ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
-CIMGUI_API void             ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
-CIMGUI_API void             ImFontAtlas_SetTexID(ImFontAtlas* atlas, void* tex);
-CIMGUI_API ImFont*          ImFontAtlas_AddFontDefault(ImFontAtlas* atlas);
-CIMGUI_API ImFont*          ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* atlas, CONST char* filename, float size_pixels, CONST ImWchar* glyph_ranges, int font_no);
-CIMGUI_API ImFont*          ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* atlas, void* ttf_data, int ttf_size, float size_pixels, CONST ImWchar* glyph_ranges, int font_no);
-CIMGUI_API ImFont*          ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* atlas, CONST void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, CONST ImWchar* glyph_ranges, int font_no);
-CIMGUI_API void             ImFontAtlas_ClearTexData(ImFontAtlas* atlas);
-CIMGUI_API void             ImFontAtlas_Clear(ImFontAtlas* atlas);

cimgui/cimgui.sln

@@ -1,22 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.31101.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cimgui", "cimgui.vcxproj", "{EDE48926-0595-4488-B1A0-32CA71397271}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{EDE48926-0595-4488-B1A0-32CA71397271}.Debug|Win32.ActiveCfg = Debug|Win32
-		{EDE48926-0595-4488-B1A0-32CA71397271}.Debug|Win32.Build.0 = Debug|Win32
-		{EDE48926-0595-4488-B1A0-32CA71397271}.Release|Win32.ActiveCfg = Release|Win32
-		{EDE48926-0595-4488-B1A0-32CA71397271}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

cimgui/cimgui.vcxproj

@@ -1,90 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{EDE48926-0595-4488-B1A0-32CA71397271}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>cimgui</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CIMGUI_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CIMGUI_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\imgui\imgui.cpp" />
-    <ClCompile Include="cimgui.cpp" />
-    <ClCompile Include="drawList.cpp" />
-    <ClCompile Include="fontAtlas.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="cimgui.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

cimgui/cimgui.vcxproj.filters

@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="cimgui.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\imgui\imgui.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="fontAtlas.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="drawList.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="cimgui.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>

cimgui/drawList.cpp

@@ -1,23 +0,0 @@
-
-#include "../imgui/imgui.h"
-#include "cimgui.h"
-
-EXTERN API int ImDrawList_GetVertexBufferSize(ImDrawList* list)
-{
-	return list->vtx_buffer.size();
-}
-
-EXTERN API ImDrawVert* ImDrawList_GetVertexPtr(ImDrawList* list, int n)
-{
-	return &list->vtx_buffer[n];
-}
-
-EXTERN API int ImDrawList_GetCmdSize(ImDrawList* list)
-{
-	return list->commands.size();
-}
-
-EXTERN API ImDrawCmd* ImDrawList_GetCmdPtr(ImDrawList* list, int n)
-{
-	return &list->commands[n];
-}

cimgui/fontAtlas.cpp

@@ -1,48 +0,0 @@
-
-#include "../imgui/imgui.h"
-#include "cimgui.h"
-
-CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
-{
-	atlas->GetTexDataAsRGBA32(out_pixels, out_width, out_height, out_bytes_per_pixel);
-}
-
-CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
-{
-	atlas->GetTexDataAsAlpha8(out_pixels, out_width, out_height, out_bytes_per_pixel);
-}
-
-CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* atlas, void* tex)
-{
-	atlas->TexID = tex;
-}
-
-CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* atlas)
-{
-	return atlas->AddFontDefault();
-}
-
-CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* atlas,CONST char* filename, float size_pixels, CONST ImWchar* glyph_ranges, int font_no)
-{
-	return atlas->AddFontFromFileTTF(filename, size_pixels, glyph_ranges, font_no);
-}
-
-CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* atlas, void* ttf_data, int ttf_size, float size_pixels, CONST ImWchar* glyph_ranges, int font_no)
-{
-	return atlas->AddFontFromMemoryTTF(ttf_data, ttf_size, size_pixels, glyph_ranges, font_no);
-}
-
-CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* atlas, CONST void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, CONST ImWchar* glyph_ranges, int font_no)
-{
-	return atlas->AddFontFromMemoryCompressedTTF(compressed_ttf_data, compressed_ttf_size, size_pixels, glyph_ranges, font_no);	
-}
-
-CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* atlas)
-{
-	return atlas->ClearTexData();
-}
-
-CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* atlas)
-{
-	return atlas->Clear();
-}

cimgui/test.c

@@ -1,2 +0,0 @@
-
-#include "cimgui.h"

generator/cimgui_template.cpp

@@ -0,0 +1,122 @@
+
+#include "./imgui/imgui.h"
+#ifdef CIMGUI_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+
+
+#include "auto_funcs.cpp"
+
+
+/////////////////////////////manual written functions
+CIMGUI_API void igLogText(CONST char *fmt, ...)
+{
+    char buffer[256];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(buffer, 256, fmt, args);
+    va_end(args);
+
+    ImGui::LogText("%s", buffer);
+}
+CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    buffer->appendfv(fmt, args);
+    va_end(args);
+}
+
+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

@@ -0,0 +1,69 @@
+#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
+#else
+    #ifdef __GNUC__
+        #define API  __attribute__((__visibility__("default")))
+    #else
+        #define API
+    #endif
+#endif
+
+#if defined __cplusplus
+    #define EXTERN extern "C"
+#else
+    #include <stdarg.h>
+    #include <stdbool.h>
+    #define EXTERN extern
+#endif
+
+#define CIMGUI_API EXTERN API
+#define CONST const
+
+
+#ifdef _MSC_VER
+typedef unsigned __int64 ImU64;
+#else
+//typedef unsigned long long ImU64;
+#endif
+
+
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "imgui_structs.h"
+#else
+struct GLFWwindow;
+struct SDL_Window;
+typedef union SDL_Event SDL_Event;
+#endif // CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+#include "auto_funcs.h"
+
+/////////////////////////hand written functions
+//no LogTextV
+CIMGUI_API void igLogText(CONST char *fmt, ...);
+//no appendfV
+CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
+//for getting FLT_MAX in bindings
+CIMGUI_API float igGET_FLT_MAX();
+//for getting FLT_MIN in bindings
+CIMGUI_API float igGET_FLT_MIN();
+
+
+CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
+CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
+CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
+
+
+#endif //CIMGUI_INCLUDED
+
+
+
+

generator/config_generator.lua

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

generator/generator.bat

@@ -0,0 +1,25 @@
+:: this script must be executed in this directory
+:: all the output goes to generator/output folder
+:: .cpp and .h files:
+:: cimgui.h and cimgui.cpp with gcc preprocess
+:: cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+:: cimgui_impl.h with implementation function cdefs
+:: lua and json files:
+:: definitions.lua for function definitions
+:: structs_and_enums.lua with struct and enum information-definitions
+:: impl_definitions.lua for implementation function definitions
+
+:: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
+set PATH=%PATH%;C:\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] compiler name gcc, clang or cl
+:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+:: examples: "" "internal" "internal freetype"
+:: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl
+
+::leave console open
+cmd /k
+

generator/generator.lua

@@ -0,0 +1,506 @@
+--------------------------------------------------------------------------
+--script for auto_funcs.h and auto_funcs.cpp generation
+--expects LuaJIT
+--------------------------------------------------------------------------
+assert(_VERSION=='Lua 5.1',"Must use LuaJIT")
+assert(bit,"Must use LuaJIT")
+local script_args = {...}
+local COMPILER = script_args[1]
+local INTERNAL_GENERATION = script_args[2]:match("internal") and true or false
+local FREETYPE_GENERATION = script_args[2]:match("freetype") and true or false
+local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
+local CFLAGS = ""
+local CPRE,CTEST
+--get implementations
+local implementations = {}
+for i=3,#script_args do
+    if script_args[i]:match(COMPILER == "cl" and "^/" or "^%-") then
+        local key, value = script_args[i]:match("^(.+)=(.+)$")
+        if key and value then
+            CFLAGS = CFLAGS .. " " .. key .. "=\"" .. value:gsub("\"", "\\\"") .. "\"";
+        else
+            CFLAGS = CFLAGS .. " " .. script_args[i]
+        end
+    else
+        table.insert(implementations,script_args[i])
+    end
+end
+
+if COMPILER == "gcc" or COMPILER == "clang" then
+    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]] .. CFLAGS
+    CTEST = COMPILER.." --version"
+elseif COMPILER == "cl" then
+    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_DEBUG_PARANOID /DIMGUI_API="" /DIMGUI_IMPL_API="" ]] .. CFLAGS
+    CTEST = COMPILER
+else
+    print("Working without compiler ")
+	error("cant work with "..COMPILER.." compiler")
+end
+--test compiler present
+local HAVE_COMPILER = false
+
+local pipe,err = io.popen(CTEST,"r")
+if pipe then
+    local str = pipe:read"*a"
+    print(str)
+    pipe:close()
+    if str=="" then
+        HAVE_COMPILER = false
+    else
+        HAVE_COMPILER = true
+    end
+else
+    HAVE_COMPILER = false
+    print(err)
+end
+assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
+
+
+print("HAVE_COMPILER",HAVE_COMPILER)
+print("INTERNAL_GENERATION",INTERNAL_GENERATION)
+print("FREETYPE_GENERATION",FREETYPE_GENERATION)
+--------------------------------------------------------------------------
+--this table has the functions to be skipped in generation
+--------------------------------------------------------------------------
+local cimgui_manuals = {
+    igLogText = true,
+    ImGuiTextBuffer_appendf = true,
+    --igColorConvertRGBtoHSV = true,
+    --igColorConvertHSVtoRGB = true
+}
+--------------------------------------------------------------------------
+--this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
+--first level is cimguiname without postfix, second level is the signature of the function, value is the
+--desired name
+---------------------------------------------------------------------------
+local cimgui_overloads = {
+    --igPushID = {
+        --["(const char*)"] =           "igPushIDStr",
+        --["(const char*,const char*)"] = "igPushIDRange",
+        --["(const void*)"] =           "igPushIDPtr",
+        --["(int)"] =                   "igPushIDInt"
+    --},
+}
+
+--------------------------header definitions
+local cimgui_header = 
+[[//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
+//based on imgui.h file version XXX from Dear ImGui https://github.com/ocornut/imgui
+]]
+local gdefines = {} --for FLT_MAX and others
+--------------------------------------------------------------------------
+--helper functions
+--------------------------------functions for C generation
+--load parser module
+local cpp2ffi = require"cpp2ffi"
+local read_data = cpp2ffi.read_data
+local save_data = cpp2ffi.save_data
+local copyfile = cpp2ffi.copyfile
+local serializeTableF = cpp2ffi.serializeTableF
+
+local function func_header_impl_generate(FP)
+
+    local outtab = {}
+    
+    for _,t in ipairs(FP.funcdefs) do
+        if t.cimguiname then
+            local cimf = FP.defsT[t.cimguiname]
+            local def = cimf[t.signature]
+			local addcoment = def.comment or ""
+			if def.constructor then
+				-- it happens with vulkan impl but constructor ImGui_ImplVulkanH_Window is not needed
+			    --assert(def.stname ~= "","constructor without struct")
+                --table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or --def.args)..";"..addcoment.."\n")
+            elseif def.destructor then
+                --table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
+			else
+                
+                if def.stname == "" then --ImGui namespace or top level
+                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
+                else
+					cpp2ffi.prtable(def)
+                    error("class function in implementations")
+                end
+            end
+        else --not cimguiname
+            table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
+        end
+    end
+    local cfuncsstr = table.concat(outtab)
+    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
+    return cfuncsstr
+end
+
+local func_header_generate = cpp2ffi.func_header_generate
+local func_implementation = cpp2ffi.func_implementation
+
+-------------------functions for getting and setting defines
+local function get_defines(t)
+    local compiler_cmd = COMPILER == "cl"
+                         and COMPILER..[[ /TP /nologo /c /Fo"NUL" /I "]]..IMGUI_PATH..[[" print_defines.cpp]]..CFLAGS
+                         or COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]..IMGUI_PATH..[[/imgui.h]]..CFLAGS
+    print(compiler_cmd)
+    local pipe,err = io.popen(compiler_cmd,"r")
+    local defines = {}
+    while true do
+        local line = pipe:read"*l"
+        if not line then break end
+        local key,value = line:match([[^#define%s+(%S+)%s*(.*)]])
+        if not key then --or not value then 
+            --print(line)
+        else
+            defines[key]=value or ""
+        end
+    end
+    pipe:close()
+    --require"anima.utils"
+    --prtable(defines)
+    --FLT_MAX
+    local ret = {}
+    for i,v in ipairs(t) do
+        local aa = defines[v]
+        while true do
+            local tmp = defines[aa]
+            if not tmp then
+                break
+            else
+                aa = tmp
+            end
+        end
+        ret[v] = aa
+    end
+    return ret
+end
+  --subtitution of FLT_MAX value for FLT_MAX or FLT_MIN
+local function set_defines(fdefs)
+	local FLT_MINpat = gdefines.FLT_MIN:gsub("([%.%-])","%%%1")
+    for k,defT in pairs(fdefs) do
+        for i,def in ipairs(defT) do
+            for name,default in pairs(def.defaults) do
+                if default == gdefines.FLT_MAX then
+                    def.defaults[name] = "FLT_MAX"
+                elseif default:match(FLT_MINpat) then
+                    def.defaults[name] = default:gsub(FLT_MINpat,"FLT_MIN")
+                end
+            end
+        end
+    end
+end 
+--this creates defsBystruct in case you need to list by struct container
+local function DefsByStruct(FP)
+    local structs = {}
+    for fun,defs in pairs(FP.defsT) do
+        local stname = defs[1].stname
+        structs[stname] = structs[stname] or {}
+        table.insert(structs[stname],defs)--fun)
+    end
+    FP.defsBystruct = structs
+end  
+
+-- function for repairing funcdefs default values
+local function repair_defaults(defsT,str_and_enu)
+	local function deleteOuterPars(def)
+		local w = def:match("^%b()$")
+		if w then
+			w = w:gsub("^%((.+)%)$","%1")
+			return w
+		else 
+			return def 
+		end
+	end
+	local function CleanImU32(def)
+		def = def:gsub("%(ImU32%)","")
+		--quitar () de numeros
+		def = def:gsub("%((%d+)%)","%1")
+		def = deleteOuterPars(def)
+		local bb=cpp2ffi.strsplit(def,"|")
+		for i=1,#bb do
+			local val = deleteOuterPars(bb[i])
+			if val:match"<<" then
+				local v1,v2 = val:match("(%d+)%s*<<%s*(%d+)")
+				val = v1*2^v2
+				bb[i] = val
+			end
+			assert(type(bb[i])=="number")
+		end
+		local res = 0 
+		for i=1,#bb do res = res + bb[i] end 
+		return res
+	end
+	for k,defT in pairs(defsT) do
+		for i,def in ipairs(defT) do
+			for k,v in pairs(def.defaults) do
+				--do only if not a c string
+				local is_cstring = v:sub(1,1)=='"' and v:sub(-1,-1) =='"'
+				if not is_cstring then
+					def.defaults[k] = def.defaults[k]:gsub("%(%(void%s*%*%)0%)","NULL")
+					if def.defaults[k]:match"%(ImU32%)" then
+						def.defaults[k] = tostring(CleanImU32(def.defaults[k]))
+					end
+				end
+			end
+		end
+	end
+end
+
+----------custom ImVector templates
+local table_do_sorted = cpp2ffi.table_do_sorted
+local function generate_templates(code,codeimpool,templates)
+    table.insert(code,"\n"..[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
+	table_do_sorted(templates , function (ttype, v)
+		if ttype == "ImVector" then
+			table_do_sorted(v, function(te,newte)
+				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+			end)
+		elseif ttype == "ImPool" then
+			--declare ImGuiStorage
+			table_do_sorted(v, function(te, newte)
+				table.insert(codeimpool,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+				table.insert(codeimpool,"typedef struct ImPool_"..newte.." {ImVector_"..te.." Buf;ImGuiStorage Map;ImPoolIdx FreeIdx;} ImPool_"..newte..";\n")
+			end)
+		elseif ttype == "ImChunkStream" then
+			table_do_sorted(v, function(te,newte)
+				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
+				table.insert(code,"typedef struct ImChunkStream_"..newte.." {ImVector_"..te.." Buf;} ImChunkStream_"..newte..";\n")
+			end)
+		elseif ttype == "ImSpan" then
+			table_do_sorted(v, function(te,newte)
+				table.insert(code,"typedef struct ImSpan_"..newte.." {"..te.."* Data;" ..te.."* DataEnd;} ImSpan_"..newte..";\n")
+			end)
+		else
+			print("generate_templates ttype not done",ttype)
+			error"generate templates"
+		end
+	end)
+end
+--generate cimgui.cpp cimgui.h 
+local function cimgui_generation(parser)
+
+--[[
+	-- clean ImVector:contains() for not applicable types
+	local clean_f = {}
+	for k,v in pairs(parser.defsT) do
+		if k:match"ImVector" and k:match"contains" then
+			--cpp2ffi.prtable(k,v)
+			local stname = v[1].stname
+			if not(stname:match"float" or stname:match"int" or stname:match"char") then
+				parser.defsT[k] = nil
+				--delete also from funcdefs
+				for i,t in ipairs(parser.funcdefs) do
+					if t.cimguiname == k then
+						table.remove(parser.funcdefs, i)
+						break
+					end
+				end
+			end
+		end
+	end
+--]]
+	--------------------------------------------------
+    local hstrfile = read_data"./cimgui_template.h"
+
+	local outpre,outpost = parser.structs_and_enums[1],parser.structs_and_enums[2]
+	cpp2ffi.prtable(parser.templates)
+	cpp2ffi.prtable(parser.typenames)
+	
+	local outtab = {}
+	local outtabpool = {}
+    generate_templates(outtab, outtabpool, parser.templates)
+	
+	--move outtabpool after ImGuiStorage definition
+	local outpost1, outpost2 = outpost:match("^(.+struct ImGuiStorage%s*\n%b{};\n)(.+)$")
+	outpost = outpost1..table.concat(outtabpool)..outpost2
+
+	local cstructsstr = outpre..table.concat(outtab,"")..outpost --..(extra or "")
+    
+	if gdefines.IMGUI_HAS_DOCK then
+		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_DOCK       1\n"
+	end
+	if gdefines.IMGUI_HAS_IMSTR then
+		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_IMSTR       1\n"
+	end
+	
+    hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
+    local cfuncsstr = func_header_generate(parser)
+    hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
+    save_data("./output/cimgui.h",cimgui_header,hstrfile)
+    
+    --merge it in cimgui_template.cpp to cimgui.cpp
+    local cimplem = func_implementation(parser)
+
+    local hstrfile = read_data"./cimgui_template.cpp"
+
+    hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
+    save_data("./output/cimgui.cpp",cimgui_header,hstrfile)
+
+end
+--------------------------------------------------------
+-----------------------------do it----------------------
+--------------------------------------------------------
+--get imgui.h version and IMGUI_HAS_DOCK--------------------------
+--defines for the cl compiler must be present in the print_defines.cpp file
+gdefines = get_defines{"IMGUI_VERSION","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR"}
+
+if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
+if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end
+
+cimgui_header = cimgui_header:gsub("XXX",gdefines.IMGUI_VERSION)
+if INTERNAL_GENERATION then
+	cimgui_header = cimgui_header..[[//with imgui_internal.h api
+]]
+end
+if FREETYPE_GENERATION then
+	cimgui_header = cimgui_header..[[//with imgui_freetype.h api
+]]
+end
+if gdefines.IMGUI_HAS_DOCK then
+	cimgui_header = cimgui_header..[[//docking branch
+]]
+	
+end
+print("IMGUI_HAS_IMSTR",gdefines.IMGUI_HAS_IMSTR)
+print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
+print("IMGUI_VERSION",gdefines.IMGUI_VERSION)
+
+
+--funtion for parsing imgui headers
+local function parseImGuiHeader(header,names)
+	--prepare parser
+	local parser = cpp2ffi.Parser()
+	
+	parser.getCname = function(stname,funcname,namespace)
+		local pre = (stname == "") and (namespace and (namespace=="ImGui" and "ig" or namespace.."_") or "ig") or stname.."_"
+		return pre..funcname
+	end
+	parser.cname_overloads = cimgui_overloads
+	parser.manuals = cimgui_manuals
+	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
+	
+	local defines = parser:take_lines(CPRE..header,names,COMPILER)
+	
+	return parser
+end
+--generation
+print("------------------generation with "..COMPILER.."------------------------")
+local parser1
+local headers = [[#include "]]..IMGUI_PATH..[[/imgui.h" 
+]]
+local headersT = {[[imgui]]}
+if INTERNAL_GENERATION then
+	headers = headers .. [[#include "]]..IMGUI_PATH..[[/imgui_internal.h"
+	]]
+	headersT[#headersT + 1] = [[imgui_internal]]
+	headersT[#headersT + 1] = [[imstb_textedit]]
+end
+if FREETYPE_GENERATION then
+	headers = headers .. [[
+	#include "]]..IMGUI_PATH..[[/misc/freetype/imgui_freetype.h"
+	]]
+	headersT[#headersT + 1] = [[imgui_freetype]]
+end
+save_data("headers.h",headers)
+local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
+local extra_includes = include_cmd.." " ..IMGUI_PATH.." "
+local parser1 = parseImGuiHeader(extra_includes .. [[headers.h]],headersT)
+os.remove("headers.h")
+parser1:do_parse()
+
+save_data("./output/overloads.txt",parser1.overloadstxt)
+cimgui_generation(parser1)
+
+----------save struct and enums lua table in structs_and_enums.lua for using in bindings
+
+local structs_and_enums_table = parser1.structs_and_enums_table
+save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
+save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
+
+----------save fundefs in definitions.lua for using in bindings
+--DefsByStruct(pFP)
+set_defines(parser1.defsT) 
+repair_defaults(parser1.defsT, structs_and_enums_table)
+save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
+
+--check every function has ov_cimguiname
+-- for k,v in pairs(parser1.defsT) do
+	-- for _,def in ipairs(v) do
+		-- assert(def.ov_cimguiname)
+	-- end
+-- end
+
+--=================================Now implementations
+local backends_folder 
+local ff,err = io.open (IMGUI_PATH .. "/examples/imgui_impl_glfw.h" ,"r")
+if ff then
+	backends_folder = IMGUI_PATH .. "/examples/"
+	ff:close()
+else
+	backends_folder = IMGUI_PATH .. "/backends/"
+end
+ 
+local parser2
+
+if #implementations > 0 then
+	print("------------------implementations generation with "..COMPILER.."------------------------")
+    parser2 = cpp2ffi.Parser()
+	
+	local config = require"config_generator"
+    
+    for i,impl in ipairs(implementations) do
+        local source = backends_folder .. [[imgui_impl_]].. impl .. ".h "
+        local locati = [[imgui_impl_]].. impl
+
+		local define_cmd = COMPILER=="cl" and [[ /E /D]] or [[ -E -D]]
+		local extra_defines = ""
+		if impl == "opengl3" then extra_defines = define_cmd .. "IMGUI_IMPL_OPENGL_LOADER_GL3W " end
+		local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
+		local extra_includes = include_cmd.." ".. IMGUI_PATH .." "
+		if config[impl] then
+			for j,inc in ipairs(config[impl]) do
+				extra_includes = extra_includes .. include_cmd .. inc .. " "
+			end
+		end
+		
+		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
+
+    end
+	
+    parser2:do_parse()
+
+    -- save ./cimgui_impl.h
+    local cfuncsstr = func_header_impl_generate(parser2) 
+	local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
+    save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
+
+    ----------save fundefs in impl_definitions.lua for using in bindings
+    save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
+
+end -- #implementations > 0 then
+
+-------------------------------json saving
+--avoid mixed tables (with string and integer keys)
+local function json_prepare(defs)
+    --delete signatures in function
+    for k,def in pairs(defs) do
+        for k2,v in pairs(def) do
+            if type(k2)=="string" then
+                def[k2] = nil
+            end
+        end
+    end
+    return defs
+end
+---[[
+local json = require"json"
+save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),{dict_on_empty={defaults=true}}))
+save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
+save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
+if parser2 then
+    save_data("./output/impl_definitions.json",json.encode(json_prepare(parser2.defsT),{dict_on_empty={defaults=true}}))
+end
+--]]
+-------------------copy C files to repo root
+copyfile("./output/cimgui.h", "../cimgui.h")
+copyfile("./output/cimgui.cpp", "../cimgui.cpp")
+os.remove("./output/cimgui.h")
+os.remove("./output/cimgui.cpp")
+print"all done!!"

generator/generator.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/sh
+
+# this script must be executed in this directory
+# all the output goes to generator/output folder
+# .cpp and .h files:
+# cimgui.h and cimgui.cpp with gcc preprocess
+# cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+# cimgui_impl.h with implementation function cdefs
+# lua and json files:
+# definitions.lua for function definitions
+# structs_and_enums.lua with struct and enum information-definitions
+# impl_definitions.lua for implementation function definitions
+
+#process  files
+# arg[1] compiler name gcc, clang, or cl
+# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+# examples: "" "internal" "internal freetype"
+# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl

generator/json.lua

@@ -0,0 +1,422 @@
+--
+-- json.lua
+--
+-- Copyright (c) 2018 rxi
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy of
+-- this software and associated documentation files (the "Software"), to deal in
+-- the Software without restriction, including without limitation the rights to
+-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+-- 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 = {
+  [ "\\" ] = "\\\\",
+  [ "\"" ] = "\\\"",
+  [ "\b" ] = "\\b",
+  [ "\f" ] = "\\f",
+  [ "\n" ] = "\\n",
+  [ "\r" ] = "\\r",
+  [ "\t" ] = "\\t",
+}
+
+local escape_char_map_inv = { [ "\\/" ] = "/" }
+for k, v in pairs(escape_char_map) do
+  escape_char_map_inv[v] = k
+end
+
+
+local function escape_char(c)
+  return escape_char_map[c] or string.format("\\u%04x", c:byte())
+end
+
+
+local function encode_nil(val)
+  return "null"
+end
+
+
+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
+
+  stack[val] = true
+
+  if val[1] ~= nil or next(val) == nil then
+    -- Treat as array -- check keys are valid and it is not sparse
+    local n = 0
+    for k in pairs(val) do
+      if type(k) ~= "number" then
+        error("invalid table: mixed or invalid key types")
+      end
+      n = n + 1
+    end
+    if n ~= #val then
+      error("invalid table: sparse array")
+    end
+
+    -- Encode
+    for i, v in ipairs(val) do
+      table.insert(res, encode(v, stack,level+1))
+    end
+
+    stack[val] = nil
+    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 in ipairs(ordered_keys) do
+      local v = val[k]
+
+      if type(k) ~= "string" then
+        error("invalid table: mixed or invalid key types")
+      end
+      if type(v) == "table" and next(v) == nil and dict_on_empty[k] then
+          table.insert(res, encode(k, stack,level+1) .. ": {}")
+      else
+          table.insert(res, encode(k, stack,level+1) .. ": " .. encode(v, stack,level+1,true))
+      end
+    end
+    stack[val] = nil
+    local inner = table.concat(res, ",\n")
+    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,stack,level,isvalue)
+  return rep(isvalue and "" or TAB,level)..'"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+end
+
+
+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 rep(isvalue and "" or TAB,level)..string.format("%.14g", val)
+end
+
+
+local type_func_map = {
+  [ "nil"     ] = encode_nil,
+  [ "table"   ] = encode_table,
+  [ "string"  ] = encode_string,
+  [ "number"  ] = encode_number,
+  [ "boolean" ] = tostring,
+}
+
+
+encode = function(val, stack,level,isvalue)
+  local t = type(val)
+  local f = type_func_map[t]
+  if f then
+    return f(val, stack,level,isvalue)
+  end
+  error("unexpected type '" .. t .. "'")
+end
+
+
+function json.encode(val,opts)
+  dict_on_empty = opts and opts.dict_on_empty or {}
+  return ( encode(val) )
+end
+
+
+-------------------------------------------------------------------------------
+-- Decode
+-------------------------------------------------------------------------------
+
+local parse
+
+local function create_set(...)
+  local res = {}
+  for i = 1, select("#", ...) do
+    res[ select(i, ...) ] = true
+  end
+  return res
+end
+
+local space_chars   = create_set(" ", "\t", "\r", "\n")
+local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
+local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
+local literals      = create_set("true", "false", "null")
+
+local literal_map = {
+  [ "true"  ] = true,
+  [ "false" ] = false,
+  [ "null"  ] = nil,
+}
+
+
+local function next_char(str, idx, set, negate)
+  for i = idx, #str do
+    if set[str:sub(i, i)] ~= negate then
+      return i
+    end
+  end
+  return #str + 1
+end
+
+
+local function decode_error(str, idx, msg)
+  local line_count = 1
+  local col_count = 1
+  for i = 1, idx - 1 do
+    col_count = col_count + 1
+    if str:sub(i, i) == "\n" then
+      line_count = line_count + 1
+      col_count = 1
+    end
+  end
+  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
+end
+
+
+local function codepoint_to_utf8(n)
+  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
+  local f = math.floor
+  if n <= 0x7f then
+    return string.char(n)
+  elseif n <= 0x7ff then
+    return string.char(f(n / 64) + 192, n % 64 + 128)
+  elseif n <= 0xffff then
+    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
+  elseif n <= 0x10ffff then
+    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
+                       f(n % 4096 / 64) + 128, n % 64 + 128)
+  end
+  error( string.format("invalid unicode codepoint '%x'", n) )
+end
+
+
+local function parse_unicode_escape(s)
+  local n1 = tonumber( s:sub(3, 6),  16 )
+  local n2 = tonumber( s:sub(9, 12), 16 )
+  -- Surrogate pair?
+  if n2 then
+    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
+  else
+    return codepoint_to_utf8(n1)
+  end
+end
+
+
+local function parse_string(str, i)
+  local has_unicode_escape = false
+  local has_surrogate_escape = false
+  local has_escape = false
+  local last
+  for j = i + 1, #str do
+    local x = str:byte(j)
+
+    if x < 32 then
+      decode_error(str, j, "control character in string")
+    end
+
+    if last == 92 then -- "\\" (escape char)
+      if x == 117 then -- "u" (unicode escape sequence)
+        local hex = str:sub(j + 1, j + 5)
+        if not hex:find("%x%x%x%x") then
+          decode_error(str, j, "invalid unicode escape in string")
+        end
+        if hex:find("^[dD][89aAbB]") then
+          has_surrogate_escape = true
+        else
+          has_unicode_escape = true
+        end
+      else
+        local c = string.char(x)
+        if not escape_chars[c] then
+          decode_error(str, j, "invalid escape char '" .. c .. "' in string")
+        end
+        has_escape = true
+      end
+      last = nil
+
+    elseif x == 34 then -- '"' (end of string)
+      local s = str:sub(i + 1, j - 1)
+      if has_surrogate_escape then
+        s = s:gsub("\\u[dD][89aAbB]..\\u....", parse_unicode_escape)
+      end
+      if has_unicode_escape then
+        s = s:gsub("\\u....", parse_unicode_escape)
+      end
+      if has_escape then
+        s = s:gsub("\\.", escape_char_map_inv)
+      end
+      return s, j + 1
+
+    else
+      last = x
+    end
+  end
+  decode_error(str, i, "expected closing quote for string")
+end
+
+
+local function parse_number(str, i)
+  local x = next_char(str, i, delim_chars)
+  local s = str:sub(i, x - 1)
+  local n = tonumber(s)
+  if not n then
+    decode_error(str, i, "invalid number '" .. s .. "'")
+  end
+  return n, x
+end
+
+
+local function parse_literal(str, i)
+  local x = next_char(str, i, delim_chars)
+  local word = str:sub(i, x - 1)
+  if not literals[word] then
+    decode_error(str, i, "invalid literal '" .. word .. "'")
+  end
+  return literal_map[word], x
+end
+
+
+local function parse_array(str, i)
+  local res = {}
+  local n = 1
+  i = i + 1
+  while 1 do
+    local x
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of array?
+    if str:sub(i, i) == "]" then
+      i = i + 1
+      break
+    end
+    -- Read token
+    x, i = parse(str, i)
+    res[n] = x
+    n = n + 1
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "]" then break end
+    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
+  end
+  return res, i
+end
+
+
+local function parse_object(str, i)
+  local res = {}
+  i = i + 1
+  while 1 do
+    local key, val
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of object?
+    if str:sub(i, i) == "}" then
+      i = i + 1
+      break
+    end
+    -- Read key
+    if str:sub(i, i) ~= '"' then
+      decode_error(str, i, "expected string for key")
+    end
+    key, i = parse(str, i)
+    -- Read ':' delimiter
+    i = next_char(str, i, space_chars, true)
+    if str:sub(i, i) ~= ":" then
+      decode_error(str, i, "expected ':' after key")
+    end
+    i = next_char(str, i + 1, space_chars, true)
+    -- Read value
+    val, i = parse(str, i)
+    -- Set
+    res[key] = val
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "}" then break end
+    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
+  end
+  return res, i
+end
+
+
+local char_func_map = {
+  [ '"' ] = parse_string,
+  [ "0" ] = parse_number,
+  [ "1" ] = parse_number,
+  [ "2" ] = parse_number,
+  [ "3" ] = parse_number,
+  [ "4" ] = parse_number,
+  [ "5" ] = parse_number,
+  [ "6" ] = parse_number,
+  [ "7" ] = parse_number,
+  [ "8" ] = parse_number,
+  [ "9" ] = parse_number,
+  [ "-" ] = parse_number,
+  [ "t" ] = parse_literal,
+  [ "f" ] = parse_literal,
+  [ "n" ] = parse_literal,
+  [ "[" ] = parse_array,
+  [ "{" ] = parse_object,
+}
+
+
+parse = function(str, idx)
+  local chr = str:sub(idx, idx)
+  local f = char_func_map[chr]
+  if f then
+    return f(str, idx)
+  end
+  decode_error(str, idx, "unexpected character '" .. chr .. "'")
+end
+
+
+function json.decode(str)
+  if type(str) ~= "string" then
+    error("expected argument of type string, got " .. type(str))
+  end
+  local res, idx = parse(str, next_char(str, 1, space_chars, true))
+  idx = next_char(str, idx, space_chars, true)
+  if idx <= #str then
+    decode_error(str, idx, "trailing garbage")
+  end
+  return res
+end
+
+return json

generator/output/cimgui_impl.h

@@ -0,0 +1,44 @@
+typedef struct SDL_Window SDL_Window;
+typedef struct GLFWmonitor GLFWmonitor;
+typedef struct GLFWwindow GLFWwindow;
+
+struct GLFWwindow;
+struct GLFWmonitor;
+
+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 bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown();
+CIMGUI_API void ImGui_ImplGlfw_NewFrame();
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
+CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+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);
+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 bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown();
+CIMGUI_API void ImGui_ImplSDL2_NewFrame();
+CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);

generator/output/impl_definitions.json

@@ -0,0 +1,743 @@
+{
+  "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:40",
+      "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:36",
+      "ov_cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_InitForOpenGL": [
+    {
+      "args": "(GLFWwindow* window,bool install_callbacks)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "install_callbacks",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,bool install_callbacks)",
+      "call_args": "(window,install_callbacks)",
+      "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_InitForOpenGL",
+      "location": "imgui_impl_glfw:26",
+      "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:28",
+      "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:27",
+      "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
+      "ret": "bool",
+      "signature": "(GLFWwindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_KeyCallback": [
+    {
+      "args": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "key",
+          "type": "int"
+        },
+        {
+          "name": "scancode",
+          "type": "int"
+        },
+        {
+          "name": "action",
+          "type": "int"
+        },
+        {
+          "name": "mods",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,int key,int scancode,int action,int mods)",
+      "call_args": "(window,key,scancode,action,mods)",
+      "cimguiname": "ImGui_ImplGlfw_KeyCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_KeyCallback",
+      "location": "imgui_impl_glfw:39",
+      "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:41",
+      "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:37",
+      "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:30",
+      "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_ScrollCallback": [
+    {
+      "args": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        },
+        {
+          "name": "xoffset",
+          "type": "double"
+        },
+        {
+          "name": "yoffset",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window,double xoffset,double yoffset)",
+      "call_args": "(window,xoffset,yoffset)",
+      "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_ScrollCallback",
+      "location": "imgui_impl_glfw:38",
+      "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
+      "ret": "void",
+      "signature": "(GLFWwindow*,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplGlfw_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_Shutdown",
+      "location": "imgui_impl_glfw:29",
+      "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:35",
+      "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:31",
+      "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:29",
+      "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:32",
+      "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:30",
+      "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:23",
+      "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:25",
+      "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:26",
+      "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:24",
+      "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:32",
+      "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:30",
+      "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:33",
+      "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:31",
+      "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=((void*)0))",
+      "call_args": "(glsl_version)",
+      "cimguiname": "ImGui_ImplOpenGL3_Init",
+      "defaults": {
+        "glsl_version": "((void*)0)"
+      },
+      "funcname": "ImGui_ImplOpenGL3_Init",
+      "location": "imgui_impl_opengl3:24",
+      "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:26",
+      "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:27",
+      "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:25",
+      "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_sdl:26",
+      "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_sdl:27",
+      "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_sdl:24",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
+      "ret": "bool",
+      "signature": "(SDL_Window*,void*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForSDLRenderer": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "location": "imgui_impl_sdl:28",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "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_sdl:25",
+      "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_sdl:30",
+      "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_sdl:31",
+      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
+      "ret": "bool",
+      "signature": "(const SDL_Event*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_Shutdown",
+      "location": "imgui_impl_sdl:29",
+      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ]
+}

generator/output/impl_definitions.lua

@@ -0,0 +1,652 @@
+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:40"
+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:36"
+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_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:26"
+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:28"
+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:27"
+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_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:39"
+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:41"
+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:37"
+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:30"
+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_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:38"
+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_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:29"
+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:35"
+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:31"
+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:29"
+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:32"
+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:30"
+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:23"
+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:25"
+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:26"
+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:24"
+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:32"
+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:30"
+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:33"
+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:31"
+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=((void*)0))"
+defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
+defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "((void*)0)"
+defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
+defs["ImGui_ImplOpenGL3_Init"][1]["location"] = "imgui_impl_opengl3:24"
+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:26"
+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:27"
+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:25"
+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_sdl:26"
+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_sdl:27"
+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_sdl:24"
+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_InitForSDLRenderer"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["funcname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["location"] = "imgui_impl_sdl:28"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForSDLRenderer"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForSDLRenderer"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForSDLRenderer"]["(SDL_Window*)"] = 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_sdl:25"
+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_sdl:30"
+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_sdl:31"
+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_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_sdl:29"
+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,258 @@
+----------------overloadings---------------------------
+ImColor_ImColor	5
+1	nil	ImColor_ImColor_Nil ()
+2	nil	ImColor_ImColor_Int (int,int,int,int)
+3	nil	ImColor_ImColor_U32 (ImU32)
+4	nil	ImColor_ImColor_Float (float,float,float,float)
+5	nil	ImColor_ImColor_Vec4 (const ImVec4)
+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)
+ImGuiWindow_GetIDNoKeepAlive	3
+1	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Str (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Ptr (const void*)
+3	ImGuiID	ImGuiWindow_GetIDNoKeepAlive_Int (int)
+ImPool_Remove	2
+1	void	ImPool_Remove_TPtr (ImGuiID,const T*)
+2	void	ImPool_Remove_PoolIdx (ImGuiID,ImPoolIdx)
+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 (const ImVector)
+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,bool,ImGuiWindowFlags)
+2	bool	igBeginChild_ID (ImGuiID,const ImVec2,bool,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_FnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),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)
+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*)
+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)
+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_FnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),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)
+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*)
+180 overloaded

generator/output/typedefs_dict.json

@@ -0,0 +1,159 @@
+{
+  "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",
+  "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",
+  "ImGuiDir": "int",
+  "ImGuiDragDropFlags": "int",
+  "ImGuiErrorLogCallback": "void(*)(void* user_data,const char* fmt,...);",
+  "ImGuiFocusedFlags": "int",
+  "ImGuiGroupData": "struct ImGuiGroupData",
+  "ImGuiHoveredFlags": "int",
+  "ImGuiID": "unsigned int",
+  "ImGuiIO": "struct ImGuiIO",
+  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
+  "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
+  "ImGuiInputTextFlags": "int",
+  "ImGuiInputTextState": "struct ImGuiInputTextState",
+  "ImGuiItemFlags": "int",
+  "ImGuiItemStatusFlags": "int",
+  "ImGuiKey": "int",
+  "ImGuiKeyModFlags": "int",
+  "ImGuiLastItemData": "struct ImGuiLastItemData",
+  "ImGuiLayoutType": "int",
+  "ImGuiListClipper": "struct ImGuiListClipper",
+  "ImGuiMemAllocFunc": "void*(*)(size_t sz,void* user_data);",
+  "ImGuiMemFreeFunc": "void(*)(void* ptr,void* user_data);",
+  "ImGuiMenuColumns": "struct ImGuiMenuColumns",
+  "ImGuiMetricsConfig": "struct ImGuiMetricsConfig",
+  "ImGuiMouseButton": "int",
+  "ImGuiMouseCursor": "int",
+  "ImGuiNavDirSourceFlags": "int",
+  "ImGuiNavHighlightFlags": "int",
+  "ImGuiNavInput": "int",
+  "ImGuiNavItemData": "struct ImGuiNavItemData",
+  "ImGuiNavMoveFlags": "int",
+  "ImGuiNextItemData": "struct ImGuiNextItemData",
+  "ImGuiNextItemDataFlags": "int",
+  "ImGuiNextWindowData": "struct ImGuiNextWindowData",
+  "ImGuiNextWindowDataFlags": "int",
+  "ImGuiOldColumnData": "struct ImGuiOldColumnData",
+  "ImGuiOldColumnFlags": "int",
+  "ImGuiOldColumns": "struct ImGuiOldColumns",
+  "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
+  "ImGuiPayload": "struct ImGuiPayload",
+  "ImGuiPopupData": "struct ImGuiPopupData",
+  "ImGuiPopupFlags": "int",
+  "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
+  "ImGuiScrollFlags": "int",
+  "ImGuiSelectableFlags": "int",
+  "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",
+  "ImGuiStackTool": "struct ImGuiStackTool",
+  "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": "ImS8",
+  "ImGuiTableColumnSettings": "struct ImGuiTableColumnSettings",
+  "ImGuiTableColumnSortSpecs": "struct ImGuiTableColumnSortSpecs",
+  "ImGuiTableColumnsSettings": "struct ImGuiTableColumnsSettings",
+  "ImGuiTableDrawChannelIdx": "ImU8",
+  "ImGuiTableFlags": "int",
+  "ImGuiTableRowFlags": "int",
+  "ImGuiTableSettings": "struct ImGuiTableSettings",
+  "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",
+  "ImGuiTableTempData": "struct ImGuiTableTempData",
+  "ImGuiTextBuffer": "struct ImGuiTextBuffer",
+  "ImGuiTextFilter": "struct ImGuiTextFilter",
+  "ImGuiTextFlags": "int",
+  "ImGuiTextRange": "struct ImGuiTextRange",
+  "ImGuiTooltipFlags": "int",
+  "ImGuiTreeNodeFlags": "int",
+  "ImGuiViewport": "struct ImGuiViewport",
+  "ImGuiViewportFlags": "int",
+  "ImGuiViewportP": "struct ImGuiViewportP",
+  "ImGuiWindow": "struct ImGuiWindow",
+  "ImGuiWindowFlags": "int",
+  "ImGuiWindowSettings": "struct ImGuiWindowSettings",
+  "ImGuiWindowStackData": "struct ImGuiWindowStackData",
+  "ImGuiWindowTempData": "struct ImGuiWindowTempData",
+  "ImPoolIdx": "int",
+  "ImRect": "struct ImRect",
+  "ImS16": "signed short",
+  "ImS32": "signed int",
+  "ImS64": "int64_t",
+  "ImS8": "signed char",
+  "ImTextureID": "void*",
+  "ImU16": "unsigned short",
+  "ImU32": "unsigned int",
+  "ImU64": "uint64_t",
+  "ImU8": "unsigned char",
+  "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,160 @@
+local defs = {}
+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["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["ImGuiDir"] = "int"
+defs["ImGuiDragDropFlags"] = "int"
+defs["ImGuiErrorLogCallback"] = "void(*)(void* user_data,const char* fmt,...);"
+defs["ImGuiFocusedFlags"] = "int"
+defs["ImGuiGroupData"] = "struct ImGuiGroupData"
+defs["ImGuiHoveredFlags"] = "int"
+defs["ImGuiID"] = "unsigned int"
+defs["ImGuiIO"] = "struct ImGuiIO"
+defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
+defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
+defs["ImGuiInputTextFlags"] = "int"
+defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
+defs["ImGuiItemFlags"] = "int"
+defs["ImGuiItemStatusFlags"] = "int"
+defs["ImGuiKey"] = "int"
+defs["ImGuiKeyModFlags"] = "int"
+defs["ImGuiLastItemData"] = "struct ImGuiLastItemData"
+defs["ImGuiLayoutType"] = "int"
+defs["ImGuiListClipper"] = "struct ImGuiListClipper"
+defs["ImGuiMemAllocFunc"] = "void*(*)(size_t sz,void* user_data);"
+defs["ImGuiMemFreeFunc"] = "void(*)(void* ptr,void* user_data);"
+defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
+defs["ImGuiMetricsConfig"] = "struct ImGuiMetricsConfig"
+defs["ImGuiMouseButton"] = "int"
+defs["ImGuiMouseCursor"] = "int"
+defs["ImGuiNavDirSourceFlags"] = "int"
+defs["ImGuiNavHighlightFlags"] = "int"
+defs["ImGuiNavInput"] = "int"
+defs["ImGuiNavItemData"] = "struct ImGuiNavItemData"
+defs["ImGuiNavMoveFlags"] = "int"
+defs["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["ImGuiPopupData"] = "struct ImGuiPopupData"
+defs["ImGuiPopupFlags"] = "int"
+defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
+defs["ImGuiScrollFlags"] = "int"
+defs["ImGuiSelectableFlags"] = "int"
+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["ImGuiStackTool"] = "struct ImGuiStackTool"
+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"] = "ImS8"
+defs["ImGuiTableColumnSettings"] = "struct ImGuiTableColumnSettings"
+defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
+defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
+defs["ImGuiTableDrawChannelIdx"] = "ImU8"
+defs["ImGuiTableFlags"] = "int"
+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["ImGuiTextRange"] = "struct ImGuiTextRange"
+defs["ImGuiTooltipFlags"] = "int"
+defs["ImGuiTreeNodeFlags"] = "int"
+defs["ImGuiViewport"] = "struct ImGuiViewport"
+defs["ImGuiViewportFlags"] = "int"
+defs["ImGuiViewportP"] = "struct ImGuiViewportP"
+defs["ImGuiWindow"] = "struct ImGuiWindow"
+defs["ImGuiWindowFlags"] = "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"] = "int64_t"
+defs["ImS8"] = "signed char"
+defs["ImTextureID"] = "void*"
+defs["ImU16"] = "unsigned short"
+defs["ImU32"] = "unsigned int"
+defs["ImU64"] = "uint64_t"
+defs["ImU8"] = "unsigned char"
+defs["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,25 @@
+#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_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

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;
+}