diff --git a/cimgui/generator/auto_funcs.cpp b/cimgui/generator/auto_funcs.cpp new file mode 100644 index 0000000..674c607 --- /dev/null +++ b/cimgui/generator/auto_funcs.cpp @@ -0,0 +1,1921 @@ +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 igRender() +{ + return ImGui::Render(); +} +CIMGUI_API ImDrawData* igGetDrawData() +{ + return ImGui::GetDrawData(); +} +CIMGUI_API void igEndFrame() +{ + return ImGui::EndFrame(); +} +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 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 igStyleColorsClassic(ImGuiStyle* dst) +{ + return ImGui::StyleColorsClassic(dst); +} +CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst) +{ + return ImGui::StyleColorsLight(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 igBeginChildStr(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags) +{ + return ImGui::BeginChild(str_id,size,border,flags); +} +CIMGUI_API bool igBeginChildID(ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags) +{ + return ImGui::BeginChild(id,size,border,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 ImVec2 igGetWindowPos() +{ + return ImGui::GetWindowPos(); +} +CIMGUI_API ImVec2 igGetWindowSize() +{ + return ImGui::GetWindowSize(); +} +CIMGUI_API float igGetWindowWidth() +{ + return ImGui::GetWindowWidth(); +} +CIMGUI_API float igGetWindowHeight() +{ + return ImGui::GetWindowHeight(); +} +CIMGUI_API ImVec2 igGetContentRegionMax() +{ + return ImGui::GetContentRegionMax(); +} +CIMGUI_API ImVec2 igGetContentRegionAvail() +{ + return ImGui::GetContentRegionAvail(); +} +CIMGUI_API float igGetContentRegionAvailWidth() +{ + return ImGui::GetContentRegionAvailWidth(); +} +CIMGUI_API ImVec2 igGetWindowContentRegionMin() +{ + return ImGui::GetWindowContentRegionMin(); +} +CIMGUI_API ImVec2 igGetWindowContentRegionMax() +{ + return ImGui::GetWindowContentRegionMax(); +} +CIMGUI_API float igGetWindowContentRegionWidth() +{ + return ImGui::GetWindowContentRegionWidth(); +} +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 igSetNextWindowBgAlpha(float alpha) +{ + return ImGui::SetNextWindowBgAlpha(alpha); +} +CIMGUI_API void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond) +{ + return ImGui::SetWindowPos(pos,cond); +} +CIMGUI_API void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond) +{ + return ImGui::SetWindowSize(size,cond); +} +CIMGUI_API void igSetWindowCollapsedBool(bool collapsed,ImGuiCond cond) +{ + return ImGui::SetWindowCollapsed(collapsed,cond); +} +CIMGUI_API void igSetWindowFocus() +{ + return ImGui::SetWindowFocus(); +} +CIMGUI_API void igSetWindowFontScale(float scale) +{ + return ImGui::SetWindowFontScale(scale); +} +CIMGUI_API void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond) +{ + return ImGui::SetWindowPos(name,pos,cond); +} +CIMGUI_API void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond) +{ + return ImGui::SetWindowSize(name,size,cond); +} +CIMGUI_API void igSetWindowCollapsedStr(const char* name,bool collapsed,ImGuiCond cond) +{ + return ImGui::SetWindowCollapsed(name,collapsed,cond); +} +CIMGUI_API void igSetWindowFocusStr(const char* name) +{ + return ImGui::SetWindowFocus(name); +} +CIMGUI_API float igGetScrollX() +{ + return ImGui::GetScrollX(); +} +CIMGUI_API float igGetScrollY() +{ + return ImGui::GetScrollY(); +} +CIMGUI_API float igGetScrollMaxX() +{ + return ImGui::GetScrollMaxX(); +} +CIMGUI_API float igGetScrollMaxY() +{ + return ImGui::GetScrollMaxY(); +} +CIMGUI_API void igSetScrollX(float scroll_x) +{ + return ImGui::SetScrollX(scroll_x); +} +CIMGUI_API void igSetScrollY(float scroll_y) +{ + return ImGui::SetScrollY(scroll_y); +} +CIMGUI_API void igSetScrollHere(float center_y_ratio) +{ + return ImGui::SetScrollHere(center_y_ratio); +} +CIMGUI_API void igSetScrollFromPosY(float pos_y,float center_y_ratio) +{ + return ImGui::SetScrollFromPosY(pos_y,center_y_ratio); +} +CIMGUI_API void igPushFont(ImFont* font) +{ + return ImGui::PushFont(font); +} +CIMGUI_API void igPopFont() +{ + return ImGui::PopFont(); +} +CIMGUI_API void igPushStyleColorU32(ImGuiCol idx,ImU32 col) +{ + return ImGui::PushStyleColor(idx,col); +} +CIMGUI_API void igPushStyleColorVec4(ImGuiCol idx,const ImVec4 col) +{ + return ImGui::PushStyleColor(idx,col); +} +CIMGUI_API void igPopStyleColor(int count) +{ + return ImGui::PopStyleColor(count); +} +CIMGUI_API void igPushStyleVarFloat(ImGuiStyleVar idx,float val) +{ + return ImGui::PushStyleVar(idx,val); +} +CIMGUI_API void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val) +{ + return ImGui::PushStyleVar(idx,val); +} +CIMGUI_API void igPopStyleVar(int count) +{ + return ImGui::PopStyleVar(count); +} +CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx) +{ + return &ImGui::GetStyleColorVec4(idx); +} +CIMGUI_API ImFont* igGetFont() +{ + return ImGui::GetFont(); +} +CIMGUI_API float igGetFontSize() +{ + return ImGui::GetFontSize(); +} +CIMGUI_API ImVec2 igGetFontTexUvWhitePixel() +{ + return ImGui::GetFontTexUvWhitePixel(); +} +CIMGUI_API ImU32 igGetColorU32Col(ImGuiCol idx,float alpha_mul) +{ + return ImGui::GetColorU32(idx,alpha_mul); +} +CIMGUI_API ImU32 igGetColorU32Vec4(const ImVec4 col) +{ + return ImGui::GetColorU32(col); +} +CIMGUI_API ImU32 igGetColorU32U32(ImU32 col) +{ + return ImGui::GetColorU32(col); +} +CIMGUI_API void igPushItemWidth(float item_width) +{ + return ImGui::PushItemWidth(item_width); +} +CIMGUI_API void igPopItemWidth() +{ + return ImGui::PopItemWidth(); +} +CIMGUI_API float igCalcItemWidth() +{ + return ImGui::CalcItemWidth(); +} +CIMGUI_API void igPushTextWrapPos(float wrap_pos_x) +{ + return ImGui::PushTextWrapPos(wrap_pos_x); +} +CIMGUI_API void igPopTextWrapPos() +{ + return ImGui::PopTextWrapPos(); +} +CIMGUI_API void igPushAllowKeyboardFocus(bool allow_keyboard_focus) +{ + return ImGui::PushAllowKeyboardFocus(allow_keyboard_focus); +} +CIMGUI_API void igPopAllowKeyboardFocus() +{ + return ImGui::PopAllowKeyboardFocus(); +} +CIMGUI_API void igPushButtonRepeat(bool repeat) +{ + return ImGui::PushButtonRepeat(repeat); +} +CIMGUI_API void igPopButtonRepeat() +{ + return ImGui::PopButtonRepeat(); +} +CIMGUI_API void igSeparator() +{ + return ImGui::Separator(); +} +CIMGUI_API void igSameLine(float pos_x,float spacing_w) +{ + return ImGui::SameLine(pos_x,spacing_w); +} +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 ImVec2 igGetCursorPos() +{ + return 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 x) +{ + return ImGui::SetCursorPosX(x); +} +CIMGUI_API void igSetCursorPosY(float y) +{ + return ImGui::SetCursorPosY(y); +} +CIMGUI_API ImVec2 igGetCursorStartPos() +{ + return ImGui::GetCursorStartPos(); +} +CIMGUI_API ImVec2 igGetCursorScreenPos() +{ + return ImGui::GetCursorScreenPos(); +} +CIMGUI_API void igSetCursorScreenPos(const ImVec2 screen_pos) +{ + return ImGui::SetCursorScreenPos(screen_pos); +} +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 igPushIDStr(const char* str_id) +{ + return ImGui::PushID(str_id); +} +CIMGUI_API void igPushIDRange(const char* str_id_begin,const char* str_id_end) +{ + return ImGui::PushID(str_id_begin,str_id_end); +} +CIMGUI_API void igPushIDPtr(const void* ptr_id) +{ + return ImGui::PushID(ptr_id); +} +CIMGUI_API void igPushIDInt(int int_id) +{ + return ImGui::PushID(int_id); +} +CIMGUI_API void igPopID() +{ + return ImGui::PopID(); +} +CIMGUI_API ImGuiID igGetIDStr(const char* str_id) +{ + return ImGui::GetID(str_id); +} +CIMGUI_API ImGuiID igGetIDStrStr(const char* str_id_begin,const char* str_id_end) +{ + return ImGui::GetID(str_id_begin,str_id_end); +} +CIMGUI_API ImGuiID igGetIDPtr(const void* ptr_id) +{ + return ImGui::GetID(ptr_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 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 igArrowButton(const char* str_id,ImGuiDir dir) +{ + return ImGui::ArrowButton(str_id,dir); +} +CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size) +{ + return ImGui::InvisibleButton(str_id,size); +} +CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col) +{ + return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col); +} +CIMGUI_API bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col) +{ + return ImGui::ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col); +} +CIMGUI_API bool igCheckbox(const char* label,bool* v) +{ + return ImGui::Checkbox(label,v); +} +CIMGUI_API bool igCheckboxFlags(const char* label,unsigned int* flags,unsigned int flags_value) +{ + return ImGui::CheckboxFlags(label,flags,flags_value); +} +CIMGUI_API bool igRadioButtonBool(const char* label,bool active) +{ + return ImGui::RadioButton(label,active); +} +CIMGUI_API bool igRadioButtonIntPtr(const char* label,int* v,int v_button) +{ + return ImGui::RadioButton(label,v,v_button); +} +CIMGUI_API void igPlotLinesFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride) +{ + return ImGui::PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride); +} +CIMGUI_API void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size) +{ + return ImGui::PlotLines(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size); +} +CIMGUI_API void igPlotHistogramFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride) +{ + return ImGui::PlotHistogram(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride); +} +CIMGUI_API void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size) +{ + return ImGui::PlotHistogram(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size); +} +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 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 igComboStr_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 igComboStr(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 igComboFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items) +{ + return ImGui::Combo(label,current_item,items_getter,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* display_format,float power) +{ + return ImGui::DragFloat(label,v,v_speed,v_min,v_max,display_format,power); +} +CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::DragFloat2(label,v,v_speed,v_min,v_max,display_format,power); +} +CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::DragFloat3(label,v,v_speed,v_min,v_max,display_format,power); +} +CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::DragFloat4(label,v,v_speed,v_min,v_max,display_format,power); +} +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* display_format,const char* display_format_max,float power) +{ + return ImGui::DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,display_format,display_format_max,power); +} +CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* display_format) +{ + return ImGui::DragInt(label,v,v_speed,v_min,v_max,display_format); +} +CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* display_format) +{ + return ImGui::DragInt2(label,v,v_speed,v_min,v_max,display_format); +} +CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* display_format) +{ + return ImGui::DragInt3(label,v,v_speed,v_min,v_max,display_format); +} +CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* display_format) +{ + return ImGui::DragInt4(label,v,v_speed,v_min,v_max,display_format); +} +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* display_format,const char* display_format_max) +{ + return ImGui::DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,display_format,display_format_max); +} +CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiTextEditCallback 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,ImGuiTextEditCallback callback,void* user_data) +{ + return ImGui::InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data); +} +CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,int decimal_precision,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputFloat(label,v,step,step_fast,decimal_precision,extra_flags); +} +CIMGUI_API bool igInputFloat2(const char* label,float v[2],int decimal_precision,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputFloat2(label,v,decimal_precision,extra_flags); +} +CIMGUI_API bool igInputFloat3(const char* label,float v[3],int decimal_precision,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputFloat3(label,v,decimal_precision,extra_flags); +} +CIMGUI_API bool igInputFloat4(const char* label,float v[4],int decimal_precision,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputFloat4(label,v,decimal_precision,extra_flags); +} +CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputInt(label,v,step,step_fast,extra_flags); +} +CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputInt2(label,v,extra_flags); +} +CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputInt3(label,v,extra_flags); +} +CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputInt4(label,v,extra_flags); +} +CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* display_format,ImGuiInputTextFlags extra_flags) +{ + return ImGui::InputDouble(label,v,step,step_fast,display_format,extra_flags); +} +CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::SliderFloat(label,v,v_min,v_max,display_format,power); +} +CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::SliderFloat2(label,v,v_min,v_max,display_format,power); +} +CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::SliderFloat3(label,v,v_min,v_max,display_format,power); +} +CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::SliderFloat4(label,v,v_min,v_max,display_format,power); +} +CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max) +{ + return ImGui::SliderAngle(label,v_rad,v_degrees_min,v_degrees_max); +} +CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* display_format) +{ + return ImGui::SliderInt(label,v,v_min,v_max,display_format); +} +CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* display_format) +{ + return ImGui::SliderInt2(label,v,v_min,v_max,display_format); +} +CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* display_format) +{ + return ImGui::SliderInt3(label,v,v_min,v_max,display_format); +} +CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* display_format) +{ + return ImGui::SliderInt4(label,v,v_min,v_max,display_format); +} +CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* display_format,float power) +{ + return ImGui::VSliderFloat(label,size,v,v_min,v_max,display_format,power); +} +CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* display_format) +{ + return ImGui::VSliderInt(label,size,v,v_min,v_max,display_format); +} +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,ImVec2 size) +{ + return ImGui::ColorButton(desc_id,col,flags,size); +} +CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags) +{ + return ImGui::SetColorEditOptions(flags); +} +CIMGUI_API bool igTreeNodeStr(const char* label) +{ + return ImGui::TreeNode(label); +} +CIMGUI_API bool igTreeNodeStrStr(const char* str_id,const char* fmt,...) +{ + va_list args; + va_start(args, fmt); + ImGui::TreeNodeV(str_id,fmt,args); + va_end(args); +} +CIMGUI_API bool igTreeNodePtr(const void* ptr_id,const char* fmt,...) +{ + va_list args; + va_start(args, fmt); + ImGui::TreeNodeV(ptr_id,fmt,args); + va_end(args); +} +CIMGUI_API bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args) +{ + return ImGui::TreeNodeV(str_id,fmt,args); +} +CIMGUI_API bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args) +{ + return ImGui::TreeNodeV(ptr_id,fmt,args); +} +CIMGUI_API bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags) +{ + return ImGui::TreeNodeEx(label,flags); +} +CIMGUI_API bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...) +{ + va_list args; + va_start(args, fmt); + ImGui::TreeNodeExV(str_id,flags,fmt,args); + va_end(args); +} +CIMGUI_API bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...) +{ + va_list args; + va_start(args, fmt); + ImGui::TreeNodeExV(ptr_id,flags,fmt,args); + va_end(args); +} +CIMGUI_API bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) +{ + return ImGui::TreeNodeExV(str_id,flags,fmt,args); +} +CIMGUI_API bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) +{ + return ImGui::TreeNodeExV(ptr_id,flags,fmt,args); +} +CIMGUI_API void igTreePushStr(const char* str_id) +{ + return ImGui::TreePush(str_id); +} +CIMGUI_API void igTreePushPtr(const void* ptr_id) +{ + return ImGui::TreePush(ptr_id); +} +CIMGUI_API void igTreePop() +{ + return ImGui::TreePop(); +} +CIMGUI_API void igTreeAdvanceToLabelPos() +{ + return ImGui::TreeAdvanceToLabelPos(); +} +CIMGUI_API float igGetTreeNodeToLabelSpacing() +{ + return ImGui::GetTreeNodeToLabelSpacing(); +} +CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond) +{ + return ImGui::SetNextTreeNodeOpen(is_open,cond); +} +CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags) +{ + return ImGui::CollapsingHeader(label,flags); +} +CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTreeNodeFlags flags) +{ + return ImGui::CollapsingHeader(label,p_open,flags); +} +CIMGUI_API bool igSelectableBool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size) +{ + return ImGui::Selectable(label,selected,flags,size); +} +CIMGUI_API bool igSelectableBoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size) +{ + return ImGui::Selectable(label,p_selected,flags,size); +} +CIMGUI_API bool igListBoxStr_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 igListBoxFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items) +{ + return ImGui::ListBox(label,current_item,items_getter,data,items_count,height_in_items); +} +CIMGUI_API bool igListBoxHeaderVec2(const char* label,const ImVec2 size) +{ + return ImGui::ListBoxHeader(label,size); +} +CIMGUI_API bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items) +{ + return ImGui::ListBoxHeader(label,items_count,height_in_items); +} +CIMGUI_API void igListBoxFooter() +{ + return ImGui::ListBoxFooter(); +} +CIMGUI_API void igValueBool(const char* prefix,bool b) +{ + return ImGui::Value(prefix,b); +} +CIMGUI_API void igValueInt(const char* prefix,int v) +{ + return ImGui::Value(prefix,v); +} +CIMGUI_API void igValueUint(const char* prefix,unsigned int v) +{ + return ImGui::Value(prefix,v); +} +CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format) +{ + return ImGui::Value(prefix,v,float_format); +} +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 void igBeginTooltip() +{ + return ImGui::BeginTooltip(); +} +CIMGUI_API void igEndTooltip() +{ + return ImGui::EndTooltip(); +} +CIMGUI_API bool igBeginMainMenuBar() +{ + return ImGui::BeginMainMenuBar(); +} +CIMGUI_API void igEndMainMenuBar() +{ + return ImGui::EndMainMenuBar(); +} +CIMGUI_API bool igBeginMenuBar() +{ + return ImGui::BeginMenuBar(); +} +CIMGUI_API void igEndMenuBar() +{ + return ImGui::EndMenuBar(); +} +CIMGUI_API bool igBeginMenu(const char* label,bool enabled) +{ + return ImGui::BeginMenu(label,enabled); +} +CIMGUI_API void igEndMenu() +{ + return ImGui::EndMenu(); +} +CIMGUI_API bool igMenuItemBool(const char* label,const char* shortcut,bool selected,bool enabled) +{ + return ImGui::MenuItem(label,shortcut,selected,enabled); +} +CIMGUI_API bool igMenuItemBoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled) +{ + return ImGui::MenuItem(label,shortcut,p_selected,enabled); +} +CIMGUI_API void igOpenPopup(const char* str_id) +{ + return ImGui::OpenPopup(str_id); +} +CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags) +{ + return ImGui::BeginPopup(str_id,flags); +} +CIMGUI_API bool igBeginPopupContextItem(const char* str_id,int mouse_button) +{ + return ImGui::BeginPopupContextItem(str_id,mouse_button); +} +CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,int mouse_button,bool also_over_items) +{ + return ImGui::BeginPopupContextWindow(str_id,mouse_button,also_over_items); +} +CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,int mouse_button) +{ + return ImGui::BeginPopupContextVoid(str_id,mouse_button); +} +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 bool igOpenPopupOnItemClick(const char* str_id,int mouse_button) +{ + return ImGui::OpenPopupOnItemClick(str_id,mouse_button); +} +CIMGUI_API bool igIsPopupOpen(const char* str_id) +{ + return ImGui::IsPopupOpen(str_id); +} +CIMGUI_API void igCloseCurrentPopup() +{ + return ImGui::CloseCurrentPopup(); +} +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 void igLogToTTY(int max_depth) +{ + return ImGui::LogToTTY(max_depth); +} +CIMGUI_API void igLogToFile(int max_depth,const char* filename) +{ + return ImGui::LogToFile(max_depth,filename); +} +CIMGUI_API void igLogToClipboard(int max_depth) +{ + return ImGui::LogToClipboard(max_depth); +} +CIMGUI_API void igLogFinish() +{ + return ImGui::LogFinish(); +} +CIMGUI_API void igLogButtons() +{ + return ImGui::LogButtons(); +} +CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags) +{ + return ImGui::BeginDragDropSource(flags); +} +CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond) +{ + return ImGui::SetDragDropPayload(type,data,size,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 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 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(int mouse_button) +{ + return ImGui::IsItemClicked(mouse_button); +} +CIMGUI_API bool igIsItemVisible() +{ + return ImGui::IsItemVisible(); +} +CIMGUI_API bool igIsAnyItemHovered() +{ + return ImGui::IsAnyItemHovered(); +} +CIMGUI_API bool igIsAnyItemActive() +{ + return ImGui::IsAnyItemActive(); +} +CIMGUI_API bool igIsAnyItemFocused() +{ + return ImGui::IsAnyItemFocused(); +} +CIMGUI_API ImVec2 igGetItemRectMin() +{ + return ImGui::GetItemRectMin(); +} +CIMGUI_API ImVec2 igGetItemRectMax() +{ + return ImGui::GetItemRectMax(); +} +CIMGUI_API ImVec2 igGetItemRectSize() +{ + return ImGui::GetItemRectSize(); +} +CIMGUI_API void igSetItemAllowOverlap() +{ + return ImGui::SetItemAllowOverlap(); +} +CIMGUI_API bool igIsRectVisible(const ImVec2 size) +{ + return ImGui::IsRectVisible(size); +} +CIMGUI_API bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max) +{ + return ImGui::IsRectVisible(rect_min,rect_max); +} +CIMGUI_API float igGetTime() +{ + return ImGui::GetTime(); +} +CIMGUI_API int igGetFrameCount() +{ + return ImGui::GetFrameCount(); +} +CIMGUI_API ImDrawList* igGetOverlayDrawList() +{ + return ImGui::GetOverlayDrawList(); +} +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 ImVec2 igCalcTextSize(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width) +{ + return ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width); +} +CIMGUI_API void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end) +{ + return ImGui::CalcListClipping(items_count,items_height,out_items_display_start,out_items_display_end); +} +CIMGUI_API bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags) +{ + return ImGui::BeginChildFrame(id,size,flags); +} +CIMGUI_API void igEndChildFrame() +{ + return ImGui::EndChildFrame(); +} +CIMGUI_API ImVec4 igColorConvertU32ToFloat4(ImU32 in) +{ + return 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 int igGetKeyIndex(ImGuiKey imgui_key) +{ + return ImGui::GetKeyIndex(imgui_key); +} +CIMGUI_API bool igIsKeyDown(int user_key_index) +{ + return ImGui::IsKeyDown(user_key_index); +} +CIMGUI_API bool igIsKeyPressed(int user_key_index,bool repeat) +{ + return ImGui::IsKeyPressed(user_key_index,repeat); +} +CIMGUI_API bool igIsKeyReleased(int user_key_index) +{ + return ImGui::IsKeyReleased(user_key_index); +} +CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate) +{ + return ImGui::GetKeyPressedAmount(key_index,repeat_delay,rate); +} +CIMGUI_API bool igIsMouseDown(int button) +{ + return ImGui::IsMouseDown(button); +} +CIMGUI_API bool igIsAnyMouseDown() +{ + return ImGui::IsAnyMouseDown(); +} +CIMGUI_API bool igIsMouseClicked(int button,bool repeat) +{ + return ImGui::IsMouseClicked(button,repeat); +} +CIMGUI_API bool igIsMouseDoubleClicked(int button) +{ + return ImGui::IsMouseDoubleClicked(button); +} +CIMGUI_API bool igIsMouseReleased(int button) +{ + return ImGui::IsMouseReleased(button); +} +CIMGUI_API bool igIsMouseDragging(int button,float lock_threshold) +{ + return ImGui::IsMouseDragging(button,lock_threshold); +} +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 ImVec2 igGetMousePos() +{ + return ImGui::GetMousePos(); +} +CIMGUI_API ImVec2 igGetMousePosOnOpeningCurrentPopup() +{ + return ImGui::GetMousePosOnOpeningCurrentPopup(); +} +CIMGUI_API ImVec2 igGetMouseDragDelta(int button,float lock_threshold) +{ + return ImGui::GetMouseDragDelta(button,lock_threshold); +} +CIMGUI_API void igResetMouseDragDelta(int button) +{ + return ImGui::ResetMouseDragDelta(button); +} +CIMGUI_API ImGuiMouseCursor igGetMouseCursor() +{ + return ImGui::GetMouseCursor(); +} +CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type) +{ + return ImGui::SetMouseCursor(type); +} +CIMGUI_API void igCaptureKeyboardFromApp(bool capture) +{ + return ImGui::CaptureKeyboardFromApp(capture); +} +CIMGUI_API void igCaptureMouseFromApp(bool capture) +{ + return ImGui::CaptureMouseFromApp(capture); +} +CIMGUI_API const char* igGetClipboardText() +{ + return ImGui::GetClipboardText(); +} +CIMGUI_API void igSetClipboardText(const char* text) +{ + return ImGui::SetClipboardText(text); +} +CIMGUI_API void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data) +{ + return ImGui::SetAllocatorFunctions(alloc_func,free_func,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 void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor) +{ + return self->ScaleAllSizes(scale_factor); +} +CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c) +{ + return self->AddInputCharacter(c); +} +CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* utf8_chars) +{ + return self->AddInputCharactersUTF8(utf8_chars); +} +CIMGUI_API inline void ImGuiIO_ClearInputCharacters(ImGuiIO* self) +{ + return self->ClearInputCharacters(); +} +CIMGUI_API const char* TextRange_begin(TextRange* self) +{ + return self->begin(); +} +CIMGUI_API const char* TextRange_end(TextRange* self) +{ + return self->end(); +} +CIMGUI_API bool TextRange_empty(TextRange* self) +{ + return self->empty(); +} +CIMGUI_API char TextRange_front(TextRange* self) +{ + return self->front(); +} +CIMGUI_API bool TextRange_is_blank(TextRange* self,char c) +{ + return self->is_blank(c); +} +CIMGUI_API void TextRange_trim_blanks(TextRange* self) +{ + return self->trim_blanks(); +} +CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange out) +{ + return self->split(separator,out); +} +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 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_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args) +{ + return self->appendfv(fmt,args); +} +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_SetAllInt(ImGuiStorage* self,int val) +{ + return self->SetAllInt(val); +} +CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self) +{ + return self->BuildSortByKey(); +} +CIMGUI_API void ImGuiTextEditCallbackData_DeleteChars(ImGuiTextEditCallbackData* self,int pos,int bytes_count) +{ + return self->DeleteChars(pos,bytes_count); +} +CIMGUI_API void ImGuiTextEditCallbackData_InsertChars(ImGuiTextEditCallbackData* self,int pos,const char* text,const char* text_end) +{ + return self->InsertChars(pos,text,text_end); +} +CIMGUI_API bool ImGuiTextEditCallbackData_HasSelection(ImGuiTextEditCallbackData* self) +{ + return self->HasSelection(); +} +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 inline void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a) +{ + return self->SetHSV(h,s,v,a); +} +CIMGUI_API ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a) +{ + return self->HSV(h,s,v,a); +} +CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self) +{ + return self->Step(); +} +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 void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,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 inline ImVec2 ImDrawList_GetClipRectMin(ImDrawList* self) +{ + return self->GetClipRectMin(); +} +CIMGUI_API inline ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self) +{ + return self->GetClipRectMax(); +} +CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness) +{ + return self->AddLine(a,b,col,thickness); +} +CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness) +{ + return self->AddRect(a,b,col,rounding,rounding_corners_flags,thickness); +} +CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags) +{ + return self->AddRectFilled(a,b,col,rounding,rounding_corners_flags); +} +CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left) +{ + return self->AddRectFilledMultiColor(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left); +} +CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness) +{ + return self->AddQuad(a,b,c,d,col,thickness); +} +CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col) +{ + return self->AddQuadFilled(a,b,c,d,col); +} +CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness) +{ + return self->AddTriangle(a,b,c,col,thickness); +} +CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col) +{ + return self->AddTriangleFilled(a,b,c,col); +} +CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness) +{ + return self->AddCircle(centre,radius,col,num_segments,thickness); +} +CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments) +{ + return self->AddCircleFilled(centre,radius,col,num_segments); +} +CIMGUI_API void ImDrawList_AddTextVec2(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_AddTextFontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect) +{ + return self->AddText(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect); +} +CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col) +{ + return self->AddImage(user_texture_id,a,b,uv_a,uv_b,col); +} +CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,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->AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col); +} +CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners) +{ + return self->AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners); +} +CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness) +{ + return self->AddPolyline(points,num_points,col,closed,thickness); +} +CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col) +{ + return self->AddConvexPolyFilled(points,num_points,col); +} +CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments) +{ + return self->AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments); +} +CIMGUI_API inline void ImDrawList_PathClear(ImDrawList* self) +{ + return self->PathClear(); +} +CIMGUI_API inline void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos) +{ + return self->PathLineTo(pos); +} +CIMGUI_API inline void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos) +{ + return self->PathLineToMergeDuplicate(pos); +} +CIMGUI_API inline void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col) +{ + return self->PathFillConvex(col); +} +CIMGUI_API inline void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,float thickness) +{ + return self->PathStroke(col,closed,thickness); +} +CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments) +{ + return self->PathArcTo(centre,radius,a_min,a_max,num_segments); +} +CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12) +{ + return self->PathArcToFast(centre,radius,a_min_of_12,a_max_of_12); +} +CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments) +{ + return self->PathBezierCurveTo(p1,p2,p3,num_segments); +} +CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags) +{ + return self->PathRect(rect_min,rect_max,rounding,rounding_corners_flags); +} +CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count) +{ + return self->ChannelsSplit(channels_count); +} +CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self) +{ + return self->ChannelsMerge(); +} +CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index) +{ + return self->ChannelsSetCurrent(channel_index); +} +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_Clear(ImDrawList* self) +{ + return self->Clear(); +} +CIMGUI_API void ImDrawList_ClearFreeMemory(ImDrawList* self) +{ + return self->ClearFreeMemory(); +} +CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count) +{ + return self->PrimReserve(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 inline void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col) +{ + return self->PrimWriteVtx(pos,uv,col); +} +CIMGUI_API inline void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx) +{ + return self->PrimWriteIdx(idx); +} +CIMGUI_API inline void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col) +{ + return self->PrimVtx(pos,uv,col); +} +CIMGUI_API void ImDrawList_UpdateClipRect(ImDrawList* self) +{ + return self->UpdateClipRect(); +} +CIMGUI_API void ImDrawList_UpdateTextureID(ImDrawList* self) +{ + return self->UpdateTextureID(); +} +CIMGUI_API void ImDrawData_Clear(ImDrawData* self) +{ + return self->Clear(); +} +CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self) +{ + return self->DeIndexAllBuffers(); +} +CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc) +{ + return self->ScaleClipRects(sc); +} +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_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) +{ + return self->AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges); +} +CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) +{ + return self->AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_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 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_GetGlyphRangesKorean(ImFontAtlas* self) +{ + return self->GetGlyphRangesKorean(); +} +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self) +{ + return self->GetGlyphRangesJapanese(); +} +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChinese(ImFontAtlas* self) +{ + return self->GetGlyphRangesChinese(); +} +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self) +{ + return self->GetGlyphRangesCyrillic(); +} +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self) +{ + return self->GetGlyphRangesThai(); +} +CIMGUI_API bool GlyphRangesBuilder_GetBit(GlyphRangesBuilder* self,int n) +{ + return self->GetBit(n); +} +CIMGUI_API void GlyphRangesBuilder_SetBit(GlyphRangesBuilder* self,int n) +{ + return self->SetBit(n); +} +CIMGUI_API void GlyphRangesBuilder_AddChar(GlyphRangesBuilder* self,ImWchar c) +{ + return self->AddChar(c); +} +CIMGUI_API void GlyphRangesBuilder_AddText(GlyphRangesBuilder* self,const char* text,const char* text_end) +{ + return self->AddText(text,text_end); +} +CIMGUI_API void GlyphRangesBuilder_AddRanges(GlyphRangesBuilder* self,const ImWchar* ranges) +{ + return self->AddRanges(ranges); +} +CIMGUI_API void GlyphRangesBuilder_BuildRanges(GlyphRangesBuilder* self,ImVector_ImWchar* out_ranges) +{ + return self->BuildRanges(out_ranges); +} +CIMGUI_API bool CustomRect_IsPacked(CustomRect* self) +{ + return self->IsPacked(); +} +CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height) +{ + return self->AddCustomRectRegular(id,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 const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index) +{ + return self->GetCustomRectByIndex(index); +} +CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* 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 void ImFont_ClearOutputData(ImFont* self) +{ + return self->ClearOutputData(); +} +CIMGUI_API void ImFont_BuildLookupTable(ImFont* self) +{ + return self->BuildLookupTable(); +} +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 void ImFont_SetFallbackChar(ImFont* self,ImWchar c) +{ + return self->SetFallbackChar(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 ImVec2 ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining) +{ + return 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,ImVec2 pos,ImU32 col,unsigned short c) +{ + return self->RenderChar(draw_list,size,pos,col,c); +} +CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip) +{ + return self->RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip); +} +CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size) +{ + return self->GrowIndex(new_size); +} +CIMGUI_API void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x) +{ + return self->AddGlyph(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); +} diff --git a/cimgui/generator/auto_funcs.h b/cimgui/generator/auto_funcs.h new file mode 100644 index 0000000..fb449d4 --- /dev/null +++ b/cimgui/generator/auto_funcs.h @@ -0,0 +1,483 @@ +#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS +typedef ImFontAtlas::GlyphRangesBuilder GlyphRangesBuilder; +typedef ImFontAtlas::CustomRect CustomRect; +typedef ImGuiTextFilter::TextRange TextRange; +typedef ImGuiStorage::Pair Pair; +typedef ImVector ImVector_TextRange; +typedef ImVector ImVector_ImWchar; +#else //CIMGUI_DEFINE_ENUMS_AND_STRUCTS +typedef ImVector ImVector_TextRange; +typedef ImVector ImVector_ImWchar; +#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS +CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas); +CIMGUI_API void igDestroyContext(ImGuiContext* ctx); +CIMGUI_API ImGuiContext* igGetCurrentContext(); +CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx); +CIMGUI_API ImGuiIO* igGetIO(); +CIMGUI_API ImGuiStyle* igGetStyle(); +CIMGUI_API void igNewFrame(); +CIMGUI_API void igRender(); +CIMGUI_API ImDrawData* igGetDrawData(); +CIMGUI_API void igEndFrame(); +CIMGUI_API void igShowDemoWindow(bool* p_open); +CIMGUI_API void igShowMetricsWindow(bool* p_open); +CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref); +CIMGUI_API bool igShowStyleSelector(const char* label); +CIMGUI_API void igShowFontSelector(const char* label); +CIMGUI_API void igShowUserGuide(); +CIMGUI_API const char* igGetVersion(); +CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst); +CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst); +CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst); +CIMGUI_API bool igBegin(const char* name,bool* p_open,ImGuiWindowFlags flags); +CIMGUI_API void igEnd(); +CIMGUI_API bool igBeginChildStr(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags); +CIMGUI_API bool igBeginChildID(ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags); +CIMGUI_API void igEndChild(); +CIMGUI_API bool igIsWindowAppearing(); +CIMGUI_API bool igIsWindowCollapsed(); +CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags); +CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags); +CIMGUI_API ImDrawList* igGetWindowDrawList(); +CIMGUI_API ImVec2 igGetWindowPos(); +CIMGUI_API ImVec2 igGetWindowSize(); +CIMGUI_API float igGetWindowWidth(); +CIMGUI_API float igGetWindowHeight(); +CIMGUI_API ImVec2 igGetContentRegionMax(); +CIMGUI_API ImVec2 igGetContentRegionAvail(); +CIMGUI_API float igGetContentRegionAvailWidth(); +CIMGUI_API ImVec2 igGetWindowContentRegionMin(); +CIMGUI_API ImVec2 igGetWindowContentRegionMax(); +CIMGUI_API float igGetWindowContentRegionWidth(); +CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot); +CIMGUI_API void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond); +CIMGUI_API void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data); +CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size); +CIMGUI_API void igSetNextWindowCollapsed(bool collapsed,ImGuiCond cond); +CIMGUI_API void igSetNextWindowFocus(); +CIMGUI_API void igSetNextWindowBgAlpha(float alpha); +CIMGUI_API void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond); +CIMGUI_API void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond); +CIMGUI_API void igSetWindowCollapsedBool(bool collapsed,ImGuiCond cond); +CIMGUI_API void igSetWindowFocus(); +CIMGUI_API void igSetWindowFontScale(float scale); +CIMGUI_API void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond); +CIMGUI_API void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond); +CIMGUI_API void igSetWindowCollapsedStr(const char* name,bool collapsed,ImGuiCond cond); +CIMGUI_API void igSetWindowFocusStr(const char* name); +CIMGUI_API float igGetScrollX(); +CIMGUI_API float igGetScrollY(); +CIMGUI_API float igGetScrollMaxX(); +CIMGUI_API float igGetScrollMaxY(); +CIMGUI_API void igSetScrollX(float scroll_x); +CIMGUI_API void igSetScrollY(float scroll_y); +CIMGUI_API void igSetScrollHere(float center_y_ratio); +CIMGUI_API void igSetScrollFromPosY(float pos_y,float center_y_ratio); +CIMGUI_API void igPushFont(ImFont* font); +CIMGUI_API void igPopFont(); +CIMGUI_API void igPushStyleColorU32(ImGuiCol idx,ImU32 col); +CIMGUI_API void igPushStyleColorVec4(ImGuiCol idx,const ImVec4 col); +CIMGUI_API void igPopStyleColor(int count); +CIMGUI_API void igPushStyleVarFloat(ImGuiStyleVar idx,float val); +CIMGUI_API void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val); +CIMGUI_API void igPopStyleVar(int count); +CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx); +CIMGUI_API ImFont* igGetFont(); +CIMGUI_API float igGetFontSize(); +CIMGUI_API ImVec2 igGetFontTexUvWhitePixel(); +CIMGUI_API ImU32 igGetColorU32Col(ImGuiCol idx,float alpha_mul); +CIMGUI_API ImU32 igGetColorU32Vec4(const ImVec4 col); +CIMGUI_API ImU32 igGetColorU32U32(ImU32 col); +CIMGUI_API void igPushItemWidth(float item_width); +CIMGUI_API void igPopItemWidth(); +CIMGUI_API float igCalcItemWidth(); +CIMGUI_API void igPushTextWrapPos(float wrap_pos_x); +CIMGUI_API void igPopTextWrapPos(); +CIMGUI_API void igPushAllowKeyboardFocus(bool allow_keyboard_focus); +CIMGUI_API void igPopAllowKeyboardFocus(); +CIMGUI_API void igPushButtonRepeat(bool repeat); +CIMGUI_API void igPopButtonRepeat(); +CIMGUI_API void igSeparator(); +CIMGUI_API void igSameLine(float pos_x,float spacing_w); +CIMGUI_API void igNewLine(); +CIMGUI_API void igSpacing(); +CIMGUI_API void igDummy(const ImVec2 size); +CIMGUI_API void igIndent(float indent_w); +CIMGUI_API void igUnindent(float indent_w); +CIMGUI_API void igBeginGroup(); +CIMGUI_API void igEndGroup(); +CIMGUI_API ImVec2 igGetCursorPos(); +CIMGUI_API float igGetCursorPosX(); +CIMGUI_API float igGetCursorPosY(); +CIMGUI_API void igSetCursorPos(const ImVec2 local_pos); +CIMGUI_API void igSetCursorPosX(float x); +CIMGUI_API void igSetCursorPosY(float y); +CIMGUI_API ImVec2 igGetCursorStartPos(); +CIMGUI_API ImVec2 igGetCursorScreenPos(); +CIMGUI_API void igSetCursorScreenPos(const ImVec2 screen_pos); +CIMGUI_API void igAlignTextToFramePadding(); +CIMGUI_API float igGetTextLineHeight(); +CIMGUI_API float igGetTextLineHeightWithSpacing(); +CIMGUI_API float igGetFrameHeight(); +CIMGUI_API float igGetFrameHeightWithSpacing(); +CIMGUI_API void igPushIDStr(const char* str_id); +CIMGUI_API void igPushIDRange(const char* str_id_begin,const char* str_id_end); +CIMGUI_API void igPushIDPtr(const void* ptr_id); +CIMGUI_API void igPushIDInt(int int_id); +CIMGUI_API void igPopID(); +CIMGUI_API ImGuiID igGetIDStr(const char* str_id); +CIMGUI_API ImGuiID igGetIDStrStr(const char* str_id_begin,const char* str_id_end); +CIMGUI_API ImGuiID igGetIDPtr(const void* ptr_id); +CIMGUI_API void igTextUnformatted(const char* text,const char* text_end); +CIMGUI_API void igText(const char* fmt,...); +CIMGUI_API void igTextV(const char* fmt,va_list args); +CIMGUI_API void igTextColored(const ImVec4 col,const char* fmt,...); +CIMGUI_API void igTextColoredV(const ImVec4 col,const char* fmt,va_list args); +CIMGUI_API void igTextDisabled(const char* fmt,...); +CIMGUI_API void igTextDisabledV(const char* fmt,va_list args); +CIMGUI_API void igTextWrapped(const char* fmt,...); +CIMGUI_API void igTextWrappedV(const char* fmt,va_list args); +CIMGUI_API void igLabelText(const char* label,const char* fmt,...); +CIMGUI_API void igLabelTextV(const char* label,const char* fmt,va_list args); +CIMGUI_API void igBulletText(const char* fmt,...); +CIMGUI_API void igBulletTextV(const char* fmt,va_list args); +CIMGUI_API bool igButton(const char* label,const ImVec2 size); +CIMGUI_API bool igSmallButton(const char* label); +CIMGUI_API bool igArrowButton(const char* str_id,ImGuiDir dir); +CIMGUI_API bool igInvisibleButton(const char* str_id,const ImVec2 size); +CIMGUI_API void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col); +CIMGUI_API bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col); +CIMGUI_API bool igCheckbox(const char* label,bool* v); +CIMGUI_API bool igCheckboxFlags(const char* label,unsigned int* flags,unsigned int flags_value); +CIMGUI_API bool igRadioButtonBool(const char* label,bool active); +CIMGUI_API bool igRadioButtonIntPtr(const char* label,int* v,int v_button); +CIMGUI_API void igPlotLinesFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +CIMGUI_API void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +CIMGUI_API void igPlotHistogramFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +CIMGUI_API void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +CIMGUI_API void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay); +CIMGUI_API void igBullet(); +CIMGUI_API bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags); +CIMGUI_API void igEndCombo(); +CIMGUI_API bool igComboStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items); +CIMGUI_API bool igComboStr(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items); +CIMGUI_API bool igComboFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items); +CIMGUI_API bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* display_format,float power); +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* display_format,const char* display_format_max,float power); +CIMGUI_API bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* display_format); +CIMGUI_API bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* display_format); +CIMGUI_API bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* display_format); +CIMGUI_API bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* display_format); +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* display_format,const char* display_format_max); +CIMGUI_API bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiTextEditCallback callback,void* user_data); +CIMGUI_API bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiTextEditCallback callback,void* user_data); +CIMGUI_API bool igInputFloat(const char* label,float* v,float step,float step_fast,int decimal_precision,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputFloat2(const char* label,float v[2],int decimal_precision,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputFloat3(const char* label,float v[3],int decimal_precision,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputFloat4(const char* label,float v[4],int decimal_precision,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* display_format,ImGuiInputTextFlags extra_flags); +CIMGUI_API bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max); +CIMGUI_API bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* display_format); +CIMGUI_API bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* display_format); +CIMGUI_API bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* display_format); +CIMGUI_API bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* display_format); +CIMGUI_API bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* display_format,float power); +CIMGUI_API bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* display_format); +CIMGUI_API bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags); +CIMGUI_API bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags); +CIMGUI_API bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags); +CIMGUI_API bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col); +CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size); +CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags); +CIMGUI_API bool igTreeNodeStr(const char* label); +CIMGUI_API bool igTreeNodeStrStr(const char* str_id,const char* fmt,...); +CIMGUI_API bool igTreeNodePtr(const void* ptr_id,const char* fmt,...); +CIMGUI_API bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args); +CIMGUI_API bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args); +CIMGUI_API bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags); +CIMGUI_API bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +CIMGUI_API bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +CIMGUI_API bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +CIMGUI_API bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +CIMGUI_API void igTreePushStr(const char* str_id); +CIMGUI_API void igTreePushPtr(const void* ptr_id); +CIMGUI_API void igTreePop(); +CIMGUI_API void igTreeAdvanceToLabelPos(); +CIMGUI_API float igGetTreeNodeToLabelSpacing(); +CIMGUI_API void igSetNextTreeNodeOpen(bool is_open,ImGuiCond cond); +CIMGUI_API bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags); +CIMGUI_API bool igCollapsingHeaderBoolPtr(const char* label,bool* p_open,ImGuiTreeNodeFlags flags); +CIMGUI_API bool igSelectableBool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size); +CIMGUI_API bool igSelectableBoolPtr(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size); +CIMGUI_API bool igListBoxStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items); +CIMGUI_API bool igListBoxFnPtr(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items); +CIMGUI_API bool igListBoxHeaderVec2(const char* label,const ImVec2 size); +CIMGUI_API bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items); +CIMGUI_API void igListBoxFooter(); +CIMGUI_API void igValueBool(const char* prefix,bool b); +CIMGUI_API void igValueInt(const char* prefix,int v); +CIMGUI_API void igValueUint(const char* prefix,unsigned int v); +CIMGUI_API void igValueFloat(const char* prefix,float v,const char* float_format); +CIMGUI_API void igSetTooltip(const char* fmt,...); +CIMGUI_API void igSetTooltipV(const char* fmt,va_list args); +CIMGUI_API void igBeginTooltip(); +CIMGUI_API void igEndTooltip(); +CIMGUI_API bool igBeginMainMenuBar(); +CIMGUI_API void igEndMainMenuBar(); +CIMGUI_API bool igBeginMenuBar(); +CIMGUI_API void igEndMenuBar(); +CIMGUI_API bool igBeginMenu(const char* label,bool enabled); +CIMGUI_API void igEndMenu(); +CIMGUI_API bool igMenuItemBool(const char* label,const char* shortcut,bool selected,bool enabled); +CIMGUI_API bool igMenuItemBoolPtr(const char* label,const char* shortcut,bool* p_selected,bool enabled); +CIMGUI_API void igOpenPopup(const char* str_id); +CIMGUI_API bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags); +CIMGUI_API bool igBeginPopupContextItem(const char* str_id,int mouse_button); +CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,int mouse_button,bool also_over_items); +CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,int mouse_button); +CIMGUI_API bool igBeginPopupModal(const char* name,bool* p_open,ImGuiWindowFlags flags); +CIMGUI_API void igEndPopup(); +CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,int mouse_button); +CIMGUI_API bool igIsPopupOpen(const char* str_id); +CIMGUI_API void igCloseCurrentPopup(); +CIMGUI_API void igColumns(int count,const char* id,bool border); +CIMGUI_API void igNextColumn(); +CIMGUI_API int igGetColumnIndex(); +CIMGUI_API float igGetColumnWidth(int column_index); +CIMGUI_API void igSetColumnWidth(int column_index,float width); +CIMGUI_API float igGetColumnOffset(int column_index); +CIMGUI_API void igSetColumnOffset(int column_index,float offset_x); +CIMGUI_API int igGetColumnsCount(); +CIMGUI_API void igLogToTTY(int max_depth); +CIMGUI_API void igLogToFile(int max_depth,const char* filename); +CIMGUI_API void igLogToClipboard(int max_depth); +CIMGUI_API void igLogFinish(); +CIMGUI_API void igLogButtons(); +CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags); +CIMGUI_API bool igSetDragDropPayload(const char* type,const void* data,size_t size,ImGuiCond cond); +CIMGUI_API void igEndDragDropSource(); +CIMGUI_API bool igBeginDragDropTarget(); +CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags); +CIMGUI_API void igEndDragDropTarget(); +CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect); +CIMGUI_API void igPopClipRect(); +CIMGUI_API void igSetItemDefaultFocus(); +CIMGUI_API void igSetKeyboardFocusHere(int offset); +CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags); +CIMGUI_API bool igIsItemActive(); +CIMGUI_API bool igIsItemFocused(); +CIMGUI_API bool igIsItemClicked(int mouse_button); +CIMGUI_API bool igIsItemVisible(); +CIMGUI_API bool igIsAnyItemHovered(); +CIMGUI_API bool igIsAnyItemActive(); +CIMGUI_API bool igIsAnyItemFocused(); +CIMGUI_API ImVec2 igGetItemRectMin(); +CIMGUI_API ImVec2 igGetItemRectMax(); +CIMGUI_API ImVec2 igGetItemRectSize(); +CIMGUI_API void igSetItemAllowOverlap(); +CIMGUI_API bool igIsRectVisible(const ImVec2 size); +CIMGUI_API bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max); +CIMGUI_API float igGetTime(); +CIMGUI_API int igGetFrameCount(); +CIMGUI_API ImDrawList* igGetOverlayDrawList(); +CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData(); +CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx); +CIMGUI_API void igSetStateStorage(ImGuiStorage* storage); +CIMGUI_API ImGuiStorage* igGetStateStorage(); +CIMGUI_API ImVec2 igCalcTextSize(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width); +CIMGUI_API void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end); +CIMGUI_API bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags); +CIMGUI_API void igEndChildFrame(); +CIMGUI_API ImVec4 igColorConvertU32ToFloat4(ImU32 in); +CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in); +CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float out_h,float out_s,float out_v); +CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float out_r,float out_g,float out_b); +CIMGUI_API int igGetKeyIndex(ImGuiKey imgui_key); +CIMGUI_API bool igIsKeyDown(int user_key_index); +CIMGUI_API bool igIsKeyPressed(int user_key_index,bool repeat); +CIMGUI_API bool igIsKeyReleased(int user_key_index); +CIMGUI_API int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate); +CIMGUI_API bool igIsMouseDown(int button); +CIMGUI_API bool igIsAnyMouseDown(); +CIMGUI_API bool igIsMouseClicked(int button,bool repeat); +CIMGUI_API bool igIsMouseDoubleClicked(int button); +CIMGUI_API bool igIsMouseReleased(int button); +CIMGUI_API bool igIsMouseDragging(int button,float lock_threshold); +CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip); +CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos); +CIMGUI_API ImVec2 igGetMousePos(); +CIMGUI_API ImVec2 igGetMousePosOnOpeningCurrentPopup(); +CIMGUI_API ImVec2 igGetMouseDragDelta(int button,float lock_threshold); +CIMGUI_API void igResetMouseDragDelta(int button); +CIMGUI_API ImGuiMouseCursor igGetMouseCursor(); +CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor type); +CIMGUI_API void igCaptureKeyboardFromApp(bool capture); +CIMGUI_API void igCaptureMouseFromApp(bool capture); +CIMGUI_API const char* igGetClipboardText(); +CIMGUI_API void igSetClipboardText(const char* text); +CIMGUI_API void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data); +CIMGUI_API void* igMemAlloc(size_t size); +CIMGUI_API void igMemFree(void* ptr); +CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor); +CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self,ImWchar c); +CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* utf8_chars); +CIMGUI_API inline void ImGuiIO_ClearInputCharacters(ImGuiIO* self); +CIMGUI_API const char* TextRange_begin(TextRange* self); +CIMGUI_API const char* TextRange_end(TextRange* self); +CIMGUI_API bool TextRange_empty(TextRange* self); +CIMGUI_API char TextRange_front(TextRange* self); +CIMGUI_API bool TextRange_is_blank(TextRange* self,char c); +CIMGUI_API void TextRange_trim_blanks(TextRange* self); +CIMGUI_API void TextRange_split(TextRange* self,char separator,ImVector_TextRange out); +CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width); +CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end); +CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self); +CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self); +CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self); +CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self); +CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self); +CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self); +CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self); +CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self); +CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity); +CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self); +CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args); +CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self); +CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val); +CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val); +CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key,bool default_val); +CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key,bool val); +CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val); +CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val); +CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key); +CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val); +CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val); +CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key,bool default_val); +CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val); +CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val); +CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val); +CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self); +CIMGUI_API void ImGuiTextEditCallbackData_DeleteChars(ImGuiTextEditCallbackData* self,int pos,int bytes_count); +CIMGUI_API void ImGuiTextEditCallbackData_InsertChars(ImGuiTextEditCallbackData* self,int pos,const char* text,const char* text_end); +CIMGUI_API bool ImGuiTextEditCallbackData_HasSelection(ImGuiTextEditCallbackData* self); +CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self); +CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type); +CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self); +CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self); +CIMGUI_API inline void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a); +CIMGUI_API ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a); +CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self); +CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height); +CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self); +CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect); +CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self); +CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self); +CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id); +CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self); +CIMGUI_API inline ImVec2 ImDrawList_GetClipRectMin(ImDrawList* self); +CIMGUI_API inline ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self); +CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness); +CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness); +CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags); +CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left); +CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness); +CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col); +CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness); +CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col); +CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness); +CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments); +CIMGUI_API void ImDrawList_AddTextVec2(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end); +CIMGUI_API void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect); +CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col); +CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,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); +CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners); +CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness); +CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col); +CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments); +CIMGUI_API inline void ImDrawList_PathClear(ImDrawList* self); +CIMGUI_API inline void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos); +CIMGUI_API inline void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos); +CIMGUI_API inline void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col); +CIMGUI_API inline void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,bool closed,float thickness); +CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments); +CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12); +CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments); +CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags); +CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self,int channels_count); +CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self); +CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int channel_index); +CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data); +CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self); +CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self); +CIMGUI_API void ImDrawList_Clear(ImDrawList* self); +CIMGUI_API void ImDrawList_ClearFreeMemory(ImDrawList* self); +CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count); +CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col); +CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 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); +CIMGUI_API inline void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +CIMGUI_API inline void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx); +CIMGUI_API inline void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +CIMGUI_API void ImDrawList_UpdateClipRect(ImDrawList* self); +CIMGUI_API void ImDrawList_UpdateTextureID(ImDrawList* self); +CIMGUI_API void ImDrawData_Clear(ImDrawData* self); +CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self); +CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 sc); +CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg); +CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg); +CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self); +CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self); +CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self); +CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self); +CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self); +CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* 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); +CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChinese(ImFontAtlas* self); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self); +CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self); +CIMGUI_API bool GlyphRangesBuilder_GetBit(GlyphRangesBuilder* self,int n); +CIMGUI_API void GlyphRangesBuilder_SetBit(GlyphRangesBuilder* self,int n); +CIMGUI_API void GlyphRangesBuilder_AddChar(GlyphRangesBuilder* self,ImWchar c); +CIMGUI_API void GlyphRangesBuilder_AddText(GlyphRangesBuilder* self,const char* text,const char* text_end); +CIMGUI_API void GlyphRangesBuilder_AddRanges(GlyphRangesBuilder* self,const ImWchar* ranges); +CIMGUI_API void GlyphRangesBuilder_BuildRanges(GlyphRangesBuilder* self,ImVector_ImWchar* out_ranges); +CIMGUI_API bool CustomRect_IsPacked(CustomRect* self); +CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height); +CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset); +CIMGUI_API const CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index); +CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* 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]); +CIMGUI_API void ImFont_ClearOutputData(ImFont* self); +CIMGUI_API void ImFont_BuildLookupTable(ImFont* self); +CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c); +CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c); +CIMGUI_API void ImFont_SetFallbackChar(ImFont* self,ImWchar c); +CIMGUI_API float ImFont_GetCharAdvance(ImFont* self,ImWchar c); +CIMGUI_API bool ImFont_IsLoaded(ImFont* self); +CIMGUI_API const char* ImFont_GetDebugName(ImFont* self); +CIMGUI_API ImVec2 ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width); +CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,unsigned short c); +CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip); +CIMGUI_API void ImFont_GrowIndex(ImFont* self,int new_size); +CIMGUI_API void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x); +CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst); diff --git a/cimgui/generator/auto_funcs.txt b/cimgui/generator/auto_funcs.txt new file mode 100644 index 0000000..b92571c --- /dev/null +++ b/cimgui/generator/auto_funcs.txt @@ -0,0 +1,745 @@ +bb: void(*SetClipboardTextFn)(void* user_data,const char* text); +b2: nil ImGuiIO void (*SetClipboardTextFn) +bb: void(*ImeSetInputScreenPosFn)(int x,int y); +b2: nil ImGuiIO void (*ImeSetInputScreenPosFn) +overloading +igCombo 3 +1 (const char*,int*,const char* const[],int,int) bool igComboStr_arr const char* const[] +2 (const char*,int*,const char*,int) bool igComboStr const char* +3 (const char*,int*,bool(*)(void*,int,const char**),void*,int,int) bool igComboFnPtr bool(*)(void*,int,const char**) +ImVec4_ImVec4 2 +1 () nil ImVec4_ImVec4 +2 (float,float,float,float) nil ImVec4_ImVec4Float float +igValue 4 +1 (const char*,bool) void igValueBool bool +2 (const char*,int) void igValueInt int +3 (const char*,unsigned int) void igValueUint unsigned int +4 (const char*,float,const char*) void igValueFloat float +igPushStyleVar 2 +1 (ImGuiStyleVar,float) void igPushStyleVarFloat float +2 (ImGuiStyleVar,const ImVec2) void igPushStyleVarVec2 const ImVec2 +igIsRectVisible 2 +1 (const ImVec2) bool igIsRectVisible +2 (const ImVec2,const ImVec2) bool igIsRectVisibleVec2 const ImVec2 +igRadioButton 2 +1 (const char*,bool) bool igRadioButtonBool bool +2 (const char*,int*,int) bool igRadioButtonIntPtr int* +TextRange_TextRange 2 +1 () nil TextRange_TextRange +2 (const char*,const char*) nil TextRange_TextRangeStr const char* +igSetWindowCollapsed 2 +1 (bool,ImGuiCond) void igSetWindowCollapsedBool bool +2 (const char*,bool,ImGuiCond) void igSetWindowCollapsedStr const char* +igPlotLines 2 +1 (const char*,const float*,int,int,const char*,float,float,ImVec2,int) void igPlotLinesFloatPtr const float* +2 (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2) void igPlotLinesFnPtr float(*)(void*,int) +ImVec2_ImVec2 2 +1 () nil ImVec2_ImVec2 +2 (float,float) nil ImVec2_ImVec2Float float +igPlotHistogram 2 +1 (const char*,const float*,int,int,const char*,float,float,ImVec2,int) void igPlotHistogramFloatPtr const float* +2 (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2) void igPlotHistogramFnPtr float(*)(void*,int) +igTreeNodeExV 2 +1 (const char*,ImGuiTreeNodeFlags,const char*,va_list) bool igTreeNodeExVStr const char* +2 (const void*,ImGuiTreeNodeFlags,const char*,va_list) bool igTreeNodeExVPtr const void* +igSetWindowSize 2 +1 (const ImVec2,ImGuiCond) void igSetWindowSizeVec2 const ImVec2 +2 (const char*,const ImVec2,ImGuiCond) void igSetWindowSizeStr const char* +igGetID 3 +1 (const char*) ImGuiID igGetIDStr const char* +2 (const char*,const char*) ImGuiID igGetIDStrStr const char*const char* +3 (const void*) ImGuiID igGetIDPtr const void* +igPushStyleColor 2 +1 (ImGuiCol,ImU32) void igPushStyleColorU32 ImU32 +2 (ImGuiCol,const ImVec4) void igPushStyleColorVec4 const ImVec4 +igBeginChild 2 +1 (const char*,const ImVec2,bool,ImGuiWindowFlags) bool igBeginChildStr const char* +2 (ImGuiID,const ImVec2,bool,ImGuiWindowFlags) bool igBeginChildID ImGuiID +igSelectable 2 +1 (const char*,bool,ImGuiSelectableFlags,const ImVec2) bool igSelectableBool bool +2 (const char*,bool*,ImGuiSelectableFlags,const ImVec2) bool igSelectableBoolPtr bool* +igListBox 2 +1 (const char*,int*,const char* const[],int,int) bool igListBoxStr_arr const char* const[] +2 (const char*,int*,bool(*)(void*,int,const char**),void*,int,int) bool igListBoxFnPtr bool(*)(void*,int,const char**) +ImDrawList_AddText 2 +1 (const ImVec2,ImU32,const char*,const char*) void ImDrawList_AddTextVec2 const ImVec2 +2 (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*) void ImDrawList_AddTextFontPtr const ImFont* +igPushID 4 +1 (const char*) void igPushIDStr const char* +2 (const char*,const char*) void igPushIDRange const char*const char* +3 (const void*) void igPushIDPtr const void* +4 (int) void igPushIDInt int +igGetColorU32 3 +1 (ImGuiCol,float) ImU32 igGetColorU32Col ImGuiCol +2 (const ImVec4) ImU32 igGetColorU32Vec4 const ImVec4 +3 (ImU32) ImU32 igGetColorU32U32 ImU32 +Pair_Pair 3 +1 (ImGuiID,int) nil Pair_PairInt int +2 (ImGuiID,float) nil Pair_PairFloat float +3 (ImGuiID,void*) nil Pair_PairPtr void* +igSetWindowFocus 2 +1 () void igSetWindowFocus +2 (const char*) void igSetWindowFocusStr const char* +igMenuItem 2 +1 (const char*,const char*,bool,bool) bool igMenuItemBool bool +2 (const char*,const char*,bool*,bool) bool igMenuItemBoolPtr bool* +ImColor_ImColor 5 +1 () nil ImColor_ImColor +2 (int,int,int,int) nil ImColor_ImColorInt int +3 (ImU32) nil ImColor_ImColorU32 ImU32 +4 (float,float,float,float) nil ImColor_ImColorFloat float +5 (const ImVec4) nil ImColor_ImColorVec4 const ImVec4 +igCollapsingHeader 2 +1 (const char*,ImGuiTreeNodeFlags) bool igCollapsingHeader ImGuiTreeNodeFlags +2 (const char*,bool*,ImGuiTreeNodeFlags) bool igCollapsingHeaderBoolPtr bool* +igSetWindowPos 2 +1 (const ImVec2,ImGuiCond) void igSetWindowPosVec2 const ImVec2 +2 (const char*,const ImVec2,ImGuiCond) void igSetWindowPosStr const char* +igTreeNodeEx 3 +1 (const char*,ImGuiTreeNodeFlags) bool igTreeNodeExStr const char* +2 (const char*,ImGuiTreeNodeFlags,const char*,...) bool igTreeNodeExStrStr const char*const char* +3 (const void*,ImGuiTreeNodeFlags,const char*,...) bool igTreeNodeExPtr const void* +igTreePush 2 +1 (const char*) void igTreePushStr const char* +2 (const void*) void igTreePushPtr const void* +igListBoxHeader 2 +1 (const char*,const ImVec2) bool igListBoxHeaderVec2 const ImVec2 +2 (const char*,int,int) bool igListBoxHeaderInt int +igTreeNode 3 +1 (const char*) bool igTreeNodeStr const char* +2 (const char*,const char*,...) bool igTreeNodeStrStr const char*const char* +3 (const void*,const char*,...) bool igTreeNodePtr const void* +igTreeNodeV 2 +1 (const char*,const char*,va_list) bool igTreeNodeVStr const char* +2 (const void*,const char*,va_list) bool igTreeNodeVPtr const void* +77 overloaded +//------------------------------------------------------------------------------------- +float Float +const ImFontConfig* FontConfigPtr +... ... +ImGuiTreeNodeFlags TreeNodeFlags +ImGuiFocusedFlags FocusedFlags +ImGuiHoveredFlags HoveredFlags +const ImVec2* Vec2Ptr +const ImVec2 Vec2 +ImVec2* Vec2Ptr +unsigned char** uStrPtr +const ImWchar* WStr +const ImVec4 Vec4 +double* doublePtr +const int Int +ImGuiColorEditFlags ColorEditFlags +int[2] arr2 +ImGuiDir Dir +ImVector_ImWchar* Vector_WStr +const void* Ptr +const CustomRect* CustomRectPtr +double double +ImGuiCol Col +float* FloatPtr +const char* const[] Str_arr +ImGuiInputTextFlags InputTextFlags +ImFont* FontPtr +ImGuiWindowFlags WindowFlags +ImGuiComboFlags ComboFlags +ImWchar Wchar +ImGuiTextEditCallback TextEditCallback +char* Str +int[4] arr4 +va_list va_list +float(*)(void*,int) FnPtr +char char +const char* Str +const char** StrPtr +ImDrawIdx DrawIdx +int[3] arr3 +void(*)(void*,void*) FnPtr +void*(*)(size_t,void*) FnPtr +ImGuiStyle* StylePtr +ImFontAtlas* FontAtlasPtr +ImGuiMouseCursor MouseCursor +void* Ptr +bool Bool +float[3] arr3 +unsigned int* UintPtr +const ImDrawListSharedData* DrawListSharedDataPtr +ImDrawCallback DrawCallback +const ImVec4* Vec4Ptr +unsigned int Uint +const ImFont* FontPtr +bool(*)(void*,int,const char**) FnPtr +ImVec2[2] arr2 +ImVec2 Vec2 +ImGuiSelectableFlags SelectableFlags +ImDrawList* DrawListPtr +unsigned short ushort +ImGuiCond Cond +ImU32 U32 +ImGuiStyleVar StyleVar +ImGuiStorage* StoragePtr +float[2] arr2 +ImGuiContext* ContextPtr +float[4] arr4 +ImTextureID TextureID +int* IntPtr +const float* FloatPtr +size_t size_t +ImGuiSizeCallback SizeCallback +bool* BoolPtr +int Int +ImGuiKey Key +ImGuiID ID +ImGuiDragDropFlags DragDropFlags +ImVector_TextRange Vector_TextRange +//------------------------------------------------------------------------------------- +ImVec2_ImVec2 ImVec2 () () () () nil +ImVec2_ImVec2 ImVec2 (float,float) (float _x,float _y) (float _x,float _y) (_x,_y) nil +ImVec4_ImVec4 ImVec4 () () () () nil +ImVec4_ImVec4 ImVec4 (float,float,float,float) (float _x,float _y,float _z,float _w) (float _x,float _y,float _z,float _w) (_x,_y,_z,_w) nil +igCreateContext CreateContext (ImFontAtlas*) (ImFontAtlas* shared_font_atlas=((void *)0)) (ImFontAtlas* shared_font_atlas) (shared_font_atlas) ImGuiContext* +igDestroyContext DestroyContext (ImGuiContext*) (ImGuiContext* ctx=((void *)0)) (ImGuiContext* ctx) (ctx) void +igGetCurrentContext GetCurrentContext () () () () ImGuiContext* +igSetCurrentContext SetCurrentContext (ImGuiContext*) (ImGuiContext* ctx) (ImGuiContext* ctx) (ctx) void +igGetIO GetIO () () () () ImGuiIO& +igGetStyle GetStyle () () () () ImGuiStyle& +igNewFrame NewFrame () () () () void +igRender Render () () () () void +igGetDrawData GetDrawData () () () () ImDrawData* +igEndFrame EndFrame () () () () void +igShowDemoWindow ShowDemoWindow (bool*) (bool* p_open=((void *)0)) (bool* p_open) (p_open) void +igShowMetricsWindow ShowMetricsWindow (bool*) (bool* p_open=((void *)0)) (bool* p_open) (p_open) void +igShowStyleEditor ShowStyleEditor (ImGuiStyle*) (ImGuiStyle* ref=((void *)0)) (ImGuiStyle* ref) (ref) void +igShowStyleSelector ShowStyleSelector (const char*) (const char* label) (const char* label) (label) bool +igShowFontSelector ShowFontSelector (const char*) (const char* label) (const char* label) (label) void +igShowUserGuide ShowUserGuide () () () () void +igGetVersion GetVersion () () () () const char* +igStyleColorsDark StyleColorsDark (ImGuiStyle*) (ImGuiStyle* dst=((void *)0)) (ImGuiStyle* dst) (dst) void +igStyleColorsClassic StyleColorsClassic (ImGuiStyle*) (ImGuiStyle* dst=((void *)0)) (ImGuiStyle* dst) (dst) void +igStyleColorsLight StyleColorsLight (ImGuiStyle*) (ImGuiStyle* dst=((void *)0)) (ImGuiStyle* dst) (dst) void +igBegin Begin (const char*,bool*,ImGuiWindowFlags) (const char* name,bool* p_open=((void *)0),ImGuiWindowFlags flags=0) (const char* name,bool* p_open,ImGuiWindowFlags flags) (name,p_open,flags) bool +igEnd End () () () () void +igBeginChild BeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags) (const char* str_id,const ImVec2& size=ImVec2(0,0),bool border=false,ImGuiWindowFlags flags=0) (const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags) (str_id,size,border,flags) bool +igBeginChild BeginChild (ImGuiID,const ImVec2,bool,ImGuiWindowFlags) (ImGuiID id,const ImVec2& size=ImVec2(0,0),bool border=false,ImGuiWindowFlags flags=0) (ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags) (id,size,border,flags) bool +igEndChild EndChild () () () () void +igIsWindowAppearing IsWindowAppearing () () () () bool +igIsWindowCollapsed IsWindowCollapsed () () () () bool +igIsWindowFocused IsWindowFocused (ImGuiFocusedFlags) (ImGuiFocusedFlags flags=0) (ImGuiFocusedFlags flags) (flags) bool +igIsWindowHovered IsWindowHovered (ImGuiHoveredFlags) (ImGuiHoveredFlags flags=0) (ImGuiHoveredFlags flags) (flags) bool +igGetWindowDrawList GetWindowDrawList () () () () ImDrawList* +igGetWindowPos GetWindowPos () () () () ImVec2 +igGetWindowSize GetWindowSize () () () () ImVec2 +igGetWindowWidth GetWindowWidth () () () () float +igGetWindowHeight GetWindowHeight () () () () float +igGetContentRegionMax GetContentRegionMax () () () () ImVec2 +igGetContentRegionAvail GetContentRegionAvail () () () () ImVec2 +igGetContentRegionAvailWidth GetContentRegionAvailWidth () () () () float +igGetWindowContentRegionMin GetWindowContentRegionMin () () () () ImVec2 +igGetWindowContentRegionMax GetWindowContentRegionMax () () () () ImVec2 +igGetWindowContentRegionWidth GetWindowContentRegionWidth () () () () float +igSetNextWindowPos SetNextWindowPos (const ImVec2,ImGuiCond,const ImVec2) (const ImVec2& pos,ImGuiCond cond=0,const ImVec2& pivot=ImVec2(0,0)) (const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot) (pos,cond,pivot) void +igSetNextWindowSize SetNextWindowSize (const ImVec2,ImGuiCond) (const ImVec2& size,ImGuiCond cond=0) (const ImVec2 size,ImGuiCond cond) (size,cond) void +igSetNextWindowSizeConstraints SetNextWindowSizeConstraints (const ImVec2,const ImVec2,ImGuiSizeCallback,void*) (const ImVec2& size_min,const ImVec2& size_max,ImGuiSizeCallback custom_callback=((void *)0),void* custom_callback_data=((void *)0)) (const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data) (size_min,size_max,custom_callback,custom_callback_data) void +igSetNextWindowContentSize SetNextWindowContentSize (const ImVec2) (const ImVec2& size) (const ImVec2 size) (size) void +igSetNextWindowCollapsed SetNextWindowCollapsed (bool,ImGuiCond) (bool collapsed,ImGuiCond cond=0) (bool collapsed,ImGuiCond cond) (collapsed,cond) void +igSetNextWindowFocus SetNextWindowFocus () () () () void +igSetNextWindowBgAlpha SetNextWindowBgAlpha (float) (float alpha) (float alpha) (alpha) void +igSetWindowPos SetWindowPos (const ImVec2,ImGuiCond) (const ImVec2& pos,ImGuiCond cond=0) (const ImVec2 pos,ImGuiCond cond) (pos,cond) void +igSetWindowSize SetWindowSize (const ImVec2,ImGuiCond) (const ImVec2& size,ImGuiCond cond=0) (const ImVec2 size,ImGuiCond cond) (size,cond) void +igSetWindowCollapsed SetWindowCollapsed (bool,ImGuiCond) (bool collapsed,ImGuiCond cond=0) (bool collapsed,ImGuiCond cond) (collapsed,cond) void +igSetWindowFocus SetWindowFocus () () () () void +igSetWindowFontScale SetWindowFontScale (float) (float scale) (float scale) (scale) void +igSetWindowPos SetWindowPos (const char*,const ImVec2,ImGuiCond) (const char* name,const ImVec2& pos,ImGuiCond cond=0) (const char* name,const ImVec2 pos,ImGuiCond cond) (name,pos,cond) void +igSetWindowSize SetWindowSize (const char*,const ImVec2,ImGuiCond) (const char* name,const ImVec2& size,ImGuiCond cond=0) (const char* name,const ImVec2 size,ImGuiCond cond) (name,size,cond) void +igSetWindowCollapsed SetWindowCollapsed (const char*,bool,ImGuiCond) (const char* name,bool collapsed,ImGuiCond cond=0) (const char* name,bool collapsed,ImGuiCond cond) (name,collapsed,cond) void +igSetWindowFocus SetWindowFocus (const char*) (const char* name) (const char* name) (name) void +igGetScrollX GetScrollX () () () () float +igGetScrollY GetScrollY () () () () float +igGetScrollMaxX GetScrollMaxX () () () () float +igGetScrollMaxY GetScrollMaxY () () () () float +igSetScrollX SetScrollX (float) (float scroll_x) (float scroll_x) (scroll_x) void +igSetScrollY SetScrollY (float) (float scroll_y) (float scroll_y) (scroll_y) void +igSetScrollHere SetScrollHere (float) (float center_y_ratio=0.5f) (float center_y_ratio) (center_y_ratio) void +igSetScrollFromPosY SetScrollFromPosY (float,float) (float pos_y,float center_y_ratio=0.5f) (float pos_y,float center_y_ratio) (pos_y,center_y_ratio) void +igPushFont PushFont (ImFont*) (ImFont* font) (ImFont* font) (font) void +igPopFont PopFont () () () () void +igPushStyleColor PushStyleColor (ImGuiCol,ImU32) (ImGuiCol idx,ImU32 col) (ImGuiCol idx,ImU32 col) (idx,col) void +igPushStyleColor PushStyleColor (ImGuiCol,const ImVec4) (ImGuiCol idx,const ImVec4& col) (ImGuiCol idx,const ImVec4 col) (idx,col) void +igPopStyleColor PopStyleColor (int) (int count=1) (int count) (count) void +igPushStyleVar PushStyleVar (ImGuiStyleVar,float) (ImGuiStyleVar idx,float val) (ImGuiStyleVar idx,float val) (idx,val) void +igPushStyleVar PushStyleVar (ImGuiStyleVar,const ImVec2) (ImGuiStyleVar idx,const ImVec2& val) (ImGuiStyleVar idx,const ImVec2 val) (idx,val) void +igPopStyleVar PopStyleVar (int) (int count=1) (int count) (count) void +igGetStyleColorVec4 GetStyleColorVec4 (ImGuiCol) (ImGuiCol idx) (ImGuiCol idx) (idx) const ImVec4& +igGetFont GetFont () () () () ImFont* +igGetFontSize GetFontSize () () () () float +igGetFontTexUvWhitePixel GetFontTexUvWhitePixel () () () () ImVec2 +igGetColorU32 GetColorU32 (ImGuiCol,float) (ImGuiCol idx,float alpha_mul=1.0f) (ImGuiCol idx,float alpha_mul) (idx,alpha_mul) ImU32 +igGetColorU32 GetColorU32 (const ImVec4) (const ImVec4& col) (const ImVec4 col) (col) ImU32 +igGetColorU32 GetColorU32 (ImU32) (ImU32 col) (ImU32 col) (col) ImU32 +igPushItemWidth PushItemWidth (float) (float item_width) (float item_width) (item_width) void +igPopItemWidth PopItemWidth () () () () void +igCalcItemWidth CalcItemWidth () () () () float +igPushTextWrapPos PushTextWrapPos (float) (float wrap_pos_x=0.0f) (float wrap_pos_x) (wrap_pos_x) void +igPopTextWrapPos PopTextWrapPos () () () () void +igPushAllowKeyboardFocus PushAllowKeyboardFocus (bool) (bool allow_keyboard_focus) (bool allow_keyboard_focus) (allow_keyboard_focus) void +igPopAllowKeyboardFocus PopAllowKeyboardFocus () () () () void +igPushButtonRepeat PushButtonRepeat (bool) (bool repeat) (bool repeat) (repeat) void +igPopButtonRepeat PopButtonRepeat () () () () void +igSeparator Separator () () () () void +igSameLine SameLine (float,float) (float pos_x=0.0f,float spacing_w=-1.0f) (float pos_x,float spacing_w) (pos_x,spacing_w) void +igNewLine NewLine () () () () void +igSpacing Spacing () () () () void +igDummy Dummy (const ImVec2) (const ImVec2& size) (const ImVec2 size) (size) void +igIndent Indent (float) (float indent_w=0.0f) (float indent_w) (indent_w) void +igUnindent Unindent (float) (float indent_w=0.0f) (float indent_w) (indent_w) void +igBeginGroup BeginGroup () () () () void +igEndGroup EndGroup () () () () void +igGetCursorPos GetCursorPos () () () () ImVec2 +igGetCursorPosX GetCursorPosX () () () () float +igGetCursorPosY GetCursorPosY () () () () float +igSetCursorPos SetCursorPos (const ImVec2) (const ImVec2& local_pos) (const ImVec2 local_pos) (local_pos) void +igSetCursorPosX SetCursorPosX (float) (float x) (float x) (x) void +igSetCursorPosY SetCursorPosY (float) (float y) (float y) (y) void +igGetCursorStartPos GetCursorStartPos () () () () ImVec2 +igGetCursorScreenPos GetCursorScreenPos () () () () ImVec2 +igSetCursorScreenPos SetCursorScreenPos (const ImVec2) (const ImVec2& screen_pos) (const ImVec2 screen_pos) (screen_pos) void +igAlignTextToFramePadding AlignTextToFramePadding () () () () void +igGetTextLineHeight GetTextLineHeight () () () () float +igGetTextLineHeightWithSpacing GetTextLineHeightWithSpacing () () () () float +igGetFrameHeight GetFrameHeight () () () () float +igGetFrameHeightWithSpacing GetFrameHeightWithSpacing () () () () float +igPushID PushID (const char*) (const char* str_id) (const char* str_id) (str_id) void +igPushID PushID (const char*,const char*) (const char* str_id_begin,const char* str_id_end) (const char* str_id_begin,const char* str_id_end) (str_id_begin,str_id_end) void +igPushID PushID (const void*) (const void* ptr_id) (const void* ptr_id) (ptr_id) void +igPushID PushID (int) (int int_id) (int int_id) (int_id) void +igPopID PopID () () () () void +igGetID GetID (const char*) (const char* str_id) (const char* str_id) (str_id) ImGuiID +igGetID GetID (const char*,const char*) (const char* str_id_begin,const char* str_id_end) (const char* str_id_begin,const char* str_id_end) (str_id_begin,str_id_end) ImGuiID +igGetID GetID (const void*) (const void* ptr_id) (const void* ptr_id) (ptr_id) ImGuiID +igTextUnformatted TextUnformatted (const char*,const char*) (const char* text,const char* text_end=((void *)0)) (const char* text,const char* text_end) (text,text_end) void +igText Text (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igTextV TextV (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +igTextColored TextColored (const ImVec4,const char*,...) (const ImVec4& col,const char* fmt,...) (const ImVec4 col,const char* fmt,...) (col,fmt,...) void +igTextColoredV TextColoredV (const ImVec4,const char*,va_list) (const ImVec4& col,const char* fmt,va_list args) (const ImVec4 col,const char* fmt,va_list args) (col,fmt,args) void +igTextDisabled TextDisabled (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igTextDisabledV TextDisabledV (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +igTextWrapped TextWrapped (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igTextWrappedV TextWrappedV (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +igLabelText LabelText (const char*,const char*,...) (const char* label,const char* fmt,...) (const char* label,const char* fmt,...) (label,fmt,...) void +igLabelTextV LabelTextV (const char*,const char*,va_list) (const char* label,const char* fmt,va_list args) (const char* label,const char* fmt,va_list args) (label,fmt,args) void +igBulletText BulletText (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igBulletTextV BulletTextV (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +igButton Button (const char*,const ImVec2) (const char* label,const ImVec2& size=ImVec2(0,0)) (const char* label,const ImVec2 size) (label,size) bool +igSmallButton SmallButton (const char*) (const char* label) (const char* label) (label) bool +igArrowButton ArrowButton (const char*,ImGuiDir) (const char* str_id,ImGuiDir dir) (const char* str_id,ImGuiDir dir) (str_id,dir) bool +igInvisibleButton InvisibleButton (const char*,const ImVec2) (const char* str_id,const ImVec2& size) (const char* str_id,const ImVec2 size) (str_id,size) bool +igImage Image (ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec4,const ImVec4) (ImTextureID user_texture_id,const ImVec2& size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),const ImVec4& tint_col=ImVec4(1,1,1,1),const ImVec4& border_col=ImVec4(0,0,0,0)) (ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col) (user_texture_id,size,uv0,uv1,tint_col,border_col) void +igImageButton ImageButton (ImTextureID,const ImVec2,const ImVec2,const ImVec2,int,const ImVec4,const ImVec4) (ImTextureID user_texture_id,const ImVec2& size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),int frame_padding=-1,const ImVec4& bg_col=ImVec4(0,0,0,0),const ImVec4& tint_col=ImVec4(1,1,1,1)) (ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col) (user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col) bool +igCheckbox Checkbox (const char*,bool*) (const char* label,bool* v) (const char* label,bool* v) (label,v) bool +igCheckboxFlags CheckboxFlags (const char*,unsigned int*,unsigned int) (const char* label,unsigned int* flags,unsigned int flags_value) (const char* label,unsigned int* flags,unsigned int flags_value) (label,flags,flags_value) bool +igRadioButton RadioButton (const char*,bool) (const char* label,bool active) (const char* label,bool active) (label,active) bool +igRadioButton RadioButton (const char*,int*,int) (const char* label,int* v,int v_button) (const char* label,int* v,int v_button) (label,v,v_button) bool +igPlotLines PlotLines (const char*,const float*,int,int,const char*,float,float,ImVec2,int) (const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void *)0),float scale_min=3.40282346638528859812e+38F,float scale_max=3.40282346638528859812e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float)) (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) (label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) void +igPlotLines PlotLines (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2) (const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void *)0),float scale_min=3.40282346638528859812e+38F,float scale_max=3.40282346638528859812e+38F,ImVec2 graph_size=ImVec2(0,0)) (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) (label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) void +igPlotHistogram PlotHistogram (const char*,const float*,int,int,const char*,float,float,ImVec2,int) (const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void *)0),float scale_min=3.40282346638528859812e+38F,float scale_max=3.40282346638528859812e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float)) (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) (label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) void +igPlotHistogram PlotHistogram (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2) (const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void *)0),float scale_min=3.40282346638528859812e+38F,float scale_max=3.40282346638528859812e+38F,ImVec2 graph_size=ImVec2(0,0)) (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) (label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) void +igProgressBar ProgressBar (float,const ImVec2,const char*) (float fraction,const ImVec2& size_arg=ImVec2(-1,0),const char* overlay=((void *)0)) (float fraction,const ImVec2 size_arg,const char* overlay) (fraction,size_arg,overlay) void +igBullet Bullet () () () () void +igBeginCombo BeginCombo (const char*,const char*,ImGuiComboFlags) (const char* label,const char* preview_value,ImGuiComboFlags flags=0) (const char* label,const char* preview_value,ImGuiComboFlags flags) (label,preview_value,flags) bool +igEndCombo EndCombo () () () () void +igCombo Combo (const char*,int*,const char* const[],int,int) (const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items=-1) (const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items) (label,current_item,items,items_count,popup_max_height_in_items) bool +igCombo Combo (const char*,int*,const char*,int) (const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items=-1) (const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items) (label,current_item,items_separated_by_zeros,popup_max_height_in_items) bool +igCombo Combo (const char*,int*,bool(*)(void*,int,const char**),void*,int,int) (const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items=-1) (const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items) (label,current_item,items_getter,data,items_count,popup_max_height_in_items) bool +igDragFloat DragFloat (const char*,float*,float,float,float,const char*,float) (const char* label,float* v,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* display_format="%.3f",float power=1.0f) (const char* label,float* v,float v_speed,float v_min,float v_max,const char* display_format,float power) (label,v,v_speed,v_min,v_max,display_format,power) bool +igDragFloat2 DragFloat2 (const char*,float[2],float,float,float,const char*,float) (const char* label,float v[2],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[2],float v_speed,float v_min,float v_max,const char* display_format,float power) (label,v,v_speed,v_min,v_max,display_format,power) bool +igDragFloat3 DragFloat3 (const char*,float[3],float,float,float,const char*,float) (const char* label,float v[3],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[3],float v_speed,float v_min,float v_max,const char* display_format,float power) (label,v,v_speed,v_min,v_max,display_format,power) bool +igDragFloat4 DragFloat4 (const char*,float[4],float,float,float,const char*,float) (const char* label,float v[4],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[4],float v_speed,float v_min,float v_max,const char* display_format,float power) (label,v,v_speed,v_min,v_max,display_format,power) bool +igDragFloatRange2 DragFloatRange2 (const char*,float*,float*,float,float,float,const char*,const char*,float) (const char* label,float* v_current_min,float* v_current_max,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* display_format="%.3f",const char* display_format_max=((void *)0),float power=1.0f) (const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* display_format,const char* display_format_max,float power) (label,v_current_min,v_current_max,v_speed,v_min,v_max,display_format,display_format_max,power) bool +igDragInt DragInt (const char*,int*,float,int,int,const char*) (const char* label,int* v,float v_speed=1.0f,int v_min=0,int v_max=0,const char* display_format="%.0f") (const char* label,int* v,float v_speed,int v_min,int v_max,const char* display_format) (label,v,v_speed,v_min,v_max,display_format) bool +igDragInt2 DragInt2 (const char*,int[2],float,int,int,const char*) (const char* label,int v[2],float v_speed=1.0f,int v_min=0,int v_max=0,const char* display_format="%.0f") (const char* label,int v[2],float v_speed,int v_min,int v_max,const char* display_format) (label,v,v_speed,v_min,v_max,display_format) bool +igDragInt3 DragInt3 (const char*,int[3],float,int,int,const char*) (const char* label,int v[3],float v_speed=1.0f,int v_min=0,int v_max=0,const char* display_format="%.0f") (const char* label,int v[3],float v_speed,int v_min,int v_max,const char* display_format) (label,v,v_speed,v_min,v_max,display_format) bool +igDragInt4 DragInt4 (const char*,int[4],float,int,int,const char*) (const char* label,int v[4],float v_speed=1.0f,int v_min=0,int v_max=0,const char* display_format="%.0f") (const char* label,int v[4],float v_speed,int v_min,int v_max,const char* display_format) (label,v,v_speed,v_min,v_max,display_format) bool +igDragIntRange2 DragIntRange2 (const char*,int*,int*,float,int,int,const char*,const char*) (const char* label,int* v_current_min,int* v_current_max,float v_speed=1.0f,int v_min=0,int v_max=0,const char* display_format="%.0f",const char* display_format_max=((void *)0)) (const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* display_format,const char* display_format_max) (label,v_current_min,v_current_max,v_speed,v_min,v_max,display_format,display_format_max) bool +igInputText InputText (const char*,char*,size_t,ImGuiInputTextFlags,ImGuiTextEditCallback,void*) (const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags=0,ImGuiTextEditCallback callback=((void *)0),void* user_data=((void *)0)) (const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiTextEditCallback callback,void* user_data) (label,buf,buf_size,flags,callback,user_data) bool +igInputTextMultiline InputTextMultiline (const char*,char*,size_t,const ImVec2,ImGuiInputTextFlags,ImGuiTextEditCallback,void*) (const char* label,char* buf,size_t buf_size,const ImVec2& size=ImVec2(0,0),ImGuiInputTextFlags flags=0,ImGuiTextEditCallback callback=((void *)0),void* user_data=((void *)0)) (const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiTextEditCallback callback,void* user_data) (label,buf,buf_size,size,flags,callback,user_data) bool +igInputFloat InputFloat (const char*,float*,float,float,int,ImGuiInputTextFlags) (const char* label,float* v,float step=0.0f,float step_fast=0.0f,int decimal_precision=-1,ImGuiInputTextFlags extra_flags=0) (const char* label,float* v,float step,float step_fast,int decimal_precision,ImGuiInputTextFlags extra_flags) (label,v,step,step_fast,decimal_precision,extra_flags) bool +igInputFloat2 InputFloat2 (const char*,float[2],int,ImGuiInputTextFlags) (const char* label,float v[2],int decimal_precision=-1,ImGuiInputTextFlags extra_flags=0) (const char* label,float v[2],int decimal_precision,ImGuiInputTextFlags extra_flags) (label,v,decimal_precision,extra_flags) bool +igInputFloat3 InputFloat3 (const char*,float[3],int,ImGuiInputTextFlags) (const char* label,float v[3],int decimal_precision=-1,ImGuiInputTextFlags extra_flags=0) (const char* label,float v[3],int decimal_precision,ImGuiInputTextFlags extra_flags) (label,v,decimal_precision,extra_flags) bool +igInputFloat4 InputFloat4 (const char*,float[4],int,ImGuiInputTextFlags) (const char* label,float v[4],int decimal_precision=-1,ImGuiInputTextFlags extra_flags=0) (const char* label,float v[4],int decimal_precision,ImGuiInputTextFlags extra_flags) (label,v,decimal_precision,extra_flags) bool +igInputInt InputInt (const char*,int*,int,int,ImGuiInputTextFlags) (const char* label,int* v,int step=1,int step_fast=100,ImGuiInputTextFlags extra_flags=0) (const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags extra_flags) (label,v,step,step_fast,extra_flags) bool +igInputInt2 InputInt2 (const char*,int[2],ImGuiInputTextFlags) (const char* label,int v[2],ImGuiInputTextFlags extra_flags=0) (const char* label,int v[2],ImGuiInputTextFlags extra_flags) (label,v,extra_flags) bool +igInputInt3 InputInt3 (const char*,int[3],ImGuiInputTextFlags) (const char* label,int v[3],ImGuiInputTextFlags extra_flags=0) (const char* label,int v[3],ImGuiInputTextFlags extra_flags) (label,v,extra_flags) bool +igInputInt4 InputInt4 (const char*,int[4],ImGuiInputTextFlags) (const char* label,int v[4],ImGuiInputTextFlags extra_flags=0) (const char* label,int v[4],ImGuiInputTextFlags extra_flags) (label,v,extra_flags) bool +igInputDouble InputDouble (const char*,double*,double,double,const char*,ImGuiInputTextFlags) (const char* label,double* v,double step=0.0f,double step_fast=0.0f,const char* display_format="%.6f",ImGuiInputTextFlags extra_flags=0) (const char* label,double* v,double step,double step_fast,const char* display_format,ImGuiInputTextFlags extra_flags) (label,v,step,step_fast,display_format,extra_flags) bool +igSliderFloat SliderFloat (const char*,float*,float,float,const char*,float) (const char* label,float* v,float v_min,float v_max,const char* display_format="%.3f",float power=1.0f) (const char* label,float* v,float v_min,float v_max,const char* display_format,float power) (label,v,v_min,v_max,display_format,power) bool +igSliderFloat2 SliderFloat2 (const char*,float[2],float,float,const char*,float) (const char* label,float v[2],float v_min,float v_max,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[2],float v_min,float v_max,const char* display_format,float power) (label,v,v_min,v_max,display_format,power) bool +igSliderFloat3 SliderFloat3 (const char*,float[3],float,float,const char*,float) (const char* label,float v[3],float v_min,float v_max,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[3],float v_min,float v_max,const char* display_format,float power) (label,v,v_min,v_max,display_format,power) bool +igSliderFloat4 SliderFloat4 (const char*,float[4],float,float,const char*,float) (const char* label,float v[4],float v_min,float v_max,const char* display_format="%.3f",float power=1.0f) (const char* label,float v[4],float v_min,float v_max,const char* display_format,float power) (label,v,v_min,v_max,display_format,power) bool +igSliderAngle SliderAngle (const char*,float*,float,float) (const char* label,float* v_rad,float v_degrees_min=-360.0f,float v_degrees_max=+360.0f) (const char* label,float* v_rad,float v_degrees_min,float v_degrees_max) (label,v_rad,v_degrees_min,v_degrees_max) bool +igSliderInt SliderInt (const char*,int*,int,int,const char*) (const char* label,int* v,int v_min,int v_max,const char* display_format="%.0f") (const char* label,int* v,int v_min,int v_max,const char* display_format) (label,v,v_min,v_max,display_format) bool +igSliderInt2 SliderInt2 (const char*,int[2],int,int,const char*) (const char* label,int v[2],int v_min,int v_max,const char* display_format="%.0f") (const char* label,int v[2],int v_min,int v_max,const char* display_format) (label,v,v_min,v_max,display_format) bool +igSliderInt3 SliderInt3 (const char*,int[3],int,int,const char*) (const char* label,int v[3],int v_min,int v_max,const char* display_format="%.0f") (const char* label,int v[3],int v_min,int v_max,const char* display_format) (label,v,v_min,v_max,display_format) bool +igSliderInt4 SliderInt4 (const char*,int[4],int,int,const char*) (const char* label,int v[4],int v_min,int v_max,const char* display_format="%.0f") (const char* label,int v[4],int v_min,int v_max,const char* display_format) (label,v,v_min,v_max,display_format) bool +igVSliderFloat VSliderFloat (const char*,const ImVec2,float*,float,float,const char*,float) (const char* label,const ImVec2& size,float* v,float v_min,float v_max,const char* display_format="%.3f",float power=1.0f) (const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* display_format,float power) (label,size,v,v_min,v_max,display_format,power) bool +igVSliderInt VSliderInt (const char*,const ImVec2,int*,int,int,const char*) (const char* label,const ImVec2& size,int* v,int v_min,int v_max,const char* display_format="%.0f") (const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* display_format) (label,size,v,v_min,v_max,display_format) bool +igColorEdit3 ColorEdit3 (const char*,float[3],ImGuiColorEditFlags) (const char* label,float col[3],ImGuiColorEditFlags flags=0) (const char* label,float col[3],ImGuiColorEditFlags flags) (label,col,flags) bool +igColorEdit4 ColorEdit4 (const char*,float[4],ImGuiColorEditFlags) (const char* label,float col[4],ImGuiColorEditFlags flags=0) (const char* label,float col[4],ImGuiColorEditFlags flags) (label,col,flags) bool +igColorPicker3 ColorPicker3 (const char*,float[3],ImGuiColorEditFlags) (const char* label,float col[3],ImGuiColorEditFlags flags=0) (const char* label,float col[3],ImGuiColorEditFlags flags) (label,col,flags) bool +igColorPicker4 ColorPicker4 (const char*,float[4],ImGuiColorEditFlags,const float*) (const char* label,float col[4],ImGuiColorEditFlags flags=0,const float* ref_col=((void *)0)) (const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col) (label,col,flags,ref_col) bool +igColorButton ColorButton (const char*,const ImVec4,ImGuiColorEditFlags,ImVec2) (const char* desc_id,const ImVec4& col,ImGuiColorEditFlags flags=0,ImVec2 size=ImVec2(0,0)) (const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size) (desc_id,col,flags,size) bool +igSetColorEditOptions SetColorEditOptions (ImGuiColorEditFlags) (ImGuiColorEditFlags flags) (ImGuiColorEditFlags flags) (flags) void +igTreeNode TreeNode (const char*) (const char* label) (const char* label) (label) bool +igTreeNode TreeNode (const char*,const char*,...) (const char* str_id,const char* fmt,...) (const char* str_id,const char* fmt,...) (str_id,fmt,...) bool +igTreeNode TreeNode (const void*,const char*,...) (const void* ptr_id,const char* fmt,...) (const void* ptr_id,const char* fmt,...) (ptr_id,fmt,...) bool +igTreeNodeV TreeNodeV (const char*,const char*,va_list) (const char* str_id,const char* fmt,va_list args) (const char* str_id,const char* fmt,va_list args) (str_id,fmt,args) bool +igTreeNodeV TreeNodeV (const void*,const char*,va_list) (const void* ptr_id,const char* fmt,va_list args) (const void* ptr_id,const char* fmt,va_list args) (ptr_id,fmt,args) bool +igTreeNodeEx TreeNodeEx (const char*,ImGuiTreeNodeFlags) (const char* label,ImGuiTreeNodeFlags flags=0) (const char* label,ImGuiTreeNodeFlags flags) (label,flags) bool +igTreeNodeEx TreeNodeEx (const char*,ImGuiTreeNodeFlags,const char*,...) (const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...) (const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...) (str_id,flags,fmt,...) bool +igTreeNodeEx TreeNodeEx (const void*,ImGuiTreeNodeFlags,const char*,...) (const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...) (const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...) (ptr_id,flags,fmt,...) bool +igTreeNodeExV TreeNodeExV (const char*,ImGuiTreeNodeFlags,const char*,va_list) (const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) (const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) (str_id,flags,fmt,args) bool +igTreeNodeExV TreeNodeExV (const void*,ImGuiTreeNodeFlags,const char*,va_list) (const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) (const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args) (ptr_id,flags,fmt,args) bool +igTreePush TreePush (const char*) (const char* str_id) (const char* str_id) (str_id) void +igTreePush TreePush (const void*) (const void* ptr_id=((void *)0)) (const void* ptr_id) (ptr_id) void +igTreePop TreePop () () () () void +igTreeAdvanceToLabelPos TreeAdvanceToLabelPos () () () () void +igGetTreeNodeToLabelSpacing GetTreeNodeToLabelSpacing () () () () float +igSetNextTreeNodeOpen SetNextTreeNodeOpen (bool,ImGuiCond) (bool is_open,ImGuiCond cond=0) (bool is_open,ImGuiCond cond) (is_open,cond) void +igCollapsingHeader CollapsingHeader (const char*,ImGuiTreeNodeFlags) (const char* label,ImGuiTreeNodeFlags flags=0) (const char* label,ImGuiTreeNodeFlags flags) (label,flags) bool +igCollapsingHeader CollapsingHeader (const char*,bool*,ImGuiTreeNodeFlags) (const char* label,bool* p_open,ImGuiTreeNodeFlags flags=0) (const char* label,bool* p_open,ImGuiTreeNodeFlags flags) (label,p_open,flags) bool +igSelectable Selectable (const char*,bool,ImGuiSelectableFlags,const ImVec2) (const char* label,bool selected=false,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0)) (const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size) (label,selected,flags,size) bool +igSelectable Selectable (const char*,bool*,ImGuiSelectableFlags,const ImVec2) (const char* label,bool* p_selected,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0)) (const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size) (label,p_selected,flags,size) bool +igListBox ListBox (const char*,int*,const char* const[],int,int) (const char* label,int* current_item,const char* const items[],int items_count,int height_in_items=-1) (const char* label,int* current_item,const char* const items[],int items_count,int height_in_items) (label,current_item,items,items_count,height_in_items) bool +igListBox ListBox (const char*,int*,bool(*)(void*,int,const char**),void*,int,int) (const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items=-1) (const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items) (label,current_item,items_getter,data,items_count,height_in_items) bool +igListBoxHeader ListBoxHeader (const char*,const ImVec2) (const char* label,const ImVec2& size=ImVec2(0,0)) (const char* label,const ImVec2 size) (label,size) bool +igListBoxHeader ListBoxHeader (const char*,int,int) (const char* label,int items_count,int height_in_items=-1) (const char* label,int items_count,int height_in_items) (label,items_count,height_in_items) bool +igListBoxFooter ListBoxFooter () () () () void +igValue Value (const char*,bool) (const char* prefix,bool b) (const char* prefix,bool b) (prefix,b) void +igValue Value (const char*,int) (const char* prefix,int v) (const char* prefix,int v) (prefix,v) void +igValue Value (const char*,unsigned int) (const char* prefix,unsigned int v) (const char* prefix,unsigned int v) (prefix,v) void +igValue Value (const char*,float,const char*) (const char* prefix,float v,const char* float_format=((void *)0)) (const char* prefix,float v,const char* float_format) (prefix,v,float_format) void +igSetTooltip SetTooltip (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igSetTooltipV SetTooltipV (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +igBeginTooltip BeginTooltip () () () () void +igEndTooltip EndTooltip () () () () void +igBeginMainMenuBar BeginMainMenuBar () () () () bool +igEndMainMenuBar EndMainMenuBar () () () () void +igBeginMenuBar BeginMenuBar () () () () bool +igEndMenuBar EndMenuBar () () () () void +igBeginMenu BeginMenu (const char*,bool) (const char* label,bool enabled=true) (const char* label,bool enabled) (label,enabled) bool +igEndMenu EndMenu () () () () void +igMenuItem MenuItem (const char*,const char*,bool,bool) (const char* label,const char* shortcut=((void *)0),bool selected=false,bool enabled=true) (const char* label,const char* shortcut,bool selected,bool enabled) (label,shortcut,selected,enabled) bool +igMenuItem MenuItem (const char*,const char*,bool*,bool) (const char* label,const char* shortcut,bool* p_selected,bool enabled=true) (const char* label,const char* shortcut,bool* p_selected,bool enabled) (label,shortcut,p_selected,enabled) bool +igOpenPopup OpenPopup (const char*) (const char* str_id) (const char* str_id) (str_id) void +igBeginPopup BeginPopup (const char*,ImGuiWindowFlags) (const char* str_id,ImGuiWindowFlags flags=0) (const char* str_id,ImGuiWindowFlags flags) (str_id,flags) bool +igBeginPopupContextItem BeginPopupContextItem (const char*,int) (const char* str_id=((void *)0),int mouse_button=1) (const char* str_id,int mouse_button) (str_id,mouse_button) bool +igBeginPopupContextWindow BeginPopupContextWindow (const char*,int,bool) (const char* str_id=((void *)0),int mouse_button=1,bool also_over_items=true) (const char* str_id,int mouse_button,bool also_over_items) (str_id,mouse_button,also_over_items) bool +igBeginPopupContextVoid BeginPopupContextVoid (const char*,int) (const char* str_id=((void *)0),int mouse_button=1) (const char* str_id,int mouse_button) (str_id,mouse_button) bool +igBeginPopupModal BeginPopupModal (const char*,bool*,ImGuiWindowFlags) (const char* name,bool* p_open=((void *)0),ImGuiWindowFlags flags=0) (const char* name,bool* p_open,ImGuiWindowFlags flags) (name,p_open,flags) bool +igEndPopup EndPopup () () () () void +igOpenPopupOnItemClick OpenPopupOnItemClick (const char*,int) (const char* str_id=((void *)0),int mouse_button=1) (const char* str_id,int mouse_button) (str_id,mouse_button) bool +igIsPopupOpen IsPopupOpen (const char*) (const char* str_id) (const char* str_id) (str_id) bool +igCloseCurrentPopup CloseCurrentPopup () () () () void +igColumns Columns (int,const char*,bool) (int count=1,const char* id=((void *)0),bool border=true) (int count,const char* id,bool border) (count,id,border) void +igNextColumn NextColumn () () () () void +igGetColumnIndex GetColumnIndex () () () () int +igGetColumnWidth GetColumnWidth (int) (int column_index=-1) (int column_index) (column_index) float +igSetColumnWidth SetColumnWidth (int,float) (int column_index,float width) (int column_index,float width) (column_index,width) void +igGetColumnOffset GetColumnOffset (int) (int column_index=-1) (int column_index) (column_index) float +igSetColumnOffset SetColumnOffset (int,float) (int column_index,float offset_x) (int column_index,float offset_x) (column_index,offset_x) void +igGetColumnsCount GetColumnsCount () () () () int +igLogToTTY LogToTTY (int) (int max_depth=-1) (int max_depth) (max_depth) void +igLogToFile LogToFile (int,const char*) (int max_depth=-1,const char* filename=((void *)0)) (int max_depth,const char* filename) (max_depth,filename) void +igLogToClipboard LogToClipboard (int) (int max_depth=-1) (int max_depth) (max_depth) void +igLogFinish LogFinish () () () () void +igLogButtons LogButtons () () () () void +igLogText LogText (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +igBeginDragDropSource BeginDragDropSource (ImGuiDragDropFlags) (ImGuiDragDropFlags flags=0) (ImGuiDragDropFlags flags) (flags) bool +igSetDragDropPayload SetDragDropPayload (const char*,const void*,size_t,ImGuiCond) (const char* type,const void* data,size_t size,ImGuiCond cond=0) (const char* type,const void* data,size_t size,ImGuiCond cond) (type,data,size,cond) bool +igEndDragDropSource EndDragDropSource () () () () void +igBeginDragDropTarget BeginDragDropTarget () () () () bool +igAcceptDragDropPayload AcceptDragDropPayload (const char*,ImGuiDragDropFlags) (const char* type,ImGuiDragDropFlags flags=0) (const char* type,ImGuiDragDropFlags flags) (type,flags) const ImGuiPayload* +igEndDragDropTarget EndDragDropTarget () () () () void +igPushClipRect PushClipRect (const ImVec2,const ImVec2,bool) (const ImVec2& clip_rect_min,const ImVec2& clip_rect_max,bool intersect_with_current_clip_rect) (const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect) (clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) void +igPopClipRect PopClipRect () () () () void +igSetItemDefaultFocus SetItemDefaultFocus () () () () void +igSetKeyboardFocusHere SetKeyboardFocusHere (int) (int offset=0) (int offset) (offset) void +igIsItemHovered IsItemHovered (ImGuiHoveredFlags) (ImGuiHoveredFlags flags=0) (ImGuiHoveredFlags flags) (flags) bool +igIsItemActive IsItemActive () () () () bool +igIsItemFocused IsItemFocused () () () () bool +igIsItemClicked IsItemClicked (int) (int mouse_button=0) (int mouse_button) (mouse_button) bool +igIsItemVisible IsItemVisible () () () () bool +igIsAnyItemHovered IsAnyItemHovered () () () () bool +igIsAnyItemActive IsAnyItemActive () () () () bool +igIsAnyItemFocused IsAnyItemFocused () () () () bool +igGetItemRectMin GetItemRectMin () () () () ImVec2 +igGetItemRectMax GetItemRectMax () () () () ImVec2 +igGetItemRectSize GetItemRectSize () () () () ImVec2 +igSetItemAllowOverlap SetItemAllowOverlap () () () () void +igIsRectVisible IsRectVisible (const ImVec2) (const ImVec2& size) (const ImVec2 size) (size) bool +igIsRectVisible IsRectVisible (const ImVec2,const ImVec2) (const ImVec2& rect_min,const ImVec2& rect_max) (const ImVec2 rect_min,const ImVec2 rect_max) (rect_min,rect_max) bool +igGetTime GetTime () () () () float +igGetFrameCount GetFrameCount () () () () int +igGetOverlayDrawList GetOverlayDrawList () () () () ImDrawList* +igGetDrawListSharedData GetDrawListSharedData () () () () ImDrawListSharedData* +igGetStyleColorName GetStyleColorName (ImGuiCol) (ImGuiCol idx) (ImGuiCol idx) (idx) const char* +igSetStateStorage SetStateStorage (ImGuiStorage*) (ImGuiStorage* storage) (ImGuiStorage* storage) (storage) void +igGetStateStorage GetStateStorage () () () () ImGuiStorage* +igCalcTextSize CalcTextSize (const char*,const char*,bool,float) (const char* text,const char* text_end=((void *)0),bool hide_text_after_double_hash=false,float wrap_width=-1.0f) (const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width) (text,text_end,hide_text_after_double_hash,wrap_width) ImVec2 +igCalcListClipping CalcListClipping (int,float,int*,int*) (int items_count,float items_height,int* out_items_display_start,int* out_items_display_end) (int items_count,float items_height,int* out_items_display_start,int* out_items_display_end) (items_count,items_height,out_items_display_start,out_items_display_end) void +igBeginChildFrame BeginChildFrame (ImGuiID,const ImVec2,ImGuiWindowFlags) (ImGuiID id,const ImVec2& size,ImGuiWindowFlags flags=0) (ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags) (id,size,flags) bool +igEndChildFrame EndChildFrame () () () () void +igColorConvertU32ToFloat4 ColorConvertU32ToFloat4 (ImU32) (ImU32 in) (ImU32 in) (in) ImVec4 +igColorConvertFloat4ToU32 ColorConvertFloat4ToU32 (const ImVec4) (const ImVec4& in) (const ImVec4 in) (in) ImU32 +igColorConvertRGBtoHSV ColorConvertRGBtoHSV (float,float,float,float,float,float) (float r,float g,float b,float& out_h,float& out_s,float& out_v) (float r,float g,float b,float out_h,float out_s,float out_v) (r,g,b,out_h,out_s,out_v) void +igColorConvertHSVtoRGB ColorConvertHSVtoRGB (float,float,float,float,float,float) (float h,float s,float v,float& out_r,float& out_g,float& out_b) (float h,float s,float v,float out_r,float out_g,float out_b) (h,s,v,out_r,out_g,out_b) void +igGetKeyIndex GetKeyIndex (ImGuiKey) (ImGuiKey imgui_key) (ImGuiKey imgui_key) (imgui_key) int +igIsKeyDown IsKeyDown (int) (int user_key_index) (int user_key_index) (user_key_index) bool +igIsKeyPressed IsKeyPressed (int,bool) (int user_key_index,bool repeat=true) (int user_key_index,bool repeat) (user_key_index,repeat) bool +igIsKeyReleased IsKeyReleased (int) (int user_key_index) (int user_key_index) (user_key_index) bool +igGetKeyPressedAmount GetKeyPressedAmount (int,float,float) (int key_index,float repeat_delay,float rate) (int key_index,float repeat_delay,float rate) (key_index,repeat_delay,rate) int +igIsMouseDown IsMouseDown (int) (int button) (int button) (button) bool +igIsAnyMouseDown IsAnyMouseDown () () () () bool +igIsMouseClicked IsMouseClicked (int,bool) (int button,bool repeat=false) (int button,bool repeat) (button,repeat) bool +igIsMouseDoubleClicked IsMouseDoubleClicked (int) (int button) (int button) (button) bool +igIsMouseReleased IsMouseReleased (int) (int button) (int button) (button) bool +igIsMouseDragging IsMouseDragging (int,float) (int button=0,float lock_threshold=-1.0f) (int button,float lock_threshold) (button,lock_threshold) bool +igIsMouseHoveringRect IsMouseHoveringRect (const ImVec2,const ImVec2,bool) (const ImVec2& r_min,const ImVec2& r_max,bool clip=true) (const ImVec2 r_min,const ImVec2 r_max,bool clip) (r_min,r_max,clip) bool +igIsMousePosValid IsMousePosValid (const ImVec2*) (const ImVec2* mouse_pos=((void *)0)) (const ImVec2* mouse_pos) (mouse_pos) bool +igGetMousePos GetMousePos () () () () ImVec2 +igGetMousePosOnOpeningCurrentPopup GetMousePosOnOpeningCurrentPopup () () () () ImVec2 +igGetMouseDragDelta GetMouseDragDelta (int,float) (int button=0,float lock_threshold=-1.0f) (int button,float lock_threshold) (button,lock_threshold) ImVec2 +igResetMouseDragDelta ResetMouseDragDelta (int) (int button=0) (int button) (button) void +igGetMouseCursor GetMouseCursor () () () () ImGuiMouseCursor +igSetMouseCursor SetMouseCursor (ImGuiMouseCursor) (ImGuiMouseCursor type) (ImGuiMouseCursor type) (type) void +igCaptureKeyboardFromApp CaptureKeyboardFromApp (bool) (bool capture=true) (bool capture) (capture) void +igCaptureMouseFromApp CaptureMouseFromApp (bool) (bool capture=true) (bool capture) (capture) void +igGetClipboardText GetClipboardText () () () () const char* +igSetClipboardText SetClipboardText (const char*) (const char* text) (const char* text) (text) void +igSetAllocatorFunctions SetAllocatorFunctions (void*(*)(size_t,void*),void(*)(void*,void*),void*) (void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data=((void *)0)) (void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data) (alloc_func,free_func,user_data) void +igMemAlloc MemAlloc (size_t) (size_t size) (size_t size) (size) void* +igMemFree MemFree (void*) (void* ptr) (void* ptr) (ptr) void +ImGuiStyle_ImGuiStyle ImGuiStyle () () () () nil +ImGuiStyle_ScaleAllSizes ScaleAllSizes (float) (float scale_factor) (float scale_factor) (scale_factor) void +ImGuiIO_AddInputCharacter AddInputCharacter (ImWchar) (ImWchar c) (ImWchar c) (c) void +ImGuiIO_AddInputCharactersUTF8 AddInputCharactersUTF8 (const char*) (const char* utf8_chars) (const char* utf8_chars) (utf8_chars) void +ImGuiIO_ClearInputCharacters ClearInputCharacters () () () () inline void +ImGuiIO_ImGuiIO ImGuiIO () () () () nil +ImGuiOnceUponAFrame_ImGuiOnceUponAFrame ImGuiOnceUponAFrame () () () () nil +TextRange_TextRange TextRange () () () () nil +TextRange_TextRange TextRange (const char*,const char*) (const char* _b,const char* _e) (const char* _b,const char* _e) (_b,_e) nil +TextRange_begin begin () () () () const char* +TextRange_end end () () () () const char* +TextRange_empty empty () () () () bool +TextRange_front front () () () () char +TextRange_is_blank is_blank (char) (char c) (char c) (c) bool +TextRange_trim_blanks trim_blanks () () () () void +TextRange_split split (char,ImVector_TextRange) (char separator,ImVector& out) (char separator,ImVector_TextRange out) (separator,out) void +ImGuiTextFilter_ImGuiTextFilter ImGuiTextFilter (const char*) (const char* default_filter="") (const char* default_filter) (default_filter) nil +ImGuiTextFilter_Draw Draw (const char*,float) (const char* label="Filter(inc,-exc)",float width=0.0f) (const char* label,float width) (label,width) bool +ImGuiTextFilter_PassFilter PassFilter (const char*,const char*) (const char* text,const char* text_end=((void *)0)) (const char* text,const char* text_end) (text,text_end) bool +ImGuiTextFilter_Build Build () () () () void +ImGuiTextFilter_Clear Clear () () () () void +ImGuiTextFilter_IsActive IsActive () () () () bool +ImGuiTextBuffer_ImGuiTextBuffer ImGuiTextBuffer () () () () nil +ImGuiTextBuffer_begin begin () () () () const char* +ImGuiTextBuffer_end end () () () () const char* +ImGuiTextBuffer_size size () () () () int +ImGuiTextBuffer_empty empty () () () () bool +ImGuiTextBuffer_clear clear () () () () void +ImGuiTextBuffer_reserve reserve (int) (int capacity) (int capacity) (capacity) void +ImGuiTextBuffer_c_str c_str () () () () const char* +ImGuiTextBuffer_appendf appendf (const char*,...) (const char* fmt,...) (const char* fmt,...) (fmt,...) void +ImGuiTextBuffer_appendfv appendfv (const char*,va_list) (const char* fmt,va_list args) (const char* fmt,va_list args) (fmt,args) void +Pair_Pair Pair (ImGuiID,int) (ImGuiID _key,int _val_i) (ImGuiID _key,int _val_i) (_key,_val_i) nil +Pair_Pair Pair (ImGuiID,float) (ImGuiID _key,float _val_f) (ImGuiID _key,float _val_f) (_key,_val_f) nil +Pair_Pair Pair (ImGuiID,void*) (ImGuiID _key,void* _val_p) (ImGuiID _key,void* _val_p) (_key,_val_p) nil +ImGuiStorage_Clear Clear () () () () void +ImGuiStorage_GetInt GetInt (ImGuiID,int) (ImGuiID key,int default_val=0) (ImGuiID key,int default_val) (key,default_val) int +ImGuiStorage_SetInt SetInt (ImGuiID,int) (ImGuiID key,int val) (ImGuiID key,int val) (key,val) void +ImGuiStorage_GetBool GetBool (ImGuiID,bool) (ImGuiID key,bool default_val=false) (ImGuiID key,bool default_val) (key,default_val) bool +ImGuiStorage_SetBool SetBool (ImGuiID,bool) (ImGuiID key,bool val) (ImGuiID key,bool val) (key,val) void +ImGuiStorage_GetFloat GetFloat (ImGuiID,float) (ImGuiID key,float default_val=0.0f) (ImGuiID key,float default_val) (key,default_val) float +ImGuiStorage_SetFloat SetFloat (ImGuiID,float) (ImGuiID key,float val) (ImGuiID key,float val) (key,val) void +ImGuiStorage_GetVoidPtr GetVoidPtr (ImGuiID) (ImGuiID key) (ImGuiID key) (key) void* +ImGuiStorage_SetVoidPtr SetVoidPtr (ImGuiID,void*) (ImGuiID key,void* val) (ImGuiID key,void* val) (key,val) void +ImGuiStorage_GetIntRef GetIntRef (ImGuiID,int) (ImGuiID key,int default_val=0) (ImGuiID key,int default_val) (key,default_val) int* +ImGuiStorage_GetBoolRef GetBoolRef (ImGuiID,bool) (ImGuiID key,bool default_val=false) (ImGuiID key,bool default_val) (key,default_val) bool* +ImGuiStorage_GetFloatRef GetFloatRef (ImGuiID,float) (ImGuiID key,float default_val=0.0f) (ImGuiID key,float default_val) (key,default_val) float* +ImGuiStorage_GetVoidPtrRef GetVoidPtrRef (ImGuiID,void*) (ImGuiID key,void* default_val=((void *)0)) (ImGuiID key,void* default_val) (key,default_val) void** +ImGuiStorage_SetAllInt SetAllInt (int) (int val) (int val) (val) void +ImGuiStorage_BuildSortByKey BuildSortByKey () () () () void +ImGuiTextEditCallbackData_DeleteChars DeleteChars (int,int) (int pos,int bytes_count) (int pos,int bytes_count) (pos,bytes_count) void +ImGuiTextEditCallbackData_InsertChars InsertChars (int,const char*,const char*) (int pos,const char* text,const char* text_end=((void *)0)) (int pos,const char* text,const char* text_end) (pos,text,text_end) void +ImGuiTextEditCallbackData_HasSelection HasSelection () () () () bool +ImGuiPayload_ImGuiPayload ImGuiPayload () () () () nil +ImGuiPayload_Clear Clear () () () () void +ImGuiPayload_IsDataType IsDataType (const char*) (const char* type) (const char* type) (type) bool +ImGuiPayload_IsPreview IsPreview () () () () bool +ImGuiPayload_IsDelivery IsDelivery () () () () bool +ImColor_ImColor ImColor () () () () nil +ImColor_ImColor ImColor (int,int,int,int) (int r,int g,int b,int a=255) (int r,int g,int b,int a) (r,g,b,a) nil +ImColor_ImColor ImColor (ImU32) (ImU32 rgba) (ImU32 rgba) (rgba) nil +ImColor_ImColor ImColor (float,float,float,float) (float r,float g,float b,float a=1.0f) (float r,float g,float b,float a) (r,g,b,a) nil +ImColor_ImColor ImColor (const ImVec4) (const ImVec4& col) (const ImVec4 col) (col) nil +ImColor_SetHSV SetHSV (float,float,float,float) (float h,float s,float v,float a=1.0f) (float h,float s,float v,float a) (h,s,v,a) inline void +ImColor_HSV HSV (float,float,float,float) (float h,float s,float v,float a=1.0f) (float h,float s,float v,float a) (h,s,v,a) ImColor +ImGuiListClipper_ImGuiListClipper ImGuiListClipper (int,float) (int items_count=-1,float items_height=-1.0f) (int items_count,float items_height) (items_count,items_height) nil +ImGuiListClipper_~ImGuiListClipper ~ImGuiListClipper () () () () nil +ImGuiListClipper_Step Step () () () () bool +ImGuiListClipper_Begin Begin (int,float) (int items_count,float items_height=-1.0f) (int items_count,float items_height) (items_count,items_height) void +ImGuiListClipper_End End () () () () void +ImDrawCmd_ImDrawCmd ImDrawCmd () () () () nil +ImDrawList_ImDrawList ImDrawList (const ImDrawListSharedData*) (const ImDrawListSharedData* shared_data) (const ImDrawListSharedData* shared_data) (shared_data) nil +ImDrawList_~ImDrawList ~ImDrawList () () () () nil +ImDrawList_PushClipRect PushClipRect (ImVec2,ImVec2,bool) (ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect=false) (ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect) (clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) void +ImDrawList_PushClipRectFullScreen PushClipRectFullScreen () () () () void +ImDrawList_PopClipRect PopClipRect () () () () void +ImDrawList_PushTextureID PushTextureID (ImTextureID) (ImTextureID texture_id) (ImTextureID texture_id) (texture_id) void +ImDrawList_PopTextureID PopTextureID () () () () void +ImDrawList_GetClipRectMin GetClipRectMin () () () () inline ImVec2 +ImDrawList_GetClipRectMax GetClipRectMax () () () () inline ImVec2 +ImDrawList_AddLine AddLine (const ImVec2,const ImVec2,ImU32,float) (const ImVec2& a,const ImVec2& b,ImU32 col,float thickness=1.0f) (const ImVec2 a,const ImVec2 b,ImU32 col,float thickness) (a,b,col,thickness) void +ImDrawList_AddRect AddRect (const ImVec2,const ImVec2,ImU32,float,int,float) (const ImVec2& a,const ImVec2& b,ImU32 col,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All,float thickness=1.0f) (const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness) (a,b,col,rounding,rounding_corners_flags,thickness) void +ImDrawList_AddRectFilled AddRectFilled (const ImVec2,const ImVec2,ImU32,float,int) (const ImVec2& a,const ImVec2& b,ImU32 col,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All) (const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags) (a,b,col,rounding,rounding_corners_flags) void +ImDrawList_AddRectFilledMultiColor AddRectFilledMultiColor (const ImVec2,const ImVec2,ImU32,ImU32,ImU32,ImU32) (const ImVec2& a,const ImVec2& b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left) (const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left) (a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left) void +ImDrawList_AddQuad AddQuad (const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float) (const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,ImU32 col,float thickness=1.0f) (const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness) (a,b,c,d,col,thickness) void +ImDrawList_AddQuadFilled AddQuadFilled (const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32) (const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,ImU32 col) (const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col) (a,b,c,d,col) void +ImDrawList_AddTriangle AddTriangle (const ImVec2,const ImVec2,const ImVec2,ImU32,float) (const ImVec2& a,const ImVec2& b,const ImVec2& c,ImU32 col,float thickness=1.0f) (const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness) (a,b,c,col,thickness) void +ImDrawList_AddTriangleFilled AddTriangleFilled (const ImVec2,const ImVec2,const ImVec2,ImU32) (const ImVec2& a,const ImVec2& b,const ImVec2& c,ImU32 col) (const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col) (a,b,c,col) void +ImDrawList_AddCircle AddCircle (const ImVec2,float,ImU32,int,float) (const ImVec2& centre,float radius,ImU32 col,int num_segments=12,float thickness=1.0f) (const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness) (centre,radius,col,num_segments,thickness) void +ImDrawList_AddCircleFilled AddCircleFilled (const ImVec2,float,ImU32,int) (const ImVec2& centre,float radius,ImU32 col,int num_segments=12) (const ImVec2 centre,float radius,ImU32 col,int num_segments) (centre,radius,col,num_segments) void +ImDrawList_AddText AddText (const ImVec2,ImU32,const char*,const char*) (const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void *)0)) (const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end) (pos,col,text_begin,text_end) void +ImDrawList_AddText AddText (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*) (const ImFont* font,float font_size,const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void *)0),float wrap_width=0.0f,const ImVec4* cpu_fine_clip_rect=((void *)0)) (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) (font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect) void +ImDrawList_AddImage AddImage (ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32) (ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& uv_a=ImVec2(0,0),const ImVec2& uv_b=ImVec2(1,1),ImU32 col=0xFFFFFFFF) (ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col) (user_texture_id,a,b,uv_a,uv_b,col) void +ImDrawList_AddImageQuad AddImageQuad (ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32) (ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,const ImVec2& uv_a=ImVec2(0,0),const ImVec2& uv_b=ImVec2(1,0),const ImVec2& uv_c=ImVec2(1,1),const ImVec2& uv_d=ImVec2(0,1),ImU32 col=0xFFFFFFFF) (ImTextureID user_texture_id,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) (user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) void +ImDrawList_AddImageRounded AddImageRounded (ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,int) (ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,ImU32 col,float rounding,int rounding_corners=ImDrawCornerFlags_All) (ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners) (user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners) void +ImDrawList_AddPolyline AddPolyline (const ImVec2*,const int,ImU32,bool,float) (const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness) (const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness) (points,num_points,col,closed,thickness) void +ImDrawList_AddConvexPolyFilled AddConvexPolyFilled (const ImVec2*,const int,ImU32) (const ImVec2* points,const int num_points,ImU32 col) (const ImVec2* points,const int num_points,ImU32 col) (points,num_points,col) void +ImDrawList_AddBezierCurve AddBezierCurve (const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,int) (const ImVec2& pos0,const ImVec2& cp0,const ImVec2& cp1,const ImVec2& pos1,ImU32 col,float thickness,int num_segments=0) (const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments) (pos0,cp0,cp1,pos1,col,thickness,num_segments) void +ImDrawList_PathClear PathClear () () () () inline void +ImDrawList_PathLineTo PathLineTo (const ImVec2) (const ImVec2& pos) (const ImVec2 pos) (pos) inline void +ImDrawList_PathLineToMergeDuplicate PathLineToMergeDuplicate (const ImVec2) (const ImVec2& pos) (const ImVec2 pos) (pos) inline void +ImDrawList_PathFillConvex PathFillConvex (ImU32) (ImU32 col) (ImU32 col) (col) inline void +ImDrawList_PathStroke PathStroke (ImU32,bool,float) (ImU32 col,bool closed,float thickness=1.0f) (ImU32 col,bool closed,float thickness) (col,closed,thickness) inline void +ImDrawList_PathArcTo PathArcTo (const ImVec2,float,float,float,int) (const ImVec2& centre,float radius,float a_min,float a_max,int num_segments=10) (const ImVec2 centre,float radius,float a_min,float a_max,int num_segments) (centre,radius,a_min,a_max,num_segments) void +ImDrawList_PathArcToFast PathArcToFast (const ImVec2,float,int,int) (const ImVec2& centre,float radius,int a_min_of_12,int a_max_of_12) (const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12) (centre,radius,a_min_of_12,a_max_of_12) void +ImDrawList_PathBezierCurveTo PathBezierCurveTo (const ImVec2,const ImVec2,const ImVec2,int) (const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,int num_segments=0) (const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments) (p1,p2,p3,num_segments) void +ImDrawList_PathRect PathRect (const ImVec2,const ImVec2,float,int) (const ImVec2& rect_min,const ImVec2& rect_max,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All) (const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags) (rect_min,rect_max,rounding,rounding_corners_flags) void +ImDrawList_ChannelsSplit ChannelsSplit (int) (int channels_count) (int channels_count) (channels_count) void +ImDrawList_ChannelsMerge ChannelsMerge () () () () void +ImDrawList_ChannelsSetCurrent ChannelsSetCurrent (int) (int channel_index) (int channel_index) (channel_index) void +ImDrawList_AddCallback AddCallback (ImDrawCallback,void*) (ImDrawCallback callback,void* callback_data) (ImDrawCallback callback,void* callback_data) (callback,callback_data) void +ImDrawList_AddDrawCmd AddDrawCmd () () () () void +ImDrawList_CloneOutput CloneOutput () () () () ImDrawList* +ImDrawList_Clear Clear () () () () void +ImDrawList_ClearFreeMemory ClearFreeMemory () () () () void +ImDrawList_PrimReserve PrimReserve (int,int) (int idx_count,int vtx_count) (int idx_count,int vtx_count) (idx_count,vtx_count) void +ImDrawList_PrimRect PrimRect (const ImVec2,const ImVec2,ImU32) (const ImVec2& a,const ImVec2& b,ImU32 col) (const ImVec2 a,const ImVec2 b,ImU32 col) (a,b,col) void +ImDrawList_PrimRectUV PrimRectUV (const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32) (const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,ImU32 col) (const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col) (a,b,uv_a,uv_b,col) void +ImDrawList_PrimQuadUV PrimQuadUV (const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32) (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) (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) (a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) void +ImDrawList_PrimWriteVtx PrimWriteVtx (const ImVec2,const ImVec2,ImU32) (const ImVec2& pos,const ImVec2& uv,ImU32 col) (const ImVec2 pos,const ImVec2 uv,ImU32 col) (pos,uv,col) inline void +ImDrawList_PrimWriteIdx PrimWriteIdx (ImDrawIdx) (ImDrawIdx idx) (ImDrawIdx idx) (idx) inline void +ImDrawList_PrimVtx PrimVtx (const ImVec2,const ImVec2,ImU32) (const ImVec2& pos,const ImVec2& uv,ImU32 col) (const ImVec2 pos,const ImVec2 uv,ImU32 col) (pos,uv,col) inline void +ImDrawList_UpdateClipRect UpdateClipRect () () () () void +ImDrawList_UpdateTextureID UpdateTextureID () () () () void +ImDrawData_ImDrawData ImDrawData () () () () nil +ImDrawData_~ImDrawData ~ImDrawData () () () () nil +ImDrawData_Clear Clear () () () () void +ImDrawData_DeIndexAllBuffers DeIndexAllBuffers () () () () void +ImDrawData_ScaleClipRects ScaleClipRects (const ImVec2) (const ImVec2& sc) (const ImVec2 sc) (sc) void +ImFontConfig_ImFontConfig ImFontConfig () () () () nil +ImFontAtlas_ImFontAtlas ImFontAtlas () () () () nil +ImFontAtlas_~ImFontAtlas ~ImFontAtlas () () () () nil +ImFontAtlas_AddFont AddFont (const ImFontConfig*) (const ImFontConfig* font_cfg) (const ImFontConfig* font_cfg) (font_cfg) ImFont* +ImFontAtlas_AddFontDefault AddFontDefault (const ImFontConfig*) (const ImFontConfig* font_cfg=((void *)0)) (const ImFontConfig* font_cfg) (font_cfg) ImFont* +ImFontAtlas_AddFontFromFileTTF AddFontFromFileTTF (const char*,float,const ImFontConfig*,const ImWchar*) (const char* filename,float size_pixels,const ImFontConfig* font_cfg=((void *)0),const ImWchar* glyph_ranges=((void *)0)) (const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) (filename,size_pixels,font_cfg,glyph_ranges) ImFont* +ImFontAtlas_AddFontFromMemoryTTF AddFontFromMemoryTTF (void*,int,float,const ImFontConfig*,const ImWchar*) (void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg=((void *)0),const ImWchar* glyph_ranges=((void *)0)) (void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) (font_data,font_size,size_pixels,font_cfg,glyph_ranges) ImFont* +ImFontAtlas_AddFontFromMemoryCompressedTTF AddFontFromMemoryCompressedTTF (const void*,int,float,const ImFontConfig*,const ImWchar*) (const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg=((void *)0),const ImWchar* glyph_ranges=((void *)0)) (const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) (compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges) ImFont* +ImFontAtlas_AddFontFromMemoryCompressedBase85TTF AddFontFromMemoryCompressedBase85TTF (const char*,float,const ImFontConfig*,const ImWchar*) (const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg=((void *)0),const ImWchar* glyph_ranges=((void *)0)) (const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges) (compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges) ImFont* +ImFontAtlas_ClearInputData ClearInputData () () () () void +ImFontAtlas_ClearTexData ClearTexData () () () () void +ImFontAtlas_ClearFonts ClearFonts () () () () void +ImFontAtlas_Clear Clear () () () () void +ImFontAtlas_Build Build () () () () bool +ImFontAtlas_GetTexDataAsAlpha8 GetTexDataAsAlpha8 (unsigned char**,int*,int*,int*) (unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void *)0)) (unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel) (out_pixels,out_width,out_height,out_bytes_per_pixel) void +ImFontAtlas_GetTexDataAsRGBA32 GetTexDataAsRGBA32 (unsigned char**,int*,int*,int*) (unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void *)0)) (unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel) (out_pixels,out_width,out_height,out_bytes_per_pixel) void +ImFontAtlas_SetTexID SetTexID (ImTextureID) (ImTextureID id) (ImTextureID id) (id) void +ImFontAtlas_GetGlyphRangesDefault GetGlyphRangesDefault () () () () const ImWchar* +ImFontAtlas_GetGlyphRangesKorean GetGlyphRangesKorean () () () () const ImWchar* +ImFontAtlas_GetGlyphRangesJapanese GetGlyphRangesJapanese () () () () const ImWchar* +ImFontAtlas_GetGlyphRangesChinese GetGlyphRangesChinese () () () () const ImWchar* +ImFontAtlas_GetGlyphRangesCyrillic GetGlyphRangesCyrillic () () () () const ImWchar* +ImFontAtlas_GetGlyphRangesThai GetGlyphRangesThai () () () () const ImWchar* +GlyphRangesBuilder_GlyphRangesBuilder GlyphRangesBuilder () () () () nil +GlyphRangesBuilder_GetBit GetBit (int) (int n) (int n) (n) bool +GlyphRangesBuilder_SetBit SetBit (int) (int n) (int n) (n) void +GlyphRangesBuilder_AddChar AddChar (ImWchar) (ImWchar c) (ImWchar c) (c) void +GlyphRangesBuilder_AddText AddText (const char*,const char*) (const char* text,const char* text_end=((void *)0)) (const char* text,const char* text_end) (text,text_end) void +GlyphRangesBuilder_AddRanges AddRanges (const ImWchar*) (const ImWchar* ranges) (const ImWchar* ranges) (ranges) void +GlyphRangesBuilder_BuildRanges BuildRanges (ImVector_ImWchar*) (ImVector* out_ranges) (ImVector_ImWchar* out_ranges) (out_ranges) void +CustomRect_CustomRect CustomRect () () () () nil +CustomRect_IsPacked IsPacked () () () () bool +ImFontAtlas_AddCustomRectRegular AddCustomRectRegular (unsigned int,int,int) (unsigned int id,int width,int height) (unsigned int id,int width,int height) (id,width,height) int +ImFontAtlas_AddCustomRectFontGlyph AddCustomRectFontGlyph (ImFont*,ImWchar,int,int,float,const ImVec2) (ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2& offset=ImVec2(0,0)) (ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset) (font,id,width,height,advance_x,offset) int +ImFontAtlas_GetCustomRectByIndex GetCustomRectByIndex (int) (int index) (int index) (index) const CustomRect* +ImFontAtlas_CalcCustomRectUV CalcCustomRectUV (const CustomRect*,ImVec2*,ImVec2*) (const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max) (const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max) (rect,out_uv_min,out_uv_max) void +ImFontAtlas_GetMouseCursorTexData GetMouseCursorTexData (ImGuiMouseCursor,ImVec2*,ImVec2*,ImVec2[2],ImVec2[2]) (ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2]) (ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2]) (cursor,out_offset,out_size,out_uv_border,out_uv_fill) bool +ImFont_ImFont ImFont () () () () nil +ImFont_~ImFont ~ImFont () () () () nil +ImFont_ClearOutputData ClearOutputData () () () () void +ImFont_BuildLookupTable BuildLookupTable () () () () void +ImFont_FindGlyph FindGlyph (ImWchar) (ImWchar c) (ImWchar c) (c) const ImFontGlyph* +ImFont_FindGlyphNoFallback FindGlyphNoFallback (ImWchar) (ImWchar c) (ImWchar c) (c) const ImFontGlyph* +ImFont_SetFallbackChar SetFallbackChar (ImWchar) (ImWchar c) (ImWchar c) (c) void +ImFont_GetCharAdvance GetCharAdvance (ImWchar) (ImWchar c) (ImWchar c) (c) float +ImFont_IsLoaded IsLoaded () () () () bool +ImFont_GetDebugName GetDebugName () () () () const char* +ImFont_CalcTextSizeA CalcTextSizeA (float,float,float,const char*,const char*,const char**) (float size,float max_width,float wrap_width,const char* text_begin,const char* text_end=((void *)0),const char** remaining=((void *)0)) (float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining) (size,max_width,wrap_width,text_begin,text_end,remaining) ImVec2 +ImFont_CalcWordWrapPositionA CalcWordWrapPositionA (float,const char*,const char*,float) (float scale,const char* text,const char* text_end,float wrap_width) (float scale,const char* text,const char* text_end,float wrap_width) (scale,text,text_end,wrap_width) const char* +ImFont_RenderChar RenderChar (ImDrawList*,float,ImVec2,ImU32,unsigned short) (ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,unsigned short c) (ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,unsigned short c) (draw_list,size,pos,col,c) void +ImFont_RenderText RenderText (ImDrawList*,float,ImVec2,ImU32,const ImVec4,const char*,const char*,float,bool) (ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4& clip_rect,const char* text_begin,const char* text_end,float wrap_width=0.0f,bool cpu_fine_clip=false) (ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip) (draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip) void +ImFont_GrowIndex GrowIndex (int) (int new_size) (int new_size) (new_size) void +ImFont_AddGlyph AddGlyph (ImWchar,float,float,float,float,float,float,float,float,float) (ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x) (ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x) (c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x) void +ImFont_AddRemapChar AddRemapChar (ImWchar,ImWchar,bool) (ImWchar dst,ImWchar src,bool overwrite_dst=true) (ImWchar dst,ImWchar src,bool overwrite_dst) (dst,src,overwrite_dst) void +//embeded_structs--------------------------------------------------------------------------- +typedef ImFontAtlas::GlyphRangesBuilder GlyphRangesBuilder; +typedef ImFontAtlas::CustomRect CustomRect; +typedef ImGuiTextFilter::TextRange TextRange; +typedef ImGuiStorage::Pair Pair; +typedef ImVector ImVector_TextRange; +typedef ImVector ImVector_ImWchar; +//constructors------------------------------------------------------------------ +ImVec2_ImVec2 () () () () nil +ImVec2_ImVec2 (float,float) (float _x,float _y) (float _x,float _y) (_x,_y) nil +ImVec4_ImVec4 () () () () nil +ImVec4_ImVec4 (float,float,float,float) (float _x,float _y,float _z,float _w) (float _x,float _y,float _z,float _w) (_x,_y,_z,_w) nil +ImGuiStyle_ImGuiStyle () () () () nil +ImGuiIO_ImGuiIO () () () () nil +ImGuiOnceUponAFrame_ImGuiOnceUponAFrame () () () () nil +TextRange_TextRange () () () () nil +TextRange_TextRange (const char*,const char*) (const char* _b,const char* _e) (const char* _b,const char* _e) (_b,_e) nil +ImGuiTextFilter_ImGuiTextFilter (const char*) (const char* default_filter="") (const char* default_filter) (default_filter) nil +ImGuiTextBuffer_ImGuiTextBuffer () () () () nil +Pair_Pair (ImGuiID,int) (ImGuiID _key,int _val_i) (ImGuiID _key,int _val_i) (_key,_val_i) nil +Pair_Pair (ImGuiID,float) (ImGuiID _key,float _val_f) (ImGuiID _key,float _val_f) (_key,_val_f) nil +Pair_Pair (ImGuiID,void*) (ImGuiID _key,void* _val_p) (ImGuiID _key,void* _val_p) (_key,_val_p) nil +ImGuiPayload_ImGuiPayload () () () () nil +ImColor_ImColor () () () () nil +ImColor_ImColor (int,int,int,int) (int r,int g,int b,int a=255) (int r,int g,int b,int a) (r,g,b,a) nil +ImColor_ImColor (ImU32) (ImU32 rgba) (ImU32 rgba) (rgba) nil +ImColor_ImColor (float,float,float,float) (float r,float g,float b,float a=1.0f) (float r,float g,float b,float a) (r,g,b,a) nil +ImColor_ImColor (const ImVec4) (const ImVec4& col) (const ImVec4 col) (col) nil +ImGuiListClipper_ImGuiListClipper (int,float) (int items_count=-1,float items_height=-1.0f) (int items_count,float items_height) (items_count,items_height) nil +ImGuiListClipper_~ImGuiListClipper () () () () nil +ImDrawCmd_ImDrawCmd () () () () nil +ImDrawList_ImDrawList (const ImDrawListSharedData*) (const ImDrawListSharedData* shared_data) (const ImDrawListSharedData* shared_data) (shared_data) nil +ImDrawList_~ImDrawList () () () () nil +ImDrawData_ImDrawData () () () () nil +ImDrawData_~ImDrawData () () () () nil +ImFontConfig_ImFontConfig () () () () nil +ImFontAtlas_ImFontAtlas () () () () nil +ImFontAtlas_~ImFontAtlas () () () () nil +GlyphRangesBuilder_GlyphRangesBuilder () () () () nil +CustomRect_CustomRect () () () () nil +ImFont_ImFont () () () () nil +ImFont_~ImFont () () () () nil +//------------------------------------------------------------------------------------- diff --git a/cimgui/gen_imgui_funcs.bat b/cimgui/generator/gen_imgui_funcs.bat similarity index 56% rename from cimgui/gen_imgui_funcs.bat rename to cimgui/generator/gen_imgui_funcs.bat index ea6af61..033627d 100644 --- a/cimgui/gen_imgui_funcs.bat +++ b/cimgui/generator/gen_imgui_funcs.bat @@ -2,7 +2,7 @@ rem this is used to rebuild imgui_structs.h rem set your PATH if necessary for gcc and lua with: set PATH=%PATH%;C:\mingw32\bin;C:\luaGL; -gcc -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS ../imgui/imgui.h | luajit.exe ./gen_imgui_funcs.lua > auto_funcs.txt +gcc -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS ../../imgui/imgui.h | luajit.exe ./gen_imgui_funcs.lua > auto_funcs.txt cmd /k diff --git a/cimgui/gen_imgui_funcs.lua b/cimgui/generator/gen_imgui_funcs.lua similarity index 100% rename from cimgui/gen_imgui_funcs.lua rename to cimgui/generator/gen_imgui_funcs.lua diff --git a/cimgui/gen_imgui_structs.bat b/cimgui/generator/gen_imgui_structs.bat similarity index 70% rename from cimgui/gen_imgui_structs.bat rename to cimgui/generator/gen_imgui_structs.bat index a04fe9b..63e703e 100644 --- a/cimgui/gen_imgui_structs.bat +++ b/cimgui/generator/gen_imgui_structs.bat @@ -2,7 +2,7 @@ rem this is used to rebuild imgui_structs.h rem set your PATH if necessary for gcc and lua with: set PATH=%PATH%;C:\mingw32\bin;C:\luaGL; -gcc -E ../imgui/imgui.h | luajit.exe ./gen_imgui_structs.lua > imgui_structs.h +gcc -E ../../imgui/imgui.h | luajit.exe ./gen_imgui_structs.lua > imgui_structs.h rem gcc -E ../imgui/imgui.h > imgui_structs.raw cmd /k diff --git a/cimgui/gen_imgui_structs.lua b/cimgui/generator/gen_imgui_structs.lua similarity index 100% rename from cimgui/gen_imgui_structs.lua rename to cimgui/generator/gen_imgui_structs.lua diff --git a/cimgui/generator/imgui_structs.h b/cimgui/generator/imgui_structs.h new file mode 100644 index 0000000..9fe26a1 --- /dev/null +++ b/cimgui/generator/imgui_structs.h @@ -0,0 +1,752 @@ +/////////////// BEGIN AUTOGENERATED SEGMENT +#ifndef IMGUI_STRUCTS_INCLUDED +#define IMGUI_STRUCTS_INCLUDED + +struct ImDrawChannel; +typedef struct ImDrawChannel ImDrawChannel; +struct ImDrawCmd; +typedef struct ImDrawCmd ImDrawCmd; +struct ImDrawData; +typedef struct ImDrawData ImDrawData; +struct ImDrawList; +typedef struct ImDrawList ImDrawList; +struct ImDrawListSharedData; +typedef struct ImDrawListSharedData ImDrawListSharedData; +struct ImDrawVert; +typedef struct ImDrawVert ImDrawVert; +struct ImFont; +typedef struct ImFont ImFont; +struct ImFontAtlas; +typedef struct ImFontAtlas ImFontAtlas; +struct ImFontConfig; +typedef struct ImFontConfig ImFontConfig; +struct ImColor; +typedef struct ImColor ImColor; +struct ImGuiIO; +typedef struct ImGuiIO ImGuiIO; +struct ImGuiOnceUponAFrame; +typedef struct ImGuiOnceUponAFrame ImGuiOnceUponAFrame; +struct ImGuiStorage; +typedef struct ImGuiStorage ImGuiStorage; +struct ImGuiStyle; +typedef struct ImGuiStyle ImGuiStyle; +struct ImGuiTextFilter; +typedef struct ImGuiTextFilter ImGuiTextFilter; +struct ImGuiTextBuffer; +typedef struct ImGuiTextBuffer ImGuiTextBuffer; +struct ImGuiTextEditCallbackData; +typedef struct ImGuiTextEditCallbackData ImGuiTextEditCallbackData; +struct ImGuiSizeCallbackData; +typedef struct ImGuiSizeCallbackData ImGuiSizeCallbackData; +struct ImGuiListClipper; +typedef struct ImGuiListClipper ImGuiListClipper; +struct ImGuiPayload; +typedef struct ImGuiPayload ImGuiPayload; +struct ImGuiContext; +typedef struct ImGuiContext ImGuiContext; +typedef void* ImTextureID; +typedef unsigned int ImU32; +typedef unsigned int ImGuiID; +typedef unsigned short ImWchar; +typedef int ImGuiCol; +typedef int ImGuiDir; +typedef int ImGuiCond; +typedef int ImGuiKey; +typedef int ImGuiNavInput; +typedef int ImGuiMouseCursor; +typedef int ImGuiStyleVar; +typedef int ImDrawCornerFlags; +typedef int ImDrawListFlags; +typedef int ImFontAtlasFlags; +typedef int ImGuiBackendFlags; +typedef int ImGuiColorEditFlags; +typedef int ImGuiColumnsFlags; +typedef int ImGuiConfigFlags; +typedef int ImGuiDragDropFlags; +typedef int ImGuiComboFlags; +typedef int ImGuiFocusedFlags; +typedef int ImGuiHoveredFlags; +typedef int ImGuiInputTextFlags; +typedef int ImGuiSelectableFlags; +typedef int ImGuiTreeNodeFlags; +typedef int ImGuiWindowFlags; +typedef int (*ImGuiTextEditCallback)(ImGuiTextEditCallbackData *data); +typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data); +typedef unsigned long long ImU64; +struct ImVec2 +{ + float x, y; +}; +typedef struct ImVec2 ImVec2; +struct ImVec4 +{ + float x, y, z, w; +}; +typedef struct ImVec4 ImVec4; +enum ImGuiWindowFlags_ +{ + ImGuiWindowFlags_NoTitleBar = 1 << 0, + ImGuiWindowFlags_NoResize = 1 << 1, + ImGuiWindowFlags_NoMove = 1 << 2, + ImGuiWindowFlags_NoScrollbar = 1 << 3, + ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, + ImGuiWindowFlags_NoCollapse = 1 << 5, + ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, + ImGuiWindowFlags_NoSavedSettings = 1 << 8, + ImGuiWindowFlags_NoInputs = 1 << 9, + ImGuiWindowFlags_MenuBar = 1 << 10, + ImGuiWindowFlags_HorizontalScrollbar = 1 << 11, + ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12, + ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, + ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14, + ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15, + ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16, + ImGuiWindowFlags_ResizeFromAnySide = 1 << 17, + ImGuiWindowFlags_NoNavInputs = 1 << 18, + ImGuiWindowFlags_NoNavFocus = 1 << 19, + ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NavFlattened = 1 << 23, + ImGuiWindowFlags_ChildWindow = 1 << 24, + ImGuiWindowFlags_Tooltip = 1 << 25, + ImGuiWindowFlags_Popup = 1 << 26, + ImGuiWindowFlags_Modal = 1 << 27, + ImGuiWindowFlags_ChildMenu = 1 << 28 +}; +enum ImGuiInputTextFlags_ +{ + ImGuiInputTextFlags_CharsDecimal = 1 << 0, + ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, + ImGuiInputTextFlags_CharsUppercase = 1 << 2, + ImGuiInputTextFlags_CharsNoBlank = 1 << 3, + ImGuiInputTextFlags_AutoSelectAll = 1 << 4, + ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, + ImGuiInputTextFlags_CallbackCompletion = 1 << 6, + ImGuiInputTextFlags_CallbackHistory = 1 << 7, + ImGuiInputTextFlags_CallbackAlways = 1 << 8, + ImGuiInputTextFlags_CallbackCharFilter = 1 << 9, + ImGuiInputTextFlags_AllowTabInput = 1 << 10, + ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11, + ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12, + ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13, + ImGuiInputTextFlags_ReadOnly = 1 << 14, + ImGuiInputTextFlags_Password = 1 << 15, + ImGuiInputTextFlags_NoUndoRedo = 1 << 16, + ImGuiInputTextFlags_CharsScientific = 1 << 17, + ImGuiInputTextFlags_Multiline = 1 << 20 +}; +enum ImGuiTreeNodeFlags_ +{ + ImGuiTreeNodeFlags_Selected = 1 << 0, + ImGuiTreeNodeFlags_Framed = 1 << 1, + ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2, + ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, + ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, + ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, + ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6, + ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7, + ImGuiTreeNodeFlags_Leaf = 1 << 8, + ImGuiTreeNodeFlags_Bullet = 1 << 9, + ImGuiTreeNodeFlags_FramePadding = 1 << 10, + ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13, + ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoAutoOpenOnLog + , ImGuiTreeNodeFlags_AllowOverlapMode = ImGuiTreeNodeFlags_AllowItemOverlap +}; +enum ImGuiSelectableFlags_ +{ + ImGuiSelectableFlags_DontClosePopups = 1 << 0, + ImGuiSelectableFlags_SpanAllColumns = 1 << 1, + ImGuiSelectableFlags_AllowDoubleClick = 1 << 2 +}; +enum ImGuiComboFlags_ +{ + ImGuiComboFlags_PopupAlignLeft = 1 << 0, + ImGuiComboFlags_HeightSmall = 1 << 1, + ImGuiComboFlags_HeightRegular = 1 << 2, + ImGuiComboFlags_HeightLarge = 1 << 3, + ImGuiComboFlags_HeightLargest = 1 << 4, + ImGuiComboFlags_NoArrowButton = 1 << 5, + ImGuiComboFlags_NoPreview = 1 << 6, + ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest +}; +enum ImGuiFocusedFlags_ +{ + ImGuiFocusedFlags_ChildWindows = 1 << 0, + ImGuiFocusedFlags_RootWindow = 1 << 1, + ImGuiFocusedFlags_AnyWindow = 1 << 2, + ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows +}; +enum ImGuiHoveredFlags_ +{ + ImGuiHoveredFlags_Default = 0, + ImGuiHoveredFlags_ChildWindows = 1 << 0, + ImGuiHoveredFlags_RootWindow = 1 << 1, + ImGuiHoveredFlags_AnyWindow = 1 << 2, + ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3, + ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5, + ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6, + ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped, + ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows +}; +enum ImGuiDragDropFlags_ +{ + ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0, + ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1, + ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2, + ImGuiDragDropFlags_SourceAllowNullID = 1 << 3, + ImGuiDragDropFlags_SourceExtern = 1 << 4, + ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10, + ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11, + ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect +}; +enum ImGuiDir_ +{ + ImGuiDir_None = -1, + ImGuiDir_Left = 0, + ImGuiDir_Right = 1, + ImGuiDir_Up = 2, + ImGuiDir_Down = 3, + ImGuiDir_COUNT +}; +enum ImGuiKey_ +{ + ImGuiKey_Tab, + ImGuiKey_LeftArrow, + ImGuiKey_RightArrow, + ImGuiKey_UpArrow, + ImGuiKey_DownArrow, + ImGuiKey_PageUp, + ImGuiKey_PageDown, + ImGuiKey_Home, + ImGuiKey_End, + ImGuiKey_Insert, + ImGuiKey_Delete, + ImGuiKey_Backspace, + ImGuiKey_Space, + ImGuiKey_Enter, + ImGuiKey_Escape, + ImGuiKey_A, + ImGuiKey_C, + ImGuiKey_V, + ImGuiKey_X, + ImGuiKey_Y, + ImGuiKey_Z, + ImGuiKey_COUNT +}; +enum ImGuiNavInput_ +{ + ImGuiNavInput_Activate, + ImGuiNavInput_Cancel, + ImGuiNavInput_Input, + ImGuiNavInput_Menu, + ImGuiNavInput_DpadLeft, + ImGuiNavInput_DpadRight, + ImGuiNavInput_DpadUp, + ImGuiNavInput_DpadDown, + ImGuiNavInput_LStickLeft, + ImGuiNavInput_LStickRight, + ImGuiNavInput_LStickUp, + ImGuiNavInput_LStickDown, + ImGuiNavInput_FocusPrev, + ImGuiNavInput_FocusNext, + ImGuiNavInput_TweakSlow, + ImGuiNavInput_TweakFast, + ImGuiNavInput_KeyMenu_, + ImGuiNavInput_KeyLeft_, + ImGuiNavInput_KeyRight_, + ImGuiNavInput_KeyUp_, + ImGuiNavInput_KeyDown_, + ImGuiNavInput_COUNT, + ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_ +}; +enum ImGuiConfigFlags_ +{ + ImGuiConfigFlags_NavEnableKeyboard = 1 << 0, + ImGuiConfigFlags_NavEnableGamepad = 1 << 1, + ImGuiConfigFlags_NavEnableSetMousePos = 1 << 2, + ImGuiConfigFlags_NavNoCaptureKeyboard = 1 << 3, + ImGuiConfigFlags_NoMouse = 1 << 4, + ImGuiConfigFlags_NoMouseCursorChange = 1 << 5, + ImGuiConfigFlags_IsSRGB = 1 << 20, + ImGuiConfigFlags_IsTouchScreen = 1 << 21 +}; +enum ImGuiBackendFlags_ +{ + ImGuiBackendFlags_HasGamepad = 1 << 0, + ImGuiBackendFlags_HasMouseCursors = 1 << 1, + ImGuiBackendFlags_HasSetMousePos = 1 << 2 +}; +enum ImGuiCol_ +{ + ImGuiCol_Text, + ImGuiCol_TextDisabled, + ImGuiCol_WindowBg, + ImGuiCol_ChildBg, + ImGuiCol_PopupBg, + ImGuiCol_Border, + ImGuiCol_BorderShadow, + ImGuiCol_FrameBg, + ImGuiCol_FrameBgHovered, + ImGuiCol_FrameBgActive, + ImGuiCol_TitleBg, + ImGuiCol_TitleBgActive, + ImGuiCol_TitleBgCollapsed, + ImGuiCol_MenuBarBg, + ImGuiCol_ScrollbarBg, + ImGuiCol_ScrollbarGrab, + ImGuiCol_ScrollbarGrabHovered, + ImGuiCol_ScrollbarGrabActive, + ImGuiCol_CheckMark, + ImGuiCol_SliderGrab, + ImGuiCol_SliderGrabActive, + ImGuiCol_Button, + ImGuiCol_ButtonHovered, + ImGuiCol_ButtonActive, + ImGuiCol_Header, + ImGuiCol_HeaderHovered, + ImGuiCol_HeaderActive, + ImGuiCol_Separator, + ImGuiCol_SeparatorHovered, + ImGuiCol_SeparatorActive, + ImGuiCol_ResizeGrip, + ImGuiCol_ResizeGripHovered, + ImGuiCol_ResizeGripActive, + ImGuiCol_PlotLines, + ImGuiCol_PlotLinesHovered, + ImGuiCol_PlotHistogram, + ImGuiCol_PlotHistogramHovered, + ImGuiCol_TextSelectedBg, + ImGuiCol_ModalWindowDarkening, + ImGuiCol_DragDropTarget, + ImGuiCol_NavHighlight, + ImGuiCol_NavWindowingHighlight, + ImGuiCol_COUNT + , ImGuiCol_ChildWindowBg = ImGuiCol_ChildBg, ImGuiCol_Column = ImGuiCol_Separator, ImGuiCol_ColumnHovered = ImGuiCol_SeparatorHovered, ImGuiCol_ColumnActive = ImGuiCol_SeparatorActive +}; +enum ImGuiStyleVar_ +{ + ImGuiStyleVar_Alpha, + ImGuiStyleVar_WindowPadding, + ImGuiStyleVar_WindowRounding, + ImGuiStyleVar_WindowBorderSize, + ImGuiStyleVar_WindowMinSize, + ImGuiStyleVar_WindowTitleAlign, + ImGuiStyleVar_ChildRounding, + ImGuiStyleVar_ChildBorderSize, + ImGuiStyleVar_PopupRounding, + ImGuiStyleVar_PopupBorderSize, + ImGuiStyleVar_FramePadding, + ImGuiStyleVar_FrameRounding, + ImGuiStyleVar_FrameBorderSize, + ImGuiStyleVar_ItemSpacing, + ImGuiStyleVar_ItemInnerSpacing, + ImGuiStyleVar_IndentSpacing, + ImGuiStyleVar_ScrollbarSize, + ImGuiStyleVar_ScrollbarRounding, + ImGuiStyleVar_GrabMinSize, + ImGuiStyleVar_GrabRounding, + ImGuiStyleVar_ButtonTextAlign, + ImGuiStyleVar_COUNT + , ImGuiStyleVar_Count_ = ImGuiStyleVar_COUNT, ImGuiStyleVar_ChildWindowRounding = ImGuiStyleVar_ChildRounding +}; +enum ImGuiColorEditFlags_ +{ + ImGuiColorEditFlags_NoAlpha = 1 << 1, + ImGuiColorEditFlags_NoPicker = 1 << 2, + ImGuiColorEditFlags_NoOptions = 1 << 3, + ImGuiColorEditFlags_NoSmallPreview = 1 << 4, + ImGuiColorEditFlags_NoInputs = 1 << 5, + ImGuiColorEditFlags_NoTooltip = 1 << 6, + ImGuiColorEditFlags_NoLabel = 1 << 7, + ImGuiColorEditFlags_NoSidePreview = 1 << 8, + ImGuiColorEditFlags_AlphaBar = 1 << 9, + ImGuiColorEditFlags_AlphaPreview = 1 << 10, + ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 11, + ImGuiColorEditFlags_HDR = 1 << 12, + ImGuiColorEditFlags_RGB = 1 << 13, + ImGuiColorEditFlags_HSV = 1 << 14, + ImGuiColorEditFlags_HEX = 1 << 15, + ImGuiColorEditFlags_Uint8 = 1 << 16, + ImGuiColorEditFlags_Float = 1 << 17, + ImGuiColorEditFlags_PickerHueBar = 1 << 18, + ImGuiColorEditFlags_PickerHueWheel = 1 << 19, + ImGuiColorEditFlags__InputsMask = ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_HSV|ImGuiColorEditFlags_HEX, + ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float, + ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_PickerHueBar +}; +enum ImGuiMouseCursor_ +{ + ImGuiMouseCursor_None = -1, + ImGuiMouseCursor_Arrow = 0, + ImGuiMouseCursor_TextInput, + ImGuiMouseCursor_ResizeAll, + ImGuiMouseCursor_ResizeNS, + ImGuiMouseCursor_ResizeEW, + ImGuiMouseCursor_ResizeNESW, + ImGuiMouseCursor_ResizeNWSE, + ImGuiMouseCursor_COUNT + , ImGuiMouseCursor_Count_ = ImGuiMouseCursor_COUNT +}; +enum ImGuiCond_ +{ + ImGuiCond_Always = 1 << 0, + ImGuiCond_Once = 1 << 1, + ImGuiCond_FirstUseEver = 1 << 2, + ImGuiCond_Appearing = 1 << 3 + , ImGuiSetCond_Always = ImGuiCond_Always, ImGuiSetCond_Once = ImGuiCond_Once, ImGuiSetCond_FirstUseEver = ImGuiCond_FirstUseEver, ImGuiSetCond_Appearing = ImGuiCond_Appearing +}; +struct ImGuiStyle +{ + float Alpha; + ImVec2 WindowPadding; + float WindowRounding; + float WindowBorderSize; + ImVec2 WindowMinSize; + ImVec2 WindowTitleAlign; + float ChildRounding; + float ChildBorderSize; + float PopupRounding; + float PopupBorderSize; + ImVec2 FramePadding; + float FrameRounding; + float FrameBorderSize; + ImVec2 ItemSpacing; + ImVec2 ItemInnerSpacing; + ImVec2 TouchExtraPadding; + float IndentSpacing; + float ColumnsMinSpacing; + float ScrollbarSize; + float ScrollbarRounding; + float GrabMinSize; + float GrabRounding; + ImVec2 ButtonTextAlign; + ImVec2 DisplayWindowPadding; + ImVec2 DisplaySafeAreaPadding; + float MouseCursorScale; + bool AntiAliasedLines; + bool AntiAliasedFill; + float CurveTessellationTol; + ImVec4 Colors[ImGuiCol_COUNT]; +}; +typedef struct ImGuiStyle ImGuiStyle; +struct ImGuiIO +{ + ImGuiConfigFlags ConfigFlags; + ImGuiBackendFlags BackendFlags; + ImVec2 DisplaySize; + float DeltaTime; + float IniSavingRate; + const char* IniFilename; + const char* LogFilename; + float MouseDoubleClickTime; + float MouseDoubleClickMaxDist; + float MouseDragThreshold; + int KeyMap[ImGuiKey_COUNT]; + float KeyRepeatDelay; + float KeyRepeatRate; + void* UserData; + ImFontAtlas* Fonts; + float FontGlobalScale; + bool FontAllowUserScaling; + ImFont* FontDefault; + ImVec2 DisplayFramebufferScale; + ImVec2 DisplayVisibleMin; + ImVec2 DisplayVisibleMax; + bool OptMacOSXBehaviors; + bool OptCursorBlink; + const char* (*GetClipboardTextFn)(void* user_data); + void (*SetClipboardTextFn)(void* user_data, const char* text); + void* ClipboardUserData; + void (*ImeSetInputScreenPosFn)(int x, int y); + void* ImeWindowHandle; + void (*RenderDrawListsFn)(ImDrawData* data); + ImVec2 MousePos; + bool MouseDown[5]; + float MouseWheel; + float MouseWheelH; + bool MouseDrawCursor; + bool KeyCtrl; + bool KeyShift; + bool KeyAlt; + bool KeySuper; + bool KeysDown[512]; + ImWchar InputCharacters[16+1]; + float NavInputs[ImGuiNavInput_COUNT]; + bool WantCaptureMouse; + bool WantCaptureKeyboard; + bool WantTextInput; + bool WantSetMousePos; + bool NavActive; + bool NavVisible; + float Framerate; + int MetricsRenderVertices; + int MetricsRenderIndices; + int MetricsActiveWindows; + ImVec2 MouseDelta; + ImVec2 MousePosPrev; + ImVec2 MouseClickedPos[5]; + float MouseClickedTime[5]; + bool MouseClicked[5]; + bool MouseDoubleClicked[5]; + bool MouseReleased[5]; + bool MouseDownOwned[5]; + float MouseDownDuration[5]; + float MouseDownDurationPrev[5]; + ImVec2 MouseDragMaxDistanceAbs[5]; + float MouseDragMaxDistanceSqr[5]; + float KeysDownDuration[512]; + float KeysDownDurationPrev[512]; + float NavInputsDownDuration[ImGuiNavInput_COUNT]; + float NavInputsDownDurationPrev[ImGuiNavInput_COUNT]; +}; +typedef struct ImGuiIO ImGuiIO; +struct ImVector +{ + int Size; + int Capacity; + void* Data; +}; +typedef struct ImVector ImVector;struct ImNewDummy {}; +struct ImGuiOnceUponAFrame +{ + int RefFrame; +}; +typedef struct ImGuiOnceUponAFrame ImGuiOnceUponAFrame; +struct ImGuiTextFilter +{ + char InputBuf[256]; + ImVector/**/ Filters; + int CountGrep; +}; +typedef struct ImGuiTextFilter ImGuiTextFilter; +struct ImGuiTextBuffer +{ + ImVector/**/ Buf; +}; +typedef struct ImGuiTextBuffer ImGuiTextBuffer; +struct ImGuiStorage +{ + ImVector/**/ Data; +}; +typedef struct ImGuiStorage ImGuiStorage; +struct ImGuiTextEditCallbackData +{ + ImGuiInputTextFlags EventFlag; + ImGuiInputTextFlags Flags; + void* UserData; + bool ReadOnly; + ImWchar EventChar; + ImGuiKey EventKey; + char* Buf; + int BufTextLen; + int BufSize; + bool BufDirty; + int CursorPos; + int SelectionStart; + int SelectionEnd; +}; +typedef struct ImGuiTextEditCallbackData ImGuiTextEditCallbackData; +struct ImGuiSizeCallbackData +{ + void* UserData; + ImVec2 Pos; + ImVec2 CurrentSize; + ImVec2 DesiredSize; +}; +typedef struct ImGuiSizeCallbackData ImGuiSizeCallbackData; +struct ImGuiPayload +{ + const void* Data; + int DataSize; + ImGuiID SourceId; + ImGuiID SourceParentId; + int DataFrameCount; + char DataType[32+1]; + bool Preview; + bool Delivery; +}; +typedef struct ImGuiPayload ImGuiPayload; +struct ImColor +{ + ImVec4 Value; +}; +typedef struct ImColor ImColor; +struct ImGuiListClipper +{ + float StartPosY; + float ItemsHeight; + int ItemsCount, StepNo, DisplayStart, DisplayEnd; +}; +typedef struct ImGuiListClipper ImGuiListClipper; +typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd); +struct ImDrawCmd +{ + unsigned int ElemCount; + ImVec4 ClipRect; + ImTextureID TextureId; + ImDrawCallback UserCallback; + void* UserCallbackData; +}; +typedef struct ImDrawCmd ImDrawCmd; +typedef unsigned short ImDrawIdx; +struct ImDrawVert +{ + ImVec2 pos; + ImVec2 uv; + ImU32 col; +}; +typedef struct ImDrawVert ImDrawVert; +struct ImDrawChannel +{ + ImVector/**/ CmdBuffer; + ImVector/**/ IdxBuffer; +}; +typedef struct ImDrawChannel ImDrawChannel; +enum ImDrawCornerFlags_ +{ + ImDrawCornerFlags_TopLeft = 1 << 0, + ImDrawCornerFlags_TopRight = 1 << 1, + ImDrawCornerFlags_BotLeft = 1 << 2, + ImDrawCornerFlags_BotRight = 1 << 3, + ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight, + ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft, + ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_All = 0xF +}; +enum ImDrawListFlags_ +{ + ImDrawListFlags_AntiAliasedLines = 1 << 0, + ImDrawListFlags_AntiAliasedFill = 1 << 1 +}; +struct ImDrawList +{ + ImVector/**/ CmdBuffer; + ImVector/**/ IdxBuffer; + ImVector/**/ VtxBuffer; + ImDrawListFlags Flags; + const ImDrawListSharedData* _Data; + const char* _OwnerName; + unsigned int _VtxCurrentIdx; + ImDrawVert* _VtxWritePtr; + ImDrawIdx* _IdxWritePtr; + ImVector/**/ _ClipRectStack; + ImVector/**/ _TextureIdStack; + ImVector/**/ _Path; + int _ChannelsCurrent; + int _ChannelsCount; + ImVector/**/ _Channels; +}; +typedef struct ImDrawList ImDrawList; +struct ImDrawData +{ + bool Valid; + ImDrawList** CmdLists; + int CmdListsCount; + int TotalIdxCount; + int TotalVtxCount; +}; +typedef struct ImDrawData ImDrawData; +struct ImFontConfig +{ + void* FontData; + int FontDataSize; + bool FontDataOwnedByAtlas; + int FontNo; + float SizePixels; + int OversampleH; + int OversampleV; + bool PixelSnapH; + ImVec2 GlyphExtraSpacing; + ImVec2 GlyphOffset; + const ImWchar* GlyphRanges; + bool MergeMode; + unsigned int RasterizerFlags; + float RasterizerMultiply; + char Name[40]; + ImFont* DstFont; +}; +typedef struct ImFontConfig ImFontConfig; +struct ImFontGlyph +{ + ImWchar Codepoint; + float AdvanceX; + float X0, Y0, X1, Y1; + float U0, V0, U1, V1; +}; +typedef struct ImFontGlyph ImFontGlyph; +enum ImFontAtlasFlags_ +{ + ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0, + ImFontAtlasFlags_NoMouseCursors = 1 << 1 +}; +struct ImFontAtlas +{ + ImFontAtlasFlags Flags; + ImTextureID TexID; + int TexDesiredWidth; + int TexGlyphPadding; + unsigned char* TexPixelsAlpha8; + unsigned int* TexPixelsRGBA32; + int TexWidth; + int TexHeight; + ImVec2 TexUvScale; + ImVec2 TexUvWhitePixel; + ImVector/**/ Fonts; + ImVector/**/ CustomRects; + ImVector/**/ ConfigData; + int CustomRectIds[1]; +}; +typedef struct ImFontAtlas ImFontAtlas; +struct ImFont +{ + float FontSize; + float Scale; + ImVec2 DisplayOffset; + ImVector/**/ Glyphs; + ImVector/**/ IndexAdvanceX; + ImVector/**/ IndexLookup; + const ImFontGlyph* FallbackGlyph; + float FallbackAdvanceX; + ImWchar FallbackChar; + short ConfigDataCount; + ImFontConfig* ConfigData; + ImFontAtlas* ContainerAtlas; + float Ascent, Descent; + bool DirtyLookupTables; + int MetricsTotalSurface; +}; +typedef struct ImFont ImFont; + struct GlyphRangesBuilder + { + ImVector/**/ UsedChars; + }; +typedef struct GlyphRangesBuilder GlyphRangesBuilder; + + struct CustomRect + { + unsigned int ID; + unsigned short Width, Height; + unsigned short X, Y; + float GlyphAdvanceX; + ImVec2 GlyphOffset; + ImFont* Font; + }; +typedef struct CustomRect CustomRect; + + struct TextRange + { + const char* b; + const char* e; + }; +typedef struct TextRange TextRange; + + struct Pair + { + ImGuiID key; + union { int val_i; float val_f; void* val_p; }; + }; +typedef struct Pair Pair; + +#endif //IMGUI_STRUCTS_INCLUDED +//////////////// END AUTOGENERATED SEGMENT