git.s-ol.nu zig-imgui / 10af763
add cimgui in the repo s-ol 29 days ago
8 changed file(s) with 4422 addition(s) and 4 deletion(s). Raw diff Collapse all Expand all
1 [submodule "cimgui"]
2 path = cimgui
3 url = https://github.com/cimgui/cimgui.git
1
2 [submodule "cimgui/imgui"]
3 path = cimgui/imgui
4 url = https://github.com/ocornut/imgui.git
+0
-1
cimgui less more
1 Submodule commit 75f2167111696e569289d323c5b85ad5ad5a3534
1 *.o
2 *.so
3 *.dylib
4 *.dll
1 #
2 # Cross Platform Makefile
3 # Compatible with Ubuntu 14.04.1 and macOS
4
5 OBJS = cimgui.o
6 OBJS += ./imgui/imgui.o
7 OBJS += ./imgui/imgui_draw.o
8 OBJS += ./imgui/imgui_demo.o
9 OBJS += ./imgui/imgui_widgets.o
10
11 CXXFLAGS=-O2 -fno-exceptions -fno-rtti
12
13 UNAME_S := $(shell uname -s)
14
15 ifeq ($(UNAME_S), Linux) #LINUX
16 ECHO_MESSAGE = "Linux"
17
18 OUTPUTNAME = cimgui.so
19 CXXFLAGS += -I./imgui/
20 CXXFLAGS += -Wall
21 CXXFLAGS += -shared -fPIC
22 CFLAGS = $(CXXFLAGS)
23 endif
24
25 ifeq ($(UNAME_S), Darwin) #APPLE
26 ECHO_MESSAGE = "macOS"
27
28 OUTPUTNAME = cimgui.dylib
29 CXXFLAGS += -I/usr/local/include
30 CXXFLAGS += -Wall
31 LINKFLAGS = -dynamiclib
32 CFLAGS = $(CXXFLAGS)
33 endif
34
35 ifeq ($(OS), Windows_NT)
36 ECHO_MESSAGE = "Windows"
37
38 OUTPUTNAME = cimgui.dll
39 CXXFLAGS += -I./imgui/
40 CXXFLAGS += -Wall
41 CXXFLAGS += -shared
42 LINKFLAGS = -limm32
43 CFLAGS = $(CXXFLAGS)
44 endif
45
46 .cpp.o:
47 $(CXX) $(CXXFLAGS) -c -o $@ $<
48
49 all:$(OUTPUTNAME)
50 @echo Build complete for $(ECHO_MESSAGE)
51
52 $(OUTPUTNAME):$(OBJS)
53 $(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
54
55 clean:
56 rm -f $(OBJS)
57
58 fclean: clean
59 rm -f $(OUTPUTNAME)
60
61 re: fclean all
62
63 .PHONY: all clean fclean re
1 this directory is generated using https://github.com/cimgui/cimgui,
2 with some small modifications, because cimgui isn't tracking the `docking` branch of imgui (yet)?
1 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
2 //based on imgui.h file version "1.74 WIP" from Dear ImGui https://github.com/ocornut/imgui
3
4 #include "./imgui/imgui.h"
5 #include "cimgui.h"
6
7 #include "./imgui/imgui_internal.h"
8
9 CIMGUI_API ImVec2* ImVec2_ImVec2(void)
10 {
11 return IM_NEW(ImVec2)();
12 }
13 CIMGUI_API void ImVec2_destroy(ImVec2* self)
14 {
15 IM_DELETE(self);
16 }
17 CIMGUI_API ImVec2* ImVec2_ImVec2Float(float _x,float _y)
18 {
19 return IM_NEW(ImVec2)(_x,_y);
20 }
21 CIMGUI_API ImVec4* ImVec4_ImVec4(void)
22 {
23 return IM_NEW(ImVec4)();
24 }
25 CIMGUI_API void ImVec4_destroy(ImVec4* self)
26 {
27 IM_DELETE(self);
28 }
29 CIMGUI_API ImVec4* ImVec4_ImVec4Float(float _x,float _y,float _z,float _w)
30 {
31 return IM_NEW(ImVec4)(_x,_y,_z,_w);
32 }
33 CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas)
34 {
35 return ImGui::CreateContext(shared_font_atlas);
36 }
37 CIMGUI_API void igDestroyContext(ImGuiContext* ctx)
38 {
39 return ImGui::DestroyContext(ctx);
40 }
41 CIMGUI_API ImGuiContext* igGetCurrentContext()
42 {
43 return ImGui::GetCurrentContext();
44 }
45 CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx)
46 {
47 return ImGui::SetCurrentContext(ctx);
48 }
49 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)
50 {
51 return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx);
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 igShowAboutWindow(bool* p_open)
82 {
83 return ImGui::ShowAboutWindow(p_open);
84 }
85 CIMGUI_API void igShowMetricsWindow(bool* p_open)
86 {
87 return ImGui::ShowMetricsWindow(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 igStyleColorsClassic(ImGuiStyle* dst)
114 {
115 return ImGui::StyleColorsClassic(dst);
116 }
117 CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst)
118 {
119 return ImGui::StyleColorsLight(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 igBeginChild(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 float igGetWindowDpiScale()
162 {
163 return ImGui::GetWindowDpiScale();
164 }
165 CIMGUI_API ImGuiViewport* igGetWindowViewport()
166 {
167 return ImGui::GetWindowViewport();
168 }
169 CIMGUI_API ImVec2 igGetWindowPos()
170 {
171 return ImGui::GetWindowPos();
172 }
173 CIMGUI_API ImVec2 igGetWindowSize()
174 {
175 return ImGui::GetWindowSize();
176 }
177 CIMGUI_API float igGetWindowWidth()
178 {
179 return ImGui::GetWindowWidth();
180 }
181 CIMGUI_API float igGetWindowHeight()
182 {
183 return ImGui::GetWindowHeight();
184 }
185 CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)
186 {
187 return ImGui::SetNextWindowPos(pos,cond,pivot);
188 }
189 CIMGUI_API void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond)
190 {
191 return ImGui::SetNextWindowSize(size,cond);
192 }
193 CIMGUI_API void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data)
194 {
195 return ImGui::SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data);
196 }
197 CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size)
198 {
199 return ImGui::SetNextWindowContentSize(size);
200 }
201 CIMGUI_API void igSetNextWindowCollapsed(bool collapsed,ImGuiCond cond)
202 {
203 return ImGui::SetNextWindowCollapsed(collapsed,cond);
204 }
205 CIMGUI_API void igSetNextWindowFocus()
206 {
207 return ImGui::SetNextWindowFocus();
208 }
209 CIMGUI_API void igSetNextWindowBgAlpha(float alpha)
210 {
211 return ImGui::SetNextWindowBgAlpha(alpha);
212 }
213 CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id)
214 {
215 return ImGui::SetNextWindowViewport(viewport_id);
216 }
217 CIMGUI_API void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond)
218 {
219 return ImGui::SetWindowPos(pos,cond);
220 }
221 CIMGUI_API void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond)
222 {
223 return ImGui::SetWindowSize(size,cond);
224 }
225 CIMGUI_API void igSetWindowCollapsedBool(bool collapsed,ImGuiCond cond)
226 {
227 return ImGui::SetWindowCollapsed(collapsed,cond);
228 }
229 CIMGUI_API void igSetWindowFocus()
230 {
231 return ImGui::SetWindowFocus();
232 }
233 CIMGUI_API void igSetWindowFontScale(float scale)
234 {
235 return ImGui::SetWindowFontScale(scale);
236 }
237 CIMGUI_API void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond)
238 {
239 return ImGui::SetWindowPos(name,pos,cond);
240 }
241 CIMGUI_API void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond)
242 {
243 return ImGui::SetWindowSize(name,size,cond);
244 }
245 CIMGUI_API void igSetWindowCollapsedStr(const char* name,bool collapsed,ImGuiCond cond)
246 {
247 return ImGui::SetWindowCollapsed(name,collapsed,cond);
248 }
249 CIMGUI_API void igSetWindowFocusStr(const char* name)
250 {
251 return ImGui::SetWindowFocus(name);
252 }
253 CIMGUI_API ImVec2 igGetContentRegionMax()
254 {
255 return ImGui::GetContentRegionMax();
256 }
257 CIMGUI_API ImVec2 igGetContentRegionAvail()
258 {
259 return ImGui::GetContentRegionAvail();
260 }
261 CIMGUI_API ImVec2 igGetWindowContentRegionMin()
262 {
263 return ImGui::GetWindowContentRegionMin();
264 }
265 CIMGUI_API ImVec2 igGetWindowContentRegionMax()
266 {
267 return ImGui::GetWindowContentRegionMax();
268 }
269 CIMGUI_API float igGetWindowContentRegionWidth()
270 {
271 return ImGui::GetWindowContentRegionWidth();
272 }
273 CIMGUI_API float igGetScrollX()
274 {
275 return ImGui::GetScrollX();
276 }
277 CIMGUI_API float igGetScrollY()
278 {
279 return ImGui::GetScrollY();
280 }
281 CIMGUI_API float igGetScrollMaxX()
282 {
283 return ImGui::GetScrollMaxX();
284 }
285 CIMGUI_API float igGetScrollMaxY()
286 {
287 return ImGui::GetScrollMaxY();
288 }
289 CIMGUI_API void igSetScrollX(float scroll_x)
290 {
291 return ImGui::SetScrollX(scroll_x);
292 }
293 CIMGUI_API void igSetScrollY(float scroll_y)
294 {
295 return ImGui::SetScrollY(scroll_y);
296 }
297 CIMGUI_API void igSetScrollHereX(float center_x_ratio)
298 {
299 return ImGui::SetScrollHereX(center_x_ratio);
300 }
301 CIMGUI_API void igSetScrollHereY(float center_y_ratio)
302 {
303 return ImGui::SetScrollHereY(center_y_ratio);
304 }
305 CIMGUI_API void igSetScrollFromPosX(float local_x,float center_x_ratio)
306 {
307 return ImGui::SetScrollFromPosX(local_x,center_x_ratio);
308 }
309 CIMGUI_API void igSetScrollFromPosY(float local_y,float center_y_ratio)
310 {
311 return ImGui::SetScrollFromPosY(local_y,center_y_ratio);
312 }
313 CIMGUI_API void igPushFont(ImFont* font)
314 {
315 return ImGui::PushFont(font);
316 }
317 CIMGUI_API void igPopFont()
318 {
319 return ImGui::PopFont();
320 }
321 CIMGUI_API void igPushStyleColorU32(ImGuiCol idx,ImU32 col)
322 {
323 return ImGui::PushStyleColor(idx,col);
324 }
325 CIMGUI_API void igPushStyleColor(ImGuiCol idx,const ImVec4 col)
326 {
327 return ImGui::PushStyleColor(idx,col);
328 }
329 CIMGUI_API void igPopStyleColor(int count)
330 {
331 return ImGui::PopStyleColor(count);
332 }
333 CIMGUI_API void igPushStyleVarFloat(ImGuiStyleVar idx,float val)
334 {
335 return ImGui::PushStyleVar(idx,val);
336 }
337 CIMGUI_API void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val)
338 {
339 return ImGui::PushStyleVar(idx,val);
340 }
341 CIMGUI_API void igPopStyleVar(int count)
342 {
343 return ImGui::PopStyleVar(count);
344 }
345 CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx)
346 {
347 return &ImGui::GetStyleColorVec4(idx);
348 }
349 CIMGUI_API ImFont* igGetFont()
350 {
351 return ImGui::GetFont();
352 }
353 CIMGUI_API float igGetFontSize()
354 {
355 return ImGui::GetFontSize();
356 }
357 CIMGUI_API ImVec2 igGetFontTexUvWhitePixel()
358 {
359 return ImGui::GetFontTexUvWhitePixel();
360 }
361 CIMGUI_API ImU32 igGetColorU32(ImGuiCol idx,float alpha_mul)
362 {
363 return ImGui::GetColorU32(idx,alpha_mul);
364 }
365 CIMGUI_API ImU32 igGetColorU32Vec4(const ImVec4 col)
366 {
367 return ImGui::GetColorU32(col);
368 }
369 CIMGUI_API ImU32 igGetColorU32U32(ImU32 col)
370 {
371 return ImGui::GetColorU32(col);
372 }
373 CIMGUI_API void igPushItemWidth(float item_width)
374 {
375 return ImGui::PushItemWidth(item_width);
376 }
377 CIMGUI_API void igPopItemWidth()
378 {
379 return ImGui::PopItemWidth();
380 }
381 CIMGUI_API void igSetNextItemWidth(float item_width)
382 {
383 return ImGui::SetNextItemWidth(item_width);
384 }
385 CIMGUI_API float igCalcItemWidth()
386 {
387 return ImGui::CalcItemWidth();
388 }
389 CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x)
390 {
391 return ImGui::PushTextWrapPos(wrap_local_pos_x);
392 }
393 CIMGUI_API void igPopTextWrapPos()
394 {
395 return ImGui::PopTextWrapPos();
396 }
397 CIMGUI_API void igPushAllowKeyboardFocus(bool allow_keyboard_focus)
398 {
399 return ImGui::PushAllowKeyboardFocus(allow_keyboard_focus);
400 }
401 CIMGUI_API void igPopAllowKeyboardFocus()
402 {
403 return ImGui::PopAllowKeyboardFocus();
404 }
405 CIMGUI_API void igPushButtonRepeat(bool repeat)
406 {
407 return ImGui::PushButtonRepeat(repeat);
408 }
409 CIMGUI_API void igPopButtonRepeat()
410 {
411 return ImGui::PopButtonRepeat();
412 }
413 CIMGUI_API void igSeparator()
414 {
415 return ImGui::Separator();
416 }
417 CIMGUI_API void igSameLine(float offset_from_start_x,float spacing)
418 {
419 return ImGui::SameLine(offset_from_start_x,spacing);
420 }
421 CIMGUI_API void igNewLine()
422 {
423 return ImGui::NewLine();
424 }
425 CIMGUI_API void igSpacing()
426 {
427 return ImGui::Spacing();
428 }
429 CIMGUI_API void igDummy(const ImVec2 size)
430 {
431 return ImGui::Dummy(size);
432 }
433 CIMGUI_API void igIndent(float indent_w)
434 {
435 return ImGui::Indent(indent_w);
436 }
437 CIMGUI_API void igUnindent(float indent_w)
438 {
439 return ImGui::Unindent(indent_w);
440 }
441 CIMGUI_API void igBeginGroup()
442 {
443 return ImGui::BeginGroup();
444 }
445 CIMGUI_API void igEndGroup()
446 {
447 return ImGui::EndGroup();
448 }
449 CIMGUI_API ImVec2 igGetCursorPos()
450 {
451 return ImGui::GetCursorPos();
452 }
453 CIMGUI_API float igGetCursorPosX()
454 {
455 return ImGui::GetCursorPosX();
456 }
457 CIMGUI_API float igGetCursorPosY()
458 {
459 return ImGui::GetCursorPosY();
460 }
461 CIMGUI_API void igSetCursorPos(const ImVec2 local_pos)
462 {
463 return ImGui::SetCursorPos(local_pos);
464 }
465 CIMGUI_API void igSetCursorPosX(float local_x)
466 {
467 return ImGui::SetCursorPosX(local_x);
468 }
469 CIMGUI_API void igSetCursorPosY(float local_y)
470 {
471 return ImGui::SetCursorPosY(local_y);
472 }
473 CIMGUI_API ImVec2 igGetCursorStartPos()
474 {
475 return ImGui::GetCursorStartPos();
476 }
477 CIMGUI_API ImVec2 igGetCursorScreenPos()
478 {
479 return ImGui::GetCursorScreenPos();
480 }
481 CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
482 {
483 return ImGui::SetCursorScreenPos(pos);
484 }
485 CIMGUI_API void igAlignTextToFramePadding()
486 {
487 return ImGui::AlignTextToFramePadding();
488 }
489 CIMGUI_API float igGetTextLineHeight()
490 {
491 return ImGui::GetTextLineHeight();
492 }
493 CIMGUI_API float igGetTextLineHeightWithSpacing()
494 {
495 return ImGui::GetTextLineHeightWithSpacing();
496 }
497 CIMGUI_API float igGetFrameHeight()
498 {
499 return ImGui::GetFrameHeight();
500 }
501 CIMGUI_API float igGetFrameHeightWithSpacing()
502 {
503 return ImGui::GetFrameHeightWithSpacing();
504 }
505 CIMGUI_API void igPushIDStr(const char* str_id)
506 {
507 return ImGui::PushID(str_id);
508 }
509 CIMGUI_API void igPushIDRange(const char* str_id_begin,const char* str_id_end)
510 {
511 return ImGui::PushID(str_id_begin,str_id_end);
512 }
513 CIMGUI_API void igPushIDPtr(const void* ptr_id)
514 {
515 return ImGui::PushID(ptr_id);
516 }
517 CIMGUI_API void igPushIDInt(int int_id)
518 {
519 return ImGui::PushID(int_id);
520 }
521 CIMGUI_API void igPopID()
522 {
523 return ImGui::PopID();
524 }
525 CIMGUI_API ImGuiID igGetIDStr(const char* str_id)
526 {
527 return ImGui::GetID(str_id);
528 }
529 CIMGUI_API ImGuiID igGetIDRange(const char* str_id_begin,const char* str_id_end)
530 {
531 return ImGui::GetID(str_id_begin,str_id_end);
532 }
533 CIMGUI_API ImGuiID igGetIDPtr(const void* ptr_id)
534 {
535 return ImGui::GetID(ptr_id);
536 }
537 CIMGUI_API void igTextUnformatted(const char* text,const char* text_end)
538 {
539 return ImGui::TextUnformatted(text,text_end);
540 }
541 CIMGUI_API void igText(const char* fmt,...)
542 {
543 va_list args;
544 va_start(args, fmt);
545 ImGui::TextV(fmt,args);
546 va_end(args);
547 }
548 CIMGUI_API void igTextV(const char* fmt,va_list args)
549 {
550 return ImGui::TextV(fmt,args);
551 }
552 CIMGUI_API void igTextColored(const ImVec4 col,const char* fmt,...)
553 {
554 va_list args;
555 va_start(args, fmt);
556 ImGui::TextColoredV(col,fmt,args);
557 va_end(args);
558 }
559 CIMGUI_API void igTextColoredV(const ImVec4 col,const char* fmt,va_list args)
560 {
561 return ImGui::TextColoredV(col,fmt,args);
562 }
563 CIMGUI_API void igTextDisabled(const char* fmt,...)
564 {
565 va_list args;
566 va_start(args, fmt);
567 ImGui::TextDisabledV(fmt,args);
568 va_end(args);
569 }
570 CIMGUI_API void igTextDisabledV(const char* fmt,va_list args)
571 {
572 return ImGui::TextDisabledV(fmt,args);
573 }
574 CIMGUI_API void igTextWrapped(const char* fmt,...)
575 {
576 va_list args;
577 va_start(args, fmt);
578 ImGui::TextWrappedV(fmt,args);
579 va_end(args);
580 }
581 CIMGUI_API void igTextWrappedV(const char* fmt,va_list args)
582 {
583 return ImGui::TextWrappedV(fmt,args);
584 }
585 CIMGUI_API void igLabelText(const char* label,const char* fmt,...)
586 {
587 va_list args;
588 va_start(args, fmt);
589 ImGui::LabelTextV(label,fmt,args);
590 va_end(args);
591 }
592 CIMGUI_API void igLabelTextV(const char* label,const char* fmt,va_list args)
593 {
594 return ImGui::LabelTextV(label,fmt,args);
595 }
596 CIMGUI_API void igBulletText(const char* fmt,...)
597 {
598 va_list args;
599 va_start(args, fmt);
600 ImGui::BulletTextV(fmt,args);
601 va_end(args);
602 }
603 CIMGUI_API void igBulletTextV(const char* fmt,va_list args)
604 {
605 return ImGui::BulletTextV(fmt,args);
606 }
607 CIMGUI_API bool igButton(const char* label,const ImVec2 size)
608 {
609 return ImGui::Button(label,size);
610 }
611 CIMGUI_API bool igSmallButton(const char* label)
612 {
613 return ImGui::SmallButton(label);
614 }
615 CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size)
616 {
617 return ImGui::InvisibleButton(str_id,size);
618 }
619 CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir)
620 {
621 return ImGui::ArrowButton(str_id,dir);
622 }
623 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)
624 {
625 return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
626 }
627 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)
628 {
629 return ImGui::ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col);
630 }
631 CIMGUI_API bool igCheckbox(const char* label,bool* v)
632 {
633 return ImGui::Checkbox(label,v);
634 }
635 CIMGUI_API bool igCheckboxFlags(const char* label,unsigned int* flags,unsigned int flags_value)
636 {
637 return ImGui::CheckboxFlags(label,flags,flags_value);
638 }
639 CIMGUI_API bool igRadioButtonBool(const char* label,bool active)
640 {
641 return ImGui::RadioButton(label,active);
642 }
643 CIMGUI_API bool igRadioButtonIntPtr(const char* label,int* v,int v_button)
644 {
645 return ImGui::RadioButton(label,v,v_button);
646 }
647 CIMGUI_API void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay)
648 {
649 return ImGui::ProgressBar(fraction,size_arg,overlay);
650 }
651 CIMGUI_API void igBullet()
652 {
653 return ImGui::Bullet();
654 }
655 CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags)
656 {
657 return ImGui::BeginCombo(label,preview_value,flags);
658 }
659 CIMGUI_API void igEndCombo()
660 {
661 return ImGui::EndCombo();
662 }
663 CIMGUI_API bool igCombo(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items)
664 {
665 return ImGui::Combo(label,current_item,items,items_count,popup_max_height_in_items);
666 }
667 CIMGUI_API bool igComboStr(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items)
668 {
669 return ImGui::Combo(label,current_item,items_separated_by_zeros,popup_max_height_in_items);
670 }
671 CIMGUI_API bool igComboFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)
672 {
673 return ImGui::Combo(label,current_item,items_getter,data,items_count,popup_max_height_in_items);
674 }
675 CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,float power)
676 {
677 return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,power);
678 }
679 CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,float power)
680 {
681 return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,power);
682 }
683 CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,float power)
684 {
685 return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,power);
686 }
687 CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,float power)
688 {
689 return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,power);
690 }
691 CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,float power)
692 {
693 return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power);
694 }
695 CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format)
696 {
697 return ImGui::DragInt(label,v,v_speed,v_min,v_max,format);
698 }
699 CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format)
700 {
701 return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format);
702 }
703 CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format)
704 {
705 return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format);
706 }
707 CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format)
708 {
709 return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format);
710 }
711 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)
712 {
713 return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max);
714 }
715 CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_max,const char* format,float power)
716 {
717 return ImGui::DragScalar(label,data_type,v,v_speed,v_min,v_max,format,power);
718 }
719 CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_max,const char* format,float power)
720 {
721 return ImGui::DragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power);
722 }
723 CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power)
724 {
725 return ImGui::SliderFloat(label,v,v_min,v_max,format,power);
726 }
727 CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,float power)
728 {
729 return ImGui::SliderFloat2(label,v,v_min,v_max,format,power);
730 }
731 CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,float power)
732 {
733 return ImGui::SliderFloat3(label,v,v_min,v_max,format,power);
734 }
735 CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,float power)
736 {
737 return ImGui::SliderFloat4(label,v,v_min,v_max,format,power);
738 }
739 CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format)
740 {
741 return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format);
742 }
743 CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format)
744 {
745 return ImGui::SliderInt(label,v,v_min,v_max,format);
746 }
747 CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format)
748 {
749 return ImGui::SliderInt2(label,v,v_min,v_max,format);
750 }
751 CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format)
752 {
753 return ImGui::SliderInt3(label,v,v_min,v_max,format);
754 }
755 CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format)
756 {
757 return ImGui::SliderInt4(label,v,v_min,v_max,format);
758 }
759 CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power)
760 {
761 return ImGui::SliderScalar(label,data_type,v,v_min,v_max,format,power);
762 }
763 CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_max,const char* format,float power)
764 {
765 return ImGui::SliderScalarN(label,data_type,v,components,v_min,v_max,format,power);
766 }
767 CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power)
768 {
769 return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,power);
770 }
771 CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format)
772 {
773 return ImGui::VSliderInt(label,size,v,v_min,v_max,format);
774 }
775 CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power)
776 {
777 return ImGui::VSliderScalar(label,size,data_type,v,v_min,v_max,format,power);
778 }
779 CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
780 {
781 return ImGui::InputText(label,buf,buf_size,flags,callback,user_data);
782 }
783 CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
784 {
785 return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data);
786 }
787 CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
788 {
789 return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data);
790 }
791 CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)
792 {
793 return ImGui::InputFloat(label,v,step,step_fast,format,flags);
794 }
795 CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)
796 {
797 return ImGui::InputFloat2(label,v,format,flags);
798 }
799 CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)
800 {
801 return ImGui::InputFloat3(label,v,format,flags);
802 }
803 CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)
804 {
805 return ImGui::InputFloat4(label,v,format,flags);
806 }
807 CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)
808 {
809 return ImGui::InputInt(label,v,step,step_fast,flags);
810 }
811 CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags)
812 {
813 return ImGui::InputInt2(label,v,flags);
814 }
815 CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags)
816 {
817 return ImGui::InputInt3(label,v,flags);
818 }
819 CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags)
820 {
821 return ImGui::InputInt4(label,v,flags);
822 }
823 CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)
824 {
825 return ImGui::InputDouble(label,v,step,step_fast,format,flags);
826 }
827 CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
828 {
829 return ImGui::InputScalar(label,data_type,v,step,step_fast,format,flags);
830 }
831 CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)
832 {
833 return ImGui::InputScalarN(label,data_type,v,components,step,step_fast,format,flags);
834 }
835 CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags)
836 {
837 return ImGui::ColorEdit3(label,col,flags);
838 }
839 CIMGUI_API bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags)
840 {
841 return ImGui::ColorEdit4(label,col,flags);
842 }
843 CIMGUI_API bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags)
844 {
845 return ImGui::ColorPicker3(label,col,flags);
846 }
847 CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col)
848 {
849 return ImGui::ColorPicker4(label,col,flags,ref_col);
850 }
851 CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size)
852 {
853 return ImGui::ColorButton(desc_id,col,flags,size);
854 }
855 CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags)
856 {
857 return ImGui::SetColorEditOptions(flags);
858 }
859 CIMGUI_API bool igTreeNodeStr(const char* label)
860 {
861 return ImGui::TreeNode(label);
862 }
863 CIMGUI_API bool igTreeNodeStrStr(const char* str_id,const char* fmt,...)
864 {
865 va_list args;
866 va_start(args, fmt);
867 bool ret = ImGui::TreeNodeV(str_id,fmt,args);
868 va_end(args);
869 return ret;
870 }
871 CIMGUI_API bool igTreeNodePtr(const void* ptr_id,const char* fmt,...)
872 {
873 va_list args;
874 va_start(args, fmt);
875 bool ret = ImGui::TreeNodeV(ptr_id,fmt,args);
876 va_end(args);
877 return ret;
878 }
879 CIMGUI_API bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args)
880 {
881 return ImGui::TreeNodeV(str_id,fmt,args);
882 }
883 CIMGUI_API bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args)
884 {
885 return ImGui::TreeNodeV(ptr_id,fmt,args);
886 }
887 CIMGUI_API bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags)
888 {
889 return ImGui::TreeNodeEx(label,flags);
890 }
891 CIMGUI_API bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
892 {
893 va_list args;
894 va_start(args, fmt);
895 bool ret = ImGui::TreeNodeExV(str_id,flags,fmt,args);
896 va_end(args);
897 return ret;
898 }
899 CIMGUI_API bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)
900 {
901 va_list args;
902 va_start(args, fmt);
903 bool ret = ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
904 va_end(args);
905 return ret;
906 }
907 CIMGUI_API bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
908 {
909 return ImGui::TreeNodeExV(str_id,flags,fmt,args);
910 }
911 CIMGUI_API bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)
912 {
913 return ImGui::TreeNodeExV(ptr_id,flags,fmt,args);
914 }
915 CIMGUI_API void igTreePushStr(const char* str_id)
916 {
917 return ImGui::TreePush(str_id);
918 }
919 CIMGUI_API void igTreePushPtr(const void* ptr_id)
920 {
921 return ImGui::TreePush(ptr_id);
922 }
923 CIMGUI_API void igTreePop()
924 {
925 return ImGui::TreePop();
926 }
927 CIMGUI_API float igGetTreeNodeToLabelSpacing()
928 {
929 return ImGui::GetTreeNodeToLabelSpacing();
930 }
931 CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags)
932 {
933 return ImGui::CollapsingHeader(label,flags);
934 }
935 CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTreeNodeFlags flags)
936 {
937 return ImGui::CollapsingHeader(label,p_open,flags);
938 }
939 CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond)
940 {
941 return ImGui::SetNextItemOpen(is_open,cond);
942 }
943 CIMGUI_API bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)
944 {
945 return ImGui::Selectable(label,selected,flags,size);
946 }
947 CIMGUI_API bool igSelectableBoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size)
948 {
949 return ImGui::Selectable(label,p_selected,flags,size);
950 }
951 CIMGUI_API bool igListBoxStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items)
952 {
953 return ImGui::ListBox(label,current_item,items,items_count,height_in_items);
954 }
955 CIMGUI_API bool igListBoxFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)
956 {
957 return ImGui::ListBox(label,current_item,items_getter,data,items_count,height_in_items);
958 }
959 CIMGUI_API bool igListBoxHeaderVec2(const char* label,const ImVec2 size)
960 {
961 return ImGui::ListBoxHeader(label,size);
962 }
963 CIMGUI_API bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items)
964 {
965 return ImGui::ListBoxHeader(label,items_count,height_in_items);
966 }
967 CIMGUI_API void igListBoxFooter()
968 {
969 return ImGui::ListBoxFooter();
970 }
971 CIMGUI_API void igPlotLines(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::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
974 }
975 CIMGUI_API void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
976 {
977 return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
978 }
979 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)
980 {
981 return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride);
982 }
983 CIMGUI_API void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)
984 {
985 return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size);
986 }
987 CIMGUI_API void igValueBool(const char* prefix,bool b)
988 {
989 return ImGui::Value(prefix,b);
990 }
991 CIMGUI_API void igValueInt(const char* prefix,int v)
992 {
993 return ImGui::Value(prefix,v);
994 }
995 CIMGUI_API void igValueUint(const char* prefix,unsigned int v)
996 {
997 return ImGui::Value(prefix,v);
998 }
999 CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format)
1000 {
1001 return ImGui::Value(prefix,v,float_format);
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 igBeginMenuBar()
1012 {
1013 return ImGui::BeginMenuBar();
1014 }
1015 CIMGUI_API void igEndMenuBar()
1016 {
1017 return ImGui::EndMenuBar();
1018 }
1019 CIMGUI_API bool igBeginMenu(const char* label,bool enabled)
1020 {
1021 return ImGui::BeginMenu(label,enabled);
1022 }
1023 CIMGUI_API void igEndMenu()
1024 {
1025 return ImGui::EndMenu();
1026 }
1027 CIMGUI_API bool igMenuItemBool(const char* label,const char* shortcut,bool selected,bool enabled)
1028 {
1029 return ImGui::MenuItem(label,shortcut,selected,enabled);
1030 }
1031 CIMGUI_API bool igMenuItemBoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled)
1032 {
1033 return ImGui::MenuItem(label,shortcut,p_selected,enabled);
1034 }
1035 CIMGUI_API void igBeginTooltip()
1036 {
1037 return ImGui::BeginTooltip();
1038 }
1039 CIMGUI_API void igEndTooltip()
1040 {
1041 return ImGui::EndTooltip();
1042 }
1043 CIMGUI_API void igSetTooltip(const char* fmt,...)
1044 {
1045 va_list args;
1046 va_start(args, fmt);
1047 ImGui::SetTooltipV(fmt,args);
1048 va_end(args);
1049 }
1050 CIMGUI_API void igSetTooltipV(const char* fmt,va_list args)
1051 {
1052 return ImGui::SetTooltipV(fmt,args);
1053 }
1054 CIMGUI_API void igOpenPopup(const char* str_id)
1055 {
1056 return ImGui::OpenPopup(str_id);
1057 }
1058 CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags)
1059 {
1060 return ImGui::BeginPopup(str_id,flags);
1061 }
1062 CIMGUI_API bool igBeginPopupContextItem(const char* str_id,int mouse_button)
1063 {
1064 return ImGui::BeginPopupContextItem(str_id,mouse_button);
1065 }
1066 CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,int mouse_button,bool also_over_items)
1067 {
1068 return ImGui::BeginPopupContextWindow(str_id,mouse_button,also_over_items);
1069 }
1070 CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,int mouse_button)
1071 {
1072 return ImGui::BeginPopupContextVoid(str_id,mouse_button);
1073 }
1074 CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags)
1075 {
1076 return ImGui::BeginPopupModal(name,p_open,flags);
1077 }
1078 CIMGUI_API void igEndPopup()
1079 {
1080 return ImGui::EndPopup();
1081 }
1082 CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,int mouse_button)
1083 {
1084 return ImGui::OpenPopupOnItemClick(str_id,mouse_button);
1085 }
1086 CIMGUI_API bool igIsPopupOpen(const char* str_id)
1087 {
1088 return ImGui::IsPopupOpen(str_id);
1089 }
1090 CIMGUI_API void igCloseCurrentPopup()
1091 {
1092 return ImGui::CloseCurrentPopup();
1093 }
1094 CIMGUI_API void igColumns(int count,const char* id,bool border)
1095 {
1096 return ImGui::Columns(count,id,border);
1097 }
1098 CIMGUI_API void igNextColumn()
1099 {
1100 return ImGui::NextColumn();
1101 }
1102 CIMGUI_API int igGetColumnIndex()
1103 {
1104 return ImGui::GetColumnIndex();
1105 }
1106 CIMGUI_API float igGetColumnWidth(int column_index)
1107 {
1108 return ImGui::GetColumnWidth(column_index);
1109 }
1110 CIMGUI_API void igSetColumnWidth(int column_index,float width)
1111 {
1112 return ImGui::SetColumnWidth(column_index,width);
1113 }
1114 CIMGUI_API float igGetColumnOffset(int column_index)
1115 {
1116 return ImGui::GetColumnOffset(column_index);
1117 }
1118 CIMGUI_API void igSetColumnOffset(int column_index,float offset_x)
1119 {
1120 return ImGui::SetColumnOffset(column_index,offset_x);
1121 }
1122 CIMGUI_API int igGetColumnsCount()
1123 {
1124 return ImGui::GetColumnsCount();
1125 }
1126 CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags)
1127 {
1128 return ImGui::BeginTabBar(str_id,flags);
1129 }
1130 CIMGUI_API void igEndTabBar()
1131 {
1132 return ImGui::EndTabBar();
1133 }
1134 CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags)
1135 {
1136 return ImGui::BeginTabItem(label,p_open,flags);
1137 }
1138 CIMGUI_API void igEndTabItem()
1139 {
1140 return ImGui::EndTabItem();
1141 }
1142 CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label)
1143 {
1144 return ImGui::SetTabItemClosed(tab_or_docked_window_label);
1145 }
1146 CIMGUI_API void igDockSpace(ImGuiID id,const ImVec2 size,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
1147 {
1148 return ImGui::DockSpace(id,size,flags,window_class);
1149 }
1150 CIMGUI_API ImGuiID igDockSpaceOverViewport(ImGuiViewport* viewport,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)
1151 {
1152 return ImGui::DockSpaceOverViewport(viewport,flags,window_class);
1153 }
1154 CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id,ImGuiCond cond)
1155 {
1156 return ImGui::SetNextWindowDockID(dock_id,cond);
1157 }
1158 CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class)
1159 {
1160 return ImGui::SetNextWindowClass(window_class);
1161 }
1162 CIMGUI_API ImGuiID igGetWindowDockID()
1163 {
1164 return ImGui::GetWindowDockID();
1165 }
1166 CIMGUI_API bool igIsWindowDocked()
1167 {
1168 return ImGui::IsWindowDocked();
1169 }
1170 CIMGUI_API void igLogToTTY(int auto_open_depth)
1171 {
1172 return ImGui::LogToTTY(auto_open_depth);
1173 }
1174 CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename)
1175 {
1176 return ImGui::LogToFile(auto_open_depth,filename);
1177 }
1178 CIMGUI_API void igLogToClipboard(int auto_open_depth)
1179 {
1180 return ImGui::LogToClipboard(auto_open_depth);
1181 }
1182 CIMGUI_API void igLogFinish()
1183 {
1184 return ImGui::LogFinish();
1185 }
1186 CIMGUI_API void igLogButtons()
1187 {
1188 return ImGui::LogButtons();
1189 }
1190 CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags)
1191 {
1192 return ImGui::BeginDragDropSource(flags);
1193 }
1194 CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond)
1195 {
1196 return ImGui::SetDragDropPayload(type,data,sz,cond);
1197 }
1198 CIMGUI_API void igEndDragDropSource()
1199 {
1200 return ImGui::EndDragDropSource();
1201 }
1202 CIMGUI_API bool igBeginDragDropTarget()
1203 {
1204 return ImGui::BeginDragDropTarget();
1205 }
1206 CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags)
1207 {
1208 return ImGui::AcceptDragDropPayload(type,flags);
1209 }
1210 CIMGUI_API void igEndDragDropTarget()
1211 {
1212 return ImGui::EndDragDropTarget();
1213 }
1214 CIMGUI_API const ImGuiPayload* igGetDragDropPayload()
1215 {
1216 return ImGui::GetDragDropPayload();
1217 }
1218 CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
1219 {
1220 return ImGui::PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
1221 }
1222 CIMGUI_API void igPopClipRect()
1223 {
1224 return ImGui::PopClipRect();
1225 }
1226 CIMGUI_API void igSetItemDefaultFocus()
1227 {
1228 return ImGui::SetItemDefaultFocus();
1229 }
1230 CIMGUI_API void igSetKeyboardFocusHere(int offset)
1231 {
1232 return ImGui::SetKeyboardFocusHere(offset);
1233 }
1234 CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags)
1235 {
1236 return ImGui::IsItemHovered(flags);
1237 }
1238 CIMGUI_API bool igIsItemActive()
1239 {
1240 return ImGui::IsItemActive();
1241 }
1242 CIMGUI_API bool igIsItemFocused()
1243 {
1244 return ImGui::IsItemFocused();
1245 }
1246 CIMGUI_API bool igIsItemClicked(int mouse_button)
1247 {
1248 return ImGui::IsItemClicked(mouse_button);
1249 }
1250 CIMGUI_API bool igIsItemVisible()
1251 {
1252 return ImGui::IsItemVisible();
1253 }
1254 CIMGUI_API bool igIsItemEdited()
1255 {
1256 return ImGui::IsItemEdited();
1257 }
1258 CIMGUI_API bool igIsItemActivated()
1259 {
1260 return ImGui::IsItemActivated();
1261 }
1262 CIMGUI_API bool igIsItemDeactivated()
1263 {
1264 return ImGui::IsItemDeactivated();
1265 }
1266 CIMGUI_API bool igIsItemDeactivatedAfterEdit()
1267 {
1268 return ImGui::IsItemDeactivatedAfterEdit();
1269 }
1270 CIMGUI_API bool igIsAnyItemHovered()
1271 {
1272 return ImGui::IsAnyItemHovered();
1273 }
1274 CIMGUI_API bool igIsAnyItemActive()
1275 {
1276 return ImGui::IsAnyItemActive();
1277 }
1278 CIMGUI_API bool igIsAnyItemFocused()
1279 {
1280 return ImGui::IsAnyItemFocused();
1281 }
1282 CIMGUI_API ImVec2 igGetItemRectMin()
1283 {
1284 return ImGui::GetItemRectMin();
1285 }
1286 CIMGUI_API ImVec2 igGetItemRectMax()
1287 {
1288 return ImGui::GetItemRectMax();
1289 }
1290 CIMGUI_API ImVec2 igGetItemRectSize()
1291 {
1292 return ImGui::GetItemRectSize();
1293 }
1294 CIMGUI_API void igSetItemAllowOverlap()
1295 {
1296 return ImGui::SetItemAllowOverlap();
1297 }
1298 CIMGUI_API bool igIsRectVisible(const ImVec2 size)
1299 {
1300 return ImGui::IsRectVisible(size);
1301 }
1302 CIMGUI_API bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max)
1303 {
1304 return ImGui::IsRectVisible(rect_min,rect_max);
1305 }
1306 CIMGUI_API double igGetTime()
1307 {
1308 return ImGui::GetTime();
1309 }
1310 CIMGUI_API int igGetFrameCount()
1311 {
1312 return ImGui::GetFrameCount();
1313 }
1314 CIMGUI_API ImDrawList* igGetBackgroundDrawList()
1315 {
1316 return ImGui::GetBackgroundDrawList();
1317 }
1318 CIMGUI_API ImDrawList* igGetForegroundDrawList()
1319 {
1320 return ImGui::GetForegroundDrawList();
1321 }
1322 CIMGUI_API ImDrawList* igGetBackgroundDrawListViewportPtr(ImGuiViewport* viewport)
1323 {
1324 return ImGui::GetBackgroundDrawList(viewport);
1325 }
1326 CIMGUI_API ImDrawList* igGetForegroundDrawListViewportPtr(ImGuiViewport* viewport)
1327 {
1328 return ImGui::GetForegroundDrawList(viewport);
1329 }
1330 CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData()
1331 {
1332 return ImGui::GetDrawListSharedData();
1333 }
1334 CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx)
1335 {
1336 return ImGui::GetStyleColorName(idx);
1337 }
1338 CIMGUI_API void igSetStateStorage(ImGuiStorage* storage)
1339 {
1340 return ImGui::SetStateStorage(storage);
1341 }
1342 CIMGUI_API ImGuiStorage* igGetStateStorage()
1343 {
1344 return ImGui::GetStateStorage();
1345 }
1346 CIMGUI_API ImVec2 igCalcTextSize(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
1347 {
1348 return ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
1349 }
1350 CIMGUI_API void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end)
1351 {
1352 return ImGui::CalcListClipping(items_count,items_height,out_items_display_start,out_items_display_end);
1353 }
1354 CIMGUI_API bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags)
1355 {
1356 return ImGui::BeginChildFrame(id,size,flags);
1357 }
1358 CIMGUI_API void igEndChildFrame()
1359 {
1360 return ImGui::EndChildFrame();
1361 }
1362 CIMGUI_API ImVec4 igColorConvertU32ToFloat4(ImU32 in)
1363 {
1364 return ImGui::ColorConvertU32ToFloat4(in);
1365 }
1366 CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in)
1367 {
1368 return ImGui::ColorConvertFloat4ToU32(in);
1369 }
1370 CIMGUI_API int igGetKeyIndex(ImGuiKey imgui_key)
1371 {
1372 return ImGui::GetKeyIndex(imgui_key);
1373 }
1374 CIMGUI_API bool igIsKeyDown(int user_key_index)
1375 {
1376 return ImGui::IsKeyDown(user_key_index);
1377 }
1378 CIMGUI_API bool igIsKeyPressed(int user_key_index,bool repeat)
1379 {
1380 return ImGui::IsKeyPressed(user_key_index,repeat);
1381 }
1382 CIMGUI_API bool igIsKeyReleased(int user_key_index)
1383 {
1384 return ImGui::IsKeyReleased(user_key_index);
1385 }
1386 CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate)
1387 {
1388 return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate);
1389 }
1390 CIMGUI_API bool igIsMouseDown(int button)
1391 {
1392 return ImGui::IsMouseDown(button);
1393 }
1394 CIMGUI_API bool igIsAnyMouseDown()
1395 {
1396 return ImGui::IsAnyMouseDown();
1397 }
1398 CIMGUI_API bool igIsMouseClicked(int button,bool repeat)
1399 {
1400 return ImGui::IsMouseClicked(button,repeat);
1401 }
1402 CIMGUI_API bool igIsMouseDoubleClicked(int button)
1403 {
1404 return ImGui::IsMouseDoubleClicked(button);
1405 }
1406 CIMGUI_API bool igIsMouseReleased(int button)
1407 {
1408 return ImGui::IsMouseReleased(button);
1409 }
1410 CIMGUI_API bool igIsMouseDragging(int button,float lock_threshold)
1411 {
1412 return ImGui::IsMouseDragging(button,lock_threshold);
1413 }
1414 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip)
1415 {
1416 return ImGui::IsMouseHoveringRect(r_min,r_max,clip);
1417 }
1418 CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos)
1419 {
1420 return ImGui::IsMousePosValid(mouse_pos);
1421 }
1422 CIMGUI_API ImVec2 igGetMousePos()
1423 {
1424 return ImGui::GetMousePos();
1425 }
1426 CIMGUI_API ImVec2 igGetMousePosOnOpeningCurrentPopup()
1427 {
1428 return ImGui::GetMousePosOnOpeningCurrentPopup();
1429 }
1430 CIMGUI_API ImVec2 igGetMouseDragDelta(int button,float lock_threshold)
1431 {
1432 return ImGui::GetMouseDragDelta(button,lock_threshold);
1433 }
1434 CIMGUI_API void igResetMouseDragDelta(int button)
1435 {
1436 return ImGui::ResetMouseDragDelta(button);
1437 }
1438 CIMGUI_API ImGuiMouseCursor igGetMouseCursor()
1439 {
1440 return ImGui::GetMouseCursor();
1441 }
1442 CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type)
1443 {
1444 return ImGui::SetMouseCursor(type);
1445 }
1446 CIMGUI_API void igCaptureKeyboardFromApp(bool want_capture_keyboard_value)
1447 {
1448 return ImGui::CaptureKeyboardFromApp(want_capture_keyboard_value);
1449 }
1450 CIMGUI_API void igCaptureMouseFromApp(bool want_capture_mouse_value)
1451 {
1452 return ImGui::CaptureMouseFromApp(want_capture_mouse_value);
1453 }
1454 CIMGUI_API const char* igGetClipboardText()
1455 {
1456 return ImGui::GetClipboardText();
1457 }
1458 CIMGUI_API void igSetClipboardText(const char* text)
1459 {
1460 return ImGui::SetClipboardText(text);
1461 }
1462 CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename)
1463 {
1464 return ImGui::LoadIniSettingsFromDisk(ini_filename);
1465 }
1466 CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size)
1467 {
1468 return ImGui::LoadIniSettingsFromMemory(ini_data,ini_size);
1469 }
1470 CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename)
1471 {
1472 return ImGui::SaveIniSettingsToDisk(ini_filename);
1473 }
1474 CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size)
1475 {
1476 return ImGui::SaveIniSettingsToMemory(out_ini_size);
1477 }
1478 CIMGUI_API void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)
1479 {
1480 return ImGui::SetAllocatorFunctions(alloc_func,free_func,user_data);
1481 }
1482 CIMGUI_API void* igMemAlloc(size_t size)
1483 {
1484 return ImGui::MemAlloc(size);
1485 }
1486 CIMGUI_API void igMemFree(void* ptr)
1487 {
1488 return ImGui::MemFree(ptr);
1489 }
1490 CIMGUI_API ImGuiPlatformIO* igGetPlatformIO()
1491 {
1492 return &ImGui::GetPlatformIO();
1493 }
1494 CIMGUI_API ImGuiViewport* igGetMainViewport()
1495 {
1496 return ImGui::GetMainViewport();
1497 }
1498 CIMGUI_API void igUpdatePlatformWindows()
1499 {
1500 return ImGui::UpdatePlatformWindows();
1501 }
1502 CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_arg,void* renderer_arg)
1503 {
1504 return ImGui::RenderPlatformWindowsDefault(platform_arg,renderer_arg);
1505 }
1506 CIMGUI_API void igDestroyPlatformWindows()
1507 {
1508 return ImGui::DestroyPlatformWindows();
1509 }
1510 CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id)
1511 {
1512 return ImGui::FindViewportByID(id);
1513 }
1514 CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle)
1515 {
1516 return ImGui::FindViewportByPlatformHandle(platform_handle);
1517 }
1518 CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void)
1519 {
1520 return IM_NEW(ImGuiStyle)();
1521 }
1522 CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self)
1523 {
1524 IM_DELETE(self);
1525 }
1526 CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor)
1527 {
1528 return self->ScaleAllSizes(scale_factor);
1529 }
1530 CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c)
1531 {
1532 return self->AddInputCharacter(c);
1533 }
1534 CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str)
1535 {
1536 return self->AddInputCharactersUTF8(str);
1537 }
1538 CIMGUI_API void ImGuiIO_ClearInputCharacters(ImGuiIO* self)
1539 {
1540 return self->ClearInputCharacters();
1541 }
1542 CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void)
1543 {
1544 return IM_NEW(ImGuiIO)();
1545 }
1546 CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self)
1547 {
1548 IM_DELETE(self);
1549 }
1550 CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void)
1551 {
1552 return IM_NEW(ImGuiInputTextCallbackData)();
1553 }
1554 CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self)
1555 {
1556 IM_DELETE(self);
1557 }
1558 CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count)
1559 {
1560 return self->DeleteChars(pos,bytes_count);
1561 }
1562 CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)
1563 {
1564 return self->InsertChars(pos,text,text_end);
1565 }
1566 CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self)
1567 {
1568 return self->HasSelection();
1569 }
1570 CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void)
1571 {
1572 return IM_NEW(ImGuiWindowClass)();
1573 }
1574 CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self)
1575 {
1576 IM_DELETE(self);
1577 }
1578 CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void)
1579 {
1580 return IM_NEW(ImGuiPayload)();
1581 }
1582 CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self)
1583 {
1584 IM_DELETE(self);
1585 }
1586 CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self)
1587 {
1588 return self->Clear();
1589 }
1590 CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type)
1591 {
1592 return self->IsDataType(type);
1593 }
1594 CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self)
1595 {
1596 return self->IsPreview();
1597 }
1598 CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self)
1599 {
1600 return self->IsDelivery();
1601 }
1602 CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void)
1603 {
1604 return IM_NEW(ImGuiOnceUponAFrame)();
1605 }
1606 CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self)
1607 {
1608 IM_DELETE(self);
1609 }
1610 CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter)
1611 {
1612 return IM_NEW(ImGuiTextFilter)(default_filter);
1613 }
1614 CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self)
1615 {
1616 IM_DELETE(self);
1617 }
1618 CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width)
1619 {
1620 return self->Draw(label,width);
1621 }
1622 CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end)
1623 {
1624 return self->PassFilter(text,text_end);
1625 }
1626 CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self)
1627 {
1628 return self->Build();
1629 }
1630 CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self)
1631 {
1632 return self->Clear();
1633 }
1634 CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self)
1635 {
1636 return self->IsActive();
1637 }
1638 CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void)
1639 {
1640 return IM_NEW(ImGuiTextRange)();
1641 }
1642 CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self)
1643 {
1644 IM_DELETE(self);
1645 }
1646 CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e)
1647 {
1648 return IM_NEW(ImGuiTextRange)(_b,_e);
1649 }
1650 CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self)
1651 {
1652 return self->empty();
1653 }
1654 CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)
1655 {
1656 return self->split(separator,out);
1657 }
1658 CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void)
1659 {
1660 return IM_NEW(ImGuiTextBuffer)();
1661 }
1662 CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self)
1663 {
1664 IM_DELETE(self);
1665 }
1666 CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self)
1667 {
1668 return self->begin();
1669 }
1670 CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self)
1671 {
1672 return self->end();
1673 }
1674 CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self)
1675 {
1676 return self->size();
1677 }
1678 CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self)
1679 {
1680 return self->empty();
1681 }
1682 CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self)
1683 {
1684 return self->clear();
1685 }
1686 CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity)
1687 {
1688 return self->reserve(capacity);
1689 }
1690 CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self)
1691 {
1692 return self->c_str();
1693 }
1694 CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end)
1695 {
1696 return self->append(str,str_end);
1697 }
1698 CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args)
1699 {
1700 return self->appendfv(fmt,args);
1701 }
1702 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i)
1703 {
1704 return IM_NEW(ImGuiStoragePair)(_key,_val_i);
1705 }
1706 CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self)
1707 {
1708 IM_DELETE(self);
1709 }
1710 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f)
1711 {
1712 return IM_NEW(ImGuiStoragePair)(_key,_val_f);
1713 }
1714 CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p)
1715 {
1716 return IM_NEW(ImGuiStoragePair)(_key,_val_p);
1717 }
1718 CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self)
1719 {
1720 return self->Clear();
1721 }
1722 CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val)
1723 {
1724 return self->GetInt(key,default_val);
1725 }
1726 CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val)
1727 {
1728 return self->SetInt(key,val);
1729 }
1730 CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key,bool default_val)
1731 {
1732 return self->GetBool(key,default_val);
1733 }
1734 CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key,bool val)
1735 {
1736 return self->SetBool(key,val);
1737 }
1738 CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val)
1739 {
1740 return self->GetFloat(key,default_val);
1741 }
1742 CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val)
1743 {
1744 return self->SetFloat(key,val);
1745 }
1746 CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key)
1747 {
1748 return self->GetVoidPtr(key);
1749 }
1750 CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val)
1751 {
1752 return self->SetVoidPtr(key,val);
1753 }
1754 CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val)
1755 {
1756 return self->GetIntRef(key,default_val);
1757 }
1758 CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key,bool default_val)
1759 {
1760 return self->GetBoolRef(key,default_val);
1761 }
1762 CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val)
1763 {
1764 return self->GetFloatRef(key,default_val);
1765 }
1766 CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val)
1767 {
1768 return self->GetVoidPtrRef(key,default_val);
1769 }
1770 CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val)
1771 {
1772 return self->SetAllInt(val);
1773 }
1774 CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self)
1775 {
1776 return self->BuildSortByKey();
1777 }
1778 CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height)
1779 {
1780 return IM_NEW(ImGuiListClipper)(items_count,items_height);
1781 }
1782 CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self)
1783 {
1784 IM_DELETE(self);
1785 }
1786 CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self)
1787 {
1788 return self->Step();
1789 }
1790 CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height)
1791 {
1792 return self->Begin(items_count,items_height);
1793 }
1794 CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self)
1795 {
1796 return self->End();
1797 }
1798 CIMGUI_API ImColor* ImColor_ImColor(void)
1799 {
1800 return IM_NEW(ImColor)();
1801 }
1802 CIMGUI_API void ImColor_destroy(ImColor* self)
1803 {
1804 IM_DELETE(self);
1805 }
1806 CIMGUI_API ImColor* ImColor_ImColorInt(int r,int g,int b,int a)
1807 {
1808 return IM_NEW(ImColor)(r,g,b,a);
1809 }
1810 CIMGUI_API ImColor* ImColor_ImColorU32(ImU32 rgba)
1811 {
1812 return IM_NEW(ImColor)(rgba);
1813 }
1814 CIMGUI_API ImColor* ImColor_ImColorFloat(float r,float g,float b,float a)
1815 {
1816 return IM_NEW(ImColor)(r,g,b,a);
1817 }
1818 CIMGUI_API ImColor* ImColor_ImColorVec4(const ImVec4 col)
1819 {
1820 return IM_NEW(ImColor)(col);
1821 }
1822 CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
1823 {
1824 return self->SetHSV(h,s,v,a);
1825 }
1826 CIMGUI_API ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a)
1827 {
1828 return self->HSV(h,s,v,a);
1829 }
1830 CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void)
1831 {
1832 return IM_NEW(ImDrawCmd)();
1833 }
1834 CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self)
1835 {
1836 IM_DELETE(self);
1837 }
1838 CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void)
1839 {
1840 return IM_NEW(ImDrawListSplitter)();
1841 }
1842 CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self)
1843 {
1844 IM_DELETE(self);
1845 }
1846 CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self)
1847 {
1848 return self->Clear();
1849 }
1850 CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self)
1851 {
1852 return self->ClearFreeMemory();
1853 }
1854 CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count)
1855 {
1856 return self->Split(draw_list,count);
1857 }
1858 CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list)
1859 {
1860 return self->Merge(draw_list);
1861 }
1862 CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)
1863 {
1864 return self->SetCurrentChannel(draw_list,channel_idx);
1865 }
1866 CIMGUI_API ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data)
1867 {
1868 return IM_NEW(ImDrawList)(shared_data);
1869 }
1870 CIMGUI_API void ImDrawList_destroy(ImDrawList* self)
1871 {
1872 IM_DELETE(self);
1873 }
1874 CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)
1875 {
1876 return self->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
1877 }
1878 CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self)
1879 {
1880 return self->PushClipRectFullScreen();
1881 }
1882 CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self)
1883 {
1884 return self->PopClipRect();
1885 }
1886 CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id)
1887 {
1888 return self->PushTextureID(texture_id);
1889 }
1890 CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self)
1891 {
1892 return self->PopTextureID();
1893 }
1894 CIMGUI_API ImVec2 ImDrawList_GetClipRectMin(ImDrawList* self)
1895 {
1896 return self->GetClipRectMin();
1897 }
1898 CIMGUI_API ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self)
1899 {
1900 return self->GetClipRectMax();
1901 }
1902 CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
1903 {
1904 return self->AddLine(p1,p2,col,thickness);
1905 }
1906 CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness)
1907 {
1908 return self->AddRect(p_min,p_max,col,rounding,rounding_corners,thickness);
1909 }
1910 CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners)
1911 {
1912 return self->AddRectFilled(p_min,p_max,col,rounding,rounding_corners);
1913 }
1914 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)
1915 {
1916 return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left);
1917 }
1918 CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)
1919 {
1920 return self->AddQuad(p1,p2,p3,p4,col,thickness);
1921 }
1922 CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)
1923 {
1924 return self->AddQuadFilled(p1,p2,p3,p4,col);
1925 }
1926 CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)
1927 {
1928 return self->AddTriangle(p1,p2,p3,col,thickness);
1929 }
1930 CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)
1931 {
1932 return self->AddTriangleFilled(p1,p2,p3,col);
1933 }
1934 CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)
1935 {
1936 return self->AddCircle(center,radius,col,num_segments,thickness);
1937 }
1938 CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)
1939 {
1940 return self->AddCircleFilled(center,radius,col,num_segments);
1941 }
1942 CIMGUI_API void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)
1943 {
1944 return self->AddText(pos,col,text_begin,text_end);
1945 }
1946 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)
1947 {
1948 return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect);
1949 }
1950 CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,bool closed,float thickness)
1951 {
1952 return self->AddPolyline(points,num_points,col,closed,thickness);
1953 }
1954 CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)
1955 {
1956 return self->AddConvexPolyFilled(points,num_points,col);
1957 }
1958 CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments)
1959 {
1960 return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments);
1961 }
1962 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)
1963 {
1964 return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col);
1965 }
1966 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)
1967 {
1968 return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col);
1969 }
1970 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)
1971 {
1972 return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,rounding_corners);
1973 }
1974 CIMGUI_API void ImDrawList_PathClear(ImDrawList* self)
1975 {
1976 return self->PathClear();
1977 }
1978 CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos)
1979 {
1980 return self->PathLineTo(pos);
1981 }
1982 CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos)
1983 {
1984 return self->PathLineToMergeDuplicate(pos);
1985 }
1986 CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col)
1987 {
1988 return self->PathFillConvex(col);
1989 }
1990 CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,float thickness)
1991 {
1992 return self->PathStroke(col,closed,thickness);
1993 }
1994 CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)
1995 {
1996 return self->PathArcTo(center,radius,a_min,a_max,num_segments);
1997 }
1998 CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)
1999 {
2000 return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12);
2001 }
2002 CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)
2003 {
2004 return self->PathBezierCurveTo(p1,p2,p3,num_segments);
2005 }
2006 CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners)
2007 {
2008 return self->PathRect(rect_min,rect_max,rounding,rounding_corners);
2009 }
2010 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data)
2011 {
2012 return self->AddCallback(callback,callback_data);
2013 }
2014 CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self)
2015 {
2016 return self->AddDrawCmd();
2017 }
2018 CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self)
2019 {
2020 return self->CloneOutput();
2021 }
2022 CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count)
2023 {
2024 return self->ChannelsSplit(count);
2025 }
2026 CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self)
2027 {
2028 return self->ChannelsMerge();
2029 }
2030 CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n)
2031 {
2032 return self->ChannelsSetCurrent(n);
2033 }
2034 CIMGUI_API void ImDrawList_Clear(ImDrawList* self)
2035 {
2036 return self->Clear();
2037 }
2038 CIMGUI_API void ImDrawList_ClearFreeMemory(ImDrawList* self)
2039 {
2040 return self->ClearFreeMemory();
2041 }
2042 CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count)
2043 {
2044 return self->PrimReserve(idx_count,vtx_count);
2045 }
2046 CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)
2047 {
2048 return self->PrimRect(a,b,col);
2049 }
2050 CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)
2051 {
2052 return self->PrimRectUV(a,b,uv_a,uv_b,col);
2053 }
2054 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)
2055 {
2056 return self->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
2057 }
2058 CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2059 {
2060 return self->PrimWriteVtx(pos,uv,col);
2061 }
2062 CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx)
2063 {
2064 return self->PrimWriteIdx(idx);
2065 }
2066 CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)
2067 {
2068 return self->PrimVtx(pos,uv,col);
2069 }
2070 CIMGUI_API void ImDrawList_UpdateClipRect(ImDrawList* self)
2071 {
2072 return self->UpdateClipRect();
2073 }
2074 CIMGUI_API void ImDrawList_UpdateTextureID(ImDrawList* self)
2075 {
2076 return self->UpdateTextureID();
2077 }
2078 CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void)
2079 {
2080 return IM_NEW(ImDrawData)();
2081 }
2082 CIMGUI_API void ImDrawData_destroy(ImDrawData* self)
2083 {
2084 IM_DELETE(self);
2085 }
2086 CIMGUI_API void ImDrawData_Clear(ImDrawData* self)
2087 {
2088 return self->Clear();
2089 }
2090 CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self)
2091 {
2092 return self->DeIndexAllBuffers();
2093 }
2094 CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale)
2095 {
2096 return self->ScaleClipRects(fb_scale);
2097 }
2098 CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void)
2099 {
2100 return IM_NEW(ImFontConfig)();
2101 }
2102 CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self)
2103 {
2104 IM_DELETE(self);
2105 }
2106 CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void)
2107 {
2108 return IM_NEW(ImFontGlyphRangesBuilder)();
2109 }
2110 CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self)
2111 {
2112 IM_DELETE(self);
2113 }
2114 CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self)
2115 {
2116 return self->Clear();
2117 }
2118 CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n)
2119 {
2120 return self->GetBit(n);
2121 }
2122 CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,int n)
2123 {
2124 return self->SetBit(n);
2125 }
2126 CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c)
2127 {
2128 return self->AddChar(c);
2129 }
2130 CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)
2131 {
2132 return self->AddText(text,text_end);
2133 }
2134 CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)
2135 {
2136 return self->AddRanges(ranges);
2137 }
2138 CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)
2139 {
2140 return self->BuildRanges(out_ranges);
2141 }
2142 CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void)
2143 {
2144 return IM_NEW(ImFontAtlasCustomRect)();
2145 }
2146 CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self)
2147 {
2148 IM_DELETE(self);
2149 }
2150 CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self)
2151 {
2152 return self->IsPacked();
2153 }
2154 CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void)
2155 {
2156 return IM_NEW(ImFontAtlas)();
2157 }
2158 CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self)
2159 {
2160 IM_DELETE(self);
2161 }
2162 CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg)
2163 {
2164 return self->AddFont(font_cfg);
2165 }
2166 CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg)
2167 {
2168 return self->AddFontDefault(font_cfg);
2169 }
2170 CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2171 {
2172 return self->AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges);
2173 }
2174 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2175 {
2176 return self->AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges);
2177 }
2178 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)
2179 {
2180 return self->AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges);
2181 }
2182 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)
2183 {
2184 return self->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges);
2185 }
2186 CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
2187 {
2188 return self->ClearInputData();
2189 }
2190 CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
2191 {
2192 return self->ClearTexData();
2193 }
2194 CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self)
2195 {
2196 return self->ClearFonts();
2197 }
2198 CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
2199 {
2200 return self->Clear();
2201 }
2202 CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self)
2203 {
2204 return self->Build();
2205 }
2206 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2207 {
2208 return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel);
2209 }
2210 CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)
2211 {
2212 return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel);
2213 }
2214 CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self)
2215 {
2216 return self->IsBuilt();
2217 }
2218 CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id)
2219 {
2220 return self->SetTexID(id);
2221 }
2222 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self)
2223 {
2224 return self->GetGlyphRangesDefault();
2225 }
2226 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self)
2227 {
2228 return self->GetGlyphRangesKorean();
2229 }
2230 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self)
2231 {
2232 return self->GetGlyphRangesJapanese();
2233 }
2234 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self)
2235 {
2236 return self->GetGlyphRangesChineseFull();
2237 }
2238 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self)
2239 {
2240 return self->GetGlyphRangesChineseSimplifiedCommon();
2241 }
2242 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self)
2243 {
2244 return self->GetGlyphRangesCyrillic();
2245 }
2246 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self)
2247 {
2248 return self->GetGlyphRangesThai();
2249 }
2250 CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self)
2251 {
2252 return self->GetGlyphRangesVietnamese();
2253 }
2254 CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height)
2255 {
2256 return self->AddCustomRectRegular(id,width,height);
2257 }
2258 CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)
2259 {
2260 return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset);
2261 }
2262 CIMGUI_API const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index)
2263 {
2264 return self->GetCustomRectByIndex(index);
2265 }
2266 CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)
2267 {
2268 return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max);
2269 }
2270 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])
2271 {
2272 return self->GetMouseCursorTexData(cursor,out_offset,out_size,out_uv_border,out_uv_fill);
2273 }
2274 CIMGUI_API ImFont* ImFont_ImFont(void)
2275 {
2276 return IM_NEW(ImFont)();
2277 }
2278 CIMGUI_API void ImFont_destroy(ImFont* self)
2279 {
2280 IM_DELETE(self);
2281 }
2282 CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c)
2283 {
2284 return self->FindGlyph(c);
2285 }
2286 CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c)
2287 {
2288 return self->FindGlyphNoFallback(c);
2289 }
2290 CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c)
2291 {
2292 return self->GetCharAdvance(c);
2293 }
2294 CIMGUI_API bool ImFont_IsLoaded(ImFont* self)
2295 {
2296 return self->IsLoaded();
2297 }
2298 CIMGUI_API const char* ImFont_GetDebugName(ImFont* self)
2299 {
2300 return self->GetDebugName();
2301 }
2302 CIMGUI_API ImVec2 ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)
2303 {
2304 return self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining);
2305 }
2306 CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width)
2307 {
2308 return self->CalcWordWrapPositionA(scale,text,text_end,wrap_width);
2309 }
2310 CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c)
2311 {
2312 return self->RenderChar(draw_list,size,pos,col,c);
2313 }
2314 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)
2315 {
2316 return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip);
2317 }
2318 CIMGUI_API void ImFont_BuildLookupTable(ImFont* self)
2319 {
2320 return self->BuildLookupTable();
2321 }
2322 CIMGUI_API void ImFont_ClearOutputData(ImFont* self)
2323 {
2324 return self->ClearOutputData();
2325 }
2326 CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size)
2327 {
2328 return self->GrowIndex(new_size);
2329 }
2330 CIMGUI_API void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)
2331 {
2332 return self->AddGlyph(c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x);
2333 }
2334 CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)
2335 {
2336 return self->AddRemapChar(dst,src,overwrite_dst);
2337 }
2338 CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c)
2339 {
2340 return self->SetFallbackChar(c);
2341 }
2342 CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(void)
2343 {
2344 return IM_NEW(ImGuiPlatformMonitor)();
2345 }
2346 CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self)
2347 {
2348 IM_DELETE(self);
2349 }
2350 CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void)
2351 {
2352 return IM_NEW(ImGuiPlatformIO)();
2353 }
2354 CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self)
2355 {
2356 IM_DELETE(self);
2357 }
2358 CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void)
2359 {
2360 return IM_NEW(ImGuiViewport)();
2361 }
2362 CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self)
2363 {
2364 IM_DELETE(self);
2365 }
2366 CIMGUI_API void igGetWindowPos_nonUDT(ImVec2 *pOut)
2367 {
2368 *pOut = ImGui::GetWindowPos();
2369 }
2370 CIMGUI_API ImVec2_Simple igGetWindowPos_nonUDT2()
2371 {
2372 ImVec2 ret = ImGui::GetWindowPos();
2373 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2374 return ret2;
2375 }
2376 CIMGUI_API void igGetWindowSize_nonUDT(ImVec2 *pOut)
2377 {
2378 *pOut = ImGui::GetWindowSize();
2379 }
2380 CIMGUI_API ImVec2_Simple igGetWindowSize_nonUDT2()
2381 {
2382 ImVec2 ret = ImGui::GetWindowSize();
2383 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2384 return ret2;
2385 }
2386 CIMGUI_API void igGetContentRegionMax_nonUDT(ImVec2 *pOut)
2387 {
2388 *pOut = ImGui::GetContentRegionMax();
2389 }
2390 CIMGUI_API ImVec2_Simple igGetContentRegionMax_nonUDT2()
2391 {
2392 ImVec2 ret = ImGui::GetContentRegionMax();
2393 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2394 return ret2;
2395 }
2396 CIMGUI_API void igGetContentRegionAvail_nonUDT(ImVec2 *pOut)
2397 {
2398 *pOut = ImGui::GetContentRegionAvail();
2399 }
2400 CIMGUI_API ImVec2_Simple igGetContentRegionAvail_nonUDT2()
2401 {
2402 ImVec2 ret = ImGui::GetContentRegionAvail();
2403 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2404 return ret2;
2405 }
2406 CIMGUI_API void igGetWindowContentRegionMin_nonUDT(ImVec2 *pOut)
2407 {
2408 *pOut = ImGui::GetWindowContentRegionMin();
2409 }
2410 CIMGUI_API ImVec2_Simple igGetWindowContentRegionMin_nonUDT2()
2411 {
2412 ImVec2 ret = ImGui::GetWindowContentRegionMin();
2413 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2414 return ret2;
2415 }
2416 CIMGUI_API void igGetWindowContentRegionMax_nonUDT(ImVec2 *pOut)
2417 {
2418 *pOut = ImGui::GetWindowContentRegionMax();
2419 }
2420 CIMGUI_API ImVec2_Simple igGetWindowContentRegionMax_nonUDT2()
2421 {
2422 ImVec2 ret = ImGui::GetWindowContentRegionMax();
2423 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2424 return ret2;
2425 }
2426 CIMGUI_API void igGetFontTexUvWhitePixel_nonUDT(ImVec2 *pOut)
2427 {
2428 *pOut = ImGui::GetFontTexUvWhitePixel();
2429 }
2430 CIMGUI_API ImVec2_Simple igGetFontTexUvWhitePixel_nonUDT2()
2431 {
2432 ImVec2 ret = ImGui::GetFontTexUvWhitePixel();
2433 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2434 return ret2;
2435 }
2436 CIMGUI_API void igGetCursorPos_nonUDT(ImVec2 *pOut)
2437 {
2438 *pOut = ImGui::GetCursorPos();
2439 }
2440 CIMGUI_API ImVec2_Simple igGetCursorPos_nonUDT2()
2441 {
2442 ImVec2 ret = ImGui::GetCursorPos();
2443 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2444 return ret2;
2445 }
2446 CIMGUI_API void igGetCursorStartPos_nonUDT(ImVec2 *pOut)
2447 {
2448 *pOut = ImGui::GetCursorStartPos();
2449 }
2450 CIMGUI_API ImVec2_Simple igGetCursorStartPos_nonUDT2()
2451 {
2452 ImVec2 ret = ImGui::GetCursorStartPos();
2453 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2454 return ret2;
2455 }
2456 CIMGUI_API void igGetCursorScreenPos_nonUDT(ImVec2 *pOut)
2457 {
2458 *pOut = ImGui::GetCursorScreenPos();
2459 }
2460 CIMGUI_API ImVec2_Simple igGetCursorScreenPos_nonUDT2()
2461 {
2462 ImVec2 ret = ImGui::GetCursorScreenPos();
2463 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2464 return ret2;
2465 }
2466 CIMGUI_API void igGetItemRectMin_nonUDT(ImVec2 *pOut)
2467 {
2468 *pOut = ImGui::GetItemRectMin();
2469 }
2470 CIMGUI_API ImVec2_Simple igGetItemRectMin_nonUDT2()
2471 {
2472 ImVec2 ret = ImGui::GetItemRectMin();
2473 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2474 return ret2;
2475 }
2476 CIMGUI_API void igGetItemRectMax_nonUDT(ImVec2 *pOut)
2477 {
2478 *pOut = ImGui::GetItemRectMax();
2479 }
2480 CIMGUI_API ImVec2_Simple igGetItemRectMax_nonUDT2()
2481 {
2482 ImVec2 ret = ImGui::GetItemRectMax();
2483 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2484 return ret2;
2485 }
2486 CIMGUI_API void igGetItemRectSize_nonUDT(ImVec2 *pOut)
2487 {
2488 *pOut = ImGui::GetItemRectSize();
2489 }
2490 CIMGUI_API ImVec2_Simple igGetItemRectSize_nonUDT2()
2491 {
2492 ImVec2 ret = ImGui::GetItemRectSize();
2493 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2494 return ret2;
2495 }
2496 CIMGUI_API void igCalcTextSize_nonUDT(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
2497 {
2498 *pOut = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
2499 }
2500 CIMGUI_API ImVec2_Simple igCalcTextSize_nonUDT2(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
2501 {
2502 ImVec2 ret = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
2503 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2504 return ret2;
2505 }
2506 CIMGUI_API void igColorConvertU32ToFloat4_nonUDT(ImVec4 *pOut,ImU32 in)
2507 {
2508 *pOut = ImGui::ColorConvertU32ToFloat4(in);
2509 }
2510 CIMGUI_API ImVec4_Simple igColorConvertU32ToFloat4_nonUDT2(ImU32 in)
2511 {
2512 ImVec4 ret = ImGui::ColorConvertU32ToFloat4(in);
2513 ImVec4_Simple ret2 = ImVec4ToSimple(ret);
2514 return ret2;
2515 }
2516 CIMGUI_API void igGetMousePos_nonUDT(ImVec2 *pOut)
2517 {
2518 *pOut = ImGui::GetMousePos();
2519 }
2520 CIMGUI_API ImVec2_Simple igGetMousePos_nonUDT2()
2521 {
2522 ImVec2 ret = ImGui::GetMousePos();
2523 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2524 return ret2;
2525 }
2526 CIMGUI_API void igGetMousePosOnOpeningCurrentPopup_nonUDT(ImVec2 *pOut)
2527 {
2528 *pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
2529 }
2530 CIMGUI_API ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2()
2531 {
2532 ImVec2 ret = ImGui::GetMousePosOnOpeningCurrentPopup();
2533 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2534 return ret2;
2535 }
2536 CIMGUI_API void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,int button,float lock_threshold)
2537 {
2538 *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
2539 }
2540 CIMGUI_API ImVec2_Simple igGetMouseDragDelta_nonUDT2(int button,float lock_threshold)
2541 {
2542 ImVec2 ret = ImGui::GetMouseDragDelta(button,lock_threshold);
2543 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2544 return ret2;
2545 }
2546 CIMGUI_API void ImColor_HSV_nonUDT(ImColor *pOut,ImColor* self,float h,float s,float v,float a)
2547 {
2548 *pOut = self->HSV(h,s,v,a);
2549 }
2550 CIMGUI_API ImColor_Simple ImColor_HSV_nonUDT2(ImColor* self,float h,float s,float v,float a)
2551 {
2552 ImColor ret = self->HSV(h,s,v,a);
2553 ImColor_Simple ret2 = ImColorToSimple(ret);
2554 return ret2;
2555 }
2556 CIMGUI_API void ImDrawList_GetClipRectMin_nonUDT(ImVec2 *pOut,ImDrawList* self)
2557 {
2558 *pOut = self->GetClipRectMin();
2559 }
2560 CIMGUI_API ImVec2_Simple ImDrawList_GetClipRectMin_nonUDT2(ImDrawList* self)
2561 {
2562 ImVec2 ret = self->GetClipRectMin();
2563 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2564 return ret2;
2565 }
2566 CIMGUI_API void ImDrawList_GetClipRectMax_nonUDT(ImVec2 *pOut,ImDrawList* self)
2567 {
2568 *pOut = self->GetClipRectMax();
2569 }
2570 CIMGUI_API ImVec2_Simple ImDrawList_GetClipRectMax_nonUDT2(ImDrawList* self)
2571 {
2572 ImVec2 ret = self->GetClipRectMax();
2573 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2574 return ret2;
2575 }
2576 CIMGUI_API void ImFont_CalcTextSizeA_nonUDT(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)
2577 {
2578 *pOut = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining);
2579 }
2580 CIMGUI_API ImVec2_Simple ImFont_CalcTextSizeA_nonUDT2(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)
2581 {
2582 ImVec2 ret = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining);
2583 ImVec2_Simple ret2 = ImVec2ToSimple(ret);
2584 return ret2;
2585 }
2586
2587
2588
2589 /////////////////////////////manual written functions
2590 CIMGUI_API void igLogText(CONST char *fmt, ...)
2591 {
2592 char buffer[256];
2593 va_list args;
2594 va_start(args, fmt);
2595 vsnprintf(buffer, 256, fmt, args);
2596 va_end(args);
2597
2598 ImGui::LogText("%s", buffer);
2599 }
2600 CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
2601 {
2602 va_list args;
2603 va_start(args, fmt);
2604 buffer->appendfv(fmt, args);
2605 va_end(args);
2606 }
2607
2608 CIMGUI_API float igGET_FLT_MAX()
2609 {
2610 return FLT_MAX;
2611 }
2612 CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v)
2613 {
2614 ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v);
2615 }
2616 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b)
2617 {
2618 ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b);
2619 }
2620
2621 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
2622 {
2623 return IM_NEW(ImVector<ImWchar>) ();
2624 }
2625
2626 CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
2627 {
2628 IM_DELETE(self);
2629 }
2630
2631 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
2632 {
2633 IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
2634 }
2635 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p)
2636 {
2637 p->~ImVector<ImWchar>();
2638 }
2639 CIMGUI_API void ImVector_ImGuiPlatformMonitor_Resize(ImVector_ImGuiPlatformMonitor* p, int new_size) {
2640 p->resize(new_size);
2641 }
1 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
2 //based on imgui.h file version "1.74 WIP" from Dear ImGui https://github.com/ocornut/imgui
3 #ifndef CIMGUI_INCLUDED
4 #define CIMGUI_INCLUDED
5 #include <stdio.h>
6 #include <stdint.h>
7 #if defined _WIN32 || defined __CYGWIN__
8 #ifdef CIMGUI_NO_EXPORT
9 #define API
10 #else
11 #define API __declspec(dllexport)
12 #endif
13 #ifndef __GNUC__
14 #define snprintf sprintf_s
15 #endif
16 #else
17 #define API
18 #endif
19
20 #if defined __cplusplus
21 #define EXTERN extern "C"
22 #else
23 #include <stdarg.h>
24 #include <stdbool.h>
25 #define EXTERN extern
26 #endif
27
28 #define CIMGUI_API EXTERN API
29 #define CONST const
30
31
32 #ifdef _MSC_VER
33 typedef unsigned __int64 ImU64;
34 #else
35 //typedef unsigned long long ImU64;
36 #endif
37
38 //UDT stuff
39 typedef struct ImVec2_Simple { float x; float y; } ImVec2_Simple;
40 typedef struct ImVec4_Simple { float x; float y; float z; float w;} ImVec4_Simple;
41 typedef struct ImColor_Simple { ImVec4_Simple Value;} ImColor_Simple;
42
43
44 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
45 typedef struct ImGuiStoragePair ImGuiStoragePair;
46 typedef struct ImGuiTextRange ImGuiTextRange;
47 typedef struct ImFontAtlasCustomRect ImFontAtlasCustomRect;
48 typedef struct ImVec4 ImVec4;
49 typedef struct ImVec2 ImVec2;
50 typedef struct ImGuiWindowClass ImGuiWindowClass;
51 typedef struct ImGuiViewport ImGuiViewport;
52 typedef struct ImGuiTextFilter ImGuiTextFilter;
53 typedef struct ImGuiTextBuffer ImGuiTextBuffer;
54 typedef struct ImGuiStyle ImGuiStyle;
55 typedef struct ImGuiStorage ImGuiStorage;
56 typedef struct ImGuiSizeCallbackData ImGuiSizeCallbackData;
57 typedef struct ImGuiPlatformMonitor ImGuiPlatformMonitor;
58 typedef struct ImGuiPlatformIO ImGuiPlatformIO;
59 typedef struct ImGuiPayload ImGuiPayload;
60 typedef struct ImGuiOnceUponAFrame ImGuiOnceUponAFrame;
61 typedef struct ImGuiListClipper ImGuiListClipper;
62 typedef struct ImGuiInputTextCallbackData ImGuiInputTextCallbackData;
63 typedef struct ImGuiIO ImGuiIO;
64 typedef struct ImGuiContext ImGuiContext;
65 typedef struct ImColor ImColor;
66 typedef struct ImFontGlyphRangesBuilder ImFontGlyphRangesBuilder;
67 typedef struct ImFontGlyph ImFontGlyph;
68 typedef struct ImFontConfig ImFontConfig;
69 typedef struct ImFontAtlas ImFontAtlas;
70 typedef struct ImFont ImFont;
71 typedef struct ImDrawVert ImDrawVert;
72 typedef struct ImDrawListSplitter ImDrawListSplitter;
73 typedef struct ImDrawListSharedData ImDrawListSharedData;
74 typedef struct ImDrawList ImDrawList;
75 typedef struct ImDrawData ImDrawData;
76 typedef struct ImDrawCmd ImDrawCmd;
77 typedef struct ImDrawChannel ImDrawChannel;
78
79 struct ImDrawChannel;
80 struct ImDrawCmd;
81 struct ImDrawData;
82 struct ImDrawList;
83 struct ImDrawListSharedData;
84 struct ImDrawListSplitter;
85 struct ImDrawVert;
86 struct ImFont;
87 struct ImFontAtlas;
88 struct ImFontConfig;
89 struct ImFontGlyph;
90 struct ImFontGlyphRangesBuilder;
91 struct ImColor;
92 struct ImGuiContext;
93 struct ImGuiIO;
94 struct ImGuiInputTextCallbackData;
95 struct ImGuiListClipper;
96 struct ImGuiOnceUponAFrame;
97 struct ImGuiPayload;
98 struct ImGuiPlatformIO;
99 struct ImGuiPlatformMonitor;
100 struct ImGuiSizeCallbackData;
101 struct ImGuiStorage;
102 struct ImGuiStyle;
103 struct ImGuiTextBuffer;
104 struct ImGuiTextFilter;
105 struct ImGuiViewport;
106 struct ImGuiWindowClass;
107 typedef void* ImTextureID;
108 typedef unsigned int ImGuiID;
109 typedef unsigned short ImWchar;
110 typedef int ImGuiCol;
111 typedef int ImGuiCond;
112 typedef int ImGuiDataType;
113 typedef int ImGuiDir;
114 typedef int ImGuiKey;
115 typedef int ImGuiNavInput;
116 typedef int ImGuiMouseCursor;
117 typedef int ImGuiStyleVar;
118 typedef int ImDrawCornerFlags;
119 typedef int ImDrawListFlags;
120 typedef int ImFontAtlasFlags;
121 typedef int ImGuiBackendFlags;
122 typedef int ImGuiColorEditFlags;
123 typedef int ImGuiConfigFlags;
124 typedef int ImGuiComboFlags;
125 typedef int ImGuiDockNodeFlags;
126 typedef int ImGuiDragDropFlags;
127 typedef int ImGuiFocusedFlags;
128 typedef int ImGuiHoveredFlags;
129 typedef int ImGuiInputTextFlags;
130 typedef int ImGuiSelectableFlags;
131 typedef int ImGuiTabBarFlags;
132 typedef int ImGuiTabItemFlags;
133 typedef int ImGuiTreeNodeFlags;
134 typedef int ImGuiViewportFlags;
135 typedef int ImGuiWindowFlags;
136 typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data);
137 typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data);
138 typedef signed char ImS8;
139 typedef unsigned char ImU8;
140 typedef signed short ImS16;
141 typedef unsigned short ImU16;
142 typedef signed int ImS32;
143 typedef unsigned int ImU32;
144 typedef int64_t ImS64;
145 typedef uint64_t ImU64;
146 typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd);
147 typedef unsigned short ImDrawIdx;typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;
148 typedef struct ImVector_float {int Size;int Capacity;float* Data;} ImVector_float;
149 typedef struct ImVector_ImWchar {int Size;int Capacity;ImWchar* Data;} ImVector_ImWchar;
150 typedef struct ImVector_ImDrawVert {int Size;int Capacity;ImDrawVert* Data;} ImVector_ImDrawVert;
151 typedef struct ImVector_ImFontGlyph {int Size;int Capacity;ImFontGlyph* Data;} ImVector_ImFontGlyph;
152 typedef struct ImVector_ImGuiTextRange {int Size;int Capacity;ImGuiTextRange* Data;} ImVector_ImGuiTextRange;
153 typedef struct ImVector_ImGuiStoragePair {int Size;int Capacity;ImGuiStoragePair* Data;} ImVector_ImGuiStoragePair;
154 typedef struct ImVector_ImDrawChannel {int Size;int Capacity;ImDrawChannel* Data;} ImVector_ImDrawChannel;
155 typedef struct ImVector_char {int Size;int Capacity;char* Data;} ImVector_char;
156 typedef struct ImVector_ImU32 {int Size;int Capacity;ImU32* Data;} ImVector_ImU32;
157 typedef struct ImVector_ImFontAtlasCustomRect {int Size;int Capacity;ImFontAtlasCustomRect* Data;} ImVector_ImFontAtlasCustomRect;
158 typedef struct ImVector_ImTextureID {int Size;int Capacity;ImTextureID* Data;} ImVector_ImTextureID;
159 typedef struct ImVector_ImFontConfig {int Size;int Capacity;ImFontConfig* Data;} ImVector_ImFontConfig;
160 typedef struct ImVector_ImGuiPlatformMonitor {int Size;int Capacity;ImGuiPlatformMonitor* Data;} ImVector_ImGuiPlatformMonitor;
161 typedef struct ImVector_ImGuiViewportPtr {int Size;int Capacity;ImGuiViewport** Data;} ImVector_ImGuiViewportPtr;
162 typedef struct ImVector_ImFontPtr {int Size;int Capacity;ImFont** Data;} ImVector_ImFontPtr;
163 typedef struct ImVector_ImDrawCmd {int Size;int Capacity;ImDrawCmd* Data;} ImVector_ImDrawCmd;
164 typedef struct ImVector_ImVec4 {int Size;int Capacity;ImVec4* Data;} ImVector_ImVec4;
165 typedef struct ImVector_ImDrawIdx {int Size;int Capacity;ImDrawIdx* Data;} ImVector_ImDrawIdx;
166 typedef struct ImVector_ImVec2 {int Size;int Capacity;ImVec2* Data;} ImVector_ImVec2;
167
168 struct ImVec2
169 {
170 float x, y;
171 };
172 struct ImVec4
173 {
174 float x, y, z, w;
175 };
176 enum ImGuiWindowFlags_
177 {
178 ImGuiWindowFlags_None = 0,
179 ImGuiWindowFlags_NoTitleBar = 1 << 0,
180 ImGuiWindowFlags_NoResize = 1 << 1,
181 ImGuiWindowFlags_NoMove = 1 << 2,
182 ImGuiWindowFlags_NoScrollbar = 1 << 3,
183 ImGuiWindowFlags_NoScrollWithMouse = 1 << 4,
184 ImGuiWindowFlags_NoCollapse = 1 << 5,
185 ImGuiWindowFlags_AlwaysAutoResize = 1 << 6,
186 ImGuiWindowFlags_NoBackground = 1 << 7,
187 ImGuiWindowFlags_NoSavedSettings = 1 << 8,
188 ImGuiWindowFlags_NoMouseInputs = 1 << 9,
189 ImGuiWindowFlags_MenuBar = 1 << 10,
190 ImGuiWindowFlags_HorizontalScrollbar = 1 << 11,
191 ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12,
192 ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13,
193 ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14,
194 ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15,
195 ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16,
196 ImGuiWindowFlags_NoNavInputs = 1 << 18,
197 ImGuiWindowFlags_NoNavFocus = 1 << 19,
198 ImGuiWindowFlags_UnsavedDocument = 1 << 20,
199 ImGuiWindowFlags_NoDocking = 1 << 21,
200 ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
201 ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse,
202 ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
203 ImGuiWindowFlags_NavFlattened = 1 << 23,
204 ImGuiWindowFlags_ChildWindow = 1 << 24,
205 ImGuiWindowFlags_Tooltip = 1 << 25,
206 ImGuiWindowFlags_Popup = 1 << 26,
207 ImGuiWindowFlags_Modal = 1 << 27,
208 ImGuiWindowFlags_ChildMenu = 1 << 28,
209 ImGuiWindowFlags_DockNodeHost = 1 << 29
210 };
211 enum ImGuiInputTextFlags_
212 {
213 ImGuiInputTextFlags_None = 0,
214 ImGuiInputTextFlags_CharsDecimal = 1 << 0,
215 ImGuiInputTextFlags_CharsHexadecimal = 1 << 1,
216 ImGuiInputTextFlags_CharsUppercase = 1 << 2,
217 ImGuiInputTextFlags_CharsNoBlank = 1 << 3,
218 ImGuiInputTextFlags_AutoSelectAll = 1 << 4,
219 ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5,
220 ImGuiInputTextFlags_CallbackCompletion = 1 << 6,
221 ImGuiInputTextFlags_CallbackHistory = 1 << 7,
222 ImGuiInputTextFlags_CallbackAlways = 1 << 8,
223 ImGuiInputTextFlags_CallbackCharFilter = 1 << 9,
224 ImGuiInputTextFlags_AllowTabInput = 1 << 10,
225 ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11,
226 ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12,
227 ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13,
228 ImGuiInputTextFlags_ReadOnly = 1 << 14,
229 ImGuiInputTextFlags_Password = 1 << 15,
230 ImGuiInputTextFlags_NoUndoRedo = 1 << 16,
231 ImGuiInputTextFlags_CharsScientific = 1 << 17,
232 ImGuiInputTextFlags_CallbackResize = 1 << 18,
233 ImGuiInputTextFlags_Multiline = 1 << 20,
234 ImGuiInputTextFlags_NoMarkEdited = 1 << 21
235 };
236 enum ImGuiTreeNodeFlags_
237 {
238 ImGuiTreeNodeFlags_None = 0,
239 ImGuiTreeNodeFlags_Selected = 1 << 0,
240 ImGuiTreeNodeFlags_Framed = 1 << 1,
241 ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2,
242 ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3,
243 ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4,
244 ImGuiTreeNodeFlags_DefaultOpen = 1 << 5,
245 ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6,
246 ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7,
247 ImGuiTreeNodeFlags_Leaf = 1 << 8,
248 ImGuiTreeNodeFlags_Bullet = 1 << 9,
249 ImGuiTreeNodeFlags_FramePadding = 1 << 10,
250 ImGuiTreeNodeFlags_SpanAvailWidth = 1 << 11,
251 ImGuiTreeNodeFlags_SpanFullWidth = 1 << 12,
252 ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13,
253 ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog
254 };
255 enum ImGuiSelectableFlags_
256 {
257 ImGuiSelectableFlags_None = 0,
258 ImGuiSelectableFlags_DontClosePopups = 1 << 0,
259 ImGuiSelectableFlags_SpanAllColumns = 1 << 1,
260 ImGuiSelectableFlags_AllowDoubleClick = 1 << 2,
261 ImGuiSelectableFlags_Disabled = 1 << 3,
262 ImGuiSelectableFlags_AllowItemOverlap = 1 << 4
263 };
264 enum ImGuiComboFlags_
265 {
266 ImGuiComboFlags_None = 0,
267 ImGuiComboFlags_PopupAlignLeft = 1 << 0,
268 ImGuiComboFlags_HeightSmall = 1 << 1,
269 ImGuiComboFlags_HeightRegular = 1 << 2,
270 ImGuiComboFlags_HeightLarge = 1 << 3,
271 ImGuiComboFlags_HeightLargest = 1 << 4,
272 ImGuiComboFlags_NoArrowButton = 1 << 5,
273 ImGuiComboFlags_NoPreview = 1 << 6,
274 ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest
275 };
276 enum ImGuiTabBarFlags_
277 {
278 ImGuiTabBarFlags_None = 0,
279 ImGuiTabBarFlags_Reorderable = 1 << 0,
280 ImGuiTabBarFlags_AutoSelectNewTabs = 1 << 1,
281 ImGuiTabBarFlags_TabListPopupButton = 1 << 2,
282 ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = 1 << 3,
283 ImGuiTabBarFlags_NoTabListScrollingButtons = 1 << 4,
284 ImGuiTabBarFlags_NoTooltip = 1 << 5,
285 ImGuiTabBarFlags_FittingPolicyResizeDown = 1 << 6,
286 ImGuiTabBarFlags_FittingPolicyScroll = 1 << 7,
287 ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll,
288 ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_FittingPolicyResizeDown
289 };
290 enum ImGuiTabItemFlags_
291 {
292 ImGuiTabItemFlags_None = 0,
293 ImGuiTabItemFlags_UnsavedDocument = 1 << 0,
294 ImGuiTabItemFlags_SetSelected = 1 << 1,
295 ImGuiTabItemFlags_NoCloseWithMiddleMouseButton = 1 << 2,
296 ImGuiTabItemFlags_NoPushId = 1 << 3
297 };
298 enum ImGuiFocusedFlags_
299 {
300 ImGuiFocusedFlags_None = 0,
301 ImGuiFocusedFlags_ChildWindows = 1 << 0,
302 ImGuiFocusedFlags_RootWindow = 1 << 1,
303 ImGuiFocusedFlags_AnyWindow = 1 << 2,
304 ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows
305 };
306 enum ImGuiHoveredFlags_
307 {
308 ImGuiHoveredFlags_None = 0,
309 ImGuiHoveredFlags_ChildWindows = 1 << 0,
310 ImGuiHoveredFlags_RootWindow = 1 << 1,
311 ImGuiHoveredFlags_AnyWindow = 1 << 2,
312 ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3,
313 ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5,
314 ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6,
315 ImGuiHoveredFlags_AllowWhenDisabled = 1 << 7,
316 ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped,
317 ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows
318 };
319 enum ImGuiDockNodeFlags_
320 {
321 ImGuiDockNodeFlags_None = 0,
322 ImGuiDockNodeFlags_KeepAliveOnly = 1 << 0,
323 ImGuiDockNodeFlags_NoDockingInCentralNode = 1 << 2,
324 ImGuiDockNodeFlags_PassthruCentralNode = 1 << 3,
325 ImGuiDockNodeFlags_NoSplit = 1 << 4,
326 ImGuiDockNodeFlags_NoResize = 1 << 5,
327 ImGuiDockNodeFlags_AutoHideTabBar = 1 << 6
328 };
329 enum ImGuiDragDropFlags_
330 {
331 ImGuiDragDropFlags_None = 0,
332 ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0,
333 ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1,
334 ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2,
335 ImGuiDragDropFlags_SourceAllowNullID = 1 << 3,
336 ImGuiDragDropFlags_SourceExtern = 1 << 4,
337 ImGuiDragDropFlags_SourceAutoExpirePayload = 1 << 5,
338 ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10,
339 ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11,
340 ImGuiDragDropFlags_AcceptNoPreviewTooltip = 1 << 12,
341 ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect
342 };
343 enum ImGuiDataType_
344 {
345 ImGuiDataType_S8,
346 ImGuiDataType_U8,
347 ImGuiDataType_S16,
348 ImGuiDataType_U16,
349 ImGuiDataType_S32,
350 ImGuiDataType_U32,
351 ImGuiDataType_S64,
352 ImGuiDataType_U64,
353 ImGuiDataType_Float,
354 ImGuiDataType_Double,
355 ImGuiDataType_COUNT
356 };
357 enum ImGuiDir_
358 {
359 ImGuiDir_None = -1,
360 ImGuiDir_Left = 0,
361 ImGuiDir_Right = 1,
362 ImGuiDir_Up = 2,
363 ImGuiDir_Down = 3,
364 ImGuiDir_COUNT
365 };
366 enum ImGuiKey_
367 {
368 ImGuiKey_Tab,
369 ImGuiKey_LeftArrow,
370 ImGuiKey_RightArrow,
371 ImGuiKey_UpArrow,
372 ImGuiKey_DownArrow,
373 ImGuiKey_PageUp,
374 ImGuiKey_PageDown,
375 ImGuiKey_Home,
376 ImGuiKey_End,
377 ImGuiKey_Insert,
378 ImGuiKey_Delete,
379 ImGuiKey_Backspace,
380 ImGuiKey_Space,
381 ImGuiKey_Enter,
382 ImGuiKey_Escape,
383 ImGuiKey_KeyPadEnter,
384 ImGuiKey_A,
385 ImGuiKey_C,
386 ImGuiKey_V,
387 ImGuiKey_X,
388 ImGuiKey_Y,
389 ImGuiKey_Z,
390 ImGuiKey_COUNT
391 };
392 enum ImGuiNavInput_
393 {
394 ImGuiNavInput_Activate,
395 ImGuiNavInput_Cancel,
396 ImGuiNavInput_Input,
397 ImGuiNavInput_Menu,
398 ImGuiNavInput_DpadLeft,
399 ImGuiNavInput_DpadRight,
400 ImGuiNavInput_DpadUp,
401 ImGuiNavInput_DpadDown,
402 ImGuiNavInput_LStickLeft,
403 ImGuiNavInput_LStickRight,
404 ImGuiNavInput_LStickUp,
405 ImGuiNavInput_LStickDown,
406 ImGuiNavInput_FocusPrev,
407 ImGuiNavInput_FocusNext,
408 ImGuiNavInput_TweakSlow,
409 ImGuiNavInput_TweakFast,
410 ImGuiNavInput_KeyMenu_,
411 ImGuiNavInput_KeyLeft_,
412 ImGuiNavInput_KeyRight_,
413 ImGuiNavInput_KeyUp_,
414 ImGuiNavInput_KeyDown_,
415 ImGuiNavInput_COUNT,
416 ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_
417 };
418 enum ImGuiConfigFlags_
419 {
420 ImGuiConfigFlags_None = 0,
421 ImGuiConfigFlags_NavEnableKeyboard = 1 << 0,
422 ImGuiConfigFlags_NavEnableGamepad = 1 << 1,
423 ImGuiConfigFlags_NavEnableSetMousePos = 1 << 2,
424 ImGuiConfigFlags_NavNoCaptureKeyboard = 1 << 3,
425 ImGuiConfigFlags_NoMouse = 1 << 4,
426 ImGuiConfigFlags_NoMouseCursorChange = 1 << 5,
427 ImGuiConfigFlags_DockingEnable = 1 << 6,
428 ImGuiConfigFlags_ViewportsEnable = 1 << 10,
429 ImGuiConfigFlags_DpiEnableScaleViewports= 1 << 14,
430 ImGuiConfigFlags_DpiEnableScaleFonts = 1 << 15,
431 ImGuiConfigFlags_IsSRGB = 1 << 20,
432 ImGuiConfigFlags_IsTouchScreen = 1 << 21
433 };
434 enum ImGuiBackendFlags_
435 {
436 ImGuiBackendFlags_None = 0,
437 ImGuiBackendFlags_HasGamepad = 1 << 0,
438 ImGuiBackendFlags_HasMouseCursors = 1 << 1,
439 ImGuiBackendFlags_HasSetMousePos = 1 << 2,
440 ImGuiBackendFlags_RendererHasVtxOffset = 1 << 3,
441 ImGuiBackendFlags_PlatformHasViewports = 1 << 10,
442 ImGuiBackendFlags_HasMouseHoveredViewport=1 << 11,
443 ImGuiBackendFlags_RendererHasViewports = 1 << 12
444 };
445 enum ImGuiCol_
446 {
447 ImGuiCol_Text,
448 ImGuiCol_TextDisabled,
449 ImGuiCol_WindowBg,
450 ImGuiCol_ChildBg,
451 ImGuiCol_PopupBg,
452 ImGuiCol_Border,
453 ImGuiCol_BorderShadow,
454 ImGuiCol_FrameBg,
455 ImGuiCol_FrameBgHovered,
456 ImGuiCol_FrameBgActive,
457 ImGuiCol_TitleBg,
458 ImGuiCol_TitleBgActive,
459 ImGuiCol_TitleBgCollapsed,
460 ImGuiCol_MenuBarBg,
461 ImGuiCol_ScrollbarBg,
462 ImGuiCol_ScrollbarGrab,
463 ImGuiCol_ScrollbarGrabHovered,
464 ImGuiCol_ScrollbarGrabActive,
465 ImGuiCol_CheckMark,
466 ImGuiCol_SliderGrab,
467 ImGuiCol_SliderGrabActive,
468 ImGuiCol_Button,
469 ImGuiCol_ButtonHovered,
470 ImGuiCol_ButtonActive,
471 ImGuiCol_Header,
472 ImGuiCol_HeaderHovered,
473 ImGuiCol_HeaderActive,
474 ImGuiCol_Separator,
475 ImGuiCol_SeparatorHovered,
476 ImGuiCol_SeparatorActive,
477 ImGuiCol_ResizeGrip,
478 ImGuiCol_ResizeGripHovered,
479 ImGuiCol_ResizeGripActive,
480 ImGuiCol_Tab,
481 ImGuiCol_TabHovered,
482 ImGuiCol_TabActive,
483 ImGuiCol_TabUnfocused,
484 ImGuiCol_TabUnfocusedActive,
485 ImGuiCol_DockingPreview,
486 ImGuiCol_DockingEmptyBg,
487 ImGuiCol_PlotLines,
488 ImGuiCol_PlotLinesHovered,
489 ImGuiCol_PlotHistogram,
490 ImGuiCol_PlotHistogramHovered,
491 ImGuiCol_TextSelectedBg,
492 ImGuiCol_DragDropTarget,
493 ImGuiCol_NavHighlight,
494 ImGuiCol_NavWindowingHighlight,
495 ImGuiCol_NavWindowingDimBg,
496 ImGuiCol_ModalWindowDimBg,
497 ImGuiCol_COUNT
498 };
499 enum ImGuiStyleVar_
500 {
501 ImGuiStyleVar_Alpha,
502 ImGuiStyleVar_WindowPadding,
503 ImGuiStyleVar_WindowRounding,
504 ImGuiStyleVar_WindowBorderSize,
505 ImGuiStyleVar_WindowMinSize,
506 ImGuiStyleVar_WindowTitleAlign,
507 ImGuiStyleVar_ChildRounding,
508 ImGuiStyleVar_ChildBorderSize,
509 ImGuiStyleVar_PopupRounding,
510 ImGuiStyleVar_PopupBorderSize,
511 ImGuiStyleVar_FramePadding,
512 ImGuiStyleVar_FrameRounding,
513 ImGuiStyleVar_FrameBorderSize,
514 ImGuiStyleVar_ItemSpacing,
515 ImGuiStyleVar_ItemInnerSpacing,
516 ImGuiStyleVar_IndentSpacing,
517 ImGuiStyleVar_ScrollbarSize,
518 ImGuiStyleVar_ScrollbarRounding,
519 ImGuiStyleVar_GrabMinSize,
520 ImGuiStyleVar_GrabRounding,
521 ImGuiStyleVar_TabRounding,
522 ImGuiStyleVar_ButtonTextAlign,
523 ImGuiStyleVar_SelectableTextAlign,
524 ImGuiStyleVar_COUNT
525 };
526 enum ImGuiColorEditFlags_
527 {
528 ImGuiColorEditFlags_None = 0,
529 ImGuiColorEditFlags_NoAlpha = 1 << 1,
530 ImGuiColorEditFlags_NoPicker = 1 << 2,
531 ImGuiColorEditFlags_NoOptions = 1 << 3,
532 ImGuiColorEditFlags_NoSmallPreview = 1 << 4,
533 ImGuiColorEditFlags_NoInputs = 1 << 5,
534 ImGuiColorEditFlags_NoTooltip = 1 << 6,
535 ImGuiColorEditFlags_NoLabel = 1 << 7,
536 ImGuiColorEditFlags_NoSidePreview = 1 << 8,
537 ImGuiColorEditFlags_NoDragDrop = 1 << 9,
538 ImGuiColorEditFlags_AlphaBar = 1 << 16,
539 ImGuiColorEditFlags_AlphaPreview = 1 << 17,
540 ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18,
541 ImGuiColorEditFlags_HDR = 1 << 19,
542 ImGuiColorEditFlags_DisplayRGB = 1 << 20,
543 ImGuiColorEditFlags_DisplayHSV = 1 << 21,
544 ImGuiColorEditFlags_DisplayHex = 1 << 22,
545 ImGuiColorEditFlags_Uint8 = 1 << 23,
546 ImGuiColorEditFlags_Float = 1 << 24,
547 ImGuiColorEditFlags_PickerHueBar = 1 << 25,
548 ImGuiColorEditFlags_PickerHueWheel = 1 << 26,
549 ImGuiColorEditFlags_InputRGB = 1 << 27,
550 ImGuiColorEditFlags_InputHSV = 1 << 28,
551 ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_PickerHueBar,
552 ImGuiColorEditFlags__DisplayMask = ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_DisplayHSV|ImGuiColorEditFlags_DisplayHex,
553 ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float,
554 ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar,
555 ImGuiColorEditFlags__InputMask = ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_InputHSV
556 };
557 enum ImGuiMouseCursor_
558 {
559 ImGuiMouseCursor_None = -1,
560 ImGuiMouseCursor_Arrow = 0,
561 ImGuiMouseCursor_TextInput,
562 ImGuiMouseCursor_ResizeAll,
563 ImGuiMouseCursor_ResizeNS,
564 ImGuiMouseCursor_ResizeEW,
565 ImGuiMouseCursor_ResizeNESW,
566 ImGuiMouseCursor_ResizeNWSE,
567 ImGuiMouseCursor_Hand,
568 ImGuiMouseCursor_COUNT
569 };
570 enum ImGuiCond_
571 {
572 ImGuiCond_Always = 1 << 0,
573 ImGuiCond_Once = 1 << 1,
574 ImGuiCond_FirstUseEver = 1 << 2,
575 ImGuiCond_Appearing = 1 << 3
576 };
577 struct ImGuiStyle
578 {
579 float Alpha;
580 ImVec2 WindowPadding;
581 float WindowRounding;
582 float WindowBorderSize;
583 ImVec2 WindowMinSize;
584 ImVec2 WindowTitleAlign;
585 ImGuiDir WindowMenuButtonPosition;
586 float ChildRounding;
587 float ChildBorderSize;
588 float PopupRounding;
589 float PopupBorderSize;
590 ImVec2 FramePadding;
591 float FrameRounding;
592 float FrameBorderSize;
593 ImVec2 ItemSpacing;
594 ImVec2 ItemInnerSpacing;
595 ImVec2 TouchExtraPadding;
596 float IndentSpacing;
597 float ColumnsMinSpacing;
598 float ScrollbarSize;
599 float ScrollbarRounding;
600 float GrabMinSize;
601 float GrabRounding;
602 float TabRounding;
603 float TabBorderSize;
604 ImGuiDir ColorButtonPosition;
605 ImVec2 ButtonTextAlign;
606 ImVec2 SelectableTextAlign;
607 ImVec2 DisplayWindowPadding;
608 ImVec2 DisplaySafeAreaPadding;
609 float MouseCursorScale;
610 bool AntiAliasedLines;
611 bool AntiAliasedFill;
612 float CurveTessellationTol;
613 ImVec4 Colors[ImGuiCol_COUNT];
614 };
615 struct ImGuiIO
616 {
617 ImGuiConfigFlags ConfigFlags;
618 ImGuiBackendFlags BackendFlags;
619 ImVec2 DisplaySize;
620 float DeltaTime;
621 float IniSavingRate;
622 const char* IniFilename;
623 const char* LogFilename;
624 float MouseDoubleClickTime;
625 float MouseDoubleClickMaxDist;
626 float MouseDragThreshold;
627 int KeyMap[ImGuiKey_COUNT];
628 float KeyRepeatDelay;
629 float KeyRepeatRate;
630 void* UserData;
631 ImFontAtlas*Fonts;
632 float FontGlobalScale;
633 bool FontAllowUserScaling;
634 ImFont* FontDefault;
635 ImVec2 DisplayFramebufferScale;
636 bool ConfigDockingNoSplit;
637 bool ConfigDockingWithShift;
638 bool ConfigDockingAlwaysTabBar;
639 bool ConfigDockingTransparentPayload;
640 bool ConfigViewportsNoAutoMerge;
641 bool ConfigViewportsNoTaskBarIcon;
642 bool ConfigViewportsNoDecoration;
643 bool ConfigViewportsNoDefaultParent;
644 bool MouseDrawCursor;
645 bool ConfigMacOSXBehaviors;
646 bool ConfigInputTextCursorBlink;
647 bool ConfigWindowsResizeFromEdges;
648 bool ConfigWindowsMoveFromTitleBarOnly;
649 float ConfigWindowsMemoryCompactTimer;
650 const char* BackendPlatformName;
651 const char* BackendRendererName;
652 void* BackendPlatformUserData;
653 void* BackendRendererUserData;
654 void* BackendLanguageUserData;
655 const char* (*GetClipboardTextFn)(void* user_data);
656 void (*SetClipboardTextFn)(void* user_data, const char* text);
657 void* ClipboardUserData;
658 void* RenderDrawListsFnUnused;
659 ImVec2 MousePos;
660 bool MouseDown[5];
661 float MouseWheel;
662 float MouseWheelH;
663 ImGuiID MouseHoveredViewport;
664 bool KeyCtrl;
665 bool KeyShift;
666 bool KeyAlt;
667 bool KeySuper;
668 bool KeysDown[512];
669 float NavInputs[ImGuiNavInput_COUNT];
670 bool WantCaptureMouse;
671 bool WantCaptureKeyboard;
672 bool WantTextInput;
673 bool WantSetMousePos;
674 bool WantSaveIniSettings;
675 bool NavActive;
676 bool NavVisible;
677 float Framerate;
678 int MetricsRenderVertices;
679 int MetricsRenderIndices;
680 int MetricsRenderWindows;
681 int MetricsActiveWindows;
682 int MetricsActiveAllocations;
683 ImVec2 MouseDelta;
684 ImVec2 MousePosPrev;
685 ImVec2 MouseClickedPos[5];
686 double MouseClickedTime[5];
687 bool MouseClicked[5];
688 bool MouseDoubleClicked[5];
689 bool MouseReleased[5];
690 bool MouseDownOwned[5];
691 bool MouseDownWasDoubleClick[5];
692 float MouseDownDuration[5];
693 float MouseDownDurationPrev[5];
694 ImVec2 MouseDragMaxDistanceAbs[5];
695 float MouseDragMaxDistanceSqr[5];
696 float KeysDownDuration[512];
697 float KeysDownDurationPrev[512];
698 float NavInputsDownDuration[ImGuiNavInput_COUNT];
699 float NavInputsDownDurationPrev[ImGuiNavInput_COUNT];
700 ImVector_ImWchar InputQueueCharacters;
701 };
702 struct ImGuiInputTextCallbackData
703 {
704 ImGuiInputTextFlags EventFlag;
705 ImGuiInputTextFlags Flags;
706 void* UserData;
707 ImWchar EventChar;
708 ImGuiKey EventKey;
709 char* Buf;
710 int BufTextLen;
711 int BufSize;
712 bool BufDirty;
713 int CursorPos;
714 int SelectionStart;
715 int SelectionEnd;
716 };
717 struct ImGuiSizeCallbackData
718 {
719 void* UserData;
720 ImVec2 Pos;
721 ImVec2 CurrentSize;
722 ImVec2 DesiredSize;
723 };
724 struct ImGuiWindowClass
725 {
726 ImGuiID ClassId;
727 ImGuiID ParentViewportId;
728 ImGuiViewportFlags ViewportFlagsOverrideSet;
729 ImGuiViewportFlags ViewportFlagsOverrideClear;
730 bool DockingAlwaysTabBar;
731 bool DockingAllowUnclassed;
732 };
733 struct ImGuiPayload
734 {
735 void* Data;
736 int DataSize;
737 ImGuiID SourceId;
738 ImGuiID SourceParentId;
739 int DataFrameCount;
740 char DataType[32+1];
741 bool Preview;
742 bool Delivery;
743 };
744 struct ImGuiOnceUponAFrame
745 {
746 int RefFrame;
747 };
748 struct ImGuiTextFilter
749 {
750 char InputBuf[256];
751 ImVector_ImGuiTextRange Filters;
752 int CountGrep;
753 };
754 struct ImGuiTextBuffer
755 {
756 ImVector_char Buf;
757 };
758 struct ImGuiStorage
759 {
760 ImVector_ImGuiStoragePair Data;
761 };
762 struct ImGuiListClipper
763 {
764 float StartPosY;
765 float ItemsHeight;
766 int ItemsCount, StepNo, DisplayStart, DisplayEnd;
767 };
768 struct ImColor
769 {
770 ImVec4 Value;
771 };
772 struct ImDrawCmd
773 {
774 unsigned int ElemCount;
775 ImVec4 ClipRect;
776 ImTextureID TextureId;
777 unsigned int VtxOffset;
778 unsigned int IdxOffset;
779 ImDrawCallback UserCallback;
780 void* UserCallbackData;
781 };
782 struct ImDrawVert
783 {
784 ImVec2 pos;
785 ImVec2 uv;
786 ImU32 col;
787 };
788 struct ImDrawChannel
789 {
790 ImVector_ImDrawCmd _CmdBuffer;
791 ImVector_ImDrawIdx _IdxBuffer;
792 };
793 struct ImDrawListSplitter
794 {
795 int _Current;
796 int _Count;
797 ImVector_ImDrawChannel _Channels;
798 };
799 enum ImDrawCornerFlags_
800 {
801 ImDrawCornerFlags_None = 0,
802 ImDrawCornerFlags_TopLeft = 1 << 0,
803 ImDrawCornerFlags_TopRight = 1 << 1,
804 ImDrawCornerFlags_BotLeft = 1 << 2,
805 ImDrawCornerFlags_BotRight = 1 << 3,
806 ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight,
807 ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight,
808 ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft,
809 ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight,
810 ImDrawCornerFlags_All = 0xF
811 };
812 enum ImDrawListFlags_
813 {
814 ImDrawListFlags_None = 0,
815 ImDrawListFlags_AntiAliasedLines = 1 << 0,
816 ImDrawListFlags_AntiAliasedFill = 1 << 1,
817 ImDrawListFlags_AllowVtxOffset = 1 << 2
818 };
819 struct ImDrawList