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