//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui //based on imgui.h file version "1.91.0" 19100 from Dear ImGui https://github.com/ocornut/imgui //with imgui_internal.h api //docking branch #ifdef IMGUI_ENABLE_FREETYPE #ifndef CIMGUI_FREETYPE #error "IMGUI_FREETYPE should be defined for Freetype linking" #endif #else #ifdef CIMGUI_FREETYPE #error "IMGUI_FREETYPE should not be defined without freetype generated cimgui" #endif #endif #include "imgui.h" #ifdef IMGUI_ENABLE_FREETYPE #include "misc/freetype/imgui_freetype.h" #endif #include "imgui_internal.h" #include "cimgui.h" CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void) { return IM_NEW(ImVec2)(); } CIMGUI_API void ImVec2_destroy(ImVec2* self) { IM_DELETE(self); } CIMGUI_API ImVec2* ImVec2_ImVec2_Float(float _x,float _y) { return IM_NEW(ImVec2)(_x,_y); } CIMGUI_API ImVec4* ImVec4_ImVec4_Nil(void) { return IM_NEW(ImVec4)(); } CIMGUI_API void ImVec4_destroy(ImVec4* self) { IM_DELETE(self); } CIMGUI_API ImVec4* ImVec4_ImVec4_Float(float _x,float _y,float _z,float _w) { return IM_NEW(ImVec4)(_x,_y,_z,_w); } CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas) { return ImGui::CreateContext(shared_font_atlas); } CIMGUI_API void igDestroyContext(ImGuiContext* ctx) { return ImGui::DestroyContext(ctx); } CIMGUI_API ImGuiContext* igGetCurrentContext() { return ImGui::GetCurrentContext(); } CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx) { return ImGui::SetCurrentContext(ctx); } CIMGUI_API ImGuiIO* igGetIO() { return &ImGui::GetIO(); } CIMGUI_API ImGuiStyle* igGetStyle() { return &ImGui::GetStyle(); } CIMGUI_API void igNewFrame() { return ImGui::NewFrame(); } CIMGUI_API void igEndFrame() { return ImGui::EndFrame(); } CIMGUI_API void igRender() { return ImGui::Render(); } CIMGUI_API ImDrawData* igGetDrawData() { return ImGui::GetDrawData(); } CIMGUI_API void igShowDemoWindow(bool* p_open) { return ImGui::ShowDemoWindow(p_open); } CIMGUI_API void igShowMetricsWindow(bool* p_open) { return ImGui::ShowMetricsWindow(p_open); } CIMGUI_API void igShowDebugLogWindow(bool* p_open) { return ImGui::ShowDebugLogWindow(p_open); } CIMGUI_API void igShowIDStackToolWindow(bool* p_open) { return ImGui::ShowIDStackToolWindow(p_open); } CIMGUI_API void igShowAboutWindow(bool* p_open) { return ImGui::ShowAboutWindow(p_open); } CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref) { return ImGui::ShowStyleEditor(ref); } CIMGUI_API bool igShowStyleSelector(const char* label) { return ImGui::ShowStyleSelector(label); } CIMGUI_API void igShowFontSelector(const char* label) { return ImGui::ShowFontSelector(label); } CIMGUI_API void igShowUserGuide() { return ImGui::ShowUserGuide(); } CIMGUI_API const char* igGetVersion() { return ImGui::GetVersion(); } CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst) { return ImGui::StyleColorsDark(dst); } CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst) { return ImGui::StyleColorsLight(dst); } CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst) { return ImGui::StyleColorsClassic(dst); } CIMGUI_API bool igBegin(const char* name,bool* p_open,ImGuiWindowFlags flags) { return ImGui::Begin(name,p_open,flags); } CIMGUI_API void igEnd() { return ImGui::End(); } CIMGUI_API bool igBeginChild_Str(const char* str_id,const ImVec2 size,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags) { return ImGui::BeginChild(str_id,size,child_flags,window_flags); } CIMGUI_API bool igBeginChild_ID(ImGuiID id,const ImVec2 size,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags) { return ImGui::BeginChild(id,size,child_flags,window_flags); } CIMGUI_API void igEndChild() { return ImGui::EndChild(); } CIMGUI_API bool igIsWindowAppearing() { return ImGui::IsWindowAppearing(); } CIMGUI_API bool igIsWindowCollapsed() { return ImGui::IsWindowCollapsed(); } CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags) { return ImGui::IsWindowFocused(flags); } CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags) { return ImGui::IsWindowHovered(flags); } CIMGUI_API ImDrawList* igGetWindowDrawList() { return ImGui::GetWindowDrawList(); } CIMGUI_API float igGetWindowDpiScale() { return ImGui::GetWindowDpiScale(); } CIMGUI_API void igGetWindowPos(ImVec2 *pOut) { *pOut = ImGui::GetWindowPos(); } CIMGUI_API void igGetWindowSize(ImVec2 *pOut) { *pOut = ImGui::GetWindowSize(); } CIMGUI_API float igGetWindowWidth() { return ImGui::GetWindowWidth(); } CIMGUI_API float igGetWindowHeight() { return ImGui::GetWindowHeight(); } CIMGUI_API ImGuiViewport* igGetWindowViewport() { return ImGui::GetWindowViewport(); } CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot) { return ImGui::SetNextWindowPos(pos,cond,pivot); } CIMGUI_API void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond) { return ImGui::SetNextWindowSize(size,cond); } CIMGUI_API void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data) { return ImGui::SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data); } CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size) { return ImGui::SetNextWindowContentSize(size); } CIMGUI_API void igSetNextWindowCollapsed(bool collapsed,ImGuiCond cond) { return ImGui::SetNextWindowCollapsed(collapsed,cond); } CIMGUI_API void igSetNextWindowFocus() { return ImGui::SetNextWindowFocus(); } CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll) { return ImGui::SetNextWindowScroll(scroll); } CIMGUI_API void igSetNextWindowBgAlpha(float alpha) { return ImGui::SetNextWindowBgAlpha(alpha); } CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id) { return ImGui::SetNextWindowViewport(viewport_id); } CIMGUI_API void igSetWindowPos_Vec2(const ImVec2 pos,ImGuiCond cond) { return ImGui::SetWindowPos(pos,cond); } CIMGUI_API void igSetWindowSize_Vec2(const ImVec2 size,ImGuiCond cond) { return ImGui::SetWindowSize(size,cond); } CIMGUI_API void igSetWindowCollapsed_Bool(bool collapsed,ImGuiCond cond) { return ImGui::SetWindowCollapsed(collapsed,cond); } CIMGUI_API void igSetWindowFocus_Nil() { return ImGui::SetWindowFocus(); } CIMGUI_API void igSetWindowFontScale(float scale) { return ImGui::SetWindowFontScale(scale); } CIMGUI_API void igSetWindowPos_Str(const char* name,const ImVec2 pos,ImGuiCond cond) { return ImGui::SetWindowPos(name,pos,cond); } CIMGUI_API void igSetWindowSize_Str(const char* name,const ImVec2 size,ImGuiCond cond) { return ImGui::SetWindowSize(name,size,cond); } CIMGUI_API void igSetWindowCollapsed_Str(const char* name,bool collapsed,ImGuiCond cond) { return ImGui::SetWindowCollapsed(name,collapsed,cond); } CIMGUI_API void igSetWindowFocus_Str(const char* name) { return ImGui::SetWindowFocus(name); } CIMGUI_API float igGetScrollX() { return ImGui::GetScrollX(); } CIMGUI_API float igGetScrollY() { return ImGui::GetScrollY(); } CIMGUI_API void igSetScrollX_Float(float scroll_x) { return ImGui::SetScrollX(scroll_x); } CIMGUI_API void igSetScrollY_Float(float scroll_y) { return ImGui::SetScrollY(scroll_y); } CIMGUI_API float igGetScrollMaxX() { return ImGui::GetScrollMaxX(); } CIMGUI_API float igGetScrollMaxY() { return ImGui::GetScrollMaxY(); } CIMGUI_API void igSetScrollHereX(float center_x_ratio) { return ImGui::SetScrollHereX(center_x_ratio); } CIMGUI_API void igSetScrollHereY(float center_y_ratio) { return ImGui::SetScrollHereY(center_y_ratio); } CIMGUI_API void igSetScrollFromPosX_Float(float local_x,float center_x_ratio) { return ImGui::SetScrollFromPosX(local_x,center_x_ratio); } CIMGUI_API void igSetScrollFromPosY_Float(float local_y,float center_y_ratio) { return ImGui::SetScrollFromPosY(local_y,center_y_ratio); } CIMGUI_API void igPushFont(ImFont* font) { return ImGui::PushFont(font); } CIMGUI_API void igPopFont() { return ImGui::PopFont(); } CIMGUI_API void igPushStyleColor_U32(ImGuiCol idx,ImU32 col) { return ImGui::PushStyleColor(idx,col); } CIMGUI_API void igPushStyleColor_Vec4(ImGuiCol idx,const ImVec4 col) { return ImGui::PushStyleColor(idx,col); } CIMGUI_API void igPopStyleColor(int count) { return ImGui::PopStyleColor(count); } CIMGUI_API void igPushStyleVar_Float(ImGuiStyleVar idx,float val) { return ImGui::PushStyleVar(idx,val); } CIMGUI_API void igPushStyleVar_Vec2(ImGuiStyleVar idx,const ImVec2 val) { return ImGui::PushStyleVar(idx,val); } CIMGUI_API void igPopStyleVar(int count) { return ImGui::PopStyleVar(count); } CIMGUI_API void igPushItemFlag(ImGuiItemFlags option,bool enabled) { return ImGui::PushItemFlag(option,enabled); } CIMGUI_API void igPopItemFlag() { return ImGui::PopItemFlag(); } CIMGUI_API void igPushItemWidth(float item_width) { return ImGui::PushItemWidth(item_width); } CIMGUI_API void igPopItemWidth() { return ImGui::PopItemWidth(); } CIMGUI_API void igSetNextItemWidth(float item_width) { return ImGui::SetNextItemWidth(item_width); } CIMGUI_API float igCalcItemWidth() { return ImGui::CalcItemWidth(); } CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x) { return ImGui::PushTextWrapPos(wrap_local_pos_x); } CIMGUI_API void igPopTextWrapPos() { return ImGui::PopTextWrapPos(); } CIMGUI_API ImFont* igGetFont() { return ImGui::GetFont(); } CIMGUI_API float igGetFontSize() { return ImGui::GetFontSize(); } CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2 *pOut) { *pOut = ImGui::GetFontTexUvWhitePixel(); } CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx,float alpha_mul) { return ImGui::GetColorU32(idx,alpha_mul); } CIMGUI_API ImU32 igGetColorU32_Vec4(const ImVec4 col) { return ImGui::GetColorU32(col); } CIMGUI_API ImU32 igGetColorU32_U32(ImU32 col,float alpha_mul) { return ImGui::GetColorU32(col,alpha_mul); } CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx) { return &ImGui::GetStyleColorVec4(idx); } CIMGUI_API void igGetCursorScreenPos(ImVec2 *pOut) { *pOut = ImGui::GetCursorScreenPos(); } CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos) { return ImGui::SetCursorScreenPos(pos); } CIMGUI_API void igGetContentRegionAvail(ImVec2 *pOut) { *pOut = ImGui::GetContentRegionAvail(); } CIMGUI_API void igGetCursorPos(ImVec2 *pOut) { *pOut = ImGui::GetCursorPos(); } CIMGUI_API float igGetCursorPosX() { return ImGui::GetCursorPosX(); } CIMGUI_API float igGetCursorPosY() { return ImGui::GetCursorPosY(); } CIMGUI_API void igSetCursorPos(const ImVec2 local_pos) { return ImGui::SetCursorPos(local_pos); } CIMGUI_API void igSetCursorPosX(float local_x) { return ImGui::SetCursorPosX(local_x); } CIMGUI_API void igSetCursorPosY(float local_y) { return ImGui::SetCursorPosY(local_y); } CIMGUI_API void igGetCursorStartPos(ImVec2 *pOut) { *pOut = ImGui::GetCursorStartPos(); } CIMGUI_API void igSeparator() { return ImGui::Separator(); } CIMGUI_API void igSameLine(float offset_from_start_x,float spacing) { return ImGui::SameLine(offset_from_start_x,spacing); } CIMGUI_API void igNewLine() { return ImGui::NewLine(); } CIMGUI_API void igSpacing() { return ImGui::Spacing(); } CIMGUI_API void igDummy(const ImVec2 size) { return ImGui::Dummy(size); } CIMGUI_API void igIndent(float indent_w) { return ImGui::Indent(indent_w); } CIMGUI_API void igUnindent(float indent_w) { return ImGui::Unindent(indent_w); } CIMGUI_API void igBeginGroup() { return ImGui::BeginGroup(); } CIMGUI_API void igEndGroup() { return ImGui::EndGroup(); } CIMGUI_API void igAlignTextToFramePadding() { return ImGui::AlignTextToFramePadding(); } CIMGUI_API float igGetTextLineHeight() { return ImGui::GetTextLineHeight(); } CIMGUI_API float igGetTextLineHeightWithSpacing() { return ImGui::GetTextLineHeightWithSpacing(); } CIMGUI_API float igGetFrameHeight() { return ImGui::GetFrameHeight(); } CIMGUI_API float igGetFrameHeightWithSpacing() { return ImGui::GetFrameHeightWithSpacing(); } CIMGUI_API void igPushID_Str(const char* str_id) { return ImGui::PushID(str_id); } CIMGUI_API void igPushID_StrStr(const char* str_id_begin,const char* str_id_end) { return ImGui::PushID(str_id_begin,str_id_end); } CIMGUI_API void igPushID_Ptr(const void* ptr_id) { return ImGui::PushID(ptr_id); } CIMGUI_API void igPushID_Int(int int_id) { return ImGui::PushID(int_id); } CIMGUI_API void igPopID() { return ImGui::PopID(); } CIMGUI_API ImGuiID igGetID_Str(const char* str_id) { return ImGui::GetID(str_id); } CIMGUI_API ImGuiID igGetID_StrStr(const char* str_id_begin,const char* str_id_end) { return ImGui::GetID(str_id_begin,str_id_end); } CIMGUI_API ImGuiID igGetID_Ptr(const void* ptr_id) { return ImGui::GetID(ptr_id); } CIMGUI_API ImGuiID igGetID_Int(int int_id) { return ImGui::GetID(int_id); } CIMGUI_API void igTextUnformatted(const char* text,const char* text_end) { return ImGui::TextUnformatted(text,text_end); } CIMGUI_API void igText(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::TextV(fmt,args); va_end(args); } CIMGUI_API void igTextV(const char* fmt,va_list args) { return ImGui::TextV(fmt,args); } CIMGUI_API void igTextColored(const ImVec4 col,const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::TextColoredV(col,fmt,args); va_end(args); } CIMGUI_API void igTextColoredV(const ImVec4 col,const char* fmt,va_list args) { return ImGui::TextColoredV(col,fmt,args); } CIMGUI_API void igTextDisabled(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::TextDisabledV(fmt,args); va_end(args); } CIMGUI_API void igTextDisabledV(const char* fmt,va_list args) { return ImGui::TextDisabledV(fmt,args); } CIMGUI_API void igTextWrapped(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::TextWrappedV(fmt,args); va_end(args); } CIMGUI_API void igTextWrappedV(const char* fmt,va_list args) { return ImGui::TextWrappedV(fmt,args); } CIMGUI_API void igLabelText(const char* label,const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::LabelTextV(label,fmt,args); va_end(args); } CIMGUI_API void igLabelTextV(const char* label,const char* fmt,va_list args) { return ImGui::LabelTextV(label,fmt,args); } CIMGUI_API void igBulletText(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::BulletTextV(fmt,args); va_end(args); } CIMGUI_API void igBulletTextV(const char* fmt,va_list args) { return ImGui::BulletTextV(fmt,args); } CIMGUI_API void igSeparatorText(const char* label) { return ImGui::SeparatorText(label); } CIMGUI_API bool igButton(const char* label,const ImVec2 size) { return ImGui::Button(label,size); } CIMGUI_API bool igSmallButton(const char* label) { return ImGui::SmallButton(label); } CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size,ImGuiButtonFlags flags) { return ImGui::InvisibleButton(str_id,size,flags); } CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir) { return ImGui::ArrowButton(str_id,dir); } CIMGUI_API bool igCheckbox(const char* label,bool* v) { return ImGui::Checkbox(label,v); } CIMGUI_API bool igCheckboxFlags_IntPtr(const char* label,int* flags,int flags_value) { return ImGui::CheckboxFlags(label,flags,flags_value); } CIMGUI_API bool igCheckboxFlags_UintPtr(const char* label,unsigned int* flags,unsigned int flags_value) { return ImGui::CheckboxFlags(label,flags,flags_value); } CIMGUI_API bool igRadioButton_Bool(const char* label,bool active) { return ImGui::RadioButton(label,active); } CIMGUI_API bool igRadioButton_IntPtr(const char* label,int* v,int v_button) { return ImGui::RadioButton(label,v,v_button); } CIMGUI_API void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay) { return ImGui::ProgressBar(fraction,size_arg,overlay); } CIMGUI_API void igBullet() { return ImGui::Bullet(); } CIMGUI_API bool igTextLink(const char* label) { return ImGui::TextLink(label); } CIMGUI_API void igTextLinkOpenURL(const char* label,const char* url) { return ImGui::TextLinkOpenURL(label,url); } CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col) { return ImGui::Image(user_texture_id,image_size,uv0,uv1,tint_col,border_col); } CIMGUI_API bool igImageButton(const char* str_id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col) { return ImGui::ImageButton(str_id,user_texture_id,image_size,uv0,uv1,bg_col,tint_col); } CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags) { return ImGui::BeginCombo(label,preview_value,flags); } CIMGUI_API void igEndCombo() { return ImGui::EndCombo(); } CIMGUI_API bool igCombo_Str_arr(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items) { return ImGui::Combo(label,current_item,items,items_count,popup_max_height_in_items); } CIMGUI_API bool igCombo_Str(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items) { return ImGui::Combo(label,current_item,items_separated_by_zeros,popup_max_height_in_items); } CIMGUI_API bool igCombo_FnStrPtr(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int popup_max_height_in_items) { return ImGui::Combo(label,current_item,getter,user_data,items_count,popup_max_height_in_items); } CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragFloat(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,ImGuiSliderFlags flags) { return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags); } CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragInt(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragInt2(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragInt3(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragInt4(label,v,v_speed,v_min,v_max,format,flags); } CIMGUI_API bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max,ImGuiSliderFlags flags) { return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags); } CIMGUI_API bool igDragScalar(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragScalar(label,data_type,p_data,v_speed,p_min,p_max,format,flags); } CIMGUI_API bool igDragScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragScalarN(label,data_type,p_data,components,v_speed,p_min,p_max,format,flags); } CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderFloat(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderFloat2(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderFloat3(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderFloat4(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format,flags); } CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderInt(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderInt2(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderInt3(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderInt4(label,v,v_min,v_max,format,flags); } CIMGUI_API bool igSliderScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderScalar(label,data_type,p_data,p_min,p_max,format,flags); } CIMGUI_API bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::SliderScalarN(label,data_type,p_data,components,p_min,p_max,format,flags); } CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::VSliderFloat(label,size,v,v_min,v_max,format,flags); } CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags) { return ImGui::VSliderInt(label,size,v,v_min,v_max,format,flags); } CIMGUI_API bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::VSliderScalar(label,size,data_type,p_data,p_min,p_max,format,flags); } CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data) { return ImGui::InputText(label,buf,buf_size,flags,callback,user_data); } CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data) { return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data); } CIMGUI_API bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data) { return ImGui::InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data); } CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags) { return ImGui::InputFloat(label,v,step,step_fast,format,flags); } CIMGUI_API bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags) { return ImGui::InputFloat2(label,v,format,flags); } CIMGUI_API bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags) { return ImGui::InputFloat3(label,v,format,flags); } CIMGUI_API bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags) { return ImGui::InputFloat4(label,v,format,flags); } CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags) { return ImGui::InputInt(label,v,step,step_fast,flags); } CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags) { return ImGui::InputInt2(label,v,flags); } CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags) { return ImGui::InputInt3(label,v,flags); } CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags) { return ImGui::InputInt4(label,v,flags); } CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags) { return ImGui::InputDouble(label,v,step,step_fast,format,flags); } CIMGUI_API bool igInputScalar(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags) { return ImGui::InputScalar(label,data_type,p_data,p_step,p_step_fast,format,flags); } CIMGUI_API bool igInputScalarN(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags) { return ImGui::InputScalarN(label,data_type,p_data,components,p_step,p_step_fast,format,flags); } CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags) { return ImGui::ColorEdit3(label,col,flags); } CIMGUI_API bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags) { return ImGui::ColorEdit4(label,col,flags); } CIMGUI_API bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags) { return ImGui::ColorPicker3(label,col,flags); } CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col) { return ImGui::ColorPicker4(label,col,flags,ref_col); } CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,const ImVec2 size) { return ImGui::ColorButton(desc_id,col,flags,size); } CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags) { return ImGui::SetColorEditOptions(flags); } CIMGUI_API bool igTreeNode_Str(const char* label) { return ImGui::TreeNode(label); } CIMGUI_API bool igTreeNode_StrStr(const char* str_id,const char* fmt,...) { va_list args; va_start(args, fmt); bool ret = ImGui::TreeNodeV(str_id,fmt,args); va_end(args); return ret; } CIMGUI_API bool igTreeNode_Ptr(const void* ptr_id,const char* fmt,...) { va_list args; va_start(args, fmt); bool ret = ImGui::TreeNodeV(ptr_id,fmt,args); va_end(args); return ret; } CIMGUI_API bool igTreeNodeV_Str(const char* str_id,const char* fmt,va_list args) { return ImGui::TreeNodeV(str_id,fmt,args); } CIMGUI_API bool igTreeNodeV_Ptr(const void* ptr_id,const char* fmt,va_list args) { return ImGui::TreeNodeV(ptr_id,fmt,args); } CIMGUI_API bool igTreeNodeEx_Str(const char* label,ImGuiTreeNodeFlags flags) { return ImGui::TreeNodeEx(label,flags); } CIMGUI_API bool igTreeNodeEx_StrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...) { va_list args; va_start(args, fmt); bool ret = ImGui::TreeNodeExV(str_id,flags,fmt,args); va_end(args); return ret; } CIMGUI_API bool igTreeNodeEx_Ptr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...) { va_list args; va_start(args, fmt); bool ret = ImGui::TreeNodeExV(ptr_id,flags,fmt,args); va_end(args); return ret; } CIMGUI_API bool igTreeNodeExV_Str(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) { return ImGui::TreeNodeExV(str_id,flags,fmt,args); } CIMGUI_API bool igTreeNodeExV_Ptr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) { return ImGui::TreeNodeExV(ptr_id,flags,fmt,args); } CIMGUI_API void igTreePush_Str(const char* str_id) { return ImGui::TreePush(str_id); } CIMGUI_API void igTreePush_Ptr(const void* ptr_id) { return ImGui::TreePush(ptr_id); } CIMGUI_API void igTreePop() { return ImGui::TreePop(); } CIMGUI_API float igGetTreeNodeToLabelSpacing() { return ImGui::GetTreeNodeToLabelSpacing(); } CIMGUI_API bool igCollapsingHeader_TreeNodeFlags(const char* label,ImGuiTreeNodeFlags flags) { return ImGui::CollapsingHeader(label,flags); } CIMGUI_API bool igCollapsingHeader_BoolPtr(const char* label,bool* p_visible,ImGuiTreeNodeFlags flags) { return ImGui::CollapsingHeader(label,p_visible,flags); } CIMGUI_API void igSetNextItemOpen(bool is_open,ImGuiCond cond) { return ImGui::SetNextItemOpen(is_open,cond); } CIMGUI_API void igSetNextItemStorageID(ImGuiID storage_id) { return ImGui::SetNextItemStorageID(storage_id); } CIMGUI_API bool igSelectable_Bool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size) { return ImGui::Selectable(label,selected,flags,size); } CIMGUI_API bool igSelectable_BoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size) { return ImGui::Selectable(label,p_selected,flags,size); } CIMGUI_API ImGuiMultiSelectIO* igBeginMultiSelect(ImGuiMultiSelectFlags flags,int selection_size,int items_count) { return ImGui::BeginMultiSelect(flags,selection_size,items_count); } CIMGUI_API ImGuiMultiSelectIO* igEndMultiSelect() { return ImGui::EndMultiSelect(); } CIMGUI_API void igSetNextItemSelectionUserData(ImGuiSelectionUserData selection_user_data) { return ImGui::SetNextItemSelectionUserData(selection_user_data); } CIMGUI_API bool igIsItemToggledSelection() { return ImGui::IsItemToggledSelection(); } CIMGUI_API bool igBeginListBox(const char* label,const ImVec2 size) { return ImGui::BeginListBox(label,size); } CIMGUI_API void igEndListBox() { return ImGui::EndListBox(); } CIMGUI_API bool igListBox_Str_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items) { return ImGui::ListBox(label,current_item,items,items_count,height_in_items); } CIMGUI_API bool igListBox_FnStrPtr(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int height_in_items) { return ImGui::ListBox(label,current_item,getter,user_data,items_count,height_in_items); } CIMGUI_API void igPlotLines_FloatPtr(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) { return ImGui::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride); } CIMGUI_API void igPlotLines_FnFloatPtr(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) { return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size); } CIMGUI_API void igPlotHistogram_FloatPtr(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) { return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride); } CIMGUI_API void igPlotHistogram_FnFloatPtr(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) { return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size); } CIMGUI_API void igValue_Bool(const char* prefix,bool b) { return ImGui::Value(prefix,b); } CIMGUI_API void igValue_Int(const char* prefix,int v) { return ImGui::Value(prefix,v); } CIMGUI_API void igValue_Uint(const char* prefix,unsigned int v) { return ImGui::Value(prefix,v); } CIMGUI_API void igValue_Float(const char* prefix,float v,const char* float_format) { return ImGui::Value(prefix,v,float_format); } CIMGUI_API bool igBeginMenuBar() { return ImGui::BeginMenuBar(); } CIMGUI_API void igEndMenuBar() { return ImGui::EndMenuBar(); } CIMGUI_API bool igBeginMainMenuBar() { return ImGui::BeginMainMenuBar(); } CIMGUI_API void igEndMainMenuBar() { return ImGui::EndMainMenuBar(); } CIMGUI_API bool igBeginMenu(const char* label,bool enabled) { return ImGui::BeginMenu(label,enabled); } CIMGUI_API void igEndMenu() { return ImGui::EndMenu(); } CIMGUI_API bool igMenuItem_Bool(const char* label,const char* shortcut,bool selected,bool enabled) { return ImGui::MenuItem(label,shortcut,selected,enabled); } CIMGUI_API bool igMenuItem_BoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled) { return ImGui::MenuItem(label,shortcut,p_selected,enabled); } CIMGUI_API bool igBeginTooltip() { return ImGui::BeginTooltip(); } CIMGUI_API void igEndTooltip() { return ImGui::EndTooltip(); } CIMGUI_API void igSetTooltip(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::SetTooltipV(fmt,args); va_end(args); } CIMGUI_API void igSetTooltipV(const char* fmt,va_list args) { return ImGui::SetTooltipV(fmt,args); } CIMGUI_API bool igBeginItemTooltip() { return ImGui::BeginItemTooltip(); } CIMGUI_API void igSetItemTooltip(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::SetItemTooltipV(fmt,args); va_end(args); } CIMGUI_API void igSetItemTooltipV(const char* fmt,va_list args) { return ImGui::SetItemTooltipV(fmt,args); } CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags) { return ImGui::BeginPopup(str_id,flags); } CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags) { return ImGui::BeginPopupModal(name,p_open,flags); } CIMGUI_API void igEndPopup() { return ImGui::EndPopup(); } CIMGUI_API void igOpenPopup_Str(const char* str_id,ImGuiPopupFlags popup_flags) { return ImGui::OpenPopup(str_id,popup_flags); } CIMGUI_API void igOpenPopup_ID(ImGuiID id,ImGuiPopupFlags popup_flags) { return ImGui::OpenPopup(id,popup_flags); } CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags) { return ImGui::OpenPopupOnItemClick(str_id,popup_flags); } CIMGUI_API void igCloseCurrentPopup() { return ImGui::CloseCurrentPopup(); } CIMGUI_API bool igBeginPopupContextItem(const char* str_id,ImGuiPopupFlags popup_flags) { return ImGui::BeginPopupContextItem(str_id,popup_flags); } CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,ImGuiPopupFlags popup_flags) { return ImGui::BeginPopupContextWindow(str_id,popup_flags); } CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,ImGuiPopupFlags popup_flags) { return ImGui::BeginPopupContextVoid(str_id,popup_flags); } CIMGUI_API bool igIsPopupOpen_Str(const char* str_id,ImGuiPopupFlags flags) { return ImGui::IsPopupOpen(str_id,flags); } CIMGUI_API bool igBeginTable(const char* str_id,int columns,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width) { return ImGui::BeginTable(str_id,columns,flags,outer_size,inner_width); } CIMGUI_API void igEndTable() { return ImGui::EndTable(); } CIMGUI_API void igTableNextRow(ImGuiTableRowFlags row_flags,float min_row_height) { return ImGui::TableNextRow(row_flags,min_row_height); } CIMGUI_API bool igTableNextColumn() { return ImGui::TableNextColumn(); } CIMGUI_API bool igTableSetColumnIndex(int column_n) { return ImGui::TableSetColumnIndex(column_n); } CIMGUI_API void igTableSetupColumn(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImGuiID user_id) { return ImGui::TableSetupColumn(label,flags,init_width_or_weight,user_id); } CIMGUI_API void igTableSetupScrollFreeze(int cols,int rows) { return ImGui::TableSetupScrollFreeze(cols,rows); } CIMGUI_API void igTableHeader(const char* label) { return ImGui::TableHeader(label); } CIMGUI_API void igTableHeadersRow() { return ImGui::TableHeadersRow(); } CIMGUI_API void igTableAngledHeadersRow() { return ImGui::TableAngledHeadersRow(); } CIMGUI_API ImGuiTableSortSpecs* igTableGetSortSpecs() { return ImGui::TableGetSortSpecs(); } CIMGUI_API int igTableGetColumnCount() { return ImGui::TableGetColumnCount(); } CIMGUI_API int igTableGetColumnIndex() { return ImGui::TableGetColumnIndex(); } CIMGUI_API int igTableGetRowIndex() { return ImGui::TableGetRowIndex(); } CIMGUI_API const char* igTableGetColumnName_Int(int column_n) { return ImGui::TableGetColumnName(column_n); } CIMGUI_API ImGuiTableColumnFlags igTableGetColumnFlags(int column_n) { return ImGui::TableGetColumnFlags(column_n); } CIMGUI_API void igTableSetColumnEnabled(int column_n,bool v) { return ImGui::TableSetColumnEnabled(column_n,v); } CIMGUI_API int igTableGetHoveredColumn() { return ImGui::TableGetHoveredColumn(); } CIMGUI_API void igTableSetBgColor(ImGuiTableBgTarget target,ImU32 color,int column_n) { return ImGui::TableSetBgColor(target,color,column_n); } CIMGUI_API void igColumns(int count,const char* id,bool border) { return ImGui::Columns(count,id,border); } CIMGUI_API void igNextColumn() { return ImGui::NextColumn(); } CIMGUI_API int igGetColumnIndex() { return ImGui::GetColumnIndex(); } CIMGUI_API float igGetColumnWidth(int column_index) { return ImGui::GetColumnWidth(column_index); } CIMGUI_API void igSetColumnWidth(int column_index,float width) { return ImGui::SetColumnWidth(column_index,width); } CIMGUI_API float igGetColumnOffset(int column_index) { return ImGui::GetColumnOffset(column_index); } CIMGUI_API void igSetColumnOffset(int column_index,float offset_x) { return ImGui::SetColumnOffset(column_index,offset_x); } CIMGUI_API int igGetColumnsCount() { return ImGui::GetColumnsCount(); } CIMGUI_API bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags) { return ImGui::BeginTabBar(str_id,flags); } CIMGUI_API void igEndTabBar() { return ImGui::EndTabBar(); } CIMGUI_API bool igBeginTabItem(const char* label,bool* p_open,ImGuiTabItemFlags flags) { return ImGui::BeginTabItem(label,p_open,flags); } CIMGUI_API void igEndTabItem() { return ImGui::EndTabItem(); } CIMGUI_API bool igTabItemButton(const char* label,ImGuiTabItemFlags flags) { return ImGui::TabItemButton(label,flags); } CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label) { return ImGui::SetTabItemClosed(tab_or_docked_window_label); } CIMGUI_API ImGuiID igDockSpace(ImGuiID dockspace_id,const ImVec2 size,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class) { return ImGui::DockSpace(dockspace_id,size,flags,window_class); } CIMGUI_API ImGuiID igDockSpaceOverViewport(ImGuiID dockspace_id,const ImGuiViewport* viewport,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class) { return ImGui::DockSpaceOverViewport(dockspace_id,viewport,flags,window_class); } CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id,ImGuiCond cond) { return ImGui::SetNextWindowDockID(dock_id,cond); } CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class) { return ImGui::SetNextWindowClass(window_class); } CIMGUI_API ImGuiID igGetWindowDockID() { return ImGui::GetWindowDockID(); } CIMGUI_API bool igIsWindowDocked() { return ImGui::IsWindowDocked(); } CIMGUI_API void igLogToTTY(int auto_open_depth) { return ImGui::LogToTTY(auto_open_depth); } CIMGUI_API void igLogToFile(int auto_open_depth,const char* filename) { return ImGui::LogToFile(auto_open_depth,filename); } CIMGUI_API void igLogToClipboard(int auto_open_depth) { return ImGui::LogToClipboard(auto_open_depth); } CIMGUI_API void igLogFinish() { return ImGui::LogFinish(); } CIMGUI_API void igLogButtons() { return ImGui::LogButtons(); } CIMGUI_API void igLogTextV(const char* fmt,va_list args) { return ImGui::LogTextV(fmt,args); } CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags) { return ImGui::BeginDragDropSource(flags); } CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond) { return ImGui::SetDragDropPayload(type,data,sz,cond); } CIMGUI_API void igEndDragDropSource() { return ImGui::EndDragDropSource(); } CIMGUI_API bool igBeginDragDropTarget() { return ImGui::BeginDragDropTarget(); } CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags) { return ImGui::AcceptDragDropPayload(type,flags); } CIMGUI_API void igEndDragDropTarget() { return ImGui::EndDragDropTarget(); } CIMGUI_API const ImGuiPayload* igGetDragDropPayload() { return ImGui::GetDragDropPayload(); } CIMGUI_API void igBeginDisabled(bool disabled) { return ImGui::BeginDisabled(disabled); } CIMGUI_API void igEndDisabled() { return ImGui::EndDisabled(); } CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect) { return ImGui::PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect); } CIMGUI_API void igPopClipRect() { return ImGui::PopClipRect(); } CIMGUI_API void igSetItemDefaultFocus() { return ImGui::SetItemDefaultFocus(); } CIMGUI_API void igSetKeyboardFocusHere(int offset) { return ImGui::SetKeyboardFocusHere(offset); } CIMGUI_API void igSetNextItemAllowOverlap() { return ImGui::SetNextItemAllowOverlap(); } CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags) { return ImGui::IsItemHovered(flags); } CIMGUI_API bool igIsItemActive() { return ImGui::IsItemActive(); } CIMGUI_API bool igIsItemFocused() { return ImGui::IsItemFocused(); } CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button) { return ImGui::IsItemClicked(mouse_button); } CIMGUI_API bool igIsItemVisible() { return ImGui::IsItemVisible(); } CIMGUI_API bool igIsItemEdited() { return ImGui::IsItemEdited(); } CIMGUI_API bool igIsItemActivated() { return ImGui::IsItemActivated(); } CIMGUI_API bool igIsItemDeactivated() { return ImGui::IsItemDeactivated(); } CIMGUI_API bool igIsItemDeactivatedAfterEdit() { return ImGui::IsItemDeactivatedAfterEdit(); } CIMGUI_API bool igIsItemToggledOpen() { return ImGui::IsItemToggledOpen(); } CIMGUI_API bool igIsAnyItemHovered() { return ImGui::IsAnyItemHovered(); } CIMGUI_API bool igIsAnyItemActive() { return ImGui::IsAnyItemActive(); } CIMGUI_API bool igIsAnyItemFocused() { return ImGui::IsAnyItemFocused(); } CIMGUI_API ImGuiID igGetItemID() { return ImGui::GetItemID(); } CIMGUI_API void igGetItemRectMin(ImVec2 *pOut) { *pOut = ImGui::GetItemRectMin(); } CIMGUI_API void igGetItemRectMax(ImVec2 *pOut) { *pOut = ImGui::GetItemRectMax(); } CIMGUI_API void igGetItemRectSize(ImVec2 *pOut) { *pOut = ImGui::GetItemRectSize(); } CIMGUI_API ImGuiViewport* igGetMainViewport() { return ImGui::GetMainViewport(); } CIMGUI_API ImDrawList* igGetBackgroundDrawList(ImGuiViewport* viewport) { return ImGui::GetBackgroundDrawList(viewport); } CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport) { return ImGui::GetForegroundDrawList(viewport); } CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size) { return ImGui::IsRectVisible(size); } CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,const ImVec2 rect_max) { return ImGui::IsRectVisible(rect_min,rect_max); } CIMGUI_API double igGetTime() { return ImGui::GetTime(); } CIMGUI_API int igGetFrameCount() { return ImGui::GetFrameCount(); } CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData() { return ImGui::GetDrawListSharedData(); } CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx) { return ImGui::GetStyleColorName(idx); } CIMGUI_API void igSetStateStorage(ImGuiStorage* storage) { return ImGui::SetStateStorage(storage); } CIMGUI_API ImGuiStorage* igGetStateStorage() { return ImGui::GetStateStorage(); } CIMGUI_API void igCalcTextSize(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width) { *pOut = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width); } CIMGUI_API void igColorConvertU32ToFloat4(ImVec4 *pOut,ImU32 in) { *pOut = ImGui::ColorConvertU32ToFloat4(in); } CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in) { return ImGui::ColorConvertFloat4ToU32(in); } CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float* out_h,float* out_s,float* out_v) { return ImGui::ColorConvertRGBtoHSV(r,g,b,*out_h,*out_s,*out_v); } CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,float* out_g,float* out_b) { return ImGui::ColorConvertHSVtoRGB(h,s,v,*out_r,*out_g,*out_b); } CIMGUI_API bool igIsKeyDown_Nil(ImGuiKey key) { return ImGui::IsKeyDown(key); } CIMGUI_API bool igIsKeyPressed_Bool(ImGuiKey key,bool repeat) { return ImGui::IsKeyPressed(key,repeat); } CIMGUI_API bool igIsKeyReleased_Nil(ImGuiKey key) { return ImGui::IsKeyReleased(key); } CIMGUI_API bool igIsKeyChordPressed_Nil(ImGuiKeyChord key_chord) { return ImGui::IsKeyChordPressed(key_chord); } CIMGUI_API int igGetKeyPressedAmount(ImGuiKey key,float repeat_delay,float rate) { return ImGui::GetKeyPressedAmount(key,repeat_delay,rate); } CIMGUI_API const char* igGetKeyName(ImGuiKey key) { return ImGui::GetKeyName(key); } CIMGUI_API void igSetNextFrameWantCaptureKeyboard(bool want_capture_keyboard) { return ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard); } CIMGUI_API bool igShortcut_Nil(ImGuiKeyChord key_chord,ImGuiInputFlags flags) { return ImGui::Shortcut(key_chord,flags); } CIMGUI_API void igSetNextItemShortcut(ImGuiKeyChord key_chord,ImGuiInputFlags flags) { return ImGui::SetNextItemShortcut(key_chord,flags); } CIMGUI_API void igSetItemKeyOwner_Nil(ImGuiKey key) { return ImGui::SetItemKeyOwner(key); } CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button) { return ImGui::IsMouseDown(button); } CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button,bool repeat) { return ImGui::IsMouseClicked(button,repeat); } CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button) { return ImGui::IsMouseReleased(button); } CIMGUI_API bool igIsMouseDoubleClicked_Nil(ImGuiMouseButton button) { return ImGui::IsMouseDoubleClicked(button); } CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button) { return ImGui::GetMouseClickedCount(button); } CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip) { return ImGui::IsMouseHoveringRect(r_min,r_max,clip); } CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos) { return ImGui::IsMousePosValid(mouse_pos); } CIMGUI_API bool igIsAnyMouseDown() { return ImGui::IsAnyMouseDown(); } CIMGUI_API void igGetMousePos(ImVec2 *pOut) { *pOut = ImGui::GetMousePos(); } CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2 *pOut) { *pOut = ImGui::GetMousePosOnOpeningCurrentPopup(); } CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold) { return ImGui::IsMouseDragging(button,lock_threshold); } CIMGUI_API void igGetMouseDragDelta(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold) { *pOut = ImGui::GetMouseDragDelta(button,lock_threshold); } CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button) { return ImGui::ResetMouseDragDelta(button); } CIMGUI_API ImGuiMouseCursor igGetMouseCursor() { return ImGui::GetMouseCursor(); } CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type) { return ImGui::SetMouseCursor(cursor_type); } CIMGUI_API void igSetNextFrameWantCaptureMouse(bool want_capture_mouse) { return ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse); } CIMGUI_API const char* igGetClipboardText() { return ImGui::GetClipboardText(); } CIMGUI_API void igSetClipboardText(const char* text) { return ImGui::SetClipboardText(text); } CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename) { return ImGui::LoadIniSettingsFromDisk(ini_filename); } CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size) { return ImGui::LoadIniSettingsFromMemory(ini_data,ini_size); } CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename) { return ImGui::SaveIniSettingsToDisk(ini_filename); } CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size) { return ImGui::SaveIniSettingsToMemory(out_ini_size); } CIMGUI_API void igDebugTextEncoding(const char* text) { return ImGui::DebugTextEncoding(text); } CIMGUI_API void igDebugFlashStyleColor(ImGuiCol idx) { return ImGui::DebugFlashStyleColor(idx); } CIMGUI_API void igDebugStartItemPicker() { return ImGui::DebugStartItemPicker(); } 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) { return ImGui::DebugCheckVersionAndDataLayout(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx); } CIMGUI_API void igDebugLog(const char* fmt,...) { va_list args; va_start(args, fmt); ImGui::DebugLogV(fmt,args); va_end(args); } CIMGUI_API void igDebugLogV(const char* fmt,va_list args) { return ImGui::DebugLogV(fmt,args); } CIMGUI_API void igSetAllocatorFunctions(ImGuiMemAllocFunc alloc_func,ImGuiMemFreeFunc free_func,void* user_data) { return ImGui::SetAllocatorFunctions(alloc_func,free_func,user_data); } CIMGUI_API void igGetAllocatorFunctions(ImGuiMemAllocFunc* p_alloc_func,ImGuiMemFreeFunc* p_free_func,void** p_user_data) { return ImGui::GetAllocatorFunctions(p_alloc_func,p_free_func,p_user_data); } CIMGUI_API void* igMemAlloc(size_t size) { return ImGui::MemAlloc(size); } CIMGUI_API void igMemFree(void* ptr) { return ImGui::MemFree(ptr); } CIMGUI_API ImGuiPlatformIO* igGetPlatformIO() { return &ImGui::GetPlatformIO(); } CIMGUI_API void igUpdatePlatformWindows() { return ImGui::UpdatePlatformWindows(); } CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_render_arg,void* renderer_render_arg) { return ImGui::RenderPlatformWindowsDefault(platform_render_arg,renderer_render_arg); } CIMGUI_API void igDestroyPlatformWindows() { return ImGui::DestroyPlatformWindows(); } CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id) { return ImGui::FindViewportByID(id); } CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle) { return ImGui::FindViewportByPlatformHandle(platform_handle); } CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void) { return IM_NEW(ImGuiTableSortSpecs)(); } CIMGUI_API void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableColumnSortSpecs* ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs(void) { return IM_NEW(ImGuiTableColumnSortSpecs)(); } CIMGUI_API void ImGuiTableColumnSortSpecs_destroy(ImGuiTableColumnSortSpecs* self) { IM_DELETE(self); } CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void) { return IM_NEW(ImGuiStyle)(); } CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self) { IM_DELETE(self); } CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor) { return self->ScaleAllSizes(scale_factor); } CIMGUI_API void ImGuiIO_AddKeyEvent(ImGuiIO* self,ImGuiKey key,bool down) { return self->AddKeyEvent(key,down); } CIMGUI_API void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self,ImGuiKey key,bool down,float v) { return self->AddKeyAnalogEvent(key,down,v); } CIMGUI_API void ImGuiIO_AddMousePosEvent(ImGuiIO* self,float x,float y) { return self->AddMousePosEvent(x,y); } CIMGUI_API void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self,int button,bool down) { return self->AddMouseButtonEvent(button,down); } CIMGUI_API void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self,float wheel_x,float wheel_y) { return self->AddMouseWheelEvent(wheel_x,wheel_y); } CIMGUI_API void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self,ImGuiMouseSource source) { return self->AddMouseSourceEvent(source); } CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self,ImGuiID id) { return self->AddMouseViewportEvent(id); } CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self,bool focused) { return self->AddFocusEvent(focused); } CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c) { return self->AddInputCharacter(c); } CIMGUI_API void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self,ImWchar16 c) { return self->AddInputCharacterUTF16(c); } CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str) { return self->AddInputCharactersUTF8(str); } CIMGUI_API void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self,ImGuiKey key,int native_keycode,int native_scancode,int native_legacy_index) { return self->SetKeyEventNativeData(key,native_keycode,native_scancode,native_legacy_index); } CIMGUI_API void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self,bool accepting_events) { return self->SetAppAcceptingEvents(accepting_events); } CIMGUI_API void ImGuiIO_ClearEventsQueue(ImGuiIO* self) { return self->ClearEventsQueue(); } CIMGUI_API void ImGuiIO_ClearInputKeys(ImGuiIO* self) { return self->ClearInputKeys(); } CIMGUI_API void ImGuiIO_ClearInputMouse(ImGuiIO* self) { return self->ClearInputMouse(); } CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void) { return IM_NEW(ImGuiIO)(); } CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self) { IM_DELETE(self); } CIMGUI_API ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void) { return IM_NEW(ImGuiInputTextCallbackData)(); } CIMGUI_API void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count) { return self->DeleteChars(pos,bytes_count); } CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end) { return self->InsertChars(pos,text,text_end); } CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self) { return self->SelectAll(); } CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self) { return self->ClearSelection(); } CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self) { return self->HasSelection(); } CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void) { return IM_NEW(ImGuiWindowClass)(); } CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self) { IM_DELETE(self); } CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void) { return IM_NEW(ImGuiPayload)(); } CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self) { IM_DELETE(self); } CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self) { return self->Clear(); } CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type) { return self->IsDataType(type); } CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self) { return self->IsPreview(); } CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self) { return self->IsDelivery(); } CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void) { return IM_NEW(ImGuiOnceUponAFrame)(); } CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self) { IM_DELETE(self); } CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter) { return IM_NEW(ImGuiTextFilter)(default_filter); } CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self) { IM_DELETE(self); } CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width) { return self->Draw(label,width); } CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end) { return self->PassFilter(text,text_end); } CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self) { return self->Build(); } CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self) { return self->Clear(); } CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self) { return self->IsActive(); } CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil(void) { return IM_NEW(ImGuiTextRange)(); } CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self) { IM_DELETE(self); } CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(const char* _b,const char* _e) { return IM_NEW(ImGuiTextRange)(_b,_e); } CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self) { return self->empty(); } CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out) { return self->split(separator,out); } CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void) { return IM_NEW(ImGuiTextBuffer)(); } CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self) { IM_DELETE(self); } CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self) { return self->begin(); } CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self) { return self->end(); } CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self) { return self->size(); } CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self) { return self->empty(); } CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self) { return self->clear(); } CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity) { return self->reserve(capacity); } CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self) { return self->c_str(); } CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end) { return self->append(str,str_end); } CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args) { return self->appendfv(fmt,args); } CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(ImGuiID _key,int _val) { return IM_NEW(ImGuiStoragePair)(_key,_val); } CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self) { IM_DELETE(self); } CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(ImGuiID _key,float _val) { return IM_NEW(ImGuiStoragePair)(_key,_val); } CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(ImGuiID _key,void* _val) { return IM_NEW(ImGuiStoragePair)(_key,_val); } CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self) { return self->Clear(); } CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val) { return self->GetInt(key,default_val); } CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val) { return self->SetInt(key,val); } CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key,bool default_val) { return self->GetBool(key,default_val); } CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key,bool val) { return self->SetBool(key,val); } CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val) { return self->GetFloat(key,default_val); } CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val) { return self->SetFloat(key,val); } CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key) { return self->GetVoidPtr(key); } CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val) { return self->SetVoidPtr(key,val); } CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val) { return self->GetIntRef(key,default_val); } CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key,bool default_val) { return self->GetBoolRef(key,default_val); } CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val) { return self->GetFloatRef(key,default_val); } CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val) { return self->GetVoidPtrRef(key,default_val); } CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self) { return self->BuildSortByKey(); } CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val) { return self->SetAllInt(val); } CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void) { return IM_NEW(ImGuiListClipper)(); } CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self) { IM_DELETE(self); } CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height) { return self->Begin(items_count,items_height); } CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self) { return self->End(); } CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self) { return self->Step(); } CIMGUI_API void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self,int item_index) { return self->IncludeItemByIndex(item_index); } CIMGUI_API void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self,int item_begin,int item_end) { return self->IncludeItemsByIndex(item_begin,item_end); } CIMGUI_API void ImGuiListClipper_SeekCursorForItem(ImGuiListClipper* self,int item_index) { return self->SeekCursorForItem(item_index); } CIMGUI_API ImColor* ImColor_ImColor_Nil(void) { return IM_NEW(ImColor)(); } CIMGUI_API void ImColor_destroy(ImColor* self) { IM_DELETE(self); } CIMGUI_API ImColor* ImColor_ImColor_Float(float r,float g,float b,float a) { return IM_NEW(ImColor)(r,g,b,a); } CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col) { return IM_NEW(ImColor)(col); } CIMGUI_API ImColor* ImColor_ImColor_Int(int r,int g,int b,int a) { return IM_NEW(ImColor)(r,g,b,a); } CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba) { return IM_NEW(ImColor)(rgba); } CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a) { return self->SetHSV(h,s,v,a); } CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a) { *pOut = ImColor::HSV(h,s,v,a); } CIMGUI_API ImGuiSelectionBasicStorage* ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage(void) { return IM_NEW(ImGuiSelectionBasicStorage)(); } CIMGUI_API void ImGuiSelectionBasicStorage_destroy(ImGuiSelectionBasicStorage* self) { IM_DELETE(self); } CIMGUI_API void ImGuiSelectionBasicStorage_ApplyRequests(ImGuiSelectionBasicStorage* self,ImGuiMultiSelectIO* ms_io) { return self->ApplyRequests(ms_io); } CIMGUI_API bool ImGuiSelectionBasicStorage_Contains(ImGuiSelectionBasicStorage* self,ImGuiID id) { return self->Contains(id); } CIMGUI_API void ImGuiSelectionBasicStorage_Clear(ImGuiSelectionBasicStorage* self) { return self->Clear(); } CIMGUI_API void ImGuiSelectionBasicStorage_Swap(ImGuiSelectionBasicStorage* self,ImGuiSelectionBasicStorage* r) { return self->Swap(*r); } CIMGUI_API void ImGuiSelectionBasicStorage_SetItemSelected(ImGuiSelectionBasicStorage* self,ImGuiID id,bool selected) { return self->SetItemSelected(id,selected); } CIMGUI_API bool ImGuiSelectionBasicStorage_GetNextSelectedItem(ImGuiSelectionBasicStorage* self,void** opaque_it,ImGuiID* out_id) { return self->GetNextSelectedItem(opaque_it,out_id); } CIMGUI_API ImGuiID ImGuiSelectionBasicStorage_GetStorageIdFromIndex(ImGuiSelectionBasicStorage* self,int idx) { return self->GetStorageIdFromIndex(idx); } CIMGUI_API ImGuiSelectionExternalStorage* ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage(void) { return IM_NEW(ImGuiSelectionExternalStorage)(); } CIMGUI_API void ImGuiSelectionExternalStorage_destroy(ImGuiSelectionExternalStorage* self) { IM_DELETE(self); } CIMGUI_API void ImGuiSelectionExternalStorage_ApplyRequests(ImGuiSelectionExternalStorage* self,ImGuiMultiSelectIO* ms_io) { return self->ApplyRequests(ms_io); } CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void) { return IM_NEW(ImDrawCmd)(); } CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self) { IM_DELETE(self); } CIMGUI_API ImTextureID ImDrawCmd_GetTexID(ImDrawCmd* self) { return self->GetTexID(); } CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void) { return IM_NEW(ImDrawListSplitter)(); } CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self) { IM_DELETE(self); } CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self) { return self->Clear(); } CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self) { return self->ClearFreeMemory(); } CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count) { return self->Split(draw_list,count); } CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list) { return self->Merge(draw_list); } CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx) { return self->SetCurrentChannel(draw_list,channel_idx); } CIMGUI_API ImDrawList* ImDrawList_ImDrawList(ImDrawListSharedData* shared_data) { return IM_NEW(ImDrawList)(shared_data); } CIMGUI_API void ImDrawList_destroy(ImDrawList* self) { IM_DELETE(self); } CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect) { return self->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect); } CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self) { return self->PushClipRectFullScreen(); } CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self) { return self->PopClipRect(); } CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id) { return self->PushTextureID(texture_id); } CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self) { return self->PopTextureID(); } CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2 *pOut,ImDrawList* self) { *pOut = self->GetClipRectMin(); } CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2 *pOut,ImDrawList* self) { *pOut = self->GetClipRectMax(); } CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness) { return self->AddLine(p1,p2,col,thickness); } CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags,float thickness) { return self->AddRect(p_min,p_max,col,rounding,flags,thickness); } CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags) { return self->AddRectFilled(p_min,p_max,col,rounding,flags); } 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) { return self->AddRectFilledMultiColor(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left); } CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness) { return self->AddQuad(p1,p2,p3,p4,col,thickness); } CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col) { return self->AddQuadFilled(p1,p2,p3,p4,col); } CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness) { return self->AddTriangle(p1,p2,p3,col,thickness); } CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col) { return self->AddTriangleFilled(p1,p2,p3,col); } CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness) { return self->AddCircle(center,radius,col,num_segments,thickness); } CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments) { return self->AddCircleFilled(center,radius,col,num_segments); } CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness) { return self->AddNgon(center,radius,col,num_segments,thickness); } CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments) { return self->AddNgonFilled(center,radius,col,num_segments); } CIMGUI_API void ImDrawList_AddEllipse(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments,float thickness) { return self->AddEllipse(center,radius,col,rot,num_segments,thickness); } CIMGUI_API void ImDrawList_AddEllipseFilled(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments) { return self->AddEllipseFilled(center,radius,col,rot,num_segments); } CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end) { return self->AddText(pos,col,text_begin,text_end); } CIMGUI_API void ImDrawList_AddText_FontPtr(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) { return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect); } CIMGUI_API void ImDrawList_AddBezierCubic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments) { return self->AddBezierCubic(p1,p2,p3,p4,col,thickness,num_segments); } CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness,int num_segments) { return self->AddBezierQuadratic(p1,p2,p3,col,thickness,num_segments); } CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness) { return self->AddPolyline(points,num_points,col,flags,thickness); } CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col) { return self->AddConvexPolyFilled(points,num_points,col); } CIMGUI_API void ImDrawList_AddConcavePolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col) { return self->AddConcavePolyFilled(points,num_points,col); } 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) { return self->AddImage(user_texture_id,p_min,p_max,uv_min,uv_max,col); } 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) { return self->AddImageQuad(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col); } 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,ImDrawFlags flags) { return self->AddImageRounded(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,flags); } CIMGUI_API void ImDrawList_PathClear(ImDrawList* self) { return self->PathClear(); } CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos) { return self->PathLineTo(pos); } CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos) { return self->PathLineToMergeDuplicate(pos); } CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col) { return self->PathFillConvex(col); } CIMGUI_API void ImDrawList_PathFillConcave(ImDrawList* self,ImU32 col) { return self->PathFillConcave(col); } CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,ImDrawFlags flags,float thickness) { return self->PathStroke(col,flags,thickness); } CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments) { return self->PathArcTo(center,radius,a_min,a_max,num_segments); } CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12) { return self->PathArcToFast(center,radius,a_min_of_12,a_max_of_12); } CIMGUI_API void ImDrawList_PathEllipticalArcTo(ImDrawList* self,const ImVec2 center,const ImVec2 radius,float rot,float a_min,float a_max,int num_segments) { return self->PathEllipticalArcTo(center,radius,rot,a_min,a_max,num_segments); } CIMGUI_API void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments) { return self->PathBezierCubicCurveTo(p2,p3,p4,num_segments); } CIMGUI_API void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,int num_segments) { return self->PathBezierQuadraticCurveTo(p2,p3,num_segments); } CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawFlags flags) { return self->PathRect(rect_min,rect_max,rounding,flags); } CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data) { return self->AddCallback(callback,callback_data); } CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self) { return self->AddDrawCmd(); } CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self) { return self->CloneOutput(); } CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int count) { return self->ChannelsSplit(count); } CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self) { return self->ChannelsMerge(); } CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n) { return self->ChannelsSetCurrent(n); } CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count) { return self->PrimReserve(idx_count,vtx_count); } CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,int idx_count,int vtx_count) { return self->PrimUnreserve(idx_count,vtx_count); } CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col) { return self->PrimRect(a,b,col); } CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col) { return self->PrimRectUV(a,b,uv_a,uv_b,col); } 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) { return self->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col); } CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col) { return self->PrimWriteVtx(pos,uv,col); } CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx) { return self->PrimWriteIdx(idx); } CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col) { return self->PrimVtx(pos,uv,col); } CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self) { return self->_ResetForNewFrame(); } CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self) { return self->_ClearFreeMemory(); } CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self) { return self->_PopUnusedDrawCmd(); } CIMGUI_API void ImDrawList__TryMergeDrawCmds(ImDrawList* self) { return self->_TryMergeDrawCmds(); } CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self) { return self->_OnChangedClipRect(); } CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self) { return self->_OnChangedTextureID(); } CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self) { return self->_OnChangedVtxOffset(); } CIMGUI_API int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self,float radius) { return self->_CalcCircleAutoSegmentCount(radius); } CIMGUI_API void ImDrawList__PathArcToFastEx(ImDrawList* self,const ImVec2 center,float radius,int a_min_sample,int a_max_sample,int a_step) { return self->_PathArcToFastEx(center,radius,a_min_sample,a_max_sample,a_step); } CIMGUI_API void ImDrawList__PathArcToN(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments) { return self->_PathArcToN(center,radius,a_min,a_max,num_segments); } CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void) { return IM_NEW(ImDrawData)(); } CIMGUI_API void ImDrawData_destroy(ImDrawData* self) { IM_DELETE(self); } CIMGUI_API void ImDrawData_Clear(ImDrawData* self) { return self->Clear(); } CIMGUI_API void ImDrawData_AddDrawList(ImDrawData* self,ImDrawList* draw_list) { return self->AddDrawList(draw_list); } CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self) { return self->DeIndexAllBuffers(); } CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale) { return self->ScaleClipRects(fb_scale); } CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void) { return IM_NEW(ImFontConfig)(); } CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self) { IM_DELETE(self); } CIMGUI_API ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void) { return IM_NEW(ImFontGlyphRangesBuilder)(); } CIMGUI_API void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self) { IM_DELETE(self); } CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self) { return self->Clear(); } CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,size_t n) { return self->GetBit(n); } CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,size_t n) { return self->SetBit(n); } CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c) { return self->AddChar(c); } CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end) { return self->AddText(text,text_end); } CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges) { return self->AddRanges(ranges); } CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges) { return self->BuildRanges(out_ranges); } CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void) { return IM_NEW(ImFontAtlasCustomRect)(); } CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self) { IM_DELETE(self); } CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self) { return self->IsPacked(); } CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void) { return IM_NEW(ImFontAtlas)(); } CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self) { IM_DELETE(self); } CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg) { return self->AddFont(font_cfg); } CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg) { return self->AddFontDefault(font_cfg); } CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) { return self->AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges); } CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_data_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) { return self->AddFontFromMemoryTTF(font_data,font_data_size,size_pixels,font_cfg,glyph_ranges); } CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_data_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) { return self->AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_data_size,size_pixels,font_cfg,glyph_ranges); } CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) { return self->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges); } CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self) { return self->ClearInputData(); } CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self) { return self->ClearTexData(); } CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self) { return self->ClearFonts(); } CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self) { return self->Clear(); } CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self) { return self->Build(); } CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel) { return self->GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel); } CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel) { return self->GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel); } CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self) { return self->IsBuilt(); } CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id) { return self->SetTexID(id); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self) { return self->GetGlyphRangesDefault(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self) { return self->GetGlyphRangesGreek(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self) { return self->GetGlyphRangesKorean(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self) { return self->GetGlyphRangesJapanese(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self) { return self->GetGlyphRangesChineseFull(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self) { return self->GetGlyphRangesChineseSimplifiedCommon(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self) { return self->GetGlyphRangesCyrillic(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self) { return self->GetGlyphRangesThai(); } CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self) { return self->GetGlyphRangesVietnamese(); } CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,int width,int height) { return self->AddCustomRectRegular(width,height); } CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset) { return self->AddCustomRectFontGlyph(font,id,width,height,advance_x,offset); } CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index) { return self->GetCustomRectByIndex(index); } CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max) { return self->CalcCustomRectUV(rect,out_uv_min,out_uv_max); } 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]) { return self->GetMouseCursorTexData(cursor,out_offset,out_size,out_uv_border,out_uv_fill); } CIMGUI_API ImFont* ImFont_ImFont(void) { return IM_NEW(ImFont)(); } CIMGUI_API void ImFont_destroy(ImFont* self) { IM_DELETE(self); } CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c) { return self->FindGlyph(c); } CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c) { return self->FindGlyphNoFallback(c); } CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c) { return self->GetCharAdvance(c); } CIMGUI_API bool ImFont_IsLoaded(ImFont* self) { return self->IsLoaded(); } CIMGUI_API const char* ImFont_GetDebugName(ImFont* self) { return self->GetDebugName(); } CIMGUI_API void ImFont_CalcTextSizeA(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining) { *pOut = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining); } CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width) { return self->CalcWordWrapPositionA(scale,text,text_end,wrap_width); } CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,ImWchar c) { return self->RenderChar(draw_list,size,pos,col,c); } CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip) { return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip); } CIMGUI_API void ImFont_BuildLookupTable(ImFont* self) { return self->BuildLookupTable(); } CIMGUI_API void ImFont_ClearOutputData(ImFont* self) { return self->ClearOutputData(); } CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size) { return self->GrowIndex(new_size); } CIMGUI_API void ImFont_AddGlyph(ImFont* self,const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x) { return self->AddGlyph(src_cfg,c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x); } CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst) { return self->AddRemapChar(dst,src,overwrite_dst); } CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self,ImWchar c,bool visible) { return self->SetGlyphVisible(c,visible); } CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,unsigned int c_begin,unsigned int c_last) { return self->IsGlyphRangeUnused(c_begin,c_last); } CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void) { return IM_NEW(ImGuiViewport)(); } CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self) { IM_DELETE(self); } CIMGUI_API void ImGuiViewport_GetCenter(ImVec2 *pOut,ImGuiViewport* self) { *pOut = self->GetCenter(); } CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2 *pOut,ImGuiViewport* self) { *pOut = self->GetWorkCenter(); } CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void) { return IM_NEW(ImGuiPlatformIO)(); } CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self) { IM_DELETE(self); } CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(void) { return IM_NEW(ImGuiPlatformMonitor)(); } CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self) { IM_DELETE(self); } CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(void) { return IM_NEW(ImGuiPlatformImeData)(); } CIMGUI_API void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self) { IM_DELETE(self); } CIMGUI_API ImGuiID igImHashData(const void* data,size_t data_size,ImGuiID seed) { return ImHashData(data,data_size,seed); } CIMGUI_API ImGuiID igImHashStr(const char* data,size_t data_size,ImGuiID seed) { return ImHashStr(data,data_size,seed); } CIMGUI_API void igImQsort(void* base,size_t count,size_t size_of_element,int(*compare_func)(void const*,void const*)) { return ImQsort(base,count,size_of_element,compare_func); } CIMGUI_API ImU32 igImAlphaBlendColors(ImU32 col_a,ImU32 col_b) { return ImAlphaBlendColors(col_a,col_b); } CIMGUI_API bool igImIsPowerOfTwo_Int(int v) { return ImIsPowerOfTwo(v); } CIMGUI_API bool igImIsPowerOfTwo_U64(ImU64 v) { return ImIsPowerOfTwo(v); } CIMGUI_API int igImUpperPowerOfTwo(int v) { return ImUpperPowerOfTwo(v); } CIMGUI_API int igImStricmp(const char* str1,const char* str2) { return ImStricmp(str1,str2); } CIMGUI_API int igImStrnicmp(const char* str1,const char* str2,size_t count) { return ImStrnicmp(str1,str2,count); } CIMGUI_API void igImStrncpy(char* dst,const char* src,size_t count) { return ImStrncpy(dst,src,count); } CIMGUI_API char* igImStrdup(const char* str) { return ImStrdup(str); } CIMGUI_API char* igImStrdupcpy(char* dst,size_t* p_dst_size,const char* str) { return ImStrdupcpy(dst,p_dst_size,str); } CIMGUI_API const char* igImStrchrRange(const char* str_begin,const char* str_end,char c) { return ImStrchrRange(str_begin,str_end,c); } CIMGUI_API const char* igImStreolRange(const char* str,const char* str_end) { return ImStreolRange(str,str_end); } CIMGUI_API const char* igImStristr(const char* haystack,const char* haystack_end,const char* needle,const char* needle_end) { return ImStristr(haystack,haystack_end,needle,needle_end); } CIMGUI_API void igImStrTrimBlanks(char* str) { return ImStrTrimBlanks(str); } CIMGUI_API const char* igImStrSkipBlank(const char* str) { return ImStrSkipBlank(str); } CIMGUI_API int igImStrlenW(const ImWchar* str) { return ImStrlenW(str); } CIMGUI_API const ImWchar* igImStrbolW(const ImWchar* buf_mid_line,const ImWchar* buf_begin) { return ImStrbolW(buf_mid_line,buf_begin); } CIMGUI_API char igImToUpper(char c) { return ImToUpper(c); } CIMGUI_API bool igImCharIsBlankA(char c) { return ImCharIsBlankA(c); } CIMGUI_API bool igImCharIsBlankW(unsigned int c) { return ImCharIsBlankW(c); } CIMGUI_API bool igImCharIsXdigitA(char c) { return ImCharIsXdigitA(c); } CIMGUI_API int igImFormatString(char* buf,size_t buf_size,const char* fmt,...) { va_list args; va_start(args, fmt); int ret = ImFormatStringV(buf,buf_size,fmt,args); va_end(args); return ret; } CIMGUI_API int igImFormatStringV(char* buf,size_t buf_size,const char* fmt,va_list args) { return ImFormatStringV(buf,buf_size,fmt,args); } CIMGUI_API void igImFormatStringToTempBuffer(const char** out_buf,const char** out_buf_end,const char* fmt,...) { va_list args; va_start(args, fmt); ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args); va_end(args); } CIMGUI_API void igImFormatStringToTempBufferV(const char** out_buf,const char** out_buf_end,const char* fmt,va_list args) { return ImFormatStringToTempBufferV(out_buf,out_buf_end,fmt,args); } CIMGUI_API const char* igImParseFormatFindStart(const char* format) { return ImParseFormatFindStart(format); } CIMGUI_API const char* igImParseFormatFindEnd(const char* format) { return ImParseFormatFindEnd(format); } CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,char* buf,size_t buf_size) { return ImParseFormatTrimDecorations(format,buf,buf_size); } CIMGUI_API void igImParseFormatSanitizeForPrinting(const char* fmt_in,char* fmt_out,size_t fmt_out_size) { return ImParseFormatSanitizeForPrinting(fmt_in,fmt_out,fmt_out_size); } CIMGUI_API const char* igImParseFormatSanitizeForScanning(const char* fmt_in,char* fmt_out,size_t fmt_out_size) { return ImParseFormatSanitizeForScanning(fmt_in,fmt_out,fmt_out_size); } CIMGUI_API int igImParseFormatPrecision(const char* format,int default_value) { return ImParseFormatPrecision(format,default_value); } CIMGUI_API const char* igImTextCharToUtf8(char out_buf[5],unsigned int c) { return ImTextCharToUtf8(out_buf,c); } CIMGUI_API int igImTextStrToUtf8(char* out_buf,int out_buf_size,const ImWchar* in_text,const ImWchar* in_text_end) { return ImTextStrToUtf8(out_buf,out_buf_size,in_text,in_text_end); } CIMGUI_API int igImTextCharFromUtf8(unsigned int* out_char,const char* in_text,const char* in_text_end) { return ImTextCharFromUtf8(out_char,in_text,in_text_end); } CIMGUI_API int igImTextStrFromUtf8(ImWchar* out_buf,int out_buf_size,const char* in_text,const char* in_text_end,const char** in_remaining) { return ImTextStrFromUtf8(out_buf,out_buf_size,in_text,in_text_end,in_remaining); } CIMGUI_API int igImTextCountCharsFromUtf8(const char* in_text,const char* in_text_end) { return ImTextCountCharsFromUtf8(in_text,in_text_end); } CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,const char* in_text_end) { return ImTextCountUtf8BytesFromChar(in_text,in_text_end); } CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,const ImWchar* in_text_end) { return ImTextCountUtf8BytesFromStr(in_text,in_text_end); } CIMGUI_API const char* igImTextFindPreviousUtf8Codepoint(const char* in_text_start,const char* in_text_curr) { return ImTextFindPreviousUtf8Codepoint(in_text_start,in_text_curr); } CIMGUI_API int igImTextCountLines(const char* in_text,const char* in_text_end) { return ImTextCountLines(in_text,in_text_end); } CIMGUI_API ImFileHandle igImFileOpen(const char* filename,const char* mode) { return ImFileOpen(filename,mode); } CIMGUI_API bool igImFileClose(ImFileHandle file) { return ImFileClose(file); } CIMGUI_API ImU64 igImFileGetSize(ImFileHandle file) { return ImFileGetSize(file); } CIMGUI_API ImU64 igImFileRead(void* data,ImU64 size,ImU64 count,ImFileHandle file) { return ImFileRead(data,size,count,file); } CIMGUI_API ImU64 igImFileWrite(const void* data,ImU64 size,ImU64 count,ImFileHandle file) { return ImFileWrite(data,size,count,file); } CIMGUI_API void* igImFileLoadToMemory(const char* filename,const char* mode,size_t* out_file_size,int padding_bytes) { return ImFileLoadToMemory(filename,mode,out_file_size,padding_bytes); } CIMGUI_API float igImPow_Float(float x,float y) { return ImPow(x,y); } CIMGUI_API double igImPow_double(double x,double y) { return ImPow(x,y); } CIMGUI_API float igImLog_Float(float x) { return ImLog(x); } CIMGUI_API double igImLog_double(double x) { return ImLog(x); } CIMGUI_API int igImAbs_Int(int x) { return ImAbs(x); } CIMGUI_API float igImAbs_Float(float x) { return ImAbs(x); } CIMGUI_API double igImAbs_double(double x) { return ImAbs(x); } CIMGUI_API float igImSign_Float(float x) { return ImSign(x); } CIMGUI_API double igImSign_double(double x) { return ImSign(x); } CIMGUI_API float igImRsqrt_Float(float x) { return ImRsqrt(x); } CIMGUI_API double igImRsqrt_double(double x) { return ImRsqrt(x); } CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs) { *pOut = ImMin(lhs,rhs); } CIMGUI_API void igImMax(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs) { *pOut = ImMax(lhs,rhs); } CIMGUI_API void igImClamp(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,const ImVec2 mx) { *pOut = ImClamp(v,mn,mx); } CIMGUI_API void igImLerp_Vec2Float(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t) { *pOut = ImLerp(a,b,t); } CIMGUI_API void igImLerp_Vec2Vec2(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t) { *pOut = ImLerp(a,b,t); } CIMGUI_API void igImLerp_Vec4(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t) { *pOut = ImLerp(a,b,t); } CIMGUI_API float igImSaturate(float f) { return ImSaturate(f); } CIMGUI_API float igImLengthSqr_Vec2(const ImVec2 lhs) { return ImLengthSqr(lhs); } CIMGUI_API float igImLengthSqr_Vec4(const ImVec4 lhs) { return ImLengthSqr(lhs); } CIMGUI_API float igImInvLength(const ImVec2 lhs,float fail_value) { return ImInvLength(lhs,fail_value); } CIMGUI_API float igImTrunc_Float(float f) { return ImTrunc(f); } CIMGUI_API void igImTrunc_Vec2(ImVec2 *pOut,const ImVec2 v) { *pOut = ImTrunc(v); } CIMGUI_API float igImFloor_Float(float f) { return ImFloor(f); } CIMGUI_API void igImFloor_Vec2(ImVec2 *pOut,const ImVec2 v) { *pOut = ImFloor(v); } CIMGUI_API int igImModPositive(int a,int b) { return ImModPositive(a,b); } CIMGUI_API float igImDot(const ImVec2 a,const ImVec2 b) { return ImDot(a,b); } CIMGUI_API void igImRotate(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a) { *pOut = ImRotate(v,cos_a,sin_a); } CIMGUI_API float igImLinearSweep(float current,float target,float speed) { return ImLinearSweep(current,target,speed); } CIMGUI_API float igImLinearRemapClamp(float s0,float s1,float d0,float d1,float x) { return ImLinearRemapClamp(s0,s1,d0,d1,x); } CIMGUI_API void igImMul(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs) { *pOut = ImMul(lhs,rhs); } CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f) { return ImIsFloatAboveGuaranteedIntegerPrecision(f); } CIMGUI_API float igImExponentialMovingAverage(float avg,float sample,int n) { return ImExponentialMovingAverage(avg,sample,n); } CIMGUI_API void igImBezierCubicCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t) { *pOut = ImBezierCubicCalc(p1,p2,p3,p4,t); } CIMGUI_API void igImBezierCubicClosestPoint(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments) { *pOut = ImBezierCubicClosestPoint(p1,p2,p3,p4,p,num_segments); } CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol) { *pOut = ImBezierCubicClosestPointCasteljau(p1,p2,p3,p4,p,tess_tol); } CIMGUI_API void igImBezierQuadraticCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t) { *pOut = ImBezierQuadraticCalc(p1,p2,p3,t); } CIMGUI_API void igImLineClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p) { *pOut = ImLineClosestPoint(a,b,p); } CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p) { return ImTriangleContainsPoint(a,b,c,p); } CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p) { *pOut = ImTriangleClosestPoint(a,b,c,p); } CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w) { return ImTriangleBarycentricCoords(a,b,c,p,*out_u,*out_v,*out_w); } CIMGUI_API float igImTriangleArea(const ImVec2 a,const ImVec2 b,const ImVec2 c) { return ImTriangleArea(a,b,c); } CIMGUI_API bool igImTriangleIsClockwise(const ImVec2 a,const ImVec2 b,const ImVec2 c) { return ImTriangleIsClockwise(a,b,c); } CIMGUI_API ImVec1* ImVec1_ImVec1_Nil(void) { return IM_NEW(ImVec1)(); } CIMGUI_API void ImVec1_destroy(ImVec1* self) { IM_DELETE(self); } CIMGUI_API ImVec1* ImVec1_ImVec1_Float(float _x) { return IM_NEW(ImVec1)(_x); } CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Nil(void) { return IM_NEW(ImVec2ih)(); } CIMGUI_API void ImVec2ih_destroy(ImVec2ih* self) { IM_DELETE(self); } CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_short(short _x,short _y) { return IM_NEW(ImVec2ih)(_x,_y); } CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Vec2(const ImVec2 rhs) { return IM_NEW(ImVec2ih)(rhs); } CIMGUI_API ImRect* ImRect_ImRect_Nil(void) { return IM_NEW(ImRect)(); } CIMGUI_API void ImRect_destroy(ImRect* self) { IM_DELETE(self); } CIMGUI_API ImRect* ImRect_ImRect_Vec2(const ImVec2 min,const ImVec2 max) { return IM_NEW(ImRect)(min,max); } CIMGUI_API ImRect* ImRect_ImRect_Vec4(const ImVec4 v) { return IM_NEW(ImRect)(v); } CIMGUI_API ImRect* ImRect_ImRect_Float(float x1,float y1,float x2,float y2) { return IM_NEW(ImRect)(x1,y1,x2,y2); } CIMGUI_API void ImRect_GetCenter(ImVec2 *pOut,ImRect* self) { *pOut = self->GetCenter(); } CIMGUI_API void ImRect_GetSize(ImVec2 *pOut,ImRect* self) { *pOut = self->GetSize(); } CIMGUI_API float ImRect_GetWidth(ImRect* self) { return self->GetWidth(); } CIMGUI_API float ImRect_GetHeight(ImRect* self) { return self->GetHeight(); } CIMGUI_API float ImRect_GetArea(ImRect* self) { return self->GetArea(); } CIMGUI_API void ImRect_GetTL(ImVec2 *pOut,ImRect* self) { *pOut = self->GetTL(); } CIMGUI_API void ImRect_GetTR(ImVec2 *pOut,ImRect* self) { *pOut = self->GetTR(); } CIMGUI_API void ImRect_GetBL(ImVec2 *pOut,ImRect* self) { *pOut = self->GetBL(); } CIMGUI_API void ImRect_GetBR(ImVec2 *pOut,ImRect* self) { *pOut = self->GetBR(); } CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self,const ImVec2 p) { return self->Contains(p); } CIMGUI_API bool ImRect_Contains_Rect(ImRect* self,const ImRect r) { return self->Contains(r); } CIMGUI_API bool ImRect_ContainsWithPad(ImRect* self,const ImVec2 p,const ImVec2 pad) { return self->ContainsWithPad(p,pad); } CIMGUI_API bool ImRect_Overlaps(ImRect* self,const ImRect r) { return self->Overlaps(r); } CIMGUI_API void ImRect_Add_Vec2(ImRect* self,const ImVec2 p) { return self->Add(p); } CIMGUI_API void ImRect_Add_Rect(ImRect* self,const ImRect r) { return self->Add(r); } CIMGUI_API void ImRect_Expand_Float(ImRect* self,const float amount) { return self->Expand(amount); } CIMGUI_API void ImRect_Expand_Vec2(ImRect* self,const ImVec2 amount) { return self->Expand(amount); } CIMGUI_API void ImRect_Translate(ImRect* self,const ImVec2 d) { return self->Translate(d); } CIMGUI_API void ImRect_TranslateX(ImRect* self,float dx) { return self->TranslateX(dx); } CIMGUI_API void ImRect_TranslateY(ImRect* self,float dy) { return self->TranslateY(dy); } CIMGUI_API void ImRect_ClipWith(ImRect* self,const ImRect r) { return self->ClipWith(r); } CIMGUI_API void ImRect_ClipWithFull(ImRect* self,const ImRect r) { return self->ClipWithFull(r); } CIMGUI_API void ImRect_Floor(ImRect* self) { return self->Floor(); } CIMGUI_API bool ImRect_IsInverted(ImRect* self) { return self->IsInverted(); } CIMGUI_API void ImRect_ToVec4(ImVec4 *pOut,ImRect* self) { *pOut = self->ToVec4(); } CIMGUI_API size_t igImBitArrayGetStorageSizeInBytes(int bitcount) { return ImBitArrayGetStorageSizeInBytes(bitcount); } CIMGUI_API void igImBitArrayClearAllBits(ImU32* arr,int bitcount) { return ImBitArrayClearAllBits(arr,bitcount); } CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr,int n) { return ImBitArrayTestBit(arr,n); } CIMGUI_API void igImBitArrayClearBit(ImU32* arr,int n) { return ImBitArrayClearBit(arr,n); } CIMGUI_API void igImBitArraySetBit(ImU32* arr,int n) { return ImBitArraySetBit(arr,n); } CIMGUI_API void igImBitArraySetBitRange(ImU32* arr,int n,int n2) { return ImBitArraySetBitRange(arr,n,n2); } CIMGUI_API void ImBitVector_Create(ImBitVector* self,int sz) { return self->Create(sz); } CIMGUI_API void ImBitVector_Clear(ImBitVector* self) { return self->Clear(); } CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self,int n) { return self->TestBit(n); } CIMGUI_API void ImBitVector_SetBit(ImBitVector* self,int n) { return self->SetBit(n); } CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self,int n) { return self->ClearBit(n); } CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self) { return self->clear(); } CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self) { return self->size(); } CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self,const char* base,int n) { return self->get_line_begin(base,n); } CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self,const char* base,int n) { return self->get_line_end(base,n); } CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,const char* base,int old_size,int new_size) { return self->append(base,old_size,new_size); } CIMGUI_API ImGuiStoragePair* igImLowerBound(ImGuiStoragePair* in_begin,ImGuiStoragePair* in_end,ImGuiID key) { return ImLowerBound(in_begin,in_end,key); } CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(void) { return IM_NEW(ImDrawListSharedData)(); } CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self) { IM_DELETE(self); } CIMGUI_API void ImDrawListSharedData_SetCircleTessellationMaxError(ImDrawListSharedData* self,float max_error) { return self->SetCircleTessellationMaxError(max_error); } CIMGUI_API ImDrawDataBuilder* ImDrawDataBuilder_ImDrawDataBuilder(void) { return IM_NEW(ImDrawDataBuilder)(); } CIMGUI_API void ImDrawDataBuilder_destroy(ImDrawDataBuilder* self) { IM_DELETE(self); } CIMGUI_API void* ImGuiDataVarInfo_GetVarPtr(ImGuiDataVarInfo* self,void* parent) { return self->GetVarPtr(parent); } CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Int(ImGuiStyleVar idx,int v) { return IM_NEW(ImGuiStyleMod)(idx,v); } CIMGUI_API void ImGuiStyleMod_destroy(ImGuiStyleMod* self) { IM_DELETE(self); } CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Float(ImGuiStyleVar idx,float v) { return IM_NEW(ImGuiStyleMod)(idx,v); } CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Vec2(ImGuiStyleVar idx,ImVec2 v) { return IM_NEW(ImGuiStyleMod)(idx,v); } CIMGUI_API ImGuiComboPreviewData* ImGuiComboPreviewData_ImGuiComboPreviewData(void) { return IM_NEW(ImGuiComboPreviewData)(); } CIMGUI_API void ImGuiComboPreviewData_destroy(ImGuiComboPreviewData* self) { IM_DELETE(self); } CIMGUI_API ImGuiMenuColumns* ImGuiMenuColumns_ImGuiMenuColumns(void) { return IM_NEW(ImGuiMenuColumns)(); } CIMGUI_API void ImGuiMenuColumns_destroy(ImGuiMenuColumns* self) { IM_DELETE(self); } CIMGUI_API void ImGuiMenuColumns_Update(ImGuiMenuColumns* self,float spacing,bool window_reappearing) { return self->Update(spacing,window_reappearing); } CIMGUI_API float ImGuiMenuColumns_DeclColumns(ImGuiMenuColumns* self,float w_icon,float w_label,float w_shortcut,float w_mark) { return self->DeclColumns(w_icon,w_label,w_shortcut,w_mark); } CIMGUI_API void ImGuiMenuColumns_CalcNextTotalWidth(ImGuiMenuColumns* self,bool update_offsets) { return self->CalcNextTotalWidth(update_offsets); } CIMGUI_API ImGuiInputTextDeactivatedState* ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState(void) { return IM_NEW(ImGuiInputTextDeactivatedState)(); } CIMGUI_API void ImGuiInputTextDeactivatedState_destroy(ImGuiInputTextDeactivatedState* self) { IM_DELETE(self); } CIMGUI_API void ImGuiInputTextDeactivatedState_ClearFreeMemory(ImGuiInputTextDeactivatedState* self) { return self->ClearFreeMemory(); } CIMGUI_API ImGuiInputTextState* ImGuiInputTextState_ImGuiInputTextState(void) { return IM_NEW(ImGuiInputTextState)(); } CIMGUI_API void ImGuiInputTextState_destroy(ImGuiInputTextState* self) { IM_DELETE(self); } CIMGUI_API void ImGuiInputTextState_ClearText(ImGuiInputTextState* self) { return self->ClearText(); } CIMGUI_API void ImGuiInputTextState_ClearFreeMemory(ImGuiInputTextState* self) { return self->ClearFreeMemory(); } CIMGUI_API int ImGuiInputTextState_GetUndoAvailCount(ImGuiInputTextState* self) { return self->GetUndoAvailCount(); } CIMGUI_API int ImGuiInputTextState_GetRedoAvailCount(ImGuiInputTextState* self) { return self->GetRedoAvailCount(); } CIMGUI_API void ImGuiInputTextState_OnKeyPressed(ImGuiInputTextState* self,int key) { return self->OnKeyPressed(key); } CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self) { return self->CursorAnimReset(); } CIMGUI_API void ImGuiInputTextState_CursorClamp(ImGuiInputTextState* self) { return self->CursorClamp(); } CIMGUI_API bool ImGuiInputTextState_HasSelection(ImGuiInputTextState* self) { return self->HasSelection(); } CIMGUI_API void ImGuiInputTextState_ClearSelection(ImGuiInputTextState* self) { return self->ClearSelection(); } CIMGUI_API int ImGuiInputTextState_GetCursorPos(ImGuiInputTextState* self) { return self->GetCursorPos(); } CIMGUI_API int ImGuiInputTextState_GetSelectionStart(ImGuiInputTextState* self) { return self->GetSelectionStart(); } CIMGUI_API int ImGuiInputTextState_GetSelectionEnd(ImGuiInputTextState* self) { return self->GetSelectionEnd(); } CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self) { return self->SelectAll(); } CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndSelectAll(ImGuiInputTextState* self) { return self->ReloadUserBufAndSelectAll(); } CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndKeepSelection(ImGuiInputTextState* self) { return self->ReloadUserBufAndKeepSelection(); } CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndMoveToEnd(ImGuiInputTextState* self) { return self->ReloadUserBufAndMoveToEnd(); } CIMGUI_API ImGuiNextWindowData* ImGuiNextWindowData_ImGuiNextWindowData(void) { return IM_NEW(ImGuiNextWindowData)(); } CIMGUI_API void ImGuiNextWindowData_destroy(ImGuiNextWindowData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiNextWindowData_ClearFlags(ImGuiNextWindowData* self) { return self->ClearFlags(); } CIMGUI_API ImGuiNextItemData* ImGuiNextItemData_ImGuiNextItemData(void) { return IM_NEW(ImGuiNextItemData)(); } CIMGUI_API void ImGuiNextItemData_destroy(ImGuiNextItemData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiNextItemData_ClearFlags(ImGuiNextItemData* self) { return self->ClearFlags(); } CIMGUI_API ImGuiLastItemData* ImGuiLastItemData_ImGuiLastItemData(void) { return IM_NEW(ImGuiLastItemData)(); } CIMGUI_API void ImGuiLastItemData_destroy(ImGuiLastItemData* self) { IM_DELETE(self); } CIMGUI_API ImGuiStackSizes* ImGuiStackSizes_ImGuiStackSizes(void) { return IM_NEW(ImGuiStackSizes)(); } CIMGUI_API void ImGuiStackSizes_destroy(ImGuiStackSizes* self) { IM_DELETE(self); } CIMGUI_API void ImGuiStackSizes_SetToContextState(ImGuiStackSizes* self,ImGuiContext* ctx) { return self->SetToContextState(ctx); } CIMGUI_API void ImGuiStackSizes_CompareWithContextState(ImGuiStackSizes* self,ImGuiContext* ctx) { return self->CompareWithContextState(ctx); } CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(void* ptr) { return IM_NEW(ImGuiPtrOrIndex)(ptr); } CIMGUI_API void ImGuiPtrOrIndex_destroy(ImGuiPtrOrIndex* self) { IM_DELETE(self); } CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(int index) { return IM_NEW(ImGuiPtrOrIndex)(index); } CIMGUI_API ImGuiPopupData* ImGuiPopupData_ImGuiPopupData(void) { return IM_NEW(ImGuiPopupData)(); } CIMGUI_API void ImGuiPopupData_destroy(ImGuiPopupData* self) { IM_DELETE(self); } CIMGUI_API ImGuiInputEvent* ImGuiInputEvent_ImGuiInputEvent(void) { return IM_NEW(ImGuiInputEvent)(); } CIMGUI_API void ImGuiInputEvent_destroy(ImGuiInputEvent* self) { IM_DELETE(self); } CIMGUI_API ImGuiKeyRoutingData* ImGuiKeyRoutingData_ImGuiKeyRoutingData(void) { return IM_NEW(ImGuiKeyRoutingData)(); } CIMGUI_API void ImGuiKeyRoutingData_destroy(ImGuiKeyRoutingData* self) { IM_DELETE(self); } CIMGUI_API ImGuiKeyRoutingTable* ImGuiKeyRoutingTable_ImGuiKeyRoutingTable(void) { return IM_NEW(ImGuiKeyRoutingTable)(); } CIMGUI_API void ImGuiKeyRoutingTable_destroy(ImGuiKeyRoutingTable* self) { IM_DELETE(self); } CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self) { return self->Clear(); } CIMGUI_API ImGuiKeyOwnerData* ImGuiKeyOwnerData_ImGuiKeyOwnerData(void) { return IM_NEW(ImGuiKeyOwnerData)(); } CIMGUI_API void ImGuiKeyOwnerData_destroy(ImGuiKeyOwnerData* self) { IM_DELETE(self); } CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min,int max) { return ImGuiListClipperRange::FromIndices(min,max); } CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromPositions(float y1,float y2,int off_min,int off_max) { return ImGuiListClipperRange::FromPositions(y1,y2,off_min,off_max); } CIMGUI_API ImGuiListClipperData* ImGuiListClipperData_ImGuiListClipperData(void) { return IM_NEW(ImGuiListClipperData)(); } CIMGUI_API void ImGuiListClipperData_destroy(ImGuiListClipperData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiListClipperData_Reset(ImGuiListClipperData* self,ImGuiListClipper* clipper) { return self->Reset(clipper); } CIMGUI_API ImGuiNavItemData* ImGuiNavItemData_ImGuiNavItemData(void) { return IM_NEW(ImGuiNavItemData)(); } CIMGUI_API void ImGuiNavItemData_destroy(ImGuiNavItemData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiNavItemData_Clear(ImGuiNavItemData* self) { return self->Clear(); } CIMGUI_API ImGuiTypingSelectState* ImGuiTypingSelectState_ImGuiTypingSelectState(void) { return IM_NEW(ImGuiTypingSelectState)(); } CIMGUI_API void ImGuiTypingSelectState_destroy(ImGuiTypingSelectState* self) { IM_DELETE(self); } CIMGUI_API void ImGuiTypingSelectState_Clear(ImGuiTypingSelectState* self) { return self->Clear(); } CIMGUI_API ImGuiOldColumnData* ImGuiOldColumnData_ImGuiOldColumnData(void) { return IM_NEW(ImGuiOldColumnData)(); } CIMGUI_API void ImGuiOldColumnData_destroy(ImGuiOldColumnData* self) { IM_DELETE(self); } CIMGUI_API ImGuiOldColumns* ImGuiOldColumns_ImGuiOldColumns(void) { return IM_NEW(ImGuiOldColumns)(); } CIMGUI_API void ImGuiOldColumns_destroy(ImGuiOldColumns* self) { IM_DELETE(self); } CIMGUI_API ImGuiBoxSelectState* ImGuiBoxSelectState_ImGuiBoxSelectState(void) { return IM_NEW(ImGuiBoxSelectState)(); } CIMGUI_API void ImGuiBoxSelectState_destroy(ImGuiBoxSelectState* self) { IM_DELETE(self); } CIMGUI_API ImGuiMultiSelectTempData* ImGuiMultiSelectTempData_ImGuiMultiSelectTempData(void) { return IM_NEW(ImGuiMultiSelectTempData)(); } CIMGUI_API void ImGuiMultiSelectTempData_destroy(ImGuiMultiSelectTempData* self) { IM_DELETE(self); } CIMGUI_API void ImGuiMultiSelectTempData_Clear(ImGuiMultiSelectTempData* self) { return self->Clear(); } CIMGUI_API void ImGuiMultiSelectTempData_ClearIO(ImGuiMultiSelectTempData* self) { return self->ClearIO(); } CIMGUI_API ImGuiMultiSelectState* ImGuiMultiSelectState_ImGuiMultiSelectState(void) { return IM_NEW(ImGuiMultiSelectState)(); } CIMGUI_API void ImGuiMultiSelectState_destroy(ImGuiMultiSelectState* self) { IM_DELETE(self); } CIMGUI_API ImGuiDockNode* ImGuiDockNode_ImGuiDockNode(ImGuiID id) { return IM_NEW(ImGuiDockNode)(id); } CIMGUI_API void ImGuiDockNode_destroy(ImGuiDockNode* self) { IM_DELETE(self); } CIMGUI_API bool ImGuiDockNode_IsRootNode(ImGuiDockNode* self) { return self->IsRootNode(); } CIMGUI_API bool ImGuiDockNode_IsDockSpace(ImGuiDockNode* self) { return self->IsDockSpace(); } CIMGUI_API bool ImGuiDockNode_IsFloatingNode(ImGuiDockNode* self) { return self->IsFloatingNode(); } CIMGUI_API bool ImGuiDockNode_IsCentralNode(ImGuiDockNode* self) { return self->IsCentralNode(); } CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(ImGuiDockNode* self) { return self->IsHiddenTabBar(); } CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self) { return self->IsNoTabBar(); } CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self) { return self->IsSplitNode(); } CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self) { return self->IsLeafNode(); } CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self) { return self->IsEmpty(); } CIMGUI_API void ImGuiDockNode_Rect(ImRect *pOut,ImGuiDockNode* self) { *pOut = self->Rect(); } CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,ImGuiDockNodeFlags flags) { return self->SetLocalFlags(flags); } CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self) { return self->UpdateMergedFlags(); } CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void) { return IM_NEW(ImGuiDockContext)(); } CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self) { IM_DELETE(self); } CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void) { return IM_NEW(ImGuiViewportP)(); } CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self) { IM_DELETE(self); } CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self) { return self->ClearRequestFlags(); } CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 off_min) { *pOut = self->CalcWorkRectPos(off_min); } CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 off_min,const ImVec2 off_max) { *pOut = self->CalcWorkRectSize(off_min,off_max); } CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self) { return self->UpdateWorkRect(); } CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect *pOut,ImGuiViewportP* self) { *pOut = self->GetMainRect(); } CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect *pOut,ImGuiViewportP* self) { *pOut = self->GetWorkRect(); } CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect *pOut,ImGuiViewportP* self) { *pOut = self->GetBuildWorkRect(); } CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void) { return IM_NEW(ImGuiWindowSettings)(); } CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self) { IM_DELETE(self); } CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self) { return self->GetName(); } CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(void) { return IM_NEW(ImGuiSettingsHandler)(); } CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self) { IM_DELETE(self); } CIMGUI_API ImGuiDebugAllocInfo* ImGuiDebugAllocInfo_ImGuiDebugAllocInfo(void) { return IM_NEW(ImGuiDebugAllocInfo)(); } CIMGUI_API void ImGuiDebugAllocInfo_destroy(ImGuiDebugAllocInfo* self) { IM_DELETE(self); } CIMGUI_API ImGuiStackLevelInfo* ImGuiStackLevelInfo_ImGuiStackLevelInfo(void) { return IM_NEW(ImGuiStackLevelInfo)(); } CIMGUI_API void ImGuiStackLevelInfo_destroy(ImGuiStackLevelInfo* self) { IM_DELETE(self); } CIMGUI_API ImGuiIDStackTool* ImGuiIDStackTool_ImGuiIDStackTool(void) { return IM_NEW(ImGuiIDStackTool)(); } CIMGUI_API void ImGuiIDStackTool_destroy(ImGuiIDStackTool* self) { IM_DELETE(self); } CIMGUI_API ImGuiContextHook* ImGuiContextHook_ImGuiContextHook(void) { return IM_NEW(ImGuiContextHook)(); } CIMGUI_API void ImGuiContextHook_destroy(ImGuiContextHook* self) { IM_DELETE(self); } CIMGUI_API ImGuiContext* ImGuiContext_ImGuiContext(ImFontAtlas* shared_font_atlas) { return IM_NEW(ImGuiContext)(shared_font_atlas); } CIMGUI_API void ImGuiContext_destroy(ImGuiContext* self) { IM_DELETE(self); } CIMGUI_API ImGuiWindow* ImGuiWindow_ImGuiWindow(ImGuiContext* context,const char* name) { return IM_NEW(ImGuiWindow)(context,name); } CIMGUI_API void ImGuiWindow_destroy(ImGuiWindow* self) { IM_DELETE(self); } CIMGUI_API ImGuiID ImGuiWindow_GetID_Str(ImGuiWindow* self,const char* str,const char* str_end) { return self->GetID(str,str_end); } CIMGUI_API ImGuiID ImGuiWindow_GetID_Ptr(ImGuiWindow* self,const void* ptr) { return self->GetID(ptr); } CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self,int n) { return self->GetID(n); } CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,const ImRect r_abs) { return self->GetIDFromRectangle(r_abs); } CIMGUI_API void ImGuiWindow_Rect(ImRect *pOut,ImGuiWindow* self) { *pOut = self->Rect(); } CIMGUI_API float ImGuiWindow_CalcFontSize(ImGuiWindow* self) { return self->CalcFontSize(); } CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect *pOut,ImGuiWindow* self) { *pOut = self->TitleBarRect(); } CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect *pOut,ImGuiWindow* self) { *pOut = self->MenuBarRect(); } CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void) { return IM_NEW(ImGuiTabItem)(); } CIMGUI_API void ImGuiTabItem_destroy(ImGuiTabItem* self) { IM_DELETE(self); } CIMGUI_API ImGuiTabBar* ImGuiTabBar_ImGuiTabBar(void) { return IM_NEW(ImGuiTabBar)(); } CIMGUI_API void ImGuiTabBar_destroy(ImGuiTabBar* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableColumn* ImGuiTableColumn_ImGuiTableColumn(void) { return IM_NEW(ImGuiTableColumn)(); } CIMGUI_API void ImGuiTableColumn_destroy(ImGuiTableColumn* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableInstanceData* ImGuiTableInstanceData_ImGuiTableInstanceData(void) { return IM_NEW(ImGuiTableInstanceData)(); } CIMGUI_API void ImGuiTableInstanceData_destroy(ImGuiTableInstanceData* self) { IM_DELETE(self); } CIMGUI_API ImGuiTable* ImGuiTable_ImGuiTable(void) { return IM_NEW(ImGuiTable)(); } CIMGUI_API void ImGuiTable_destroy(ImGuiTable* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableTempData* ImGuiTableTempData_ImGuiTableTempData(void) { return IM_NEW(ImGuiTableTempData)(); } CIMGUI_API void ImGuiTableTempData_destroy(ImGuiTableTempData* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableColumnSettings* ImGuiTableColumnSettings_ImGuiTableColumnSettings(void) { return IM_NEW(ImGuiTableColumnSettings)(); } CIMGUI_API void ImGuiTableColumnSettings_destroy(ImGuiTableColumnSettings* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableSettings* ImGuiTableSettings_ImGuiTableSettings(void) { return IM_NEW(ImGuiTableSettings)(); } CIMGUI_API void ImGuiTableSettings_destroy(ImGuiTableSettings* self) { IM_DELETE(self); } CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiTableSettings* self) { return self->GetColumnSettings(); } CIMGUI_API ImGuiWindow* igGetCurrentWindowRead() { return ImGui::GetCurrentWindowRead(); } CIMGUI_API ImGuiWindow* igGetCurrentWindow() { return ImGui::GetCurrentWindow(); } CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id) { return ImGui::FindWindowByID(id); } CIMGUI_API ImGuiWindow* igFindWindowByName(const char* name) { return ImGui::FindWindowByName(name); } CIMGUI_API void igUpdateWindowParentAndRootLinks(ImGuiWindow* window,ImGuiWindowFlags flags,ImGuiWindow* parent_window) { return ImGui::UpdateWindowParentAndRootLinks(window,flags,parent_window); } CIMGUI_API void igUpdateWindowSkipRefresh(ImGuiWindow* window) { return ImGui::UpdateWindowSkipRefresh(window); } CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2 *pOut,ImGuiWindow* window) { *pOut = ImGui::CalcWindowNextAutoFitSize(window); } CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy) { return ImGui::IsWindowChildOf(window,potential_parent,popup_hierarchy,dock_hierarchy); } CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,ImGuiWindow* potential_parent) { return ImGui::IsWindowWithinBeginStackOf(window,potential_parent); } CIMGUI_API bool igIsWindowAbove(ImGuiWindow* potential_above,ImGuiWindow* potential_below) { return ImGui::IsWindowAbove(potential_above,potential_below); } CIMGUI_API bool igIsWindowNavFocusable(ImGuiWindow* window) { return ImGui::IsWindowNavFocusable(window); } CIMGUI_API void igSetWindowPos_WindowPtr(ImGuiWindow* window,const ImVec2 pos,ImGuiCond cond) { return ImGui::SetWindowPos(window,pos,cond); } CIMGUI_API void igSetWindowSize_WindowPtr(ImGuiWindow* window,const ImVec2 size,ImGuiCond cond) { return ImGui::SetWindowSize(window,size,cond); } CIMGUI_API void igSetWindowCollapsed_WindowPtr(ImGuiWindow* window,bool collapsed,ImGuiCond cond) { return ImGui::SetWindowCollapsed(window,collapsed,cond); } CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,const ImVec2 pos,const ImVec2 size) { return ImGui::SetWindowHitTestHole(window,pos,size); } CIMGUI_API void igSetWindowHiddenAndSkipItemsForCurrentFrame(ImGuiWindow* window) { return ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame(window); } CIMGUI_API void igSetWindowParentWindowForFocusRoute(ImGuiWindow* window,ImGuiWindow* parent_window) { return ImGui::SetWindowParentWindowForFocusRoute(window,parent_window); } CIMGUI_API void igWindowRectAbsToRel(ImRect *pOut,ImGuiWindow* window,const ImRect r) { *pOut = ImGui::WindowRectAbsToRel(window,r); } CIMGUI_API void igWindowRectRelToAbs(ImRect *pOut,ImGuiWindow* window,const ImRect r) { *pOut = ImGui::WindowRectRelToAbs(window,r); } CIMGUI_API void igWindowPosRelToAbs(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p) { *pOut = ImGui::WindowPosRelToAbs(window,p); } CIMGUI_API void igWindowPosAbsToRel(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p) { *pOut = ImGui::WindowPosAbsToRel(window,p); } CIMGUI_API void igFocusWindow(ImGuiWindow* window,ImGuiFocusRequestFlags flags) { return ImGui::FocusWindow(window,flags); } CIMGUI_API void igFocusTopMostWindowUnderOne(ImGuiWindow* under_this_window,ImGuiWindow* ignore_window,ImGuiViewport* filter_viewport,ImGuiFocusRequestFlags flags) { return ImGui::FocusTopMostWindowUnderOne(under_this_window,ignore_window,filter_viewport,flags); } CIMGUI_API void igBringWindowToFocusFront(ImGuiWindow* window) { return ImGui::BringWindowToFocusFront(window); } CIMGUI_API void igBringWindowToDisplayFront(ImGuiWindow* window) { return ImGui::BringWindowToDisplayFront(window); } CIMGUI_API void igBringWindowToDisplayBack(ImGuiWindow* window) { return ImGui::BringWindowToDisplayBack(window); } CIMGUI_API void igBringWindowToDisplayBehind(ImGuiWindow* window,ImGuiWindow* above_window) { return ImGui::BringWindowToDisplayBehind(window,above_window); } CIMGUI_API int igFindWindowDisplayIndex(ImGuiWindow* window) { return ImGui::FindWindowDisplayIndex(window); } CIMGUI_API ImGuiWindow* igFindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* window) { return ImGui::FindBottomMostVisibleWindowWithinBeginStack(window); } CIMGUI_API void igSetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags) { return ImGui::SetNextWindowRefreshPolicy(flags); } CIMGUI_API void igSetCurrentFont(ImFont* font) { return ImGui::SetCurrentFont(font); } CIMGUI_API ImFont* igGetDefaultFont() { return ImGui::GetDefaultFont(); } CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window) { return ImGui::GetForegroundDrawList(window); } CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,ImVector_ImDrawListPtr* out_list,ImDrawList* draw_list) { return ImGui::AddDrawListToDrawDataEx(draw_data,out_list,draw_list); } CIMGUI_API void igInitialize() { return ImGui::Initialize(); } CIMGUI_API void igShutdown() { return ImGui::Shutdown(); } CIMGUI_API void igUpdateInputEvents(bool trickle_fast_inputs) { return ImGui::UpdateInputEvents(trickle_fast_inputs); } CIMGUI_API void igUpdateHoveredWindowAndCaptureFlags() { return ImGui::UpdateHoveredWindowAndCaptureFlags(); } CIMGUI_API void igFindHoveredWindowEx(const ImVec2 pos,bool find_first_and_in_any_viewport,ImGuiWindow** out_hovered_window,ImGuiWindow** out_hovered_window_under_moving_window) { return ImGui::FindHoveredWindowEx(pos,find_first_and_in_any_viewport,out_hovered_window,out_hovered_window_under_moving_window); } CIMGUI_API void igStartMouseMovingWindow(ImGuiWindow* window) { return ImGui::StartMouseMovingWindow(window); } CIMGUI_API void igStartMouseMovingWindowOrNode(ImGuiWindow* window,ImGuiDockNode* node,bool undock) { return ImGui::StartMouseMovingWindowOrNode(window,node,undock); } CIMGUI_API void igUpdateMouseMovingWindowNewFrame() { return ImGui::UpdateMouseMovingWindowNewFrame(); } CIMGUI_API void igUpdateMouseMovingWindowEndFrame() { return ImGui::UpdateMouseMovingWindowEndFrame(); } CIMGUI_API ImGuiID igAddContextHook(ImGuiContext* context,const ImGuiContextHook* hook) { return ImGui::AddContextHook(context,hook); } CIMGUI_API void igRemoveContextHook(ImGuiContext* context,ImGuiID hook_to_remove) { return ImGui::RemoveContextHook(context,hook_to_remove); } CIMGUI_API void igCallContextHooks(ImGuiContext* context,ImGuiContextHookType type) { return ImGui::CallContextHooks(context,type); } CIMGUI_API void igTranslateWindowsInViewport(ImGuiViewportP* viewport,const ImVec2 old_pos,const ImVec2 new_pos) { return ImGui::TranslateWindowsInViewport(viewport,old_pos,new_pos); } CIMGUI_API void igScaleWindowsInViewport(ImGuiViewportP* viewport,float scale) { return ImGui::ScaleWindowsInViewport(viewport,scale); } CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport) { return ImGui::DestroyPlatformWindow(viewport); } CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,ImGuiViewportP* viewport) { return ImGui::SetWindowViewport(window,viewport); } CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,ImGuiViewportP* viewport) { return ImGui::SetCurrentViewport(window,viewport); } CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(ImGuiViewport* viewport) { return ImGui::GetViewportPlatformMonitor(viewport); } CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(const ImVec2 mouse_platform_pos) { return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos); } CIMGUI_API void igMarkIniSettingsDirty_Nil() { return ImGui::MarkIniSettingsDirty(); } CIMGUI_API void igMarkIniSettingsDirty_WindowPtr(ImGuiWindow* window) { return ImGui::MarkIniSettingsDirty(window); } CIMGUI_API void igClearIniSettings() { return ImGui::ClearIniSettings(); } CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler) { return ImGui::AddSettingsHandler(handler); } CIMGUI_API void igRemoveSettingsHandler(const char* type_name) { return ImGui::RemoveSettingsHandler(type_name); } CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name) { return ImGui::FindSettingsHandler(type_name); } CIMGUI_API ImGuiWindowSettings* igCreateNewWindowSettings(const char* name) { return ImGui::CreateNewWindowSettings(name); } CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByID(ImGuiID id) { return ImGui::FindWindowSettingsByID(id); } CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByWindow(ImGuiWindow* window) { return ImGui::FindWindowSettingsByWindow(window); } CIMGUI_API void igClearWindowSettings(const char* name) { return ImGui::ClearWindowSettings(name); } CIMGUI_API void igLocalizeRegisterEntries(const ImGuiLocEntry* entries,int count) { return ImGui::LocalizeRegisterEntries(entries,count); } CIMGUI_API const char* igLocalizeGetMsg(ImGuiLocKey key) { return ImGui::LocalizeGetMsg(key); } CIMGUI_API void igSetScrollX_WindowPtr(ImGuiWindow* window,float scroll_x) { return ImGui::SetScrollX(window,scroll_x); } CIMGUI_API void igSetScrollY_WindowPtr(ImGuiWindow* window,float scroll_y) { return ImGui::SetScrollY(window,scroll_y); } CIMGUI_API void igSetScrollFromPosX_WindowPtr(ImGuiWindow* window,float local_x,float center_x_ratio) { return ImGui::SetScrollFromPosX(window,local_x,center_x_ratio); } CIMGUI_API void igSetScrollFromPosY_WindowPtr(ImGuiWindow* window,float local_y,float center_y_ratio) { return ImGui::SetScrollFromPosY(window,local_y,center_y_ratio); } CIMGUI_API void igScrollToItem(ImGuiScrollFlags flags) { return ImGui::ScrollToItem(flags); } CIMGUI_API void igScrollToRect(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags) { return ImGui::ScrollToRect(window,rect,flags); } CIMGUI_API void igScrollToRectEx(ImVec2 *pOut,ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags) { *pOut = ImGui::ScrollToRectEx(window,rect,flags); } CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,const ImRect rect) { return ImGui::ScrollToBringRectIntoView(window,rect); } CIMGUI_API ImGuiItemStatusFlags igGetItemStatusFlags() { return ImGui::GetItemStatusFlags(); } CIMGUI_API ImGuiItemFlags igGetItemFlags() { return ImGui::GetItemFlags(); } CIMGUI_API ImGuiID igGetActiveID() { return ImGui::GetActiveID(); } CIMGUI_API ImGuiID igGetFocusID() { return ImGui::GetFocusID(); } CIMGUI_API void igSetActiveID(ImGuiID id,ImGuiWindow* window) { return ImGui::SetActiveID(id,window); } CIMGUI_API void igSetFocusID(ImGuiID id,ImGuiWindow* window) { return ImGui::SetFocusID(id,window); } CIMGUI_API void igClearActiveID() { return ImGui::ClearActiveID(); } CIMGUI_API ImGuiID igGetHoveredID() { return ImGui::GetHoveredID(); } CIMGUI_API void igSetHoveredID(ImGuiID id) { return ImGui::SetHoveredID(id); } CIMGUI_API void igKeepAliveID(ImGuiID id) { return ImGui::KeepAliveID(id); } CIMGUI_API void igMarkItemEdited(ImGuiID id) { return ImGui::MarkItemEdited(id); } CIMGUI_API void igPushOverrideID(ImGuiID id) { return ImGui::PushOverrideID(id); } CIMGUI_API ImGuiID igGetIDWithSeed_Str(const char* str_id_begin,const char* str_id_end,ImGuiID seed) { return ImGui::GetIDWithSeed(str_id_begin,str_id_end,seed); } CIMGUI_API ImGuiID igGetIDWithSeed_Int(int n,ImGuiID seed) { return ImGui::GetIDWithSeed(n,seed); } CIMGUI_API void igItemSize_Vec2(const ImVec2 size,float text_baseline_y) { return ImGui::ItemSize(size,text_baseline_y); } CIMGUI_API void igItemSize_Rect(const ImRect bb,float text_baseline_y) { return ImGui::ItemSize(bb,text_baseline_y); } CIMGUI_API bool igItemAdd(const ImRect bb,ImGuiID id,const ImRect* nav_bb,ImGuiItemFlags extra_flags) { return ImGui::ItemAdd(bb,id,nav_bb,extra_flags); } CIMGUI_API bool igItemHoverable(const ImRect bb,ImGuiID id,ImGuiItemFlags item_flags) { return ImGui::ItemHoverable(bb,id,item_flags); } CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,ImGuiHoveredFlags flags) { return ImGui::IsWindowContentHoverable(window,flags); } CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID id) { return ImGui::IsClippedEx(bb,id); } CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags in_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect) { return ImGui::SetLastItemData(item_id,in_flags,status_flags,item_rect); } CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h) { *pOut = ImGui::CalcItemSize(size,default_w,default_h); } CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos,float wrap_pos_x) { return ImGui::CalcWrapWidthForPos(pos,wrap_pos_x); } CIMGUI_API void igPushMultiItemsWidths(int components,float width_full) { return ImGui::PushMultiItemsWidths(components,width_full); } CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,int count,float width_excess) { return ImGui::ShrinkWidths(items,count,width_excess); } CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx) { return ImGui::GetStyleVarInfo(idx); } CIMGUI_API void igBeginDisabledOverrideReenable() { return ImGui::BeginDisabledOverrideReenable(); } CIMGUI_API void igEndDisabledOverrideReenable() { return ImGui::EndDisabledOverrideReenable(); } CIMGUI_API void igLogBegin(ImGuiLogType type,int auto_open_depth) { return ImGui::LogBegin(type,auto_open_depth); } CIMGUI_API void igLogToBuffer(int auto_open_depth) { return ImGui::LogToBuffer(auto_open_depth); } CIMGUI_API void igLogRenderedText(const ImVec2* ref_pos,const char* text,const char* text_end) { return ImGui::LogRenderedText(ref_pos,text,text_end); } CIMGUI_API void igLogSetNextTextDecoration(const char* prefix,const char* suffix) { return ImGui::LogSetNextTextDecoration(prefix,suffix); } CIMGUI_API bool igBeginChildEx(const char* name,ImGuiID id,const ImVec2 size_arg,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags) { return ImGui::BeginChildEx(name,id,size_arg,child_flags,window_flags); } CIMGUI_API bool igBeginPopupEx(ImGuiID id,ImGuiWindowFlags extra_window_flags) { return ImGui::BeginPopupEx(id,extra_window_flags); } CIMGUI_API void igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags) { return ImGui::OpenPopupEx(id,popup_flags); } CIMGUI_API void igClosePopupToLevel(int remaining,bool restore_focus_to_window_under_popup) { return ImGui::ClosePopupToLevel(remaining,restore_focus_to_window_under_popup); } CIMGUI_API void igClosePopupsOverWindow(ImGuiWindow* ref_window,bool restore_focus_to_window_under_popup) { return ImGui::ClosePopupsOverWindow(ref_window,restore_focus_to_window_under_popup); } CIMGUI_API void igClosePopupsExceptModals() { return ImGui::ClosePopupsExceptModals(); } CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id,ImGuiPopupFlags popup_flags) { return ImGui::IsPopupOpen(id,popup_flags); } CIMGUI_API void igGetPopupAllowedExtentRect(ImRect *pOut,ImGuiWindow* window) { *pOut = ImGui::GetPopupAllowedExtentRect(window); } CIMGUI_API ImGuiWindow* igGetTopMostPopupModal() { return ImGui::GetTopMostPopupModal(); } CIMGUI_API ImGuiWindow* igGetTopMostAndVisiblePopupModal() { return ImGui::GetTopMostAndVisiblePopupModal(); } CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window) { return ImGui::FindBlockingModal(window); } CIMGUI_API void igFindBestWindowPosForPopup(ImVec2 *pOut,ImGuiWindow* window) { *pOut = ImGui::FindBestWindowPosForPopup(window); } CIMGUI_API void igFindBestWindowPosForPopupEx(ImVec2 *pOut,const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy) { *pOut = ImGui::FindBestWindowPosForPopupEx(ref_pos,size,last_dir,r_outer,r_avoid,policy); } CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags) { return ImGui::BeginTooltipEx(tooltip_flags,extra_window_flags); } CIMGUI_API bool igBeginTooltipHidden() { return ImGui::BeginTooltipHidden(); } CIMGUI_API bool igBeginViewportSideBar(const char* name,ImGuiViewport* viewport,ImGuiDir dir,float size,ImGuiWindowFlags window_flags) { return ImGui::BeginViewportSideBar(name,viewport,dir,size,window_flags); } CIMGUI_API bool igBeginMenuEx(const char* label,const char* icon,bool enabled) { return ImGui::BeginMenuEx(label,icon,enabled); } CIMGUI_API bool igMenuItemEx(const char* label,const char* icon,const char* shortcut,bool selected,bool enabled) { return ImGui::MenuItemEx(label,icon,shortcut,selected,enabled); } CIMGUI_API bool igBeginComboPopup(ImGuiID popup_id,const ImRect bb,ImGuiComboFlags flags) { return ImGui::BeginComboPopup(popup_id,bb,flags); } CIMGUI_API bool igBeginComboPreview() { return ImGui::BeginComboPreview(); } CIMGUI_API void igEndComboPreview() { return ImGui::EndComboPreview(); } CIMGUI_API void igNavInitWindow(ImGuiWindow* window,bool force_reinit) { return ImGui::NavInitWindow(window,force_reinit); } CIMGUI_API void igNavInitRequestApplyResult() { return ImGui::NavInitRequestApplyResult(); } CIMGUI_API bool igNavMoveRequestButNoResultYet() { return ImGui::NavMoveRequestButNoResultYet(); } CIMGUI_API void igNavMoveRequestSubmit(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags) { return ImGui::NavMoveRequestSubmit(move_dir,clip_dir,move_flags,scroll_flags); } CIMGUI_API void igNavMoveRequestForward(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags) { return ImGui::NavMoveRequestForward(move_dir,clip_dir,move_flags,scroll_flags); } CIMGUI_API void igNavMoveRequestResolveWithLastItem(ImGuiNavItemData* result) { return ImGui::NavMoveRequestResolveWithLastItem(result); } CIMGUI_API void igNavMoveRequestResolveWithPastTreeNode(ImGuiNavItemData* result,ImGuiTreeNodeStackData* tree_node_data) { return ImGui::NavMoveRequestResolveWithPastTreeNode(result,tree_node_data); } CIMGUI_API void igNavMoveRequestCancel() { return ImGui::NavMoveRequestCancel(); } CIMGUI_API void igNavMoveRequestApplyResult() { return ImGui::NavMoveRequestApplyResult(); } CIMGUI_API void igNavMoveRequestTryWrapping(ImGuiWindow* window,ImGuiNavMoveFlags move_flags) { return ImGui::NavMoveRequestTryWrapping(window,move_flags); } CIMGUI_API void igNavHighlightActivated(ImGuiID id) { return ImGui::NavHighlightActivated(id); } CIMGUI_API void igNavClearPreferredPosForAxis(ImGuiAxis axis) { return ImGui::NavClearPreferredPosForAxis(axis); } CIMGUI_API void igNavRestoreHighlightAfterMove() { return ImGui::NavRestoreHighlightAfterMove(); } CIMGUI_API void igNavUpdateCurrentWindowIsScrollPushableX() { return ImGui::NavUpdateCurrentWindowIsScrollPushableX(); } CIMGUI_API void igSetNavWindow(ImGuiWindow* window) { return ImGui::SetNavWindow(window); } CIMGUI_API void igSetNavID(ImGuiID id,ImGuiNavLayer nav_layer,ImGuiID focus_scope_id,const ImRect rect_rel) { return ImGui::SetNavID(id,nav_layer,focus_scope_id,rect_rel); } CIMGUI_API void igSetNavFocusScope(ImGuiID focus_scope_id) { return ImGui::SetNavFocusScope(focus_scope_id); } CIMGUI_API void igFocusItem() { return ImGui::FocusItem(); } CIMGUI_API void igActivateItemByID(ImGuiID id) { return ImGui::ActivateItemByID(id); } CIMGUI_API bool igIsNamedKey(ImGuiKey key) { return ImGui::IsNamedKey(key); } CIMGUI_API bool igIsNamedKeyOrMod(ImGuiKey key) { return ImGui::IsNamedKeyOrMod(key); } CIMGUI_API bool igIsLegacyKey(ImGuiKey key) { return ImGui::IsLegacyKey(key); } CIMGUI_API bool igIsKeyboardKey(ImGuiKey key) { return ImGui::IsKeyboardKey(key); } CIMGUI_API bool igIsGamepadKey(ImGuiKey key) { return ImGui::IsGamepadKey(key); } CIMGUI_API bool igIsMouseKey(ImGuiKey key) { return ImGui::IsMouseKey(key); } CIMGUI_API bool igIsAliasKey(ImGuiKey key) { return ImGui::IsAliasKey(key); } CIMGUI_API bool igIsModKey(ImGuiKey key) { return ImGui::IsModKey(key); } CIMGUI_API ImGuiKeyChord igFixupKeyChord(ImGuiKeyChord key_chord) { return ImGui::FixupKeyChord(key_chord); } CIMGUI_API ImGuiKey igConvertSingleModFlagToKey(ImGuiKey key) { return ImGui::ConvertSingleModFlagToKey(key); } CIMGUI_API ImGuiKeyData* igGetKeyData_ContextPtr(ImGuiContext* ctx,ImGuiKey key) { return ImGui::GetKeyData(ctx,key); } CIMGUI_API ImGuiKeyData* igGetKeyData_Key(ImGuiKey key) { return ImGui::GetKeyData(key); } CIMGUI_API const char* igGetKeyChordName(ImGuiKeyChord key_chord) { return ImGui::GetKeyChordName(key_chord); } CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button) { return ImGui::MouseButtonToKey(button); } CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,float lock_threshold) { return ImGui::IsMouseDragPastThreshold(button,lock_threshold); } CIMGUI_API void igGetKeyMagnitude2d(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down) { *pOut = ImGui::GetKeyMagnitude2d(key_left,key_right,key_up,key_down); } CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis) { return ImGui::GetNavTweakPressedAmount(axis); } CIMGUI_API int igCalcTypematicRepeatAmount(float t0,float t1,float repeat_delay,float repeat_rate) { return ImGui::CalcTypematicRepeatAmount(t0,t1,repeat_delay,repeat_rate); } CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate) { return ImGui::GetTypematicRepeatRate(flags,repeat_delay,repeat_rate); } CIMGUI_API void igTeleportMousePos(const ImVec2 pos) { return ImGui::TeleportMousePos(pos); } CIMGUI_API void igSetActiveIdUsingAllKeyboardKeys() { return ImGui::SetActiveIdUsingAllKeyboardKeys(); } CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir) { return ImGui::IsActiveIdUsingNavDir(dir); } CIMGUI_API ImGuiID igGetKeyOwner(ImGuiKey key) { return ImGui::GetKeyOwner(key); } CIMGUI_API void igSetKeyOwner(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags) { return ImGui::SetKeyOwner(key,owner_id,flags); } CIMGUI_API void igSetKeyOwnersForKeyChord(ImGuiKeyChord key,ImGuiID owner_id,ImGuiInputFlags flags) { return ImGui::SetKeyOwnersForKeyChord(key,owner_id,flags); } CIMGUI_API void igSetItemKeyOwner_InputFlags(ImGuiKey key,ImGuiInputFlags flags) { return ImGui::SetItemKeyOwner(key,flags); } CIMGUI_API bool igTestKeyOwner(ImGuiKey key,ImGuiID owner_id) { return ImGui::TestKeyOwner(key,owner_id); } CIMGUI_API ImGuiKeyOwnerData* igGetKeyOwnerData(ImGuiContext* ctx,ImGuiKey key) { return ImGui::GetKeyOwnerData(ctx,key); } CIMGUI_API bool igIsKeyDown_ID(ImGuiKey key,ImGuiID owner_id) { return ImGui::IsKeyDown(key,owner_id); } CIMGUI_API bool igIsKeyPressed_InputFlags(ImGuiKey key,ImGuiInputFlags flags,ImGuiID owner_id) { return ImGui::IsKeyPressed(key,flags,owner_id); } CIMGUI_API bool igIsKeyReleased_ID(ImGuiKey key,ImGuiID owner_id) { return ImGui::IsKeyReleased(key,owner_id); } CIMGUI_API bool igIsKeyChordPressed_InputFlags(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id) { return ImGui::IsKeyChordPressed(key_chord,flags,owner_id); } CIMGUI_API bool igIsMouseDown_ID(ImGuiMouseButton button,ImGuiID owner_id) { return ImGui::IsMouseDown(button,owner_id); } CIMGUI_API bool igIsMouseClicked_InputFlags(ImGuiMouseButton button,ImGuiInputFlags flags,ImGuiID owner_id) { return ImGui::IsMouseClicked(button,flags,owner_id); } CIMGUI_API bool igIsMouseReleased_ID(ImGuiMouseButton button,ImGuiID owner_id) { return ImGui::IsMouseReleased(button,owner_id); } CIMGUI_API bool igIsMouseDoubleClicked_ID(ImGuiMouseButton button,ImGuiID owner_id) { return ImGui::IsMouseDoubleClicked(button,owner_id); } CIMGUI_API bool igShortcut_ID(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id) { return ImGui::Shortcut(key_chord,flags,owner_id); } CIMGUI_API bool igSetShortcutRouting(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id) { return ImGui::SetShortcutRouting(key_chord,flags,owner_id); } CIMGUI_API bool igTestShortcutRouting(ImGuiKeyChord key_chord,ImGuiID owner_id) { return ImGui::TestShortcutRouting(key_chord,owner_id); } CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(ImGuiKeyChord key_chord) { return ImGui::GetShortcutRoutingData(key_chord); } CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx) { return ImGui::DockContextInitialize(ctx); } CIMGUI_API void igDockContextShutdown(ImGuiContext* ctx) { return ImGui::DockContextShutdown(ctx); } CIMGUI_API void igDockContextClearNodes(ImGuiContext* ctx,ImGuiID root_id,bool clear_settings_refs) { return ImGui::DockContextClearNodes(ctx,root_id,clear_settings_refs); } CIMGUI_API void igDockContextRebuildNodes(ImGuiContext* ctx) { return ImGui::DockContextRebuildNodes(ctx); } CIMGUI_API void igDockContextNewFrameUpdateUndocking(ImGuiContext* ctx) { return ImGui::DockContextNewFrameUpdateUndocking(ctx); } CIMGUI_API void igDockContextNewFrameUpdateDocking(ImGuiContext* ctx) { return ImGui::DockContextNewFrameUpdateDocking(ctx); } CIMGUI_API void igDockContextEndFrame(ImGuiContext* ctx) { return ImGui::DockContextEndFrame(ctx); } CIMGUI_API ImGuiID igDockContextGenNodeID(ImGuiContext* ctx) { return ImGui::DockContextGenNodeID(ctx); } CIMGUI_API void igDockContextQueueDock(ImGuiContext* ctx,ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,float split_ratio,bool split_outer) { return ImGui::DockContextQueueDock(ctx,target,target_node,payload,split_dir,split_ratio,split_outer); } CIMGUI_API void igDockContextQueueUndockWindow(ImGuiContext* ctx,ImGuiWindow* window) { return ImGui::DockContextQueueUndockWindow(ctx,window); } CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,ImGuiDockNode* node) { return ImGui::DockContextQueueUndockNode(ctx,node); } CIMGUI_API void igDockContextProcessUndockWindow(ImGuiContext* ctx,ImGuiWindow* window,bool clear_persistent_docking_ref) { return ImGui::DockContextProcessUndockWindow(ctx,window,clear_persistent_docking_ref); } CIMGUI_API void igDockContextProcessUndockNode(ImGuiContext* ctx,ImGuiDockNode* node) { return ImGui::DockContextProcessUndockNode(ctx,node); } CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos) { return ImGui::DockContextCalcDropPosForDocking(target,target_node,payload_window,payload_node,split_dir,split_outer,out_pos); } CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,ImGuiID id) { return ImGui::DockContextFindNodeByID(ctx,id); } CIMGUI_API void igDockNodeWindowMenuHandler_Default(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar) { return ImGui::DockNodeWindowMenuHandler_Default(ctx,node,tab_bar); } CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node) { return ImGui::DockNodeBeginAmendTabBar(node); } CIMGUI_API void igDockNodeEndAmendTabBar() { return ImGui::DockNodeEndAmendTabBar(); } CIMGUI_API ImGuiDockNode* igDockNodeGetRootNode(ImGuiDockNode* node) { return ImGui::DockNodeGetRootNode(node); } CIMGUI_API bool igDockNodeIsInHierarchyOf(ImGuiDockNode* node,ImGuiDockNode* parent) { return ImGui::DockNodeIsInHierarchyOf(node,parent); } CIMGUI_API int igDockNodeGetDepth(const ImGuiDockNode* node) { return ImGui::DockNodeGetDepth(node); } CIMGUI_API ImGuiID igDockNodeGetWindowMenuButtonId(const ImGuiDockNode* node) { return ImGui::DockNodeGetWindowMenuButtonId(node); } CIMGUI_API ImGuiDockNode* igGetWindowDockNode() { return ImGui::GetWindowDockNode(); } CIMGUI_API bool igGetWindowAlwaysWantOwnTabBar(ImGuiWindow* window) { return ImGui::GetWindowAlwaysWantOwnTabBar(window); } CIMGUI_API void igBeginDocked(ImGuiWindow* window,bool* p_open) { return ImGui::BeginDocked(window,p_open); } CIMGUI_API void igBeginDockableDragDropSource(ImGuiWindow* window) { return ImGui::BeginDockableDragDropSource(window); } CIMGUI_API void igBeginDockableDragDropTarget(ImGuiWindow* window) { return ImGui::BeginDockableDragDropTarget(window); } CIMGUI_API void igSetWindowDock(ImGuiWindow* window,ImGuiID dock_id,ImGuiCond cond) { return ImGui::SetWindowDock(window,dock_id,cond); } CIMGUI_API void igDockBuilderDockWindow(const char* window_name,ImGuiID node_id) { return ImGui::DockBuilderDockWindow(window_name,node_id); } CIMGUI_API ImGuiDockNode* igDockBuilderGetNode(ImGuiID node_id) { return ImGui::DockBuilderGetNode(node_id); } CIMGUI_API ImGuiDockNode* igDockBuilderGetCentralNode(ImGuiID node_id) { return ImGui::DockBuilderGetCentralNode(node_id); } CIMGUI_API ImGuiID igDockBuilderAddNode(ImGuiID node_id,ImGuiDockNodeFlags flags) { return ImGui::DockBuilderAddNode(node_id,flags); } CIMGUI_API void igDockBuilderRemoveNode(ImGuiID node_id) { return ImGui::DockBuilderRemoveNode(node_id); } CIMGUI_API void igDockBuilderRemoveNodeDockedWindows(ImGuiID node_id,bool clear_settings_refs) { return ImGui::DockBuilderRemoveNodeDockedWindows(node_id,clear_settings_refs); } CIMGUI_API void igDockBuilderRemoveNodeChildNodes(ImGuiID node_id) { return ImGui::DockBuilderRemoveNodeChildNodes(node_id); } CIMGUI_API void igDockBuilderSetNodePos(ImGuiID node_id,ImVec2 pos) { return ImGui::DockBuilderSetNodePos(node_id,pos); } CIMGUI_API void igDockBuilderSetNodeSize(ImGuiID node_id,ImVec2 size) { return ImGui::DockBuilderSetNodeSize(node_id,size); } CIMGUI_API ImGuiID igDockBuilderSplitNode(ImGuiID node_id,ImGuiDir split_dir,float size_ratio_for_node_at_dir,ImGuiID* out_id_at_dir,ImGuiID* out_id_at_opposite_dir) { return ImGui::DockBuilderSplitNode(node_id,split_dir,size_ratio_for_node_at_dir,out_id_at_dir,out_id_at_opposite_dir); } CIMGUI_API void igDockBuilderCopyDockSpace(ImGuiID src_dockspace_id,ImGuiID dst_dockspace_id,ImVector_const_charPtr* in_window_remap_pairs) { return ImGui::DockBuilderCopyDockSpace(src_dockspace_id,dst_dockspace_id,in_window_remap_pairs); } CIMGUI_API void igDockBuilderCopyNode(ImGuiID src_node_id,ImGuiID dst_node_id,ImVector_ImGuiID* out_node_remap_pairs) { return ImGui::DockBuilderCopyNode(src_node_id,dst_node_id,out_node_remap_pairs); } CIMGUI_API void igDockBuilderCopyWindowSettings(const char* src_name,const char* dst_name) { return ImGui::DockBuilderCopyWindowSettings(src_name,dst_name); } CIMGUI_API void igDockBuilderFinish(ImGuiID node_id) { return ImGui::DockBuilderFinish(node_id); } CIMGUI_API void igPushFocusScope(ImGuiID id) { return ImGui::PushFocusScope(id); } CIMGUI_API void igPopFocusScope() { return ImGui::PopFocusScope(); } CIMGUI_API ImGuiID igGetCurrentFocusScope() { return ImGui::GetCurrentFocusScope(); } CIMGUI_API bool igIsDragDropActive() { return ImGui::IsDragDropActive(); } CIMGUI_API bool igBeginDragDropTargetCustom(const ImRect bb,ImGuiID id) { return ImGui::BeginDragDropTargetCustom(bb,id); } CIMGUI_API void igClearDragDrop() { return ImGui::ClearDragDrop(); } CIMGUI_API bool igIsDragDropPayloadBeingAccepted() { return ImGui::IsDragDropPayloadBeingAccepted(); } CIMGUI_API void igRenderDragDropTargetRect(const ImRect bb,const ImRect item_clip_rect) { return ImGui::RenderDragDropTargetRect(bb,item_clip_rect); } CIMGUI_API ImGuiTypingSelectRequest* igGetTypingSelectRequest(ImGuiTypingSelectFlags flags) { return ImGui::GetTypingSelectRequest(flags); } CIMGUI_API int igTypingSelectFindMatch(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx) { return ImGui::TypingSelectFindMatch(req,items_count,get_item_name_func,user_data,nav_item_idx); } CIMGUI_API int igTypingSelectFindNextSingleCharMatch(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx) { return ImGui::TypingSelectFindNextSingleCharMatch(req,items_count,get_item_name_func,user_data,nav_item_idx); } CIMGUI_API int igTypingSelectFindBestLeadingMatch(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data) { return ImGui::TypingSelectFindBestLeadingMatch(req,items_count,get_item_name_func,user_data); } CIMGUI_API bool igBeginBoxSelect(const ImRect scope_rect,ImGuiWindow* window,ImGuiID box_select_id,ImGuiMultiSelectFlags ms_flags) { return ImGui::BeginBoxSelect(scope_rect,window,box_select_id,ms_flags); } CIMGUI_API void igEndBoxSelect(const ImRect scope_rect,ImGuiMultiSelectFlags ms_flags) { return ImGui::EndBoxSelect(scope_rect,ms_flags); } CIMGUI_API void igMultiSelectItemHeader(ImGuiID id,bool* p_selected,ImGuiButtonFlags* p_button_flags) { return ImGui::MultiSelectItemHeader(id,p_selected,p_button_flags); } CIMGUI_API void igMultiSelectItemFooter(ImGuiID id,bool* p_selected,bool* p_pressed) { return ImGui::MultiSelectItemFooter(id,p_selected,p_pressed); } CIMGUI_API void igMultiSelectAddSetAll(ImGuiMultiSelectTempData* ms,bool selected) { return ImGui::MultiSelectAddSetAll(ms,selected); } CIMGUI_API void igMultiSelectAddSetRange(ImGuiMultiSelectTempData* ms,bool selected,int range_dir,ImGuiSelectionUserData first_item,ImGuiSelectionUserData last_item) { return ImGui::MultiSelectAddSetRange(ms,selected,range_dir,first_item,last_item); } CIMGUI_API ImGuiBoxSelectState* igGetBoxSelectState(ImGuiID id) { return ImGui::GetBoxSelectState(id); } CIMGUI_API ImGuiMultiSelectState* igGetMultiSelectState(ImGuiID id) { return ImGui::GetMultiSelectState(id); } CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect clip_rect) { return ImGui::SetWindowClipRectBeforeSetChannel(window,clip_rect); } CIMGUI_API void igBeginColumns(const char* str_id,int count,ImGuiOldColumnFlags flags) { return ImGui::BeginColumns(str_id,count,flags); } CIMGUI_API void igEndColumns() { return ImGui::EndColumns(); } CIMGUI_API void igPushColumnClipRect(int column_index) { return ImGui::PushColumnClipRect(column_index); } CIMGUI_API void igPushColumnsBackground() { return ImGui::PushColumnsBackground(); } CIMGUI_API void igPopColumnsBackground() { return ImGui::PopColumnsBackground(); } CIMGUI_API ImGuiID igGetColumnsID(const char* str_id,int count) { return ImGui::GetColumnsID(str_id,count); } CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,ImGuiID id) { return ImGui::FindOrCreateColumns(window,id); } CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,float offset_norm) { return ImGui::GetColumnOffsetFromNorm(columns,offset_norm); } CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,float offset) { return ImGui::GetColumnNormFromOffset(columns,offset); } CIMGUI_API void igTableOpenContextMenu(int column_n) { return ImGui::TableOpenContextMenu(column_n); } CIMGUI_API void igTableSetColumnWidth(int column_n,float width) { return ImGui::TableSetColumnWidth(column_n,width); } CIMGUI_API void igTableSetColumnSortDirection(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs) { return ImGui::TableSetColumnSortDirection(column_n,sort_direction,append_to_sort_specs); } CIMGUI_API int igTableGetHoveredRow() { return ImGui::TableGetHoveredRow(); } CIMGUI_API float igTableGetHeaderRowHeight() { return ImGui::TableGetHeaderRowHeight(); } CIMGUI_API float igTableGetHeaderAngledMaxLabelWidth() { return ImGui::TableGetHeaderAngledMaxLabelWidth(); } CIMGUI_API void igTablePushBackgroundChannel() { return ImGui::TablePushBackgroundChannel(); } CIMGUI_API void igTablePopBackgroundChannel() { return ImGui::TablePopBackgroundChannel(); } CIMGUI_API void igTableAngledHeadersRowEx(ImGuiID row_id,float angle,float max_label_width,const ImGuiTableHeaderData* data,int data_count) { return ImGui::TableAngledHeadersRowEx(row_id,angle,max_label_width,data,data_count); } CIMGUI_API ImGuiTable* igGetCurrentTable() { return ImGui::GetCurrentTable(); } CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id) { return ImGui::TableFindByID(id); } CIMGUI_API bool igBeginTableEx(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width) { return ImGui::BeginTableEx(name,id,columns_count,flags,outer_size,inner_width); } CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table,int columns_count) { return ImGui::TableBeginInitMemory(table,columns_count); } CIMGUI_API void igTableBeginApplyRequests(ImGuiTable* table) { return ImGui::TableBeginApplyRequests(table); } CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table) { return ImGui::TableSetupDrawChannels(table); } CIMGUI_API void igTableUpdateLayout(ImGuiTable* table) { return ImGui::TableUpdateLayout(table); } CIMGUI_API void igTableUpdateBorders(ImGuiTable* table) { return ImGui::TableUpdateBorders(table); } CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table) { return ImGui::TableUpdateColumnsWeightFromWidth(table); } CIMGUI_API void igTableDrawBorders(ImGuiTable* table) { return ImGui::TableDrawBorders(table); } CIMGUI_API void igTableDrawDefaultContextMenu(ImGuiTable* table,ImGuiTableFlags flags_for_section_to_display) { return ImGui::TableDrawDefaultContextMenu(table,flags_for_section_to_display); } CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table) { return ImGui::TableBeginContextMenuPopup(table); } CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table) { return ImGui::TableMergeDrawChannels(table); } CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,int instance_no) { return ImGui::TableGetInstanceData(table,instance_no); } CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table,int instance_no) { return ImGui::TableGetInstanceID(table,instance_no); } CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table) { return ImGui::TableSortSpecsSanitize(table); } CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table) { return ImGui::TableSortSpecsBuild(table); } CIMGUI_API ImGuiSortDirection igTableGetColumnNextSortDirection(ImGuiTableColumn* column) { return ImGui::TableGetColumnNextSortDirection(column); } CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,ImGuiTableColumn* column) { return ImGui::TableFixColumnSortDirection(table,column); } CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,ImGuiTableColumn* column) { return ImGui::TableGetColumnWidthAuto(table,column); } CIMGUI_API void igTableBeginRow(ImGuiTable* table) { return ImGui::TableBeginRow(table); } CIMGUI_API void igTableEndRow(ImGuiTable* table) { return ImGui::TableEndRow(table); } CIMGUI_API void igTableBeginCell(ImGuiTable* table,int column_n) { return ImGui::TableBeginCell(table,column_n); } CIMGUI_API void igTableEndCell(ImGuiTable* table) { return ImGui::TableEndCell(table); } CIMGUI_API void igTableGetCellBgRect(ImRect *pOut,const ImGuiTable* table,int column_n) { *pOut = ImGui::TableGetCellBgRect(table,column_n); } CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n) { return ImGui::TableGetColumnName(table,column_n); } CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,int column_n,int instance_no) { return ImGui::TableGetColumnResizeID(table,column_n,instance_no); } CIMGUI_API float igTableGetMaxColumnWidth(const ImGuiTable* table,int column_n) { return ImGui::TableGetMaxColumnWidth(table,column_n); } CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,int column_n) { return ImGui::TableSetColumnWidthAutoSingle(table,column_n); } CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table) { return ImGui::TableSetColumnWidthAutoAll(table); } CIMGUI_API void igTableRemove(ImGuiTable* table) { return ImGui::TableRemove(table); } CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table) { return ImGui::TableGcCompactTransientBuffers(table); } CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(ImGuiTableTempData* table) { return ImGui::TableGcCompactTransientBuffers(table); } CIMGUI_API void igTableGcCompactSettings() { return ImGui::TableGcCompactSettings(); } CIMGUI_API void igTableLoadSettings(ImGuiTable* table) { return ImGui::TableLoadSettings(table); } CIMGUI_API void igTableSaveSettings(ImGuiTable* table) { return ImGui::TableSaveSettings(table); } CIMGUI_API void igTableResetSettings(ImGuiTable* table) { return ImGui::TableResetSettings(table); } CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table) { return ImGui::TableGetBoundSettings(table); } CIMGUI_API void igTableSettingsAddSettingsHandler() { return ImGui::TableSettingsAddSettingsHandler(); } CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,int columns_count) { return ImGui::TableSettingsCreate(id,columns_count); } CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id) { return ImGui::TableSettingsFindByID(id); } CIMGUI_API ImGuiTabBar* igGetCurrentTabBar() { return ImGui::GetCurrentTabBar(); } CIMGUI_API bool igBeginTabBarEx(ImGuiTabBar* tab_bar,const ImRect bb,ImGuiTabBarFlags flags) { return ImGui::BeginTabBarEx(tab_bar,bb,flags); } CIMGUI_API ImGuiTabItem* igTabBarFindTabByID(ImGuiTabBar* tab_bar,ImGuiID tab_id) { return ImGui::TabBarFindTabByID(tab_bar,tab_id); } CIMGUI_API ImGuiTabItem* igTabBarFindTabByOrder(ImGuiTabBar* tab_bar,int order) { return ImGui::TabBarFindTabByOrder(tab_bar,order); } CIMGUI_API ImGuiTabItem* igTabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar) { return ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar); } CIMGUI_API ImGuiTabItem* igTabBarGetCurrentTab(ImGuiTabBar* tab_bar) { return ImGui::TabBarGetCurrentTab(tab_bar); } CIMGUI_API int igTabBarGetTabOrder(ImGuiTabBar* tab_bar,ImGuiTabItem* tab) { return ImGui::TabBarGetTabOrder(tab_bar,tab); } CIMGUI_API const char* igTabBarGetTabName(ImGuiTabBar* tab_bar,ImGuiTabItem* tab) { return ImGui::TabBarGetTabName(tab_bar,tab); } CIMGUI_API void igTabBarAddTab(ImGuiTabBar* tab_bar,ImGuiTabItemFlags tab_flags,ImGuiWindow* window) { return ImGui::TabBarAddTab(tab_bar,tab_flags,window); } CIMGUI_API void igTabBarRemoveTab(ImGuiTabBar* tab_bar,ImGuiID tab_id) { return ImGui::TabBarRemoveTab(tab_bar,tab_id); } CIMGUI_API void igTabBarCloseTab(ImGuiTabBar* tab_bar,ImGuiTabItem* tab) { return ImGui::TabBarCloseTab(tab_bar,tab); } CIMGUI_API void igTabBarQueueFocus(ImGuiTabBar* tab_bar,ImGuiTabItem* tab) { return ImGui::TabBarQueueFocus(tab_bar,tab); } CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,int offset) { return ImGui::TabBarQueueReorder(tab_bar,tab,offset); } CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,ImVec2 mouse_pos) { return ImGui::TabBarQueueReorderFromMousePos(tab_bar,tab,mouse_pos); } CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar) { return ImGui::TabBarProcessReorder(tab_bar); } CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window) { return ImGui::TabItemEx(tab_bar,label,p_open,flags,docked_window); } CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker) { *pOut = ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker); } CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window) { *pOut = ImGui::TabItemCalcSize(window); } CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col) { return ImGui::TabItemBackground(draw_list,bb,flags,col); } CIMGUI_API void igTabItemLabelAndCloseButton(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible,bool* out_just_closed,bool* out_text_clipped) { return ImGui::TabItemLabelAndCloseButton(draw_list,bb,flags,frame_padding,label,tab_id,close_button_id,is_contents_visible,out_just_closed,out_text_clipped); } CIMGUI_API void igRenderText(ImVec2 pos,const char* text,const char* text_end,bool hide_text_after_hash) { return ImGui::RenderText(pos,text,text_end,hide_text_after_hash); } CIMGUI_API void igRenderTextWrapped(ImVec2 pos,const char* text,const char* text_end,float wrap_width) { return ImGui::RenderTextWrapped(pos,text,text_end,wrap_width); } CIMGUI_API void igRenderTextClipped(const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect) { return ImGui::RenderTextClipped(pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect); } CIMGUI_API void igRenderTextClippedEx(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect) { return ImGui::RenderTextClippedEx(draw_list,pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect); } CIMGUI_API void igRenderTextEllipsis(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,float clip_max_x,float ellipsis_max_x,const char* text,const char* text_end,const ImVec2* text_size_if_known) { return ImGui::RenderTextEllipsis(draw_list,pos_min,pos_max,clip_max_x,ellipsis_max_x,text,text_end,text_size_if_known); } CIMGUI_API void igRenderFrame(ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,bool border,float rounding) { return ImGui::RenderFrame(p_min,p_max,fill_col,border,rounding); } CIMGUI_API void igRenderFrameBorder(ImVec2 p_min,ImVec2 p_max,float rounding) { return ImGui::RenderFrameBorder(p_min,p_max,rounding); } CIMGUI_API void igRenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list,ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,float grid_step,ImVec2 grid_off,float rounding,ImDrawFlags flags) { return ImGui::RenderColorRectWithAlphaCheckerboard(draw_list,p_min,p_max,fill_col,grid_step,grid_off,rounding,flags); } CIMGUI_API void igRenderNavHighlight(const ImRect bb,ImGuiID id,ImGuiNavHighlightFlags flags) { return ImGui::RenderNavHighlight(bb,id,flags); } CIMGUI_API const char* igFindRenderedTextEnd(const char* text,const char* text_end) { return ImGui::FindRenderedTextEnd(text,text_end); } CIMGUI_API void igRenderMouseCursor(ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow) { return ImGui::RenderMouseCursor(pos,scale,mouse_cursor,col_fill,col_border,col_shadow); } CIMGUI_API void igRenderArrow(ImDrawList* draw_list,ImVec2 pos,ImU32 col,ImGuiDir dir,float scale) { return ImGui::RenderArrow(draw_list,pos,col,dir,scale); } CIMGUI_API void igRenderBullet(ImDrawList* draw_list,ImVec2 pos,ImU32 col) { return ImGui::RenderBullet(draw_list,pos,col); } CIMGUI_API void igRenderCheckMark(ImDrawList* draw_list,ImVec2 pos,ImU32 col,float sz) { return ImGui::RenderCheckMark(draw_list,pos,col,sz); } CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,ImVec2 pos,ImVec2 half_sz,ImGuiDir direction,ImU32 col) { return ImGui::RenderArrowPointingAt(draw_list,pos,half_sz,direction,col); } CIMGUI_API void igRenderArrowDockMenu(ImDrawList* draw_list,ImVec2 p_min,float sz,ImU32 col) { return ImGui::RenderArrowDockMenu(draw_list,p_min,sz,col); } CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,const ImRect rect,ImU32 col,float x_start_norm,float x_end_norm,float rounding) { return ImGui::RenderRectFilledRangeH(draw_list,rect,col,x_start_norm,x_end_norm,rounding); } CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,const ImRect outer,const ImRect inner,ImU32 col,float rounding) { return ImGui::RenderRectFilledWithHole(draw_list,outer,inner,col,rounding); } CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,const ImRect r_outer,float threshold) { return ImGui::CalcRoundingFlagsForRectInRect(r_in,r_outer,threshold); } CIMGUI_API void igTextEx(const char* text,const char* text_end,ImGuiTextFlags flags) { return ImGui::TextEx(text,text_end,flags); } CIMGUI_API bool igButtonEx(const char* label,const ImVec2 size_arg,ImGuiButtonFlags flags) { return ImGui::ButtonEx(label,size_arg,flags); } CIMGUI_API bool igArrowButtonEx(const char* str_id,ImGuiDir dir,ImVec2 size_arg,ImGuiButtonFlags flags) { return ImGui::ArrowButtonEx(str_id,dir,size_arg,flags); } CIMGUI_API bool igImageButtonEx(ImGuiID id,ImTextureID texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags) { return ImGui::ImageButtonEx(id,texture_id,image_size,uv0,uv1,bg_col,tint_col,flags); } CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags,float thickness) { return ImGui::SeparatorEx(flags,thickness); } CIMGUI_API void igSeparatorTextEx(ImGuiID id,const char* label,const char* label_end,float extra_width) { return ImGui::SeparatorTextEx(id,label,label_end,extra_width); } CIMGUI_API bool igCheckboxFlags_S64Ptr(const char* label,ImS64* flags,ImS64 flags_value) { return ImGui::CheckboxFlags(label,flags,flags_value); } CIMGUI_API bool igCheckboxFlags_U64Ptr(const char* label,ImU64* flags,ImU64 flags_value) { return ImGui::CheckboxFlags(label,flags,flags_value); } CIMGUI_API bool igCloseButton(ImGuiID id,const ImVec2 pos) { return ImGui::CloseButton(id,pos); } CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node) { return ImGui::CollapseButton(id,pos,dock_node); } CIMGUI_API void igScrollbar(ImGuiAxis axis) { return ImGui::Scrollbar(axis); } CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags flags) { return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,flags); } CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis) { *pOut = ImGui::GetWindowScrollbarRect(window,axis); } CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window,ImGuiAxis axis) { return ImGui::GetWindowScrollbarID(window,axis); } CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window,int n) { return ImGui::GetWindowResizeCornerID(window,n); } CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,ImGuiDir dir) { return ImGui::GetWindowResizeBorderID(window,dir); } CIMGUI_API bool igButtonBehavior(const ImRect bb,ImGuiID id,bool* out_hovered,bool* out_held,ImGuiButtonFlags flags) { return ImGui::ButtonBehavior(bb,id,out_hovered,out_held,flags); } CIMGUI_API bool igDragBehavior(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags) { return ImGui::DragBehavior(id,data_type,p_v,v_speed,p_min,p_max,format,flags); } CIMGUI_API bool igSliderBehavior(const ImRect bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags,ImRect* out_grab_bb) { return ImGui::SliderBehavior(bb,id,data_type,p_v,p_min,p_max,format,flags,out_grab_bb); } CIMGUI_API bool igSplitterBehavior(const ImRect bb,ImGuiID id,ImGuiAxis axis,float* size1,float* size2,float min_size1,float min_size2,float hover_extend,float hover_visibility_delay,ImU32 bg_col) { return ImGui::SplitterBehavior(bb,id,axis,size1,size2,min_size1,min_size2,hover_extend,hover_visibility_delay,bg_col); } CIMGUI_API bool igTreeNodeBehavior(ImGuiID id,ImGuiTreeNodeFlags flags,const char* label,const char* label_end) { return ImGui::TreeNodeBehavior(id,flags,label,label_end); } CIMGUI_API void igTreePushOverrideID(ImGuiID id) { return ImGui::TreePushOverrideID(id); } CIMGUI_API bool igTreeNodeGetOpen(ImGuiID storage_id) { return ImGui::TreeNodeGetOpen(storage_id); } CIMGUI_API void igTreeNodeSetOpen(ImGuiID storage_id,bool open) { return ImGui::TreeNodeSetOpen(storage_id,open); } CIMGUI_API bool igTreeNodeUpdateNextOpen(ImGuiID storage_id,ImGuiTreeNodeFlags flags) { return ImGui::TreeNodeUpdateNextOpen(storage_id,flags); } CIMGUI_API const ImGuiDataTypeInfo* igDataTypeGetInfo(ImGuiDataType data_type) { return ImGui::DataTypeGetInfo(data_type); } CIMGUI_API int igDataTypeFormatString(char* buf,int buf_size,ImGuiDataType data_type,const void* p_data,const char* format) { return ImGui::DataTypeFormatString(buf,buf_size,data_type,p_data,format); } CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,int op,void* output,const void* arg_1,const void* arg_2) { return ImGui::DataTypeApplyOp(data_type,op,output,arg_1,arg_2); } CIMGUI_API bool igDataTypeApplyFromText(const char* buf,ImGuiDataType data_type,void* p_data,const char* format,void* p_data_when_empty) { return ImGui::DataTypeApplyFromText(buf,data_type,p_data,format,p_data_when_empty); } CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,const void* arg_1,const void* arg_2) { return ImGui::DataTypeCompare(data_type,arg_1,arg_2); } CIMGUI_API bool igDataTypeClamp(ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max) { return ImGui::DataTypeClamp(data_type,p_data,p_min,p_max); } CIMGUI_API bool igInputTextEx(const char* label,const char* hint,char* buf,int buf_size,const ImVec2 size_arg,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data) { return ImGui::InputTextEx(label,hint,buf,buf_size,size_arg,flags,callback,user_data); } CIMGUI_API void igInputTextDeactivateHook(ImGuiID id) { return ImGui::InputTextDeactivateHook(id); } CIMGUI_API bool igTempInputText(const ImRect bb,ImGuiID id,const char* label,char* buf,int buf_size,ImGuiInputTextFlags flags) { return ImGui::TempInputText(bb,id,label,buf,buf_size,flags); } CIMGUI_API bool igTempInputScalar(const ImRect bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min,const void* p_clamp_max) { return ImGui::TempInputScalar(bb,id,label,data_type,p_data,format,p_clamp_min,p_clamp_max); } CIMGUI_API bool igTempInputIsActive(ImGuiID id) { return ImGui::TempInputIsActive(id); } CIMGUI_API ImGuiInputTextState* igGetInputTextState(ImGuiID id) { return ImGui::GetInputTextState(id); } CIMGUI_API void igSetNextItemRefVal(ImGuiDataType data_type,void* p_data) { return ImGui::SetNextItemRefVal(data_type,p_data); } CIMGUI_API void igColorTooltip(const char* text,const float* col,ImGuiColorEditFlags flags) { return ImGui::ColorTooltip(text,col,flags); } CIMGUI_API void igColorEditOptionsPopup(const float* col,ImGuiColorEditFlags flags) { return ImGui::ColorEditOptionsPopup(col,flags); } CIMGUI_API void igColorPickerOptionsPopup(const float* ref_col,ImGuiColorEditFlags flags) { return ImGui::ColorPickerOptionsPopup(ref_col,flags); } CIMGUI_API int igPlotEx(ImGuiPlotType plot_type,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,const ImVec2 size_arg) { return ImGui::PlotEx(plot_type,label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,size_arg); } CIMGUI_API void igShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,ImVec2 gradient_p0,ImVec2 gradient_p1,ImU32 col0,ImU32 col1) { return ImGui::ShadeVertsLinearColorGradientKeepAlpha(draw_list,vert_start_idx,vert_end_idx,gradient_p0,gradient_p1,col0,col1); } CIMGUI_API void igShadeVertsLinearUV(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,bool clamp) { return ImGui::ShadeVertsLinearUV(draw_list,vert_start_idx,vert_end_idx,a,b,uv_a,uv_b,clamp); } CIMGUI_API void igShadeVertsTransformPos(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2 pivot_in,float cos_a,float sin_a,const ImVec2 pivot_out) { return ImGui::ShadeVertsTransformPos(draw_list,vert_start_idx,vert_end_idx,pivot_in,cos_a,sin_a,pivot_out); } CIMGUI_API void igGcCompactTransientMiscBuffers() { return ImGui::GcCompactTransientMiscBuffers(); } CIMGUI_API void igGcCompactTransientWindowBuffers(ImGuiWindow* window) { return ImGui::GcCompactTransientWindowBuffers(window); } CIMGUI_API void igGcAwakeTransientWindowBuffers(ImGuiWindow* window) { return ImGui::GcAwakeTransientWindowBuffers(window); } CIMGUI_API void igDebugAllocHook(ImGuiDebugAllocInfo* info,int frame_count,void* ptr,size_t size) { return ImGui::DebugAllocHook(info,frame_count,ptr,size); } CIMGUI_API void igErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,void* user_data) { return ImGui::ErrorCheckEndFrameRecover(log_callback,user_data); } CIMGUI_API void igErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,void* user_data) { return ImGui::ErrorCheckEndWindowRecover(log_callback,user_data); } CIMGUI_API void igErrorCheckUsingSetCursorPosToExtendParentBoundaries() { return ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries(); } CIMGUI_API void igDebugDrawCursorPos(ImU32 col) { return ImGui::DebugDrawCursorPos(col); } CIMGUI_API void igDebugDrawLineExtents(ImU32 col) { return ImGui::DebugDrawLineExtents(col); } CIMGUI_API void igDebugDrawItemRect(ImU32 col) { return ImGui::DebugDrawItemRect(col); } CIMGUI_API void igDebugTextUnformattedWithLocateItem(const char* line_begin,const char* line_end) { return ImGui::DebugTextUnformattedWithLocateItem(line_begin,line_end); } CIMGUI_API void igDebugLocateItem(ImGuiID target_id) { return ImGui::DebugLocateItem(target_id); } CIMGUI_API void igDebugLocateItemOnHover(ImGuiID target_id) { return ImGui::DebugLocateItemOnHover(target_id); } CIMGUI_API void igDebugLocateItemResolveWithLastItem() { return ImGui::DebugLocateItemResolveWithLastItem(); } CIMGUI_API void igDebugBreakClearData() { return ImGui::DebugBreakClearData(); } CIMGUI_API bool igDebugBreakButton(const char* label,const char* description_of_location) { return ImGui::DebugBreakButton(label,description_of_location); } CIMGUI_API void igDebugBreakButtonTooltip(bool keyboard_only,const char* description_of_location) { return ImGui::DebugBreakButtonTooltip(keyboard_only,description_of_location); } CIMGUI_API void igShowFontAtlas(ImFontAtlas* atlas) { return ImGui::ShowFontAtlas(atlas); } CIMGUI_API void igDebugHookIdInfo(ImGuiID id,ImGuiDataType data_type,const void* data_id,const void* data_id_end) { return ImGui::DebugHookIdInfo(id,data_type,data_id,data_id_end); } CIMGUI_API void igDebugNodeColumns(ImGuiOldColumns* columns) { return ImGui::DebugNodeColumns(columns); } CIMGUI_API void igDebugNodeDockNode(ImGuiDockNode* node,const char* label) { return ImGui::DebugNodeDockNode(node,label); } CIMGUI_API void igDebugNodeDrawList(ImGuiWindow* window,ImGuiViewportP* viewport,const ImDrawList* draw_list,const char* label) { return ImGui::DebugNodeDrawList(window,viewport,draw_list,label); } CIMGUI_API void igDebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list,const ImDrawList* draw_list,const ImDrawCmd* draw_cmd,bool show_mesh,bool show_aabb) { return ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(out_draw_list,draw_list,draw_cmd,show_mesh,show_aabb); } CIMGUI_API void igDebugNodeFont(ImFont* font) { return ImGui::DebugNodeFont(font); } CIMGUI_API void igDebugNodeFontGlyph(ImFont* font,const ImFontGlyph* glyph) { return ImGui::DebugNodeFontGlyph(font,glyph); } CIMGUI_API void igDebugNodeStorage(ImGuiStorage* storage,const char* label) { return ImGui::DebugNodeStorage(storage,label); } CIMGUI_API void igDebugNodeTabBar(ImGuiTabBar* tab_bar,const char* label) { return ImGui::DebugNodeTabBar(tab_bar,label); } CIMGUI_API void igDebugNodeTable(ImGuiTable* table) { return ImGui::DebugNodeTable(table); } CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings) { return ImGui::DebugNodeTableSettings(settings); } CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state) { return ImGui::DebugNodeInputTextState(state); } CIMGUI_API void igDebugNodeTypingSelectState(ImGuiTypingSelectState* state) { return ImGui::DebugNodeTypingSelectState(state); } CIMGUI_API void igDebugNodeMultiSelectState(ImGuiMultiSelectState* state) { return ImGui::DebugNodeMultiSelectState(state); } CIMGUI_API void igDebugNodeWindow(ImGuiWindow* window,const char* label) { return ImGui::DebugNodeWindow(window,label); } CIMGUI_API void igDebugNodeWindowSettings(ImGuiWindowSettings* settings) { return ImGui::DebugNodeWindowSettings(settings); } CIMGUI_API void igDebugNodeWindowsList(ImVector_ImGuiWindowPtr* windows,const char* label) { return ImGui::DebugNodeWindowsList(windows,label); } CIMGUI_API void igDebugNodeWindowsListByBeginStackParent(ImGuiWindow** windows,int windows_size,ImGuiWindow* parent_in_begin_stack) { return ImGui::DebugNodeWindowsListByBeginStackParent(windows,windows_size,parent_in_begin_stack); } CIMGUI_API void igDebugNodeViewport(ImGuiViewportP* viewport) { return ImGui::DebugNodeViewport(viewport); } CIMGUI_API void igDebugNodePlatformMonitor(ImGuiPlatformMonitor* monitor,const char* label,int idx) { return ImGui::DebugNodePlatformMonitor(monitor,label,idx); } CIMGUI_API void igDebugRenderKeyboardPreview(ImDrawList* draw_list) { return ImGui::DebugRenderKeyboardPreview(draw_list); } CIMGUI_API void igDebugRenderViewportThumbnail(ImDrawList* draw_list,ImGuiViewportP* viewport,const ImRect bb) { return ImGui::DebugRenderViewportThumbnail(draw_list,viewport,bb); } CIMGUI_API void igImFontAtlasUpdateConfigDataPointers(ImFontAtlas* atlas) { return ImFontAtlasUpdateConfigDataPointers(atlas); } CIMGUI_API void igImFontAtlasBuildInit(ImFontAtlas* atlas) { return ImFontAtlasBuildInit(atlas); } CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,ImFont* font,ImFontConfig* font_config,float ascent,float descent) { return ImFontAtlasBuildSetupFont(atlas,font,font_config,ascent,descent); } CIMGUI_API void igImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas,void* stbrp_context_opaque) { return ImFontAtlasBuildPackCustomRects(atlas,stbrp_context_opaque); } CIMGUI_API void igImFontAtlasBuildFinish(ImFontAtlas* atlas) { return ImFontAtlasBuildFinish(atlas); } CIMGUI_API void igImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned char in_marker_pixel_value) { return ImFontAtlasBuildRender8bppRectFromString(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value); } CIMGUI_API void igImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned int in_marker_pixel_value) { return ImFontAtlasBuildRender32bppRectFromString(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value); } CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256],float in_multiply_factor) { return ImFontAtlasBuildMultiplyCalcLookupTable(out_table,in_multiply_factor); } CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256],unsigned char* pixels,int x,int y,int w,int h,int stride) { return ImFontAtlasBuildMultiplyRectAlpha8(table,pixels,x,y,w,h,stride); } /////////////////////////////manual written functions CIMGUI_API void igLogText(CONST char *fmt, ...) { char buffer[256]; va_list args; va_start(args, fmt); vsnprintf(buffer, 256, fmt, args); va_end(args); ImGui::LogText("%s", buffer); } CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...) { va_list args; va_start(args, fmt); buffer->appendfv(fmt, args); va_end(args); } CIMGUI_API float igGET_FLT_MAX() { return FLT_MAX; } CIMGUI_API float igGET_FLT_MIN() { return FLT_MIN; } CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create() { return IM_NEW(ImVector) (); } CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self) { IM_DELETE(self); } CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p) { IM_PLACEMENT_NEW(p) ImVector(); } CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p) { p->~ImVector(); } #ifdef IMGUI_HAS_DOCK // NOTE: Some function pointers in the ImGuiPlatformIO structure are not C-compatible because of their // use of a complex return type. To work around this, we store a custom CimguiStorage object inside // ImGuiIO::BackendLanguageUserData, which contains C-compatible function pointer variants for these // functions. When a user function pointer is provided, we hook up the underlying ImGuiPlatformIO // function pointer to a thunk which accesses the user function pointer through CimguiStorage. struct CimguiStorage { void(*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos); void(*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos); }; // Gets a reference to the CimguiStorage object stored in the current ImGui context's BackendLanguageUserData. CimguiStorage& GetCimguiStorage() { ImGuiIO& io = ImGui::GetIO(); if (io.BackendLanguageUserData == NULL) { io.BackendLanguageUserData = IM_NEW(CimguiStorage)(); } return *(CimguiStorage*)io.BackendLanguageUserData; } // Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos. ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp) { ImVec2 pos; GetCimguiStorage().Platform_GetWindowPos(vp, &pos); return pos; }; // Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowPos. CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos)) { CimguiStorage& storage = GetCimguiStorage(); storage.Platform_GetWindowPos = user_callback; platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook; } // Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize. ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp) { ImVec2 size; GetCimguiStorage().Platform_GetWindowSize(vp, &size); return size; }; // Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowSize. CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size)) { CimguiStorage& storage = GetCimguiStorage(); storage.Platform_GetWindowSize = user_callback; platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook; } #endif