Commit 10af763b2922343215286f2156e6cbbf1b023762 - zig-imgui

add cimgui in the repo s-ol 3 years ago

8 changed file(s) with 4421 addition(s) and 3 deletion(s). Raw diff Collapse all Expand all

-3

.gitmodules 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

~~cimgui~~ less more

(Empty file)

-0

cimgui/.gitignore less more

	0	*.o
	1	*.so
	2	*.dylib
	3	*.dll

+63

-0

cimgui/Makefile less more

	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

cimgui/README.md less more

	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)?

+2641

-0

cimgui/cimgui.cpp less more

	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	}

+1707

-0

cimgui/cimgui.h less more

	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	ImGuiNavInput_Input,
	396	ImGuiNavInput_Menu,
	397	ImGuiNavInput_DpadLeft,
	398	ImGuiNavInput_DpadRight,
	399	ImGuiNavInput_DpadUp,
	400	ImGuiNavInput_DpadDown,
	401