git.haldean.org qb / 82e04e9
yet another start on this miserable project! haldean 1 year, 1 month ago
37 changed file(s) with 83870 addition(s) and 0 deletion(s). Raw diff Collapse all Expand all
0 .vscode/
1 build/
0 cmake_minimum_required(VERSION 3.0)
1 project(cimgui-sokol-starterkit)
2 set(CMAKE_C_STANDARD 11)
3 set(CMAKE_CXX_STANDARD 17)
4 set(CMAKE_CXX_STANDARD_REQUIRED ON)
5 if (CMAKE_SYSTEM_NAME STREQUAL Emscripten)
6 set(CMAKE_EXECUTABLE_SUFFIX ".html")
7 endif()
8 if(MSVC)
9 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17")
10 endif(MSVC)
11
12 # Linux -pthread shenanigans
13 if (CMAKE_SYSTEM_NAME STREQUAL Linux)
14 set(THREADS_PREFER_PTHREAD_FLAG ON)
15 find_package(Threads REQUIRED)
16 endif()
17
18 #=== LIBRARY: cimgui + Dear ImGui
19 add_library(cimgui STATIC
20 cimgui/cimgui.cpp
21 cimgui/cimgui.h
22 cimgui/imgui/imgui.cpp
23 cimgui/imgui/imgui.h
24 cimgui/imgui/imgui_widgets.cpp
25 cimgui/imgui/imgui_draw.cpp
26 cimgui/imgui/imgui_tables.cpp
27 cimgui/imgui/imgui_demo.cpp)
28 target_include_directories(cimgui INTERFACE cimgui)
29
30 #=== LIBRARY: sokol
31 # add headers to the the file list because they are useful to have in IDEs
32 set(SOKOL_HEADERS
33 sokol/sokol_gfx.h
34 sokol/sokol_app.h
35 sokol/sokol_time.h
36 sokol/sokol_imgui.h
37 sokol/sokol_glue.h)
38 if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
39 add_library(sokol STATIC sokol/sokol.m ${SOKOL_HEADERS})
40 target_link_libraries(sokol PUBLIC
41 "-framework QuartzCore"
42 "-framework Cocoa"
43 "-framework MetalKit"
44 "-framework Metal")
45 else()
46 add_library(sokol STATIC sokol/sokol.c ${SOKOL_HEADERS})
47 if (CMAKE_SYSTEM_NAME STREQUAL Linux)
48 target_link_libraries(sokol INTERFACE X11 Xi Xcursor GL dl m)
49 target_link_libraries(sokol PUBLIC Threads::Threads)
50 endif()
51 endif()
52 target_link_libraries(sokol PUBLIC cimgui)
53 target_include_directories(sokol INTERFACE sokol)
54
55 #=== EXECUTABLE: qb
56 set(QB_SOURCES
57 launch.c
58 qb.cpp
59 qb.hpp
60 qbshim.cpp
61 qbshim.hpp
62 nodeui.cpp
63 nodeui.hpp
64 )
65 if(CMAKE_SYSTEM_NAME STREQUAL Windows)
66 add_executable(qb WIN32 ${QB_SOURCES})
67 else()
68 add_executable(qb ${QB_SOURCES})
69 endif()
70 target_link_libraries(qb sokol)
71
72 # explicitly strip dead code
73 if (CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME STREQUAL Emscripten)
74 target_link_options(qb PRIVATE LINKER:-dead_strip)
75 endif()
76
77 # this hack removes the xxx-CMakeForceLinker.cxx dummy file
78 set_target_properties(qb PROPERTIES LINKER_LANGUAGE C)
0 Proprietary code, do not distribute
1
2 Copyright (c) 2021 Haldean Brown
0 MIT License from cimgui-sokol-starterkit
1
2 Copyright (c) 2020 Andre Weissflog
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in all
12 copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 SOFTWARE.
0 # cimgui-sokol-starterkit
1
2 A minimal cross-platform starter-kit to write simple
3 Dear ImGui tools for Windows, Linux and macOS in C.
4
5 [WASM version](https://floooh.github.io/cimgui-sokol-starterkit/) (see below for build instructions)
6
7 ## Clone:
8
9 ```bash
10 > git clone https://github.com/floooh/cimgui-sokol-starterkit
11 > cd cimgui-sokol-starterkit
12 ```
13
14 ## Build:
15
16 ```bash
17 > mkdir build
18 > cd build
19
20 > cmake ..
21 > cmake --build .
22 ```
23
24 To build a Release version on Linux and Mac:
25
26 ```bash
27 > cmake -DCMAKE_BUILD_TYPE=MinSizeRel ..
28 > cmake --build .
29 ```
30
31 To build a Release version on Windows with the VisualStudio toolchain:
32
33 ```bash
34 > cmake ..
35 > cmake --build . --config MinSizeRel
36 ```
37
38 NOTE: on Linux you'll also need to install the 'usual' dev-packages needed for X11+GL development.
39
40 ## Run:
41
42 On Linux and macOS:
43 ```bash
44 > ./demo
45 ```
46
47 On Windows with the Visual Studio toolchain the exe is in a subdirectory:
48 ```bash
49 > Debug\demo.exe
50 > MinSizeRel\demo.exe
51 ```
52
53 ## Build and Run WASM/HTML version via Emscripten (Linux, macOS)
54
55 Setup the emscripten SDK as described here:
56
57 https://emscripten.org/docs/getting_started/downloads.html#installation-instructions
58
59 Don't forget to run ```source ./emsdk_env.sh``` after activating the SDK.
60
61 And then in the ```cimgui-sokol-starterkit``` directory:
62
63 ```
64 mkdir build
65 cd build
66 emcmake cmake -DCMAKE_BUILD_TYPE=MinSizeRel ..
67 cmake --build .
68 ```
69
70 To run the compilation result in the system web browser:
71
72 ```
73 > emrun demo.html
74 ```
75
76 ...which should look like [this](https://floooh.github.io/cimgui-sokol-starterkit/).
77
78 (this procedure should also work on Windows with ```make``` in the path, but
79 is currently untested)
80
81 ## IDE Support
82
83 ### Visual Studio (Windows)
84
85 On Windows, cmake will automatically create a Visual Studio solution file in
86 the build directory, which can be opened with:
87
88 ```bash
89 > start cimgui-sokol-starterkit.sln
90 ```
91
92 ### Xcode (macOS)
93
94 Replace ```cmake ..``` with ```cmake -GXcode ..``` and open the generated
95 Xcode project:
96
97 ```bash
98 > cmake -GXcode ..
99 > open cimgui-sokol-starterkit.xcodeproj
100 ```
101
102 ### Visual Studio Code (Windows, Linux, macOS)
103
104 Use the [MS C/C++ extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)
105 together with the [MS CMake Tools extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools)
106 and start Visual Studio code from the project's root directory. The CMake
107 extension will detect the CMakeLists.txt file and take over from there.
108
109 ## Notes:
110
111 The repository contains snapshots of the following libraries:
112
113 - [Dear ImGui](https://github.com/ocornut/imgui)
114 - [cimgui](https://github.com/cimgui/cimgui) (C bindings for Dear ImGui)
115 - [Sokol Headers](https://github.com/floooh/sokol) (only what's needed)
116
117 I'm not planning to do frequent updates to newer versions of those
118 files, so the versions contained in here may be behind. Updating
119 your own copies is trivial though, just copy the new files from
120 the original repositories over the files contained here.
121
122 I tried to keep the CMake file as simple as possible (unfortunately
123 it's not quite as simple as I had liked, because of some cross-platform
124 differences).
125
126 All the important code is in ```demo.c```.
127
128 Enjoy!
0 The MIT License (MIT)
1
2 Copyright (c) 2015 Stephan Dilly
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in all
12 copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 SOFTWARE.
21
0 # cimgui [![Build Status](https://travis-ci.org/cimgui/cimgui.svg?branch=master)](https://travis-ci.org/cimgui/cimgui)
1
2
3 This is a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui [Dear ImGui](https://github.com/ocornut/imgui).
4 All imgui.h functions are programmatically wrapped.
5 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`.
6 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))
7
8 History:
9
10 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)
11
12 Notes:
13 * currently this wrapper is based on version [1.79 of Dear ImGui with internal api]
14 * only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
15 * if you are interested in imgui backends you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
16 * 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.
17 * Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)
18
19 # compilation
20
21 * clone
22 * `git clone --recursive https://github.com/cimgui/cimgui.git`
23 * `git submodule update`
24 * compile
25 * using makefile on linux/macOS/mingw (Or use CMake to generate project)
26 * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location)
27 * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
28
29 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.
30
31 # using generator
32
33
34 * this is only needed (before compilation) if you want an imgui version different from the one provided, otherwise generation is already done.
35 * 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
36 * 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)
37 * update `imgui` folder to the version you desire.
38 * 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.
39 * the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, opengl2 and opengl3 as backends.
40 * edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
41 * Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
42 * 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.
43 * 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)
44
45 # generate binding
46 * C interface is exposed by cimgui.h when you define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
47 * with your prefered language you can use the lua or json files generated as in:
48 * 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)
49 * https://github.com/mellinoe/ImGui.NET/tree/autogen/src/CodeGenerator
50 ### definitions description
51 * 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)
52 * Each overloading is a collection. Some relevant keys and values are:
53 * stname : the name of the struct the function belongs to (will be "" if it is top level in ImGui namespace)
54 * ov_cimguiname : the overloaded cimgui name (if absent it would be taken from cimguiname)
55 * cimguiname : the name without overloading (this should be used if there is not ov_cimguiname)
56 * ret : the return type
57 * retref : is set if original return type is a reference. (will be a pointer in cimgui)
58 * 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)
59 * args : a string of argsT concatenated and separated by commas
60 * call_args : a string with the argument names separated by commas for calling imgui function
61 * defaults : a collection in which key is argument name and value is the default value.
62 * manual : will be true if this function is hand-written (not generated)
63 * skipped : will be true if this function is not generated (and not hand-written)
64 * isvararg : is set if some argument is a vararg
65 * constructor : is set if the function is a constructor for a class.
66 * destructor : is set if the function is a destructor for a class but not just a default destructor.
67 * realdestructor : is set if the function is a destructor for a class
68 * templated : is set if the function belongs to a templated class (ImVector)
69 * templatedgen: is set if the function belongs to a struct generated from template (ImVector_ImWchar)
70 * 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.
71 * location : name of the header file and linenumber this function comes from. (imgui:000, internal:123, imgui_impl_xxx:123)
72 * is_static_function : is setted when it is an struct static function.
73 ### structs_and_enums description
74 * Is is a collection with three items:
75 * 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
76 * name : the name of this enum value
77 * value : the C string
78 * calc_value : the numeric value corresponding to value
79 * 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
80 * type : the type of the struct member
81 * template_type : if type has a template argument (as ImVector) here will be
82 * name : the name of the struct member
83 * size : the number of array elements (when it is an array)
84 * bitfield : the bitfield width (in case it is a bitfield)
85 * 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.
86 # usage
87
88 * 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`
89 * methods have the same parameter list and return values (where possible)
90 * functions that belong to a struct have an extra first argument with a pointer to the struct.
91 * 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).
92
93 # usage with backends
94
95 * look at backend_test folder for a cmake module building with SDL and opengl3.
96
97 # example bindings based on cimgui
98
99 * [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
100 * [ImGui.NET](https://github.com/mellinoe/ImGui.NET)
101 * [nimgl/imgui](https://github.com/nimgl/imgui)
102 * [kotlin-imgui](https://github.com/Dominaezzz/kotlin-imgui)
103 * [CImGui.jl](https://github.com/Gnimuc/CImGui.jl)
104 * [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
105 * [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
106 * [BindBC-CimGui](https://github.com/MrcSnm/bindbc-cimgui)
107 * [imgui-rs](https://github.com/Gekkio/imgui-rs)
108 * [imgui-pas](https://github.com/dpethes/imgui-pas)
109 * [crystal-imgui](https://github.com/oprypin/crystal-imgui)
110
111 # C examples based on cimgui
112
113 * [sdl2_opengl3](https://github.com/cimgui/cimgui/tree/docking_inter/backend_test)
114 * [sdl2-cimgui-demo](https://github.com/haxpor/sdl2-cimgui-demo)
115 * [cimgui_c_sdl2_example](https://github.com/canoi12/cimgui_c_sdl2_example/)
116 * [cimgui-c-example](https://github.com/peko/cimgui-c-example) with GLFW
0 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
1 //based on imgui.h file version "1.80" from Dear ImGui https://github.com/ocornut/imgui
2 //with imgui_internal.h api
3
4 #include "./imgui/imgui.h"
5 #ifdef CIMGUI_FREETYPE
6 #include "./imgui/misc/freetype/imgui_freetype.h"
7 #endif
8 #include "./imgui/imgui_internal.h"
9 #include "cimgui.h"
10
11
12
13 CIMGUI_API ImVec2* ImVec2_ImVec2Nil(void)
14 {
15 return IM_NEW(ImVec2)();
16 }
17 CIMGUI_API void ImVec2_destroy(ImVec2* self)
18 {
19 IM_DELETE(self);
20 }
21 CIMGUI_API ImVec2* ImVec2_ImVec2Float(float _x,float _y)
22 {
23 return IM_NEW(ImVec2)(_x,_y);
24 }
25 CIMGUI_API ImVec4* ImVec4_ImVec4Nil(void)
26 {
27 return IM_NEW(ImVec4)();
28 }
29 CIMGUI_API void ImVec4_destroy(ImVec4* self)
30 {
31 IM_DELETE(self);
32 }
33 CIMGUI_API ImVec4* ImVec4_ImVec4Float(float _x,float _y,float _z,float _w)
34 {
35 return IM_NEW(ImVec4)(_x,_y,_z,_w);
36 }
37 CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas)
38 {
39 return ImGui::CreateContext(shared_font_atlas);
40 }
41 CIMGUI_API void igDestroyContext(ImGuiContext* ctx)
42 {
43 return ImGui::DestroyContext(ctx);
44 }
45 CIMGUI_API ImGuiContext* igGetCurrentContext()
46 {
47 return ImGui::GetCurrentContext();
48 }
49 CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
50 {
51 return ImGui::SetCurrentContext(ctx);
52 }
53 CIMGUI_API ImGuiIO* igGetIO()
54 {
55 return &ImGui::GetIO();
56 }
57 CIMGUI_API ImGuiStyle* igGetStyle()
58 {
59 return &ImGui::GetStyle();
60 }
61 CIMGUI_API void igNewFrame()
62 {
63 return ImGui::NewFrame();
64 }
65 CIMGUI_API void igEndFrame()
66 {
67 return ImGui::EndFrame();
68 }
69 CIMGUI_API void igRender()
70 {
71 return ImGui::Render();
72 }
73 CIMGUI_API ImDrawData* igGetDrawData()
74 {
75 return ImGui::GetDrawData();
76 }
77 CIMGUI_API void igShowDemoWindow(bool* p_open)
78 {
79 return ImGui::ShowDemoWindow(p_open);
80 }
81 CIMGUI_API void igShowMetricsWindow(bool* p_open)
82 {
83 return ImGui::ShowMetricsWindow(p_open);
84 }
85 CIMGUI_API void igShowAboutWindow(bool* p_open)
86 {
87 return ImGui::ShowAboutWindow(p_open);
88 }
89 CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref)
90 {
91 return ImGui::ShowStyleEditor(ref);
92 }
93 CIMGUI_API bool igShowStyleSelector(const char* label)
94 {
95 return ImGui::ShowStyleSelector(label);
96 }
97 CIMGUI_API void igShowFontSelector(const char* label)
98 {
99 return ImGui::ShowFontSelector(label);
100 }
101 CIMGUI_API void igShowUserGuide()
102 {
103 return ImGui::ShowUserGuide();
104 }
105 CIMGUI_API const char* igGetVersion()
106 {
107 return ImGui::GetVersion();
108 }
109 CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst)
110 {
111 return ImGui::StyleColorsDark(dst);
112 }
113 CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst)
114 {
115 return ImGui::StyleColorsLight(dst);
116 }
117 CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst)
118 {
119 return ImGui::StyleColorsClassic(dst);
120 }
121 CIMGUI_API bool igBegin(const char* name,bool* p_open,ImGuiWindowFlags flags)
122 {
123 return ImGui::Begin(name,p_open,flags);
124 }
125 CIMGUI_API void igEnd()
126 {
127 return ImGui::End();
128 }
129 CIMGUI_API bool igBeginChildStr(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags)
130 {
131 return ImGui::BeginChild(str_id,size,border,flags);
132 }
133 CIMGUI_API bool igBeginChildID(ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags)
134 {
135 return ImGui::BeginChild(id,size,border,flags);
136 }
137 CIMGUI_API void igEndChild()
138 {
139 return ImGui::EndChild();
140 }
141 CIMGUI_API bool igIsWindowAppearing()
142 {
143 return ImGui::IsWindowAppearing();
144 }
145 CIMGUI_API bool igIsWindowCollapsed()
146 {
147 return ImGui::IsWindowCollapsed();
148 }
149 CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags)
150 {
151 return ImGui::IsWindowFocused(flags);
152 }
153 CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags)
154 {
155 return ImGui::IsWindowHovered(flags);
156 }
157 CIMGUI_API ImDrawList* igGetWindowDrawList()
158 {
159 return ImGui::GetWindowDrawList();
160 }
161 CIMGUI_API void igGetWindowPos(ImVec2 *pOut)
162 {
163 *pOut = ImGui::GetWindowPos();
164 }
165 CIMGUI_API void igGetWindowSize(ImVec2 *pOut)
166 {
167 *pOut = ImGui::GetWindowSize();
168 }
169 CIMGUI_API float igGetWindowWidth()
170 {
171 return ImGui::GetWindowWidth();
172 }
173 CIMGUI_API float igGetWindowHeight()
174 {
175 return ImGui::GetWindowHeight();
176 }
177 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
178 {
179 return ImGui::SetNextWindowPos(pos,cond,pivot);
180 }
181 CIMGUI_API void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond)
182 {
183 return ImGui::SetNextWindowSize(size,cond);
184 }
185 CIMGUI_API void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data)
186 {
187 return ImGui::SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data);
188 }
189 CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size)
190 {
191 return ImGui::SetNextWindowContentSize(size);
192 }
193 CIMGUI_API void igSetNextWindowCollapsed(bool collapsed,ImGuiCond cond)
194 {
195 return ImGui::SetNextWindowCollapsed(collapsed,cond);
196 }
197 CIMGUI_API void igSetNextWindowFocus()
198 {
199 return ImGui::SetNextWindowFocus();
200 }
201 CIMGUI_API void igSetNextWindowBgAlpha(float alpha)
202 {
203 return ImGui::SetNextWindowBgAlpha(alpha);
204 }
205 CIMGUI_API void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond)
206 {
207 return ImGui::SetWindowPos(pos,cond);
208 }
209 CIMGUI_API void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond)
210 {
211 return ImGui::SetWindowSize(size,cond);
212 }
213 CIMGUI_API void igSetWindowCollapsedBool(bool collapsed,ImGuiCond cond)
214 {
215 return ImGui::SetWindowCollapsed(collapsed,cond);
216 }
217 CIMGUI_API void igSetWindowFocusNil()
218 {
219 return ImGui::SetWindowFocus();
220 }
221 CIMGUI_API void igSetWindowFontScale(float scale)
222 {
223 return ImGui::SetWindowFontScale(scale);
224 }
225 CIMGUI_API void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond)
226 {
227 return ImGui::SetWindowPos(name,pos,cond);
228 }
229 CIMGUI_API void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond)
230 {
231 return ImGui::SetWindowSize(name,size,cond);
232 }
233 CIMGUI_API void igSetWindowCollapsedStr(const char* name,bool collapsed,ImGuiCond cond)
234 {
235 return ImGui::SetWindowCollapsed(name,collapsed,cond);
236 }
237 CIMGUI_API void igSetWindowFocusStr(const char* name)
238 {
239 return ImGui::SetWindowFocus(name);
240 }
241 CIMGUI_API void igGetContentRegionAvail(ImVec2 *pOut)
242 {
243 *pOut = ImGui::GetContentRegionAvail();
244 }
245 CIMGUI_API void igGetContentRegionMax(ImVec2 *pOut)
246 {
247 *pOut = ImGui::GetContentRegionMax();
248 }
249 CIMGUI_API void igGetWindowContentRegionMin(ImVec2 *pOut)
250 {
251 *pOut = ImGui::GetWindowContentRegionMin();
252 }
253 CIMGUI_API void igGetWindowContentRegionMax(ImVec2 *pOut)
254 {
255 *pOut = ImGui::GetWindowContentRegionMax();
256 }
257 CIMGUI_API float igGetWindowContentRegionWidth()
258 {
259 return ImGui::GetWindowContentRegionWidth();
260 }
261 CIMGUI_API float igGetScrollX()
262 {
263 return ImGui::GetScrollX();
264 }
265 CIMGUI_API float igGetScrollY()
266 {
267 return ImGui::GetScrollY();
268 }
269 CIMGUI_API void igSetScrollXFloat(float scroll_x)
270 {
271 return ImGui::SetScrollX(scroll_x);
272 }
273 CIMGUI_API void igSetScrollYFloat(float scroll_y)
274 {
275 return ImGui::SetScrollY(scroll_y);
276 }
277 CIMGUI_API float igGetScrollMaxX()
278 {
279 return ImGui::GetScrollMaxX();
280 }
281 CIMGUI_API float igGetScrollMaxY()
282 {
283 return ImGui::GetScrollMaxY();
284 }
285 CIMGUI_API void igSetScrollHereX(float center_x_ratio)
286 {
287 return ImGui::SetScrollHereX(center_x_ratio);
288 }
289 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
290 {
291 return ImGui::SetScrollHereY(center_y_ratio);
292 }
293 CIMGUI_API void igSetScrollFromPosXFloat(float local_x,float center_x_ratio)
294 {
295 return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
296 }
297 CIMGUI_API void igSetScrollFromPosYFloat(float local_y,float center_y_ratio)
298 {
299 return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
300 }
301 CIMGUI_API void igPushFont(ImFont* font)
302 {
303 return ImGui::PushFont(font);
304 }
305 CIMGUI_API void igPopFont()
306 {
307 return ImGui::PopFont();
308 }
309 CIMGUI_API void igPushStyleColorU32(ImGuiCol idx,ImU32 col)
310 {
311 return ImGui::PushStyleColor(idx,col);
312 }
313 CIMGUI_API void igPushStyleColorVec4(ImGuiCol idx,const ImVec4 col)
314 {
315 return ImGui::PushStyleColor(idx,col);
316 }
317 CIMGUI_API void igPopStyleColor(int count)
318 {
319 return ImGui::PopStyleColor(count);
320 }
321 CIMGUI_API void igPushStyleVarFloat(ImGuiStyleVar idx,float val)
322 {
323 return ImGui::PushStyleVar(idx,val);
324 }
325 CIMGUI_API void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val)
326 {
327 return ImGui::PushStyleVar(idx,val);
328 }
329 CIMGUI_API void igPopStyleVar(int count)
330 {
331 return ImGui::PopStyleVar(count);
332 }
333 CIMGUI_API void igPushAllowKeyboardFocus(bool allow_keyboard_focus)
334 {
335 return ImGui::PushAllowKeyboardFocus(allow_keyboard_focus);
336 }
337 CIMGUI_API void igPopAllowKeyboardFocus()
338 {
339 return ImGui::PopAllowKeyboardFocus();
340 }
341 CIMGUI_API void igPushButtonRepeat(bool repeat)
342 {
343 return ImGui::PushButtonRepeat(repeat);
344 }
345 CIMGUI_API void igPopButtonRepeat()
346 {
347 return ImGui::PopButtonRepeat();
348 }
349 CIMGUI_API void igPushItemWidth(float item_width)
350 {
351 return ImGui::PushItemWidth(item_width);
352 }
353 CIMGUI_API void igPopItemWidth()
354 {
355 return ImGui::PopItemWidth();
356 }
357 CIMGUI_API void igSetNextItemWidth(float item_width)
358 {
359 return ImGui::SetNextItemWidth(item_width);
360 }
361 CIMGUI_API float igCalcItemWidth()
362 {
363 return ImGui::CalcItemWidth();
364 }
365 CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x)
366 {
367 return ImGui::PushTextWrapPos(wrap_local_pos_x);
368 }
369 CIMGUI_API void igPopTextWrapPos()
370 {
371 return ImGui::PopTextWrapPos();
372 }
373 CIMGUI_API ImFont* igGetFont()
374 {
375 return ImGui::GetFont();
376 }
377 CIMGUI_API float igGetFontSize()
378 {
379 return ImGui::GetFontSize();
380 }
381 CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2 *pOut)
382 {
383 *pOut = ImGui::GetFontTexUvWhitePixel();
384 }
385 CIMGUI_API ImU32 igGetColorU32Col(ImGuiCol idx,float alpha_mul)
386 {
387 return ImGui::GetColorU32(idx,alpha_mul);
388 }
389 CIMGUI_API ImU32 igGetColorU32Vec4(const ImVec4 col)
390 {
391 return ImGui::GetColorU32(col);
392 }
393 CIMGUI_API ImU32 igGetColorU32U32(ImU32 col)
394 {
395 return ImGui::GetColorU32(col);
396 }
397 CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx)
398 {
399 return &ImGui::GetStyleColorVec4(idx);
400 }
401 CIMGUI_API void igSeparator()
402 {
403 return ImGui::Separator();
404 }
405 CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
406 {
407 return ImGui::SameLine(offset_from_start_x,spacing);
408 }
409 CIMGUI_API void igNewLine()
410 {
411 return ImGui::NewLine();
412 }
413 CIMGUI_API void igSpacing()
414 {
415 return ImGui::Spacing();
416 }
417 CIMGUI_API void igDummy(const ImVec2 size)
418 {
419 return ImGui::Dummy(size);
420 }
421 CIMGUI_API void igIndent(float indent_w)
422 {
423 return ImGui::Indent(indent_w);
424 }
425 CIMGUI_API void igUnindent(float indent_w)
426 {
427 return ImGui::Unindent(indent_w);
428 }
429 CIMGUI_API void igBeginGroup()
430 {
431 return ImGui::BeginGroup();
432 }
433 CIMGUI_API void igEndGroup()
434 {
435 return ImGui::EndGroup();
436 }
437 CIMGUI_API void igGetCursorPos(ImVec2 *pOut)
438 {
439 *pOut = ImGui::GetCursorPos();
440 }
441 CIMGUI_API float igGetCursorPosX()
442 {
443 return ImGui::GetCursorPosX();
444 }
445 CIMGUI_API float igGetCursorPosY()
446 {
447 return ImGui::GetCursorPosY();
448 }
449 CIMGUI_API void igSetCursorPos(const ImVec2 local_pos)
450 {
451 return ImGui::SetCursorPos(local_pos);
452 }
453 CIMGUI_API void igSetCursorPosX(float local_x)
454 {
455 return ImGui::SetCursorPosX(local_x);
456 }
457 CIMGUI_API void igSetCursorPosY(float local_y)
458 {
459 return ImGui::SetCursorPosY(local_y);
460 }
461 CIMGUI_API void igGetCursorStartPos(ImVec2 *pOut)
462 {
463 *pOut = ImGui::GetCursorStartPos();
464 }
465 CIMGUI_API void igGetCursorScreenPos(ImVec2 *pOut)
466 {
467 *pOut = ImGui::GetCursorScreenPos();
468 }
469 CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
470 {
471 return ImGui::SetCursorScreenPos(pos);
472 }
473 CIMGUI_API void igAlignTextToFramePadding()
474 {
475 return ImGui::AlignTextToFramePadding();
476 }
477 CIMGUI_API float igGetTextLineHeight()
478 {
479 return ImGui::GetTextLineHeight();
480 }
481 CIMGUI_API float igGetTextLineHeightWithSpacing()
482 {
483 return ImGui::GetTextLineHeightWithSpacing();
484 }
485 CIMGUI_API float igGetFrameHeight()
486 {
487 return ImGui::GetFrameHeight();
488 }
489 CIMGUI_API float igGetFrameHeightWithSpacing()
490 {
491 return ImGui::GetFrameHeightWithSpacing();
492 }
493 CIMGUI_API void igPushIDStr(const char* str_id)
494 {
495 return ImGui::PushID(str_id);
496 }
497 CIMGUI_API void igPushIDStrStr(const char* str_id_begin,const char* str_id_end)
498 {
499 return ImGui::PushID(str_id_begin,str_id_end);
500 }
501 CIMGUI_API void igPushIDPtr(const void* ptr_id)
502 {
503 return ImGui::PushID(ptr_id);
504 }
505 CIMGUI_API void igPushIDInt(int int_id)
506 {
507 return ImGui::PushID(int_id);
508 }
509 CIMGUI_API void igPopID()
510 {
511 return ImGui::PopID();
512 }
513 CIMGUI_API ImGuiID igGetIDStr(const char* str_id)
514 {
515 return ImGui::GetID(str_id);
516 }
517 CIMGUI_API ImGuiID igGetIDStrStr(const char* str_id_begin,const char* str_id_end)
518 {
519 return ImGui::GetID(str_id_begin,str_id_end);
520 }
521 CIMGUI_API ImGuiID igGetIDPtr(const void* ptr_id)
522 {
523 return ImGui::GetID(ptr_id);
524 }
525 CIMGUI_API void igTextUnformatted(const char* text,const char* text_end)
526 {
527 return ImGui::TextUnformatted(text,text_end);
528 }
529 CIMGUI_API void igText(const char* fmt,...)
530 {
531 va_list args;
532 va_start(args, fmt);
533 ImGui::TextV(fmt,args);
534 va_end(args);
535 }
536 CIMGUI_API void igTextV(const char* fmt,va_list args)
537 {
538 return ImGui::TextV(fmt,args);
539 }
540 CIMGUI_API void igTextColored(const ImVec4 col,const char* fmt,...)
541 {
542 va_list args;
543 va_start(args, fmt);
544 ImGui::TextColoredV(col,fmt,args);
545 va_end(args);
546 }
547 CIMGUI_API void igTextColoredV(const ImVec4 col,const char* fmt,va_list args)
548 {
549 return ImGui::TextColoredV(col,fmt,args);
550 }
551 CIMGUI_API void igTextDisabled(const char* fmt,...)
552 {
553 va_list args;
554 va_start(args, fmt);
555 ImGui::TextDisabledV(fmt,args);
556 va_end(args);
557 }
558 CIMGUI_API void igTextDisabledV(const char* fmt,va_list args)
559 {
560 return ImGui::TextDisabledV(fmt,args);
561 }
562 CIMGUI_API void igTextWrapped(const char* fmt,...)
563 {
564 va_list args;
565 va_start(args, fmt);
566 ImGui::TextWrappedV(fmt,args);
567 va_end(args);
568 }
569 CIMGUI_API void igTextWrappedV(const char* fmt,va_list args)
570 {
571 return ImGui::TextWrappedV(fmt,args);
572 }
573 CIMGUI_API void igLabelText(const char* label,const char* fmt,...)
574 {
575 va_list args;
576 va_start(args, fmt);
577 ImGui::LabelTextV(label,fmt,args);
578 va_end(args);
579 }
580 CIMGUI_API void igLabelTextV(const char* label,const char* fmt,va_list args)
581 {
582 return ImGui::LabelTextV(label,fmt,args);
583 }
584 CIMGUI_API void igBulletText(const char* fmt,...)
585 {
586 va_list args;
587 va_start(args, fmt);
588 ImGui::BulletTextV(fmt,args);
589 va_end(args);
590 }
591 CIMGUI_API void igBulletTextV(const char* fmt,va_list args)
592 {
593 return ImGui::BulletTextV(fmt,args);
594 }
595 CIMGUI_API bool igButton(const char* label,const ImVec2 size)
596 {
597 return ImGui::Button(label,size);
598 }
599 CIMGUI_API bool igSmallButton(const char* label)
600 {
601 return ImGui::SmallButton(label);
602 }
603 CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size,ImGuiButtonFlags flags)
604 {
605 return ImGui::InvisibleButton(str_id,size,flags);
606 }
607 CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir)
608 {
609 return ImGui::ArrowButton(str_id,dir);
610 }
611 CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)
612 {
613 return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
614 }
615 CIMGUI_API bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col)
616 {
617 return ImGui::ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col);
618 }
619 CIMGUI_API bool igCheckbox(const char* label,bool* v)
620 {
621 return ImGui::Checkbox(label,v);
622 }
623 CIMGUI_API bool igCheckboxFlagsIntPtr(const char* label,int* flags,int flags_value)
624 {
625 return ImGui::CheckboxFlags(label,flags,flags_value);
626 }
627 CIMGUI_API bool igCheckboxFlagsUintPtr(const char* label,unsigned int* flags,unsigned int flags_value)
628 {
629 return ImGui::CheckboxFlags(label,flags,flags_value);
630 }
631 CIMGUI_API bool igRadioButtonBool(const char* label,bool active)
632 {
633 return ImGui::RadioButton(label,active);
634 }
635 CIMGUI_API bool igRadioButtonIntPtr(const char* label,int* v,int v_button)
636 {
637 return ImGui::RadioButton(label,v,v_button);
638 }
639 CIMGUI_API void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay)
640 {
641 return ImGui::ProgressBar(fraction,size_arg,overlay);
642 }
643 CIMGUI_API void igBullet()
644 {
645 return ImGui::Bullet();
646 }
647 CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags)
648 {
649 return ImGui::BeginCombo(label,preview_value,flags);
650 }
651 CIMGUI_API void igEndCombo()
652 {
653 return ImGui::EndCombo();
654 }
655 CIMGUI_API bool igComboStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items)
656 {
657 return ImGui::Combo(label,current_item,items,items_count,popup_max_height_in_items);
658 }
659 CIMGUI_API bool igComboStr(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items)
660 {
661 return ImGui::Combo(label,current_item,items_separated_by_zeros,popup_max_height_in_items);
662 }
663 CIMGUI_API bool igComboFnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)
664 {
665 return ImGui::Combo(label,current_item,items_getter,data,items_count,popup_max_height_in_items);
666 }
667 CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
668 {
669 return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,flags);
670 }
671 CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
672 {
673 return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,flags);
674 }
675 CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
676 {
677 return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,flags);
678 }
679 CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
680 {
681 return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,flags);
682 }
683 CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
684 {
685 return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
686 }
687 CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
688 {
689 return ImGui::DragInt(label,v,v_speed,v_min,v_max,format,flags);
690 }
691 CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
692 {
693 return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format,flags);
694 }
695 CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
696 {
697 return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format,flags);
698 }
699 CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
700 {
701 return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format,flags);
702 }
703 CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)
704 {
705 return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags);
706 }
707 CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
708 {
709 return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,flags);
710 }
711 CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
712 {
713 return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,flags);
714 }
715 CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
716 {
717 return ImGui::SliderFloat(label,v,v_min,v_max,format,flags);
718 }
719 CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
720 {
721 return ImGui::SliderFloat2(label,v,v_min,v_max,format,flags);
722 }
723 CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
724 {
725 return ImGui::SliderFloat3(label,v,v_min,v_max,format,flags);
726 }
727 CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
728 {
729 return ImGui::SliderFloat4(label,v,v_min,v_max,format,flags);
730 }
731 CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format,ImGuiSliderFlags flags)
732 {
733 return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format,flags);
734 }
735 CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
736 {
737 return ImGui::SliderInt(label,v,v_min,v_max,format,flags);
738 }
739 CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
740 {
741 return ImGui::SliderInt2(label,v,v_min,v_max,format,flags);
742 }
743 CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
744 {
745 return ImGui::SliderInt3(label,v,v_min,v_max,format,flags);
746 }
747 CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
748 {
749 return ImGui::SliderInt4(label,v,v_min,v_max,format,flags);
750 }
751 CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
752 {
753 return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,flags);
754 }
755 CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
756 {
757 return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,flags);
758 }
759 CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)
760 {
761 return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,flags);
762 }
763 CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)
764 {
765 return ImGui::VSliderInt(label,size,v,v_min,v_max,format,flags);
766 }
767 CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)
768 {
769 return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,flags);
770 }
771 CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
772 {
773 return ImGui::InputText(label,buf,buf_size,flags,callback,user_data);
774 }
775 CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
776 {
777 return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
778 }
779 CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
780 {
781 return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
782 }
783 CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
784 {
785 return ImGui::InputFloat(label,v,step,step_fast,format,flags);
786 }
787 CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)
788 {
789 return ImGui::InputFloat2(label,v,format,flags);
790 }
791 CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)
792 {
793 return ImGui::InputFloat3(label,v,format,flags);
794 }
795 CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)
796 {
797 return ImGui::InputFloat4(label,v,format,flags);
798 }
799 CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)
800 {
801 return ImGui::InputInt(label,v,step,step_fast,flags);
802 }
803 CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags)
804 {
805 return ImGui::InputInt2(label,v,flags);
806 }
807 CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags)
808 {
809 return ImGui::InputInt3(label,v,flags);
810 }
811 CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags)
812 {
813 return ImGui::InputInt4(label,v,flags);
814 }
815 CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)
816 {
817 return ImGui::InputDouble(label,v,step,step_fast,format,flags);
818 }
819 CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
820 {
821 return ImGui::InputScalar(label,data_type,p_data,p_step,p_step_fast,format,flags);
822 }
823 CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)
824 {
825 return ImGui::InputScalarN(label,data_type,p_data,components,p_step,p_step_fast,format,flags);
826 }
827 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
828 {
829 return ImGui::ColorEdit3(label,col,flags);
830 }
831 CIMGUI_API bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags)
832 {
833 return ImGui::ColorEdit4(label,col,flags);
834 }
835 CIMGUI_API bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags)
836 {
837 return ImGui::ColorPicker3(label,col,flags);
838 }
839 CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col)
840 {
841 return ImGui::ColorPicker4(label,col,flags,ref_col);
842 }
843 CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size)
844 {
845 return ImGui::ColorButton(desc_id,col,flags,size);
846 }
847 CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags)
848 {
849 return ImGui::SetColorEditOptions(flags);
850 }
851 CIMGUI_API bool igTreeNodeStr(const char* label)
852 {
853 return ImGui::TreeNode(label);
854 }
855 CIMGUI_API bool igTreeNodeStrStr(const char* str_id,const char* fmt,...)
856 {
857 va_list args;
858 va_start(args, fmt);
859 bool ret = ImGui::TreeNodeV(str_id,fmt,args);
860 va_end(args);
861 return ret;
862 }
863 CIMGUI_API bool igTreeNodePtr(const void* ptr_id,const char* fmt,...)
864 {
865 va_list args;
866 va_start(args, fmt);
867 bool ret = ImGui::TreeNodeV(ptr_id,fmt,args);
868 va_end(args);
869 return ret;
870 }
871 CIMGUI_API bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args)
872 {
873 return ImGui::TreeNodeV(str_id,fmt,args);
874 }
875 CIMGUI_API bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args)
876 {
877 return ImGui::TreeNodeV(ptr_id,fmt,args);
878 }
879 CIMGUI_API bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags)
880 {
881 return ImGui::TreeNodeEx(label,flags);
882 }
883 CIMGUI_API bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
884 {
885 va_list args;
886 va_start(args, fmt);
887 bool ret = ImGui::TreeNodeExV(str_id,flags,fmt,args);
888 va_end(args);
889 return ret;
890 }
891 CIMGUI_API bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
892 {
893 va_list args;
894 va_start(args, fmt);
895 bool ret = ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
896 va_end(args);
897 return ret;
898 }
899 CIMGUI_API bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
900 {
901 return ImGui::TreeNodeExV(str_id,flags,fmt,args);
902 }
903 CIMGUI_API bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
904 {
905 return ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
906 }
907 CIMGUI_API void igTreePushStr(const char* str_id)
908 {
909 return ImGui::TreePush(str_id);
910 }
911 CIMGUI_API void igTreePushPtr(const void* ptr_id)
912 {
913 return ImGui::TreePush(ptr_id);
914 }
915 CIMGUI_API void igTreePop()
916 {
917 return ImGui::TreePop();
918 }
919 CIMGUI_API float igGetTreeNodeToLabelSpacing()
920 {
921 return ImGui::GetTreeNodeToLabelSpacing();
922 }
923 CIMGUI_API bool igCollapsingHeaderTreeNodeFlags(const char* label,ImGuiTreeNodeFlags flags)
924 {
925 return ImGui::CollapsingHeader(label,flags);
926 }
927 CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_visible,ImGuiTreeNodeFlags flags)
928 {
929 return ImGui::CollapsingHeader(label,p_visible,flags);
930 }
931 CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
932 {
933 return ImGui::SetNextItemOpen(is_open,cond);
934 }
935 CIMGUI_API bool igSelectableBool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
936 {
937 return ImGui::Selectable(label,selected,flags,size);
938 }
939 CIMGUI_API bool igSelectableBoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size)
940 {
941 return ImGui::Selectable(label,p_selected,flags,size);
942 }
943 CIMGUI_API bool igListBoxStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items)
944 {
945 return ImGui::ListBox(label,current_item,items,items_count,height_in_items);
946 }
947 CIMGUI_API bool igListBoxFnBoolPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)
948 {
949 return ImGui::ListBox(label,current_item,items_getter,data,items_count,height_in_items);
950 }
951 CIMGUI_API bool igListBoxHeaderVec2(const char* label,const ImVec2 size)
952 {
953 return ImGui::ListBoxHeader(label,size);
954 }
955 CIMGUI_API bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items)
956 {
957 return ImGui::ListBoxHeader(label,items_count,height_in_items);
958 }
959 CIMGUI_API void igListBoxFooter()
960 {
961 return ImGui::ListBoxFooter();
962 }
963 CIMGUI_API void igPlotLinesFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)
964 {
965 return ImGui::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
966 }
967 CIMGUI_API void igPlotLinesFnFloatPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
968 {
969 return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
970 }
971 CIMGUI_API void igPlotHistogramFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)
972 {
973 return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
974 }
975 CIMGUI_API void igPlotHistogramFnFloatPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
976 {
977 return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
978 }
979 CIMGUI_API void igValueBool(const char* prefix,bool b)
980 {
981 return ImGui::Value(prefix,b);
982 }
983 CIMGUI_API void igValueInt(const char* prefix,int v)
984 {
985 return ImGui::Value(prefix,v);
986 }
987 CIMGUI_API void igValueUint(const char* prefix,unsigned int v)
988 {
989 return ImGui::Value(prefix,v);
990 }
991 CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format)
992 {
993 return ImGui::Value(prefix,v,float_format);
994 }
995 CIMGUI_API bool igBeginMenuBar()
996 {
997 return ImGui::BeginMenuBar();
998 }
999 CIMGUI_API void igEndMenuBar()
1000 {
1001 return ImGui::EndMenuBar();
1002 }
1003 CIMGUI_API bool igBeginMainMenuBar()
1004 {
1005 return ImGui::BeginMainMenuBar();
1006 }
1007 CIMGUI_API void igEndMainMenuBar()
1008 {
1009 return ImGui::EndMainMenuBar();
1010 }
1011 CIMGUI_API bool igBeginMenu(const char* label,bool enabled)
1012 {
1013 return ImGui::BeginMenu(label,enabled);
1014 }
1015 CIMGUI_API void igEndMenu()
1016 {
1017 return ImGui::EndMenu();
1018 }
1019 CIMGUI_API bool igMenuItemBool(const char* label,const char* shortcut,bool selected,bool enabled)
1020 {
1021 return ImGui::MenuItem(label,shortcut,selected,enabled);
1022 }
1023 CIMGUI_API bool igMenuItemBoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled)
1024 {
1025 return ImGui::MenuItem(label,shortcut,p_selected,enabled);
1026 }
1027 CIMGUI_API void igBeginTooltip()
1028 {
1029 return ImGui::BeginTooltip();
1030 }
1031 CIMGUI_API void igEndTooltip()
1032 {
1033 return ImGui::EndTooltip();
1034 }
1035 CIMGUI_API void igSetTooltip(const char* fmt,...)
1036 {
1037 va_list args;
1038 va_start(args, fmt);
1039 ImGui::SetTooltipV(fmt,args);
1040 va_end(args);
1041 }
1042 CIMGUI_API void igSetTooltipV(const char* fmt,va_list args)
1043 {
1044 return ImGui::SetTooltipV(fmt,args);
1045 }
1046 CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
1047 {
1048 return ImGui::BeginPopup(str_id,flags);
1049 }
1050 CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags)
1051 {
1052 return ImGui::BeginPopupModal(name,p_open,flags);
1053 }
1054 CIMGUI_API void igEndPopup()
1055 {
1056 return ImGui::EndPopup();
1057 }
1058 CIMGUI_API void igOpenPopup(const char* str_id,ImGuiPopupFlags popup_flags)
1059 {
1060 return ImGui::OpenPopup(str_id,popup_flags);
1061 }
1062 CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags)
1063 {
1064 return ImGui::OpenPopupOnItemClick(str_id,popup_flags);
1065 }
1066 CIMGUI_API void igCloseCurrentPopup()
1067 {
1068 return ImGui::CloseCurrentPopup();
1069 }
1070 CIMGUI_API bool igBeginPopupContextItem(const char* str_id,ImGuiPopupFlags popup_flags)
1071 {
1072 return ImGui::BeginPopupContextItem(str_id,popup_flags);
1073 }
1074 CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,ImGuiPopupFlags popup_flags)
1075 {
1076 return ImGui::BeginPopupContextWindow(str_id,popup_flags);
1077 }
1078 CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiPopupFlags popup_flags)
1079 {
1080 return ImGui::BeginPopupContextVoid(str_id,popup_flags);
1081 }
1082 CIMGUI_API bool igIsPopupOpenStr(const char* str_id,ImGuiPopupFlags flags)
1083 {
1084 return ImGui::IsPopupOpen(str_id,flags);
1085 }
1086 CIMGUI_API bool igBeginTable(const char* str_id,int column,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width)
1087 {
1088 return ImGui::BeginTable(str_id,column,flags,outer_size,inner_width);
1089 }
1090 CIMGUI_API void igEndTable()
1091 {
1092 return ImGui::EndTable();
1093 }
1094 CIMGUI_API void igTableNextRow(ImGuiTableRowFlags row_flags,float min_row_height)
1095 {
1096 return ImGui::TableNextRow(row_flags,min_row_height);
1097 }
1098 CIMGUI_API bool igTableNextColumn()
1099 {
1100 return ImGui::TableNextColumn();
1101 }
1102 CIMGUI_API bool igTableSetColumnIndex(int column_n)
1103 {
1104 return ImGui::TableSetColumnIndex(column_n);
1105 }
1106 CIMGUI_API void igTableSetupColumn(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImU32 user_id)
1107 {
1108 return ImGui::TableSetupColumn(label,flags,init_width_or_weight,user_id);
1109 }
1110 CIMGUI_API void igTableSetupScrollFreeze(int cols,int rows)
1111 {
1112 return ImGui::TableSetupScrollFreeze(cols,rows);
1113 }
1114 CIMGUI_API void igTableHeadersRow()
1115 {
1116 return ImGui::TableHeadersRow();
1117 }
1118 CIMGUI_API void igTableHeader(const char* label)
1119 {
1120 return ImGui::TableHeader(label);
1121 }
1122 CIMGUI_API ImGuiTableSortSpecs* igTableGetSortSpecs()
1123 {
1124 return ImGui::TableGetSortSpecs();
1125 }
1126 CIMGUI_API int igTableGetColumnCount()
1127 {
1128 return ImGui::TableGetColumnCount();
1129 }
1130 CIMGUI_API int igTableGetColumnIndex()
1131 {
1132 return ImGui::TableGetColumnIndex();
1133 }
1134 CIMGUI_API int igTableGetRowIndex()
1135 {
1136 return ImGui::TableGetRowIndex();
1137 }
1138 CIMGUI_API const char* igTableGetColumnNameInt(int column_n)
1139 {
1140 return ImGui::TableGetColumnName(column_n);
1141 }
1142 CIMGUI_API ImGuiTableColumnFlags igTableGetColumnFlags(int column_n)
1143 {
1144 return ImGui::TableGetColumnFlags(column_n);
1145 }
1146 CIMGUI_API void igTableSetBgColor(ImGuiTableBgTarget target,ImU32 color,int column_n)
1147 {
1148 return ImGui::TableSetBgColor(target,color,column_n);
1149 }
1150 CIMGUI_API void igColumns(int count,const char* id,bool border)
1151 {
1152 return ImGui::Columns(count,id,border);
1153 }
1154 CIMGUI_API void igNextColumn()
1155 {
1156 return ImGui::NextColumn();
1157 }
1158 CIMGUI_API int igGetColumnIndex()
1159 {
1160 return ImGui::GetColumnIndex();
1161 }
1162 CIMGUI_API float igGetColumnWidth(int column_index)
1163 {
1164 return ImGui::GetColumnWidth(column_index);
1165 }
1166 CIMGUI_API void igSetColumnWidth(int column_index,float width)
1167 {
1168 return ImGui::SetColumnWidth(column_index,width);
1169 }
1170 CIMGUI_API float igGetColumnOffset(int column_index)
1171 {
1172 return ImGui::GetColumnOffset(column_index);
1173 }
1174 CIMGUI_API void igSetColumnOffset(int column_index,float offset_x)
1175 {
1176 return ImGui::SetColumnOffset(column_index,offset_x);
1177 }
1178 CIMGUI_API int igGetColumnsCount()
1179 {
1180 return ImGui::GetColumnsCount();
1181 }
1182 CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags)
1183 {
1184 return ImGui::BeginTabBar(str_id,flags);
1185 }
1186 CIMGUI_API void igEndTabBar()
1187 {
1188 return ImGui::EndTabBar();
1189 }
1190 CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags)
1191 {
1192 return ImGui::BeginTabItem(label,p_open,flags);
1193 }
1194 CIMGUI_API void igEndTabItem()
1195 {
1196 return ImGui::EndTabItem();
1197 }
1198 CIMGUI_API bool igTabItemButton(const char* label,ImGuiTabItemFlags flags)
1199 {
1200 return ImGui::TabItemButton(label,flags);
1201 }
1202 CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
1203 {
1204 return ImGui::SetTabItemClosed(tab_or_docked_window_label);
1205 }
1206 CIMGUI_API void igLogToTTY(int auto_open_depth)
1207 {
1208 return ImGui::LogToTTY(auto_open_depth);
1209 }
1210 CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
1211 {
1212 return ImGui::LogToFile(auto_open_depth,filename);
1213 }
1214 CIMGUI_API void igLogToClipboard(int auto_open_depth)
1215 {
1216 return ImGui::LogToClipboard(auto_open_depth);
1217 }
1218 CIMGUI_API void igLogFinish()
1219 {
1220 return ImGui::LogFinish();
1221 }
1222 CIMGUI_API void igLogButtons()
1223 {
1224 return ImGui::LogButtons();
1225 }
1226 CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
1227 {
1228 return ImGui::BeginDragDropSource(flags);
1229 }
1230 CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
1231 {
1232 return ImGui::SetDragDropPayload(type,data,sz,cond);
1233 }
1234 CIMGUI_API void igEndDragDropSource()
1235 {
1236 return ImGui::EndDragDropSource();
1237 }
1238 CIMGUI_API bool igBeginDragDropTarget()
1239 {
1240 return ImGui::BeginDragDropTarget();
1241 }
1242 CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags)
1243 {
1244 return ImGui::AcceptDragDropPayload(type,flags);
1245 }
1246 CIMGUI_API void igEndDragDropTarget()
1247 {
1248 return ImGui::EndDragDropTarget();
1249 }
1250 CIMGUI_API const ImGuiPayload* igGetDragDropPayload()
1251 {
1252 return ImGui::GetDragDropPayload();
1253 }
1254 CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
1255 {
1256 return ImGui::PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
1257 }
1258 CIMGUI_API void igPopClipRect()
1259 {
1260 return ImGui::PopClipRect();
1261 }
1262 CIMGUI_API void igSetItemDefaultFocus()
1263 {
1264 return ImGui::SetItemDefaultFocus();
1265 }
1266 CIMGUI_API void igSetKeyboardFocusHere(int offset)
1267 {
1268 return ImGui::SetKeyboardFocusHere(offset);
1269 }
1270 CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags)
1271 {
1272 return ImGui::IsItemHovered(flags);
1273 }
1274 CIMGUI_API bool igIsItemActive()
1275 {
1276 return ImGui::IsItemActive();
1277 }
1278 CIMGUI_API bool igIsItemFocused()
1279 {
1280 return ImGui::IsItemFocused();
1281 }
1282 CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button)
1283 {
1284 return ImGui::IsItemClicked(mouse_button);
1285 }
1286 CIMGUI_API bool igIsItemVisible()
1287 {
1288 return ImGui::IsItemVisible();
1289 }
1290 CIMGUI_API bool igIsItemEdited()
1291 {
1292 return ImGui::IsItemEdited();
1293 }
1294 CIMGUI_API bool igIsItemActivated()
1295 {
1296 return ImGui::IsItemActivated();
1297 }
1298 CIMGUI_API bool igIsItemDeactivated()
1299 {
1300 return ImGui::IsItemDeactivated();
1301 }
1302 CIMGUI_API bool igIsItemDeactivatedAfterEdit()
1303 {
1304 return ImGui::IsItemDeactivatedAfterEdit();
1305 }
1306 CIMGUI_API bool igIsItemToggledOpen()
1307 {
1308 return ImGui::IsItemToggledOpen();
1309 }
1310 CIMGUI_API bool igIsAnyItemHovered()
1311 {
1312 return ImGui::IsAnyItemHovered();
1313 }
1314 CIMGUI_API bool igIsAnyItemActive()
1315 {
1316 return ImGui::IsAnyItemActive();
1317 }
1318 CIMGUI_API bool igIsAnyItemFocused()
1319 {
1320 return ImGui::IsAnyItemFocused();
1321 }
1322 CIMGUI_API void igGetItemRectMin(ImVec2 *pOut)
1323 {
1324 *pOut = ImGui::GetItemRectMin();
1325 }
1326 CIMGUI_API void igGetItemRectMax(ImVec2 *pOut)
1327 {
1328 *pOut = ImGui::GetItemRectMax();
1329 }
1330 CIMGUI_API void igGetItemRectSize(ImVec2 *pOut)
1331 {
1332 *pOut = ImGui::GetItemRectSize();
1333 }
1334 CIMGUI_API void igSetItemAllowOverlap()
1335 {
1336 return ImGui::SetItemAllowOverlap();
1337 }
1338 CIMGUI_API bool igIsRectVisibleNil(const ImVec2 size)
1339 {
1340 return ImGui::IsRectVisible(size);
1341 }
1342 CIMGUI_API bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max)
1343 {
1344 return ImGui::IsRectVisible(rect_min,rect_max);
1345 }
1346 CIMGUI_API double igGetTime()
1347 {
1348 return ImGui::GetTime();
1349 }
1350 CIMGUI_API int igGetFrameCount()
1351 {
1352 return ImGui::GetFrameCount();
1353 }
1354 CIMGUI_API ImDrawList* igGetBackgroundDrawList()
1355 {
1356 return ImGui::GetBackgroundDrawList();
1357 }
1358 CIMGUI_API ImDrawList* igGetForegroundDrawListNil()
1359 {
1360 return ImGui::GetForegroundDrawList();
1361 }
1362 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
1363 {
1364 return ImGui::GetDrawListSharedData();
1365 }
1366 CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx)
1367 {
1368 return ImGui::GetStyleColorName(idx);
1369 }
1370 CIMGUI_API void igSetStateStorage(ImGuiStorage* storage)
1371 {
1372 return ImGui::SetStateStorage(storage);
1373 }
1374 CIMGUI_API ImGuiStorage* igGetStateStorage()
1375 {
1376 return ImGui::GetStateStorage();
1377 }
1378 CIMGUI_API void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end)
1379 {
1380 return ImGui::CalcListClipping(items_count,items_height,out_items_display_start,out_items_display_end);
1381 }
1382 CIMGUI_API bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags)
1383 {
1384 return ImGui::BeginChildFrame(id,size,flags);
1385 }
1386 CIMGUI_API void igEndChildFrame()
1387 {
1388 return ImGui::EndChildFrame();
1389 }
1390 CIMGUI_API void igCalcTextSize(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
1391 {
1392 *pOut = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
1393 }
1394 CIMGUI_API void igColorConvertU32ToFloat4(ImVec4 *pOut,ImU32 in)
1395 {
1396 *pOut = ImGui::ColorConvertU32ToFloat4(in);
1397 }
1398 CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in)
1399 {
1400 return ImGui::ColorConvertFloat4ToU32(in);
1401 }
1402 CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float* out_h,float* out_s,float* out_v)
1403 {
1404 return ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
1405 }
1406 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,float* out_g,float* out_b)
1407 {
1408 return ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
1409 }
1410 CIMGUI_API int igGetKeyIndex(ImGuiKey imgui_key)
1411 {
1412 return ImGui::GetKeyIndex(imgui_key);
1413 }
1414 CIMGUI_API bool igIsKeyDown(int user_key_index)
1415 {
1416 return ImGui::IsKeyDown(user_key_index);
1417 }
1418 CIMGUI_API bool igIsKeyPressed(int user_key_index,bool repeat)
1419 {
1420 return ImGui::IsKeyPressed(user_key_index,repeat);
1421 }
1422 CIMGUI_API bool igIsKeyReleased(int user_key_index)
1423 {
1424 return ImGui::IsKeyReleased(user_key_index);
1425 }
1426 CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate)
1427 {
1428 return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate);
1429 }
1430 CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
1431 {
1432 return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
1433 }
1434 CIMGUI_API bool igIsMouseDown(ImGuiMouseButton button)
1435 {
1436 return ImGui::IsMouseDown(button);
1437 }
1438 CIMGUI_API bool igIsMouseClicked(ImGuiMouseButton button,bool repeat)
1439 {
1440 return ImGui::IsMouseClicked(button,repeat);
1441 }
1442 CIMGUI_API bool igIsMouseReleased(ImGuiMouseButton button)
1443 {
1444 return ImGui::IsMouseReleased(button);
1445 }
1446 CIMGUI_API bool igIsMouseDoubleClicked(ImGuiMouseButton button)
1447 {
1448 return ImGui::IsMouseDoubleClicked(button);
1449 }
1450 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip)
1451 {
1452 return ImGui::IsMouseHoveringRect(r_min,r_max,clip);
1453 }
1454 CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos)
1455 {
1456 return ImGui::IsMousePosValid(mouse_pos);
1457 }
1458 CIMGUI_API bool igIsAnyMouseDown()
1459 {
1460 return ImGui::IsAnyMouseDown();
1461 }
1462 CIMGUI_API void igGetMousePos(ImVec2 *pOut)
1463 {
1464 *pOut = ImGui::GetMousePos();
1465 }
1466 CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2 *pOut)
1467 {
1468 *pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
1469 }
1470 CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold)
1471 {
1472 return ImGui::IsMouseDragging(button,lock_threshold);
1473 }
1474 CIMGUI_API void igGetMouseDragDelta(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)
1475 {
1476 *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
1477 }
1478 CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button)
1479 {
1480 return ImGui::ResetMouseDragDelta(button);
1481 }
1482 CIMGUI_API ImGuiMouseCursor igGetMouseCursor()
1483 {
1484 return ImGui::GetMouseCursor();
1485 }
1486 CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type)
1487 {
1488 return ImGui::SetMouseCursor(cursor_type);
1489 }
1490 CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
1491 {
1492 return ImGui::CaptureMouseFromApp(want_capture_mouse_value);
1493 }
1494 CIMGUI_API const char* igGetClipboardText()
1495 {
1496 return ImGui::GetClipboardText();
1497 }
1498 CIMGUI_API void igSetClipboardText(const char* text)
1499 {
1500 return ImGui::SetClipboardText(text);
1501 }
1502 CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename)
1503 {
1504 return ImGui::LoadIniSettingsFromDisk(ini_filename);
1505 }
1506 CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size)
1507 {
1508 return ImGui::LoadIniSettingsFromMemory(ini_data,ini_size);
1509 }
1510 CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename)
1511 {
1512 return ImGui::SaveIniSettingsToDisk(ini_filename);
1513 }
1514 CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size)
1515 {
1516 return ImGui::SaveIniSettingsToMemory(out_ini_size);
1517 }
1518 CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)
1519 {
1520 return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
1521 }
1522 CIMGUI_API void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)
1523 {
1524 return ImGui::SetAllocatorFunctions(alloc_func,free_func,user_data);
1525 }
1526 CIMGUI_API void* igMemAlloc(size_t size)
1527 {
1528 return ImGui::MemAlloc(size);
1529 }
1530 CIMGUI_API void igMemFree(void* ptr)
1531 {
1532 return ImGui::MemFree(ptr);
1533 }
1534 CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void)
1535 {
1536 return IM_NEW(ImGuiStyle)();
1537 }
1538 CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self)
1539 {
1540 IM_DELETE(self);
1541 }
1542 CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
1543 {
1544 return self->ScaleAllSizes(scale_factor);
1545 }
1546 CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
1547 {
1548 return self->AddInputCharacter(c);
1549 }
1550 CIMGUI_API void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self,ImWchar16 c)
1551 {
1552 return self->AddInputCharacterUTF16(c);
1553 }
1554 CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
1555 {
1556 return self->AddInputCharactersUTF8(str);
1557 }
1558 CIMGUI_API void ImGuiIO_ClearInputCharacters(ImGuiIO* self)
1559 {
1560 return self->ClearInputCharacters();
1561 }
1562 CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void)
1563 {
1564 return IM_NEW(ImGuiIO)();
1565 }
1566 CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self)
1567 {
1568 IM_DELETE(self);
1569 }
1570 CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
1571 {
1572 return IM_NEW(ImGuiInputTextCallbackData)();
1573 }
1574 CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
1575 {
1576 IM_DELETE(self);
1577 }
1578 CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
1579 {
1580 return self->DeleteChars(pos,bytes_count);
1581 }
1582 CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
1583 {
1584 return self->InsertChars(pos,text,text_end);
1585 }
1586 CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self)
1587 {
1588 return self->SelectAll();
1589 }
1590 CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self)
1591 {
1592 return self->ClearSelection();
1593 }
1594 CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
1595 {
1596 return self->HasSelection();
1597 }
1598 CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
1599 {
1600 return IM_NEW(ImGuiPayload)();
1601 }
1602 CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
1603 {
1604 IM_DELETE(self);
1605 }
1606 CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
1607 {
1608 return self->Clear();
1609 }
1610 CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
1611 {
1612 return self->IsDataType(type);
1613 }
1614 CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
1615 {
1616 return self->IsPreview();
1617 }
1618 CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
1619 {
1620 return self->IsDelivery();
1621 }
1622 CIMGUI_API ImGuiTableColumnSortSpecs* ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs(void)
1623 {
1624 return IM_NEW(ImGuiTableColumnSortSpecs)();
1625 }
1626 CIMGUI_API void ImGuiTableColumnSortSpecs_destroy(ImGuiTableColumnSortSpecs* self)
1627 {
1628 IM_DELETE(self);
1629 }
1630 CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void)
1631 {
1632 return IM_NEW(ImGuiTableSortSpecs)();
1633 }
1634 CIMGUI_API void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self)
1635 {
1636 IM_DELETE(self);
1637 }
1638 CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void)
1639 {
1640 return IM_NEW(ImGuiOnceUponAFrame)();
1641 }
1642 CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self)
1643 {
1644 IM_DELETE(self);
1645 }
1646 CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter)
1647 {
1648 return IM_NEW(ImGuiTextFilter)(default_filter);
1649 }
1650 CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self)
1651 {
1652 IM_DELETE(self);
1653 }
1654 CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width)
1655 {
1656 return self->Draw(label,width);
1657 }
1658 CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end)
1659 {
1660 return self->PassFilter(text,text_end);
1661 }
1662 CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self)
1663 {
1664 return self->Build();
1665 }
1666 CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self)
1667 {
1668 return self->Clear();
1669 }
1670 CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
1671 {
1672 return self->IsActive();
1673 }
1674 CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeNil(void)
1675 {
1676 return IM_NEW(ImGuiTextRange)();
1677 }
1678 CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
1679 {
1680 IM_DELETE(self);
1681 }
1682 CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
1683 {
1684 return IM_NEW(ImGuiTextRange)(_b,_e);
1685 }
1686 CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
1687 {
1688 return self->empty();
1689 }
1690 CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
1691 {
1692 return self->split(separator,out);
1693 }
1694 CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void)
1695 {
1696 return IM_NEW(ImGuiTextBuffer)();
1697 }
1698 CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self)
1699 {
1700 IM_DELETE(self);
1701 }
1702 CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self)
1703 {
1704 return self->begin();
1705 }
1706 CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self)
1707 {
1708 return self->end();
1709 }
1710 CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self)
1711 {
1712 return self->size();
1713 }
1714 CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self)
1715 {
1716 return self->empty();
1717 }
1718 CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self)
1719 {
1720 return self->clear();
1721 }
1722 CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity)
1723 {
1724 return self->reserve(capacity);
1725 }
1726 CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
1727 {
1728 return self->c_str();
1729 }
1730 CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
1731 {
1732 return self->append(str,str_end);
1733 }
1734 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
1735 {
1736 return self->appendfv(fmt,args);
1737 }
1738 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
1739 {
1740 return IM_NEW(ImGuiStoragePair)(_key,_val_i);
1741 }
1742 CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
1743 {
1744 IM_DELETE(self);
1745 }
1746 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
1747 {
1748 return IM_NEW(ImGuiStoragePair)(_key,_val_f);
1749 }
1750 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
1751 {
1752 return IM_NEW(ImGuiStoragePair)(_key,_val_p);
1753 }
1754 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
1755 {
1756 return self->Clear();
1757 }
1758 CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val)
1759 {
1760 return self->GetInt(key,default_val);
1761 }
1762 CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val)
1763 {
1764 return self->SetInt(key,val);
1765 }
1766 CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key,bool default_val)
1767 {
1768 return self->GetBool(key,default_val);
1769 }
1770 CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key,bool val)
1771 {
1772 return self->SetBool(key,val);
1773 }
1774 CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val)
1775 {
1776 return self->GetFloat(key,default_val);
1777 }
1778 CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val)
1779 {
1780 return self->SetFloat(key,val);
1781 }
1782 CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key)
1783 {
1784 return self->GetVoidPtr(key);
1785 }
1786 CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val)
1787 {
1788 return self->SetVoidPtr(key,val);
1789 }
1790 CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val)
1791 {
1792 return self->GetIntRef(key,default_val);
1793 }
1794 CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key,bool default_val)
1795 {
1796 return self->GetBoolRef(key,default_val);
1797 }
1798 CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val)
1799 {
1800 return self->GetFloatRef(key,default_val);
1801 }
1802 CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val)
1803 {
1804 return self->GetVoidPtrRef(key,default_val);
1805 }
1806 CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val)
1807 {
1808 return self->SetAllInt(val);
1809 }
1810 CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
1811 {
1812 return self->BuildSortByKey();
1813 }
1814 CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void)
1815 {
1816 return IM_NEW(ImGuiListClipper)();
1817 }
1818 CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
1819 {
1820 IM_DELETE(self);
1821 }
1822 CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
1823 {
1824 return self->Begin(items_count,items_height);
1825 }
1826 CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
1827 {
1828 return self->End();
1829 }
1830 CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
1831 {
1832 return self->Step();
1833 }
1834 CIMGUI_API ImColor* ImColor_ImColorNil(void)
1835 {
1836 return IM_NEW(ImColor)();
1837 }
1838 CIMGUI_API void ImColor_destroy(ImColor* self)
1839 {
1840 IM_DELETE(self);
1841 }
1842 CIMGUI_API ImColor* ImColor_ImColorInt(int r,int g,int b,int a)
1843 {
1844 return IM_NEW(ImColor)(r,g,b,a);
1845 }
1846 CIMGUI_API ImColor* ImColor_ImColorU32(ImU32 rgba)
1847 {
1848 return IM_NEW(ImColor)(rgba);
1849 }
1850 CIMGUI_API ImColor* ImColor_ImColorFloat(float r,float g,float b,float a)
1851 {
1852 return IM_NEW(ImColor)(r,g,b,a);
1853 }
1854 CIMGUI_API ImColor* ImColor_ImColorVec4(const ImVec4 col)
1855 {
1856 return IM_NEW(ImColor)(col);
1857 }
1858 CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
1859 {
1860 return self->SetHSV(h,s,v,a);
1861 }
1862 CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a)
1863 {
1864 *pOut = ImColor::HSV(h,s,v,a);
1865 }
1866 CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
1867 {
1868 return IM_NEW(ImDrawCmd)();
1869 }
1870 CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
1871 {
1872 IM_DELETE(self);
1873 }
1874 CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
1875 {
1876 return IM_NEW(ImDrawListSplitter)();
1877 }
1878 CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
1879 {
1880 IM_DELETE(self);
1881 }
1882 CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
1883 {
1884 return self->Clear();
1885 }
1886 CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
1887 {
1888 return self->ClearFreeMemory();
1889 }
1890 CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
1891 {
1892 return self->Split(draw_list,count);
1893 }
1894 CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
1895 {
1896 return self->Merge(draw_list);
1897 }
1898 CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
1899 {
1900 return self->SetCurrentChannel(draw_list,channel_idx);
1901 }
1902 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
1903 {
1904 return IM_NEW(ImDrawList)(shared_data);
1905 }
1906 CIMGUI_API void ImDrawList_destroy(ImDrawList* self)
1907 {
1908 IM_DELETE(self);
1909 }
1910 CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
1911 {
1912 return self->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
1913 }
1914 CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self)
1915 {
1916 return self->PushClipRectFullScreen();
1917 }
1918 CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self)
1919 {
1920 return self->PopClipRect();
1921 }
1922 CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id)
1923 {
1924 return self->PushTextureID(texture_id);
1925 }
1926 CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self)
1927 {
1928 return self->PopTextureID();
1929 }
1930 CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2 *pOut,ImDrawList* self)
1931 {
1932 *pOut = self->GetClipRectMin();
1933 }
1934 CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2 *pOut,ImDrawList* self)
1935 {
1936 *pOut = self->GetClipRectMax();
1937 }
1938 CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
1939 {
1940 return self->AddLine(p1,p2,col,thickness);
1941 }
1942 CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
1943 {
1944 return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
1945 }
1946 CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
1947 {
1948 return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
1949 }
1950 CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)
1951 {
1952 return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
1953 }
1954 CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
1955 {
1956 return self->AddQuad(p1,p2,p3,p4,col,thickness);
1957 }
1958 CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
1959 {
1960 return self->AddQuadFilled(p1,p2,p3,p4,col);
1961 }
1962 CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
1963 {
1964 return self->AddTriangle(p1,p2,p3,col,thickness);
1965 }
1966 CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
1967 {
1968 return self->AddTriangleFilled(p1,p2,p3,col);
1969 }
1970 CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
1971 {
1972 return self->AddCircle(center,radius,col,num_segments,thickness);
1973 }
1974 CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
1975 {
1976 return self->AddCircleFilled(center,radius,col,num_segments);
1977 }
1978 CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
1979 {
1980 return self->AddNgon(center,radius,col,num_segments,thickness);
1981 }
1982 CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
1983 {
1984 return self->AddNgonFilled(center,radius,col,num_segments);
1985 }
1986 CIMGUI_API void ImDrawList_AddTextVec2(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
1987 {
1988 return self->AddText(pos,col,text_begin,text_end);
1989 }
1990 CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)
1991 {
1992 return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
1993 }
1994 CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
1995 {
1996 return self->AddPolyline(points,num_points,col,closed,thickness);
1997 }
1998 CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
1999 {
2000 return self->AddConvexPolyFilled(points,num_points,col);
2001 }
2002 CIMGUI_API void ImDrawList_AddBezierCubic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments)
2003 {
2004 return self->AddBezierCubic(p1,p2,p3,p4,col,thickness,num_segments);
2005 }
2006 CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness,int num_segments)
2007 {
2008 return self->AddBezierQuadratic(p1,p2,p3,col,thickness,num_segments);
2009 }
2010 CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)
2011 {
2012 return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
2013 }
2014 CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)
2015 {
2016 return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
2017 }
2018 CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
2019 {
2020 return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
2021 }
2022 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
2023 {
2024 return self->PathClear();
2025 }
2026 CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos)
2027 {
2028 return self->PathLineTo(pos);
2029 }
2030 CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos)
2031 {
2032 return self->PathLineToMergeDuplicate(pos);
2033 }
2034 CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col)
2035 {
2036 return self->PathFillConvex(col);
2037 }
2038 CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,float thickness)
2039 {
2040 return self->PathStroke(col,closed,thickness);
2041 }
2042 CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
2043 {
2044 return self->PathArcTo(center,radius,a_min,a_max,num_segments);
2045 }
2046 CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
2047 {
2048 return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
2049 }
2050 CIMGUI_API void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments)
2051 {
2052 return self->PathBezierCubicCurveTo(p2,p3,p4,num_segments);
2053 }
2054 CIMGUI_API void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,int num_segments)
2055 {
2056 return self->PathBezierQuadraticCurveTo(p2,p3,num_segments);
2057 }
2058 CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
2059 {
2060 return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
2061 }
2062 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
2063 {
2064 return self->AddCallback(callback,callback_data);
2065 }
2066 CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self)
2067 {
2068 return self->AddDrawCmd();
2069 }
2070 CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
2071 {
2072 return self->CloneOutput();
2073 }
2074 CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
2075 {
2076 return self->ChannelsSplit(count);
2077 }
2078 CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
2079 {
2080 return self->ChannelsMerge();
2081 }
2082 CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
2083 {
2084 return self->ChannelsSetCurrent(n);
2085 }
2086 CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count)
2087 {
2088 return self->PrimReserve(idx_count,vtx_count);
2089 }
2090 CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,int idx_count,int vtx_count)
2091 {
2092 return self->PrimUnreserve(idx_count,vtx_count);
2093 }
2094 CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)
2095 {
2096 return self->PrimRect(a,b,col);
2097 }
2098 CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
2099 {
2100 return self->PrimRectUV(a,b,uv_a,uv_b,col);
2101 }
2102 CIMGUI_API void ImDrawList_PrimQuadUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)
2103 {
2104 return self->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
2105 }
2106 CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2107 {
2108 return self->PrimWriteVtx(pos,uv,col);
2109 }
2110 CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx)
2111 {
2112 return self->PrimWriteIdx(idx);
2113 }
2114 CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2115 {
2116 return self->PrimVtx(pos,uv,col);
2117 }
2118 CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self)
2119 {
2120 return self->_ResetForNewFrame();
2121 }
2122 CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self)
2123 {
2124 return self->_ClearFreeMemory();
2125 }
2126 CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self)
2127 {
2128 return self->_PopUnusedDrawCmd();
2129 }
2130 CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self)
2131 {
2132 return self->_OnChangedClipRect();
2133 }
2134 CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self)
2135 {
2136 return self->_OnChangedTextureID();
2137 }
2138 CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self)
2139 {
2140 return self->_OnChangedVtxOffset();
2141 }
2142 CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void)
2143 {
2144 return IM_NEW(ImDrawData)();
2145 }
2146 CIMGUI_API void ImDrawData_destroy(ImDrawData* self)
2147 {
2148 IM_DELETE(self);
2149 }
2150 CIMGUI_API void ImDrawData_Clear(ImDrawData* self)
2151 {
2152 return self->Clear();
2153 }
2154 CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
2155 {
2156 return self->DeIndexAllBuffers();
2157 }
2158 CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
2159 {
2160 return self->ScaleClipRects(fb_scale);
2161 }
2162 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
2163 {
2164 return IM_NEW(ImFontConfig)();
2165 }
2166 CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self)
2167 {
2168 IM_DELETE(self);
2169 }
2170 CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void)
2171 {
2172 return IM_NEW(ImFontGlyphRangesBuilder)();
2173 }
2174 CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
2175 {
2176 IM_DELETE(self);
2177 }
2178 CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
2179 {
2180 return self->Clear();
2181 }
2182 CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,size_t n)
2183 {
2184 return self->GetBit(n);
2185 }
2186 CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,size_t n)
2187 {
2188 return self->SetBit(n);
2189 }
2190 CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c)
2191 {
2192 return self->AddChar(c);
2193 }
2194 CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)
2195 {
2196 return self->AddText(text,text_end);
2197 }
2198 CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)
2199 {
2200 return self->AddRanges(ranges);
2201 }
2202 CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
2203 {
2204 return self->BuildRanges(out_ranges);
2205 }
2206 CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
2207 {
2208 return IM_NEW(ImFontAtlasCustomRect)();
2209 }
2210 CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
2211 {
2212 IM_DELETE(self);
2213 }
2214 CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
2215 {
2216 return self->IsPacked();
2217 }
2218 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
2219 {
2220 return IM_NEW(ImFontAtlas)();
2221 }
2222 CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self)
2223 {
2224 IM_DELETE(self);
2225 }
2226 CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg)
2227 {
2228 return self->AddFont(font_cfg);
2229 }
2230 CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg)
2231 {
2232 return self->AddFontDefault(font_cfg);
2233 }
2234 CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2235 {
2236 return self->AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges);
2237 }
2238 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2239 {
2240 return self->AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges);
2241 }
2242 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2243 {
2244 return self->AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges);
2245 }
2246 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2247 {
2248 return self->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges);
2249 }
2250 CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
2251 {
2252 return self->ClearInputData();
2253 }
2254 CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
2255 {
2256 return self->ClearTexData();
2257 }
2258 CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self)
2259 {
2260 return self->ClearFonts();
2261 }
2262 CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
2263 {
2264 return self->Clear();
2265 }
2266 CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self)
2267 {
2268 return self->Build();
2269 }
2270 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2271 {
2272 return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel);
2273 }
2274 CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2275 {
2276 return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel);
2277 }
2278 CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
2279 {
2280 return self->IsBuilt();
2281 }
2282 CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id)
2283 {
2284 return self->SetTexID(id);
2285 }
2286 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self)
2287 {
2288 return self->GetGlyphRangesDefault();
2289 }
2290 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self)
2291 {
2292 return self->GetGlyphRangesKorean();
2293 }
2294 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self)
2295 {
2296 return self->GetGlyphRangesJapanese();
2297 }
2298 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self)
2299 {
2300 return self->GetGlyphRangesChineseFull();
2301 }
2302 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self)
2303 {
2304 return self->GetGlyphRangesChineseSimplifiedCommon();
2305 }
2306 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self)
2307 {
2308 return self->GetGlyphRangesCyrillic();
2309 }
2310 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
2311 {
2312 return self->GetGlyphRangesThai();
2313 }
2314 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
2315 {
2316 return self->GetGlyphRangesVietnamese();
2317 }
2318 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,int width,int height)
2319 {
2320 return self->AddCustomRectRegular(width,height);
2321 }
2322 CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)
2323 {
2324 return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
2325 }
2326 CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
2327 {
2328 return self->GetCustomRectByIndex(index);
2329 }
2330 CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
2331 {
2332 return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
2333 }
2334 CIMGUI_API bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])
2335 {
2336 return self->GetMouseCursorTexData(cursor,out_offset,out_size,out_uv_border,out_uv_fill);
2337 }
2338 CIMGUI_API ImFont* ImFont_ImFont(void)
2339 {
2340 return IM_NEW(ImFont)();
2341 }
2342 CIMGUI_API void ImFont_destroy(ImFont* self)
2343 {
2344 IM_DELETE(self);
2345 }
2346 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
2347 {
2348 return self->FindGlyph(c);
2349 }
2350 CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
2351 {
2352 return self->FindGlyphNoFallback(c);
2353 }
2354 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
2355 {
2356 return self->GetCharAdvance(c);
2357 }
2358 CIMGUI_API bool ImFont_IsLoaded(ImFont* self)
2359 {
2360 return self->IsLoaded();
2361 }
2362 CIMGUI_API const char* ImFont_GetDebugName(ImFont* self)
2363 {
2364 return self->GetDebugName();
2365 }
2366 CIMGUI_API void ImFont_CalcTextSizeA(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)
2367 {
2368 *pOut = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining);
2369 }
2370 CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width)
2371 {
2372 return self->CalcWordWrapPositionA(scale,text,text_end,wrap_width);
2373 }
2374 CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c)
2375 {
2376 return self->RenderChar(draw_list,size,pos,col,c);
2377 }
2378 CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)
2379 {
2380 return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
2381 }
2382 CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
2383 {
2384 return self->BuildLookupTable();
2385 }
2386 CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
2387 {
2388 return self->ClearOutputData();
2389 }
2390 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
2391 {
2392 return self->GrowIndex(new_size);
2393 }
2394 CIMGUI_API void ImFont_AddGlyph(ImFont* self,const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)
2395 {
2396 return self->AddGlyph(src_cfg,c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x);
2397 }
2398 CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)
2399 {
2400 return self->AddRemapChar(dst,src,overwrite_dst);
2401 }
2402 CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self,ImWchar c,bool visible)
2403 {
2404 return self->SetGlyphVisible(c,visible);
2405 }
2406 CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
2407 {
2408 return self->SetFallbackChar(c);
2409 }
2410 CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,unsigned int c_begin,unsigned int c_last)
2411 {
2412 return self->IsGlyphRangeUnused(c_begin,c_last);
2413 }
2414 CIMGUI_API ImGuiID igImHashData(const void* data,size_t data_size,ImU32 seed)
2415 {
2416 return ImHashData(data,data_size,seed);
2417 }
2418 CIMGUI_API ImGuiID igImHashStr(const char* data,size_t data_size,ImU32 seed)
2419 {
2420 return ImHashStr(data,data_size,seed);
2421 }
2422 CIMGUI_API ImU32 igImAlphaBlendColors(ImU32 col_a,ImU32 col_b)
2423 {
2424 return ImAlphaBlendColors(col_a,col_b);
2425 }
2426 CIMGUI_API bool igImIsPowerOfTwoInt(int v)
2427 {
2428 return ImIsPowerOfTwo(v);
2429 }
2430 CIMGUI_API bool igImIsPowerOfTwoU64(ImU64 v)
2431 {
2432 return ImIsPowerOfTwo(v);
2433 }
2434 CIMGUI_API int igImUpperPowerOfTwo(int v)
2435 {
2436 return ImUpperPowerOfTwo(v);
2437 }
2438 CIMGUI_API int igImStricmp(const char* str1,const char* str2)
2439 {
2440 return ImStricmp(str1,str2);
2441 }
2442 CIMGUI_API int igImStrnicmp(const char* str1,const char* str2,size_t count)
2443 {
2444 return ImStrnicmp(str1,str2,count);
2445 }
2446 CIMGUI_API void igImStrncpy(char* dst,const char* src,size_t count)
2447 {
2448 return ImStrncpy(dst,src,count);
2449 }
2450 CIMGUI_API char* igImStrdup(const char* str)
2451 {
2452 return ImStrdup(str);
2453 }
2454 CIMGUI_API char* igImStrdupcpy(char* dst,size_t* p_dst_size,const char* str)
2455 {
2456 return ImStrdupcpy(dst,p_dst_size,str);
2457 }
2458 CIMGUI_API const char* igImStrchrRange(const char* str_begin,const char* str_end,char c)
2459 {
2460 return ImStrchrRange(str_begin,str_end,c);
2461 }
2462 CIMGUI_API int igImStrlenW(const ImWchar* str)
2463 {
2464 return ImStrlenW(str);
2465 }
2466 CIMGUI_API const char* igImStreolRange(const char* str,const char* str_end)
2467 {
2468 return ImStreolRange(str,str_end);
2469 }
2470 CIMGUI_API const ImWchar* igImStrbolW(const ImWchar* buf_mid_line,const ImWchar* buf_begin)
2471 {
2472 return ImStrbolW(buf_mid_line,buf_begin);
2473 }
2474 CIMGUI_API const char* igImStristr(const char* haystack,const char* haystack_end,const char* needle,const char* needle_end)
2475 {
2476 return ImStristr(haystack,haystack_end,needle,needle_end);
2477 }
2478 CIMGUI_API void igImStrTrimBlanks(char* str)
2479 {
2480 return ImStrTrimBlanks(str);
2481 }
2482 CIMGUI_API const char* igImStrSkipBlank(const char* str)
2483 {
2484 return ImStrSkipBlank(str);
2485 }
2486 CIMGUI_API int igImFormatString(char* buf,size_t buf_size,const char* fmt,...)
2487 {
2488 va_list args;
2489 va_start(args, fmt);
2490 int ret = ImFormatStringV(buf,buf_size,fmt,args);
2491 va_end(args);
2492 return ret;
2493 }
2494 CIMGUI_API int igImFormatStringV(char* buf,size_t buf_size,const char* fmt,va_list args)
2495 {
2496 return ImFormatStringV(buf,buf_size,fmt,args);
2497 }
2498 CIMGUI_API const char* igImParseFormatFindStart(const char* format)
2499 {
2500 return ImParseFormatFindStart(format);
2501 }
2502 CIMGUI_API const char* igImParseFormatFindEnd(const char* format)
2503 {
2504 return ImParseFormatFindEnd(format);
2505 }
2506 CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,char* buf,size_t buf_size)
2507 {
2508 return ImParseFormatTrimDecorations(format,buf,buf_size);
2509 }
2510 CIMGUI_API int igImParseFormatPrecision(const char* format,int default_value)
2511 {
2512 return ImParseFormatPrecision(format,default_value);
2513 }
2514 CIMGUI_API bool igImCharIsBlankA(char c)
2515 {
2516 return ImCharIsBlankA(c);
2517 }
2518 CIMGUI_API bool igImCharIsBlankW(unsigned int c)
2519 {
2520 return ImCharIsBlankW(c);
2521 }
2522 CIMGUI_API int igImTextStrToUtf8(char* buf,int buf_size,const ImWchar* in_text,const ImWchar* in_text_end)
2523 {
2524 return ImTextStrToUtf8(buf,buf_size,in_text,in_text_end);
2525 }
2526 CIMGUI_API int igImTextCharFromUtf8(unsigned int* out_char,const char* in_text,const char* in_text_end)
2527 {
2528 return ImTextCharFromUtf8(out_char,in_text,in_text_end);
2529 }
2530 CIMGUI_API int igImTextStrFromUtf8(ImWchar* buf,int buf_size,const char* in_text,const char* in_text_end,const char** in_remaining)
2531 {
2532 return ImTextStrFromUtf8(buf,buf_size,in_text,in_text_end,in_remaining);
2533 }
2534 CIMGUI_API int igImTextCountCharsFromUtf8(const char* in_text,const char* in_text_end)
2535 {
2536 return ImTextCountCharsFromUtf8(in_text,in_text_end);
2537 }
2538 CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,const char* in_text_end)
2539 {
2540 return ImTextCountUtf8BytesFromChar(in_text,in_text_end);
2541 }
2542 CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,const ImWchar* in_text_end)
2543 {
2544 return ImTextCountUtf8BytesFromStr(in_text,in_text_end);
2545 }
2546 CIMGUI_API ImFileHandle igImFileOpen(const char* filename,const char* mode)
2547 {
2548 return ImFileOpen(filename,mode);
2549 }
2550 CIMGUI_API bool igImFileClose(ImFileHandle file)
2551 {
2552 return ImFileClose(file);
2553 }
2554 CIMGUI_API ImU64 igImFileGetSize(ImFileHandle file)
2555 {
2556 return ImFileGetSize(file);
2557 }
2558 CIMGUI_API ImU64 igImFileRead(void* data,ImU64 size,ImU64 count,ImFileHandle file)
2559 {
2560 return ImFileRead(data,size,count,file);
2561 }
2562 CIMGUI_API ImU64 igImFileWrite(const void* data,ImU64 size,ImU64 count,ImFileHandle file)
2563 {
2564 return ImFileWrite(data,size,count,file);
2565 }
2566 CIMGUI_API void* igImFileLoadToMemory(const char* filename,const char* mode,size_t* out_file_size,int padding_bytes)
2567 {
2568 return ImFileLoadToMemory(filename,mode,out_file_size,padding_bytes);
2569 }
2570 CIMGUI_API float igImPowFloat(float x,float y)
2571 {
2572 return ImPow(x,y);
2573 }
2574 CIMGUI_API double igImPowdouble(double x,double y)
2575 {
2576 return ImPow(x,y);
2577 }
2578 CIMGUI_API float igImLogFloat(float x)
2579 {
2580 return ImLog(x);
2581 }
2582 CIMGUI_API double igImLogdouble(double x)
2583 {
2584 return ImLog(x);
2585 }
2586 CIMGUI_API float igImAbsFloat(float x)
2587 {
2588 return ImAbs(x);
2589 }
2590 CIMGUI_API double igImAbsdouble(double x)
2591 {
2592 return ImAbs(x);
2593 }
2594 CIMGUI_API float igImSignFloat(float x)
2595 {
2596 return ImSign(x);
2597 }
2598 CIMGUI_API double igImSigndouble(double x)
2599 {
2600 return ImSign(x);
2601 }
2602 CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2603 {
2604 *pOut = ImMin(lhs,rhs);
2605 }
2606 CIMGUI_API void igImMax(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2607 {
2608 *pOut = ImMax(lhs,rhs);
2609 }
2610 CIMGUI_API void igImClamp(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,ImVec2 mx)
2611 {
2612 *pOut = ImClamp(v,mn,mx);
2613 }
2614 CIMGUI_API void igImLerpVec2Float(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t)
2615 {
2616 *pOut = ImLerp(a,b,t);
2617 }
2618 CIMGUI_API void igImLerpVec2Vec2(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t)
2619 {
2620 *pOut = ImLerp(a,b,t);
2621 }
2622 CIMGUI_API void igImLerpVec4(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t)
2623 {
2624 *pOut = ImLerp(a,b,t);
2625 }
2626 CIMGUI_API float igImSaturate(float f)
2627 {
2628 return ImSaturate(f);
2629 }
2630 CIMGUI_API float igImLengthSqrVec2(const ImVec2 lhs)
2631 {
2632 return ImLengthSqr(lhs);
2633 }
2634 CIMGUI_API float igImLengthSqrVec4(const ImVec4 lhs)
2635 {
2636 return ImLengthSqr(lhs);
2637 }
2638 CIMGUI_API float igImInvLength(const ImVec2 lhs,float fail_value)
2639 {
2640 return ImInvLength(lhs,fail_value);
2641 }
2642 CIMGUI_API float igImFloorFloat(float f)
2643 {
2644 return ImFloor(f);
2645 }
2646 CIMGUI_API void igImFloorVec2(ImVec2 *pOut,const ImVec2 v)
2647 {
2648 *pOut = ImFloor(v);
2649 }
2650 CIMGUI_API int igImModPositive(int a,int b)
2651 {
2652 return ImModPositive(a,b);
2653 }
2654 CIMGUI_API float igImDot(const ImVec2 a,const ImVec2 b)
2655 {
2656 return ImDot(a,b);
2657 }
2658 CIMGUI_API void igImRotate(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a)
2659 {
2660 *pOut = ImRotate(v,cos_a,sin_a);
2661 }
2662 CIMGUI_API float igImLinearSweep(float current,float target,float speed)
2663 {
2664 return ImLinearSweep(current,target,speed);
2665 }
2666 CIMGUI_API void igImMul(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
2667 {
2668 *pOut = ImMul(lhs,rhs);
2669 }
2670 CIMGUI_API void igImBezierCubicCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t)
2671 {
2672 *pOut = ImBezierCubicCalc(p1,p2,p3,p4,t);
2673 }
2674 CIMGUI_API void igImBezierCubicClosestPoint(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments)
2675 {
2676 *pOut = ImBezierCubicClosestPoint(p1,p2,p3,p4,p,num_segments);
2677 }
2678 CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol)
2679 {
2680 *pOut = ImBezierCubicClosestPointCasteljau(p1,p2,p3,p4,p,tess_tol);
2681 }
2682 CIMGUI_API void igImBezierQuadraticCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t)
2683 {
2684 *pOut = ImBezierQuadraticCalc(p1,p2,p3,t);
2685 }
2686 CIMGUI_API void igImLineClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p)
2687 {
2688 *pOut = ImLineClosestPoint(a,b,p);
2689 }
2690 CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
2691 {
2692 return ImTriangleContainsPoint(a,b,c,p);
2693 }
2694 CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
2695 {
2696 *pOut = ImTriangleClosestPoint(a,b,c,p);
2697 }
2698 CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w)
2699 {
2700 return ImTriangleBarycentricCoords(a,b,c,p,*out_u,*out_v,*out_w);
2701 }
2702 CIMGUI_API float igImTriangleArea(const ImVec2 a,const ImVec2 b,const ImVec2 c)
2703 {
2704 return ImTriangleArea(a,b,c);
2705 }
2706 CIMGUI_API ImGuiDir igImGetDirQuadrantFromDelta(float dx,float dy)
2707 {
2708 return ImGetDirQuadrantFromDelta(dx,dy);
2709 }
2710 CIMGUI_API ImVec1* ImVec1_ImVec1Nil(void)
2711 {
2712 return IM_NEW(ImVec1)();
2713 }
2714 CIMGUI_API void ImVec1_destroy(ImVec1* self)
2715 {
2716 IM_DELETE(self);
2717 }
2718 CIMGUI_API ImVec1* ImVec1_ImVec1Float(float _x)
2719 {
2720 return IM_NEW(ImVec1)(_x);
2721 }
2722 CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ihNil(void)
2723 {
2724 return IM_NEW(ImVec2ih)();
2725 }
2726 CIMGUI_API void ImVec2ih_destroy(ImVec2ih* self)
2727 {
2728 IM_DELETE(self);
2729 }
2730 CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ihshort(short _x,short _y)