//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
//based on imgui.h file version "1.92.5" 19250 from Dear ImGui https://github.com/ocornut/imgui
//with imgui_internal.h api
//with imgui_freetype.h api
//docking branch

#include "./imgui/imgui.h"
#include "./imgui/imgui_internal.h"
#include "cimgui.h"



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

CIMGUI_API void ImGuiFreeType_SetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)
{
    return ImGuiFreeType::SetAllocatorFunctions(alloc_func,free_func,user_data);
}

CIMGUI_API bool ImGuiFreeType_DebugEditFontLoaderFlags(ImGuiFreeTypeLoaderFlags* p_font_loader_flags)
{
    return ImGuiFreeType::DebugEditFontLoaderFlags(p_font_loader_flags);
}

#endif



/////////////////////////////manual written functions

CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    self->appendfv(fmt, args);
    va_end(args);
}

CIMGUI_API float igGET_FLT_MAX()
{
    return FLT_MAX;
}

CIMGUI_API float igGET_FLT_MIN()
{
    return FLT_MIN;
}


CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
{
	return IM_NEW(ImVector<ImWchar>) ();
}

CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
{
    IM_DELETE(self);
}

CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
{
	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
}
CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p)
{
	p->~ImVector<ImWchar>();
}


#ifdef IMGUI_HAS_DOCK

// NOTE: Some function pointers in the ImGuiPlatformIO structure are not C-compatible because of their
// use of a complex return type. To work around this, we store a custom CimguiStorage object inside
// ImGuiIO::BackendLanguageUserData, which contains C-compatible function pointer variants for these
// functions. When a user function pointer is provided, we hook up the underlying ImGuiPlatformIO
// function pointer to a thunk which accesses the user function pointer through CimguiStorage.

struct CimguiStorage
{
    void(*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
    void(*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
};

// Gets a reference to the CimguiStorage object stored in the current ImGui context's BackendLanguageUserData.
CimguiStorage& GetCimguiStorage()
{
    ImGuiIO& io = ImGui::GetIO();
    if (io.BackendLanguageUserData == NULL)
    {
        io.BackendLanguageUserData = IM_NEW(CimguiStorage)();
    }

    return *(CimguiStorage*)io.BackendLanguageUserData;
}

// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp)
{
    ImVec2 pos;
    GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
    return pos;
};

// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowPos.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos))
{
    CimguiStorage& storage = GetCimguiStorage();
    storage.Platform_GetWindowPos = user_callback;
    platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
}

// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp)
{
    ImVec2 size;
    GetCimguiStorage().Platform_GetWindowSize(vp, &size);
    return size;
};

// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowSize.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size))
{
    CimguiStorage& storage = GetCimguiStorage();
    storage.Platform_GetWindowSize = user_callback;
    platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
}

#endif
