cimgui.cpp

// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR.
// **DO NOT EDIT DIRECTLY**
// https://github.com/dearimgui/dear_bindings

#include "imgui.h"
#include "imgui_internal.h"

#include <stdio.h>
#include <stdarg.h>

// Wrap this in a namespace to keep it separate from the C++ API
namespace cimgui
{
#include "cimgui.h"
}

// Manual helpers
// These implement functionality that isn't in the original C++ API, but is useful to callers from other languages

CIMGUI_API void cimgui::ImVector_Construct(void* vector)
{
    // All ImVector classes are the same size, so it doesn't matter which we use for sizeof() here
    memset(vector, 0, sizeof(::ImVector<int>));
}

CIMGUI_API void cimgui::ImVector_Destruct(void* vector)
{
    // As with ImVector_construct(), it doesn't matter what the type parameter is here as we just want to get the
    // pointer and free it (without calling destructors or anything similar)
    ::ImVector<int>* real_vector = reinterpret_cast<::ImVector<int>*>(vector);
    if (real_vector->Data)
    {
        IM_FREE(real_vector->Data);
    }
}

#if defined(IMGUI_HAS_IMSTR)
#if IMGUI_HAS_IMSTR

// User-facing helper to convert char* to ImStr
CIMGUI_API cimgui::ImStr cimgui::ImStr_FromCharStr(const char* b)
{
    ImStr str;
    str.Begin = b;
    str.End = b ? b + strlen(b) : NULL;
    return str;
}

// Internal helper to convert char* directly to C++-style ImStr
static inline ::ImStr MarshalToCPP_ImStr_FromCharStr(const char* b)
{
    ::ImStr str;
    str.Begin = b;
    str.End = b ? b + strlen(b) : NULL;
    return str;
}
#endif // IMGUI_HAS_IMSTR
#endif // defined(IMGUI_HAS_IMSTR)
// By-value struct conversions

static inline cimgui::ImVec2 ConvertFromCPP_ImVec2(const ::ImVec2& src)
{
    cimgui::ImVec2 dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}

static inline ::ImVec2 ConvertToCPP_ImVec2(const cimgui::ImVec2& src)
{
    ::ImVec2 dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}

static inline cimgui::ImVec4 ConvertFromCPP_ImVec4(const ::ImVec4& src)
{
    cimgui::ImVec4 dest;
    dest.x = src.x;
    dest.y = src.y;
    dest.z = src.z;
    dest.w = src.w;
    return dest;
}

static inline ::ImVec4 ConvertToCPP_ImVec4(const cimgui::ImVec4& src)
{
    ::ImVec4 dest;
    dest.x = src.x;
    dest.y = src.y;
    dest.z = src.z;
    dest.w = src.w;
    return dest;
}

static inline cimgui::ImColor ConvertFromCPP_ImColor(const ::ImColor& src)
{
    cimgui::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 ConvertToCPP_ImColor(const cimgui::ImColor& 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;
}

// Function stubs

#ifndef IMGUI_DISABLE

CIMGUI_API cimgui::ImGuiContext* cimgui::ImGui_CreateContext(cimgui::ImFontAtlas* shared_font_atlas)
{
    return reinterpret_cast<::cimgui::ImGuiContext*>(ImGui::CreateContext(reinterpret_cast<::ImFontAtlas*>(shared_font_atlas)));
}

CIMGUI_API void          cimgui::ImGui_DestroyContext(cimgui::ImGuiContext* ctx)
{
    ImGui::DestroyContext(reinterpret_cast<::ImGuiContext*>(ctx));
}

CIMGUI_API cimgui::ImGuiContext* cimgui::ImGui_GetCurrentContext(void)
{
    return reinterpret_cast<::cimgui::ImGuiContext*>(ImGui::GetCurrentContext());
}

CIMGUI_API void          cimgui::ImGui_SetCurrentContext(cimgui::ImGuiContext* ctx)
{
    ImGui::SetCurrentContext(reinterpret_cast<::ImGuiContext*>(ctx));
}

CIMGUI_API cimgui::ImGuiIO* cimgui::ImGui_GetIO(void)
{
    return reinterpret_cast<::cimgui::ImGuiIO*>(&ImGui::GetIO());
}

CIMGUI_API cimgui::ImGuiStyle* cimgui::ImGui_GetStyle(void)
{
    return reinterpret_cast<::cimgui::ImGuiStyle*>(&ImGui::GetStyle());
}

CIMGUI_API void        cimgui::ImGui_NewFrame(void)
{
    ImGui::NewFrame();
}

CIMGUI_API void        cimgui::ImGui_EndFrame(void)
{
    ImGui::EndFrame();
}

CIMGUI_API void        cimgui::ImGui_Render(void)
{
    ImGui::Render();
}

CIMGUI_API cimgui::ImDrawData* cimgui::ImGui_GetDrawData(void)
{
    return reinterpret_cast<::cimgui::ImDrawData*>(ImGui::GetDrawData());
}

CIMGUI_API void        cimgui::ImGui_ShowDemoWindow(bool* p_open)
{
    ImGui::ShowDemoWindow(p_open);
}

CIMGUI_API void        cimgui::ImGui_ShowMetricsWindow(bool* p_open)
{
    ImGui::ShowMetricsWindow(p_open);
}

CIMGUI_API void        cimgui::ImGui_ShowDebugLogWindow(bool* p_open)
{
    ImGui::ShowDebugLogWindow(p_open);
}

CIMGUI_API void        cimgui::ImGui_ShowStackToolWindow(bool* p_open)
{
    ImGui::ShowStackToolWindow(p_open);
}

CIMGUI_API void        cimgui::ImGui_ShowAboutWindow(bool* p_open)
{
    ImGui::ShowAboutWindow(p_open);
}

CIMGUI_API void        cimgui::ImGui_ShowStyleEditor(cimgui::ImGuiStyle* ref)
{
    ImGui::ShowStyleEditor(reinterpret_cast<::ImGuiStyle*>(ref));
}

CIMGUI_API bool        cimgui::ImGui_ShowStyleSelector(const char* label)
{
    return ImGui::ShowStyleSelector(label);
}

CIMGUI_API void        cimgui::ImGui_ShowFontSelector(const char* label)
{
    ImGui::ShowFontSelector(label);
}

CIMGUI_API void        cimgui::ImGui_ShowUserGuide(void)
{
    ImGui::ShowUserGuide();
}

CIMGUI_API const char* cimgui::ImGui_GetVersion(void)
{
    return ImGui::GetVersion();
}

CIMGUI_API void cimgui::ImGui_StyleColorsDark(cimgui::ImGuiStyle* dst)
{
    ImGui::StyleColorsDark(reinterpret_cast<::ImGuiStyle*>(dst));
}

CIMGUI_API void cimgui::ImGui_StyleColorsLight(cimgui::ImGuiStyle* dst)
{
    ImGui::StyleColorsLight(reinterpret_cast<::ImGuiStyle*>(dst));
}

CIMGUI_API void cimgui::ImGui_StyleColorsClassic(cimgui::ImGuiStyle* dst)
{
    ImGui::StyleColorsClassic(reinterpret_cast<::ImGuiStyle*>(dst));
}

CIMGUI_API bool cimgui::ImGui_Begin(const char* name, bool* p_open, ImGuiWindowFlags flags)
{
    return ImGui::Begin(name, p_open, flags);
}

CIMGUI_API void cimgui::ImGui_End(void)
{
    ImGui::End();
}

CIMGUI_API bool cimgui::ImGui_BeginChild(const char* str_id, cimgui::ImVec2 size, bool border, ImGuiWindowFlags flags)
{
    return ImGui::BeginChild(str_id, ConvertToCPP_ImVec2(size), border, flags);
}

CIMGUI_API bool cimgui::ImGui_BeginChildID(ImGuiID id, cimgui::ImVec2 size, bool border, ImGuiWindowFlags flags)
{
    return ImGui::BeginChild(id, ConvertToCPP_ImVec2(size), border, flags);
}

CIMGUI_API void cimgui::ImGui_EndChild(void)
{
    ImGui::EndChild();
}

CIMGUI_API bool           cimgui::ImGui_IsWindowAppearing(void)
{
    return ImGui::IsWindowAppearing();
}

CIMGUI_API bool           cimgui::ImGui_IsWindowCollapsed(void)
{
    return ImGui::IsWindowCollapsed();
}

CIMGUI_API bool           cimgui::ImGui_IsWindowFocused(ImGuiFocusedFlags flags)
{
    return ImGui::IsWindowFocused(flags);
}

CIMGUI_API bool           cimgui::ImGui_IsWindowHovered(ImGuiHoveredFlags flags)
{
    return ImGui::IsWindowHovered(flags);
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetWindowDrawList(void)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(ImGui::GetWindowDrawList());
}

CIMGUI_API float          cimgui::ImGui_GetWindowDpiScale(void)
{
    return ImGui::GetWindowDpiScale();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetWindowPos(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetWindowPos());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetWindowSize(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetWindowSize());
}

CIMGUI_API float          cimgui::ImGui_GetWindowWidth(void)
{
    return ImGui::GetWindowWidth();
}

CIMGUI_API float          cimgui::ImGui_GetWindowHeight(void)
{
    return ImGui::GetWindowHeight();
}

CIMGUI_API cimgui::ImGuiViewport* cimgui::ImGui_GetWindowViewport(void)
{
    return reinterpret_cast<::cimgui::ImGuiViewport*>(ImGui::GetWindowViewport());
}

CIMGUI_API void cimgui::ImGui_SetNextWindowPos(cimgui::ImVec2 pos, ImGuiCond cond)
{
    ImGui::SetNextWindowPos(ConvertToCPP_ImVec2(pos), cond);
}

CIMGUI_API void cimgui::ImGui_SetNextWindowPosEx(cimgui::ImVec2 pos, ImGuiCond cond, cimgui::ImVec2 pivot)
{
    ImGui::SetNextWindowPos(ConvertToCPP_ImVec2(pos), cond, ConvertToCPP_ImVec2(pivot));
}

CIMGUI_API void cimgui::ImGui_SetNextWindowSize(cimgui::ImVec2 size, ImGuiCond cond)
{
    ImGui::SetNextWindowSize(ConvertToCPP_ImVec2(size), cond);
}

CIMGUI_API void cimgui::ImGui_SetNextWindowSizeConstraints(cimgui::ImVec2 size_min, cimgui::ImVec2 size_max, cimgui::ImGuiSizeCallback custom_callback, void* custom_callback_data)
{
    ImGui::SetNextWindowSizeConstraints(ConvertToCPP_ImVec2(size_min), ConvertToCPP_ImVec2(size_max), reinterpret_cast<::ImGuiSizeCallback>(custom_callback), custom_callback_data);
}

CIMGUI_API void cimgui::ImGui_SetNextWindowContentSize(cimgui::ImVec2 size)
{
    ImGui::SetNextWindowContentSize(ConvertToCPP_ImVec2(size));
}

CIMGUI_API void cimgui::ImGui_SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
{
    ImGui::SetNextWindowCollapsed(collapsed, cond);
}

CIMGUI_API void cimgui::ImGui_SetNextWindowFocus(void)
{
    ImGui::SetNextWindowFocus();
}

CIMGUI_API void cimgui::ImGui_SetNextWindowScroll(cimgui::ImVec2 scroll)
{
    ImGui::SetNextWindowScroll(ConvertToCPP_ImVec2(scroll));
}

CIMGUI_API void cimgui::ImGui_SetNextWindowBgAlpha(float alpha)
{
    ImGui::SetNextWindowBgAlpha(alpha);
}

CIMGUI_API void cimgui::ImGui_SetNextWindowViewport(ImGuiID viewport_id)
{
    ImGui::SetNextWindowViewport(viewport_id);
}

CIMGUI_API void cimgui::ImGui_SetWindowPos(cimgui::ImVec2 pos, ImGuiCond cond)
{
    ImGui::SetWindowPos(ConvertToCPP_ImVec2(pos), cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowSize(cimgui::ImVec2 size, ImGuiCond cond)
{
    ImGui::SetWindowSize(ConvertToCPP_ImVec2(size), cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowCollapsed(bool collapsed, ImGuiCond cond)
{
    ImGui::SetWindowCollapsed(collapsed, cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowFocus(void)
{
    ImGui::SetWindowFocus();
}

CIMGUI_API void cimgui::ImGui_SetWindowFontScale(float scale)
{
    ImGui::SetWindowFontScale(scale);
}

CIMGUI_API void cimgui::ImGui_SetWindowPosStr(const char* name, cimgui::ImVec2 pos, ImGuiCond cond)
{
    ImGui::SetWindowPos(name, ConvertToCPP_ImVec2(pos), cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowSizeStr(const char* name, cimgui::ImVec2 size, ImGuiCond cond)
{
    ImGui::SetWindowSize(name, ConvertToCPP_ImVec2(size), cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowCollapsedStr(const char* name, bool collapsed, ImGuiCond cond)
{
    ImGui::SetWindowCollapsed(name, collapsed, cond);
}

CIMGUI_API void cimgui::ImGui_SetWindowFocusStr(const char* name)
{
    ImGui::SetWindowFocus(name);
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetContentRegionAvail(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetContentRegionAvail());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetContentRegionMax(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetContentRegionMax());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetWindowContentRegionMin(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetWindowContentRegionMin());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetWindowContentRegionMax(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetWindowContentRegionMax());
}

CIMGUI_API float cimgui::ImGui_GetScrollX(void)
{
    return ImGui::GetScrollX();
}

CIMGUI_API float cimgui::ImGui_GetScrollY(void)
{
    return ImGui::GetScrollY();
}

CIMGUI_API void  cimgui::ImGui_SetScrollX(float scroll_x)
{
    ImGui::SetScrollX(scroll_x);
}

CIMGUI_API void  cimgui::ImGui_SetScrollY(float scroll_y)
{
    ImGui::SetScrollY(scroll_y);
}

CIMGUI_API float cimgui::ImGui_GetScrollMaxX(void)
{
    return ImGui::GetScrollMaxX();
}

CIMGUI_API float cimgui::ImGui_GetScrollMaxY(void)
{
    return ImGui::GetScrollMaxY();
}

CIMGUI_API void  cimgui::ImGui_SetScrollHereX(float center_x_ratio)
{
    ImGui::SetScrollHereX(center_x_ratio);
}

CIMGUI_API void  cimgui::ImGui_SetScrollHereY(float center_y_ratio)
{
    ImGui::SetScrollHereY(center_y_ratio);
}

CIMGUI_API void  cimgui::ImGui_SetScrollFromPosX(float local_x, float center_x_ratio)
{
    ImGui::SetScrollFromPosX(local_x, center_x_ratio);
}

CIMGUI_API void  cimgui::ImGui_SetScrollFromPosY(float local_y, float center_y_ratio)
{
    ImGui::SetScrollFromPosY(local_y, center_y_ratio);
}

CIMGUI_API void cimgui::ImGui_PushFont(cimgui::ImFont* font)
{
    ImGui::PushFont(reinterpret_cast<::ImFont*>(font));
}

CIMGUI_API void cimgui::ImGui_PopFont(void)
{
    ImGui::PopFont();
}

CIMGUI_API void cimgui::ImGui_PushStyleColor(ImGuiCol idx, ImU32 col)
{
    ImGui::PushStyleColor(idx, col);
}

CIMGUI_API void cimgui::ImGui_PushStyleColorImVec4(ImGuiCol idx, cimgui::ImVec4 col)
{
    ImGui::PushStyleColor(idx, ConvertToCPP_ImVec4(col));
}

CIMGUI_API void cimgui::ImGui_PopStyleColor(void)
{
    ImGui::PopStyleColor();
}

CIMGUI_API void cimgui::ImGui_PopStyleColorEx(int count)
{
    ImGui::PopStyleColor(count);
}

CIMGUI_API void cimgui::ImGui_PushStyleVar(ImGuiStyleVar idx, float val)
{
    ImGui::PushStyleVar(idx, val);
}

CIMGUI_API void cimgui::ImGui_PushStyleVarImVec2(ImGuiStyleVar idx, cimgui::ImVec2 val)
{
    ImGui::PushStyleVar(idx, ConvertToCPP_ImVec2(val));
}

CIMGUI_API void cimgui::ImGui_PopStyleVar(void)
{
    ImGui::PopStyleVar();
}

CIMGUI_API void cimgui::ImGui_PopStyleVarEx(int count)
{
    ImGui::PopStyleVar(count);
}

CIMGUI_API void cimgui::ImGui_PushTabStop(bool tab_stop)
{
    ImGui::PushTabStop(tab_stop);
}

CIMGUI_API void cimgui::ImGui_PopTabStop(void)
{
    ImGui::PopTabStop();
}

CIMGUI_API void cimgui::ImGui_PushButtonRepeat(bool repeat)
{
    ImGui::PushButtonRepeat(repeat);
}

CIMGUI_API void cimgui::ImGui_PopButtonRepeat(void)
{
    ImGui::PopButtonRepeat();
}

CIMGUI_API void  cimgui::ImGui_PushItemWidth(float item_width)
{
    ImGui::PushItemWidth(item_width);
}

CIMGUI_API void  cimgui::ImGui_PopItemWidth(void)
{
    ImGui::PopItemWidth();
}

CIMGUI_API void  cimgui::ImGui_SetNextItemWidth(float item_width)
{
    ImGui::SetNextItemWidth(item_width);
}

CIMGUI_API float cimgui::ImGui_CalcItemWidth(void)
{
    return ImGui::CalcItemWidth();
}

CIMGUI_API void  cimgui::ImGui_PushTextWrapPos(float wrap_local_pos_x)
{
    ImGui::PushTextWrapPos(wrap_local_pos_x);
}

CIMGUI_API void  cimgui::ImGui_PopTextWrapPos(void)
{
    ImGui::PopTextWrapPos();
}

CIMGUI_API cimgui::ImFont* cimgui::ImGui_GetFont(void)
{
    return reinterpret_cast<::cimgui::ImFont*>(ImGui::GetFont());
}

CIMGUI_API float         cimgui::ImGui_GetFontSize(void)
{
    return ImGui::GetFontSize();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetFontTexUvWhitePixel(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetFontTexUvWhitePixel());
}

CIMGUI_API ImU32         cimgui::ImGui_GetColorU32(ImGuiCol idx)
{
    return ImGui::GetColorU32(idx);
}

CIMGUI_API ImU32         cimgui::ImGui_GetColorU32Ex(ImGuiCol idx, float alpha_mul)
{
    return ImGui::GetColorU32(idx, alpha_mul);
}

CIMGUI_API ImU32         cimgui::ImGui_GetColorU32ImVec4(cimgui::ImVec4 col)
{
    return ImGui::GetColorU32(ConvertToCPP_ImVec4(col));
}

CIMGUI_API ImU32         cimgui::ImGui_GetColorU32ImU32(ImU32 col)
{
    return ImGui::GetColorU32(col);
}

CIMGUI_API const cimgui::ImVec4* cimgui::ImGui_GetStyleColorVec4(ImGuiCol idx)
{
    return reinterpret_cast<const ::cimgui::ImVec4*>(&ImGui::GetStyleColorVec4(idx));
}

CIMGUI_API void   cimgui::ImGui_Separator(void)
{
    ImGui::Separator();
}

CIMGUI_API void   cimgui::ImGui_SameLine(void)
{
    ImGui::SameLine();
}

CIMGUI_API void   cimgui::ImGui_SameLineEx(float offset_from_start_x, float spacing)
{
    ImGui::SameLine(offset_from_start_x, spacing);
}

CIMGUI_API void   cimgui::ImGui_NewLine(void)
{
    ImGui::NewLine();
}

CIMGUI_API void   cimgui::ImGui_Spacing(void)
{
    ImGui::Spacing();
}

CIMGUI_API void   cimgui::ImGui_Dummy(cimgui::ImVec2 size)
{
    ImGui::Dummy(ConvertToCPP_ImVec2(size));
}

CIMGUI_API void   cimgui::ImGui_Indent(void)
{
    ImGui::Indent();
}

CIMGUI_API void   cimgui::ImGui_IndentEx(float indent_w)
{
    ImGui::Indent(indent_w);
}

CIMGUI_API void   cimgui::ImGui_Unindent(void)
{
    ImGui::Unindent();
}

CIMGUI_API void   cimgui::ImGui_UnindentEx(float indent_w)
{
    ImGui::Unindent(indent_w);
}

CIMGUI_API void   cimgui::ImGui_BeginGroup(void)
{
    ImGui::BeginGroup();
}

CIMGUI_API void   cimgui::ImGui_EndGroup(void)
{
    ImGui::EndGroup();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetCursorPos(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetCursorPos());
}

CIMGUI_API float  cimgui::ImGui_GetCursorPosX(void)
{
    return ImGui::GetCursorPosX();
}

CIMGUI_API float  cimgui::ImGui_GetCursorPosY(void)
{
    return ImGui::GetCursorPosY();
}

CIMGUI_API void   cimgui::ImGui_SetCursorPos(cimgui::ImVec2 local_pos)
{
    ImGui::SetCursorPos(ConvertToCPP_ImVec2(local_pos));
}

CIMGUI_API void   cimgui::ImGui_SetCursorPosX(float local_x)
{
    ImGui::SetCursorPosX(local_x);
}

CIMGUI_API void   cimgui::ImGui_SetCursorPosY(float local_y)
{
    ImGui::SetCursorPosY(local_y);
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetCursorStartPos(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetCursorStartPos());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetCursorScreenPos(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetCursorScreenPos());
}

CIMGUI_API void   cimgui::ImGui_SetCursorScreenPos(cimgui::ImVec2 pos)
{
    ImGui::SetCursorScreenPos(ConvertToCPP_ImVec2(pos));
}

CIMGUI_API void   cimgui::ImGui_AlignTextToFramePadding(void)
{
    ImGui::AlignTextToFramePadding();
}

CIMGUI_API float  cimgui::ImGui_GetTextLineHeight(void)
{
    return ImGui::GetTextLineHeight();
}

CIMGUI_API float  cimgui::ImGui_GetTextLineHeightWithSpacing(void)
{
    return ImGui::GetTextLineHeightWithSpacing();
}

CIMGUI_API float  cimgui::ImGui_GetFrameHeight(void)
{
    return ImGui::GetFrameHeight();
}

CIMGUI_API float  cimgui::ImGui_GetFrameHeightWithSpacing(void)
{
    return ImGui::GetFrameHeightWithSpacing();
}

CIMGUI_API void    cimgui::ImGui_PushID(const char* str_id)
{
    ImGui::PushID(str_id);
}

CIMGUI_API void    cimgui::ImGui_PushIDStr(const char* str_id_begin, const char* str_id_end)
{
    ImGui::PushID(str_id_begin, str_id_end);
}

CIMGUI_API void    cimgui::ImGui_PushIDPtr(const void* ptr_id)
{
    ImGui::PushID(ptr_id);
}

CIMGUI_API void    cimgui::ImGui_PushIDInt(int int_id)
{
    ImGui::PushID(int_id);
}

CIMGUI_API void    cimgui::ImGui_PopID(void)
{
    ImGui::PopID();
}

CIMGUI_API ImGuiID cimgui::ImGui_GetID(const char* str_id)
{
    return ImGui::GetID(str_id);
}

CIMGUI_API ImGuiID cimgui::ImGui_GetIDStr(const char* str_id_begin, const char* str_id_end)
{
    return ImGui::GetID(str_id_begin, str_id_end);
}

CIMGUI_API ImGuiID cimgui::ImGui_GetIDPtr(const void* ptr_id)
{
    return ImGui::GetID(ptr_id);
}

CIMGUI_API void cimgui::ImGui_TextUnformatted(const char* text)
{
    ImGui::TextUnformatted(text);
}

CIMGUI_API void cimgui::ImGui_TextUnformattedEx(const char* text, const char* text_end)
{
    ImGui::TextUnformatted(text, text_end);
}

CIMGUI_API void cimgui::ImGui_Text(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::TextV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_TextV(const char* fmt, va_list args)
{
    ImGui::TextV(fmt, args);
}

CIMGUI_API void cimgui::ImGui_TextColored(cimgui::ImVec4 col, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::TextColoredV(ConvertToCPP_ImVec4(col), fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_TextColoredV(cimgui::ImVec4 col, const char* fmt, va_list args)
{
    ImGui::TextColoredV(ConvertToCPP_ImVec4(col), fmt, args);
}

CIMGUI_API void cimgui::ImGui_TextDisabled(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::TextDisabledV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_TextDisabledV(const char* fmt, va_list args)
{
    ImGui::TextDisabledV(fmt, args);
}

CIMGUI_API void cimgui::ImGui_TextWrapped(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::TextWrappedV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_TextWrappedV(const char* fmt, va_list args)
{
    ImGui::TextWrappedV(fmt, args);
}

CIMGUI_API void cimgui::ImGui_LabelText(const char* label, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::LabelTextV(label, fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_LabelTextV(const char* label, const char* fmt, va_list args)
{
    ImGui::LabelTextV(label, fmt, args);
}

CIMGUI_API void cimgui::ImGui_BulletText(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::BulletTextV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_BulletTextV(const char* fmt, va_list args)
{
    ImGui::BulletTextV(fmt, args);
}

CIMGUI_API void cimgui::ImGui_SeparatorText(const char* label)
{
    ImGui::SeparatorText(label);
}

CIMGUI_API bool cimgui::ImGui_Button(const char* label)
{
    return ImGui::Button(label);
}

CIMGUI_API bool cimgui::ImGui_ButtonEx(const char* label, cimgui::ImVec2 size)
{
    return ImGui::Button(label, ConvertToCPP_ImVec2(size));
}

CIMGUI_API bool cimgui::ImGui_SmallButton(const char* label)
{
    return ImGui::SmallButton(label);
}

CIMGUI_API bool cimgui::ImGui_InvisibleButton(const char* str_id, cimgui::ImVec2 size, ImGuiButtonFlags flags)
{
    return ImGui::InvisibleButton(str_id, ConvertToCPP_ImVec2(size), flags);
}

CIMGUI_API bool cimgui::ImGui_ArrowButton(const char* str_id, ImGuiDir dir)
{
    return ImGui::ArrowButton(str_id, dir);
}

CIMGUI_API bool cimgui::ImGui_Checkbox(const char* label, bool* v)
{
    return ImGui::Checkbox(label, v);
}

CIMGUI_API bool cimgui::ImGui_CheckboxFlagsIntPtr(const char* label, int* flags, int flags_value)
{
    return ImGui::CheckboxFlags(label, flags, flags_value);
}

CIMGUI_API bool cimgui::ImGui_CheckboxFlagsUintPtr(const char* label, unsigned int* flags, unsigned int flags_value)
{
    return ImGui::CheckboxFlags(label, flags, flags_value);
}

CIMGUI_API bool cimgui::ImGui_RadioButton(const char* label, bool active)
{
    return ImGui::RadioButton(label, active);
}

CIMGUI_API bool cimgui::ImGui_RadioButtonIntPtr(const char* label, int* v, int v_button)
{
    return ImGui::RadioButton(label, v, v_button);
}

CIMGUI_API void cimgui::ImGui_ProgressBar(float fraction, cimgui::ImVec2 size_arg, const char* overlay)
{
    ImGui::ProgressBar(fraction, ConvertToCPP_ImVec2(size_arg), overlay);
}

CIMGUI_API void cimgui::ImGui_Bullet(void)
{
    ImGui::Bullet();
}

CIMGUI_API void cimgui::ImGui_Image(ImTextureID user_texture_id, cimgui::ImVec2 size)
{
    ImGui::Image(user_texture_id, ConvertToCPP_ImVec2(size));
}

CIMGUI_API void cimgui::ImGui_ImageEx(ImTextureID user_texture_id, cimgui::ImVec2 size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 tint_col, cimgui::ImVec4 border_col)
{
    ImGui::Image(user_texture_id, ConvertToCPP_ImVec2(size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(tint_col), ConvertToCPP_ImVec4(border_col));
}

CIMGUI_API bool cimgui::ImGui_ImageButton(const char* str_id, ImTextureID user_texture_id, cimgui::ImVec2 size)
{
    return ImGui::ImageButton(str_id, user_texture_id, ConvertToCPP_ImVec2(size));
}

CIMGUI_API bool cimgui::ImGui_ImageButtonEx(const char* str_id, ImTextureID user_texture_id, cimgui::ImVec2 size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col)
{
    return ImGui::ImageButton(str_id, user_texture_id, ConvertToCPP_ImVec2(size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col));
}

CIMGUI_API bool cimgui::ImGui_BeginCombo(const char* label, const char* preview_value, ImGuiComboFlags flags)
{
    return ImGui::BeginCombo(label, preview_value, flags);
}

CIMGUI_API void cimgui::ImGui_EndCombo(void)
{
    ImGui::EndCombo();
}

CIMGUI_API bool cimgui::ImGui_ComboChar(const char* label, int* current_item, const char*const items[], int items_count)
{
    return ImGui::Combo(label, current_item, items, items_count);
}

CIMGUI_API bool cimgui::ImGui_ComboCharEx(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 cimgui::ImGui_Combo(const char* label, int* current_item, const char* items_separated_by_zeros)
{
    return ImGui::Combo(label, current_item, items_separated_by_zeros);
}

CIMGUI_API bool cimgui::ImGui_ComboEx(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 cimgui::ImGui_ComboCallback(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count)
{
    return ImGui::Combo(label, current_item, items_getter, data, items_count);
}

CIMGUI_API bool cimgui::ImGui_ComboCallbackEx(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int popup_max_height_in_items)
{
    return ImGui::Combo(label, current_item, items_getter, data, items_count, popup_max_height_in_items);
}

CIMGUI_API bool cimgui::ImGui_DragFloat(const char* label, float* v)
{
    return ImGui::DragFloat(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragFloatEx(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 cimgui::ImGui_DragFloat2(const char* label, float v[2])
{
    return ImGui::DragFloat2(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragFloat2Ex(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 cimgui::ImGui_DragFloat3(const char* label, float v[3])
{
    return ImGui::DragFloat3(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragFloat3Ex(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 cimgui::ImGui_DragFloat4(const char* label, float v[4])
{
    return ImGui::DragFloat4(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragFloat4Ex(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 cimgui::ImGui_DragFloatRange2(const char* label, float* v_current_min, float* v_current_max)
{
    return ImGui::DragFloatRange2(label, v_current_min, v_current_max);
}

CIMGUI_API bool cimgui::ImGui_DragFloatRange2Ex(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 cimgui::ImGui_DragInt(const char* label, int* v)
{
    return ImGui::DragInt(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragIntEx(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 cimgui::ImGui_DragInt2(const char* label, int v[2])
{
    return ImGui::DragInt2(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragInt2Ex(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 cimgui::ImGui_DragInt3(const char* label, int v[3])
{
    return ImGui::DragInt3(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragInt3Ex(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 cimgui::ImGui_DragInt4(const char* label, int v[4])
{
    return ImGui::DragInt4(label, v);
}

CIMGUI_API bool cimgui::ImGui_DragInt4Ex(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 cimgui::ImGui_DragIntRange2(const char* label, int* v_current_min, int* v_current_max)
{
    return ImGui::DragIntRange2(label, v_current_min, v_current_max);
}

CIMGUI_API bool cimgui::ImGui_DragIntRange2Ex(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 cimgui::ImGui_DragScalar(const char* label, ImGuiDataType data_type, void* p_data)
{
    return ImGui::DragScalar(label, data_type, p_data);
}

CIMGUI_API bool cimgui::ImGui_DragScalarEx(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 cimgui::ImGui_DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components)
{
    return ImGui::DragScalarN(label, data_type, p_data, components);
}

CIMGUI_API bool cimgui::ImGui_DragScalarNEx(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 cimgui::ImGui_SliderFloat(const char* label, float* v, float v_min, float v_max)
{
    return ImGui::SliderFloat(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderFloatEx(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 cimgui::ImGui_SliderFloat2(const char* label, float v[2], float v_min, float v_max)
{
    return ImGui::SliderFloat2(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderFloat2Ex(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 cimgui::ImGui_SliderFloat3(const char* label, float v[3], float v_min, float v_max)
{
    return ImGui::SliderFloat3(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderFloat3Ex(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 cimgui::ImGui_SliderFloat4(const char* label, float v[4], float v_min, float v_max)
{
    return ImGui::SliderFloat4(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderFloat4Ex(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 cimgui::ImGui_SliderAngle(const char* label, float* v_rad)
{
    return ImGui::SliderAngle(label, v_rad);
}

CIMGUI_API bool cimgui::ImGui_SliderAngleEx(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 cimgui::ImGui_SliderInt(const char* label, int* v, int v_min, int v_max)
{
    return ImGui::SliderInt(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderIntEx(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 cimgui::ImGui_SliderInt2(const char* label, int v[2], int v_min, int v_max)
{
    return ImGui::SliderInt2(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderInt2Ex(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 cimgui::ImGui_SliderInt3(const char* label, int v[3], int v_min, int v_max)
{
    return ImGui::SliderInt3(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderInt3Ex(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 cimgui::ImGui_SliderInt4(const char* label, int v[4], int v_min, int v_max)
{
    return ImGui::SliderInt4(label, v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_SliderInt4Ex(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 cimgui::ImGui_SliderScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max)
{
    return ImGui::SliderScalar(label, data_type, p_data, p_min, p_max);
}

CIMGUI_API bool cimgui::ImGui_SliderScalarEx(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 cimgui::ImGui_SliderScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_min, const void* p_max)
{
    return ImGui::SliderScalarN(label, data_type, p_data, components, p_min, p_max);
}

CIMGUI_API bool cimgui::ImGui_SliderScalarNEx(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 cimgui::ImGui_VSliderFloat(const char* label, cimgui::ImVec2 size, float* v, float v_min, float v_max)
{
    return ImGui::VSliderFloat(label, ConvertToCPP_ImVec2(size), v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_VSliderFloatEx(const char* label, cimgui::ImVec2 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 cimgui::ImGui_VSliderInt(const char* label, cimgui::ImVec2 size, int* v, int v_min, int v_max)
{
    return ImGui::VSliderInt(label, ConvertToCPP_ImVec2(size), v, v_min, v_max);
}

CIMGUI_API bool cimgui::ImGui_VSliderIntEx(const char* label, cimgui::ImVec2 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 cimgui::ImGui_VSliderScalar(const char* label, cimgui::ImVec2 size, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max)
{
    return ImGui::VSliderScalar(label, ConvertToCPP_ImVec2(size), data_type, p_data, p_min, p_max);
}

CIMGUI_API bool cimgui::ImGui_VSliderScalarEx(const char* label, cimgui::ImVec2 size, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)
{
    return ImGui::VSliderScalar(label, ConvertToCPP_ImVec2(size), data_type, p_data, p_min, p_max, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags)
{
    return ImGui::InputText(label, buf, buf_size, flags);
}

CIMGUI_API bool cimgui::ImGui_InputTextEx(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data)
{
    return ImGui::InputText(label, buf, buf_size, flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data);
}

CIMGUI_API bool cimgui::ImGui_InputTextMultiline(const char* label, char* buf, size_t buf_size)
{
    return ImGui::InputTextMultiline(label, buf, buf_size);
}

CIMGUI_API bool cimgui::ImGui_InputTextMultilineEx(const char* label, char* buf, size_t buf_size, cimgui::ImVec2 size, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data)
{
    return ImGui::InputTextMultiline(label, buf, buf_size, ConvertToCPP_ImVec2(size), flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data);
}

CIMGUI_API bool cimgui::ImGui_InputTextWithHint(const char* label, const char* hint, char* buf, size_t buf_size, ImGuiInputTextFlags flags)
{
    return ImGui::InputTextWithHint(label, hint, buf, buf_size, flags);
}

CIMGUI_API bool cimgui::ImGui_InputTextWithHintEx(const char* label, const char* hint, char* buf, size_t buf_size, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data)
{
    return ImGui::InputTextWithHint(label, hint, buf, buf_size, flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data);
}

CIMGUI_API bool cimgui::ImGui_InputFloat(const char* label, float* v)
{
    return ImGui::InputFloat(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputFloatEx(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 cimgui::ImGui_InputFloat2(const char* label, float v[2])
{
    return ImGui::InputFloat2(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputFloat2Ex(const char* label, float v[2], const char* format, ImGuiInputTextFlags flags)
{
    return ImGui::InputFloat2(label, v, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputFloat3(const char* label, float v[3])
{
    return ImGui::InputFloat3(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputFloat3Ex(const char* label, float v[3], const char* format, ImGuiInputTextFlags flags)
{
    return ImGui::InputFloat3(label, v, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputFloat4(const char* label, float v[4])
{
    return ImGui::InputFloat4(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputFloat4Ex(const char* label, float v[4], const char* format, ImGuiInputTextFlags flags)
{
    return ImGui::InputFloat4(label, v, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputInt(const char* label, int* v)
{
    return ImGui::InputInt(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputIntEx(const char* label, int* v, int step, int step_fast, ImGuiInputTextFlags flags)
{
    return ImGui::InputInt(label, v, step, step_fast, flags);
}

CIMGUI_API bool cimgui::ImGui_InputInt2(const char* label, int v[2], ImGuiInputTextFlags flags)
{
    return ImGui::InputInt2(label, v, flags);
}

CIMGUI_API bool cimgui::ImGui_InputInt3(const char* label, int v[3], ImGuiInputTextFlags flags)
{
    return ImGui::InputInt3(label, v, flags);
}

CIMGUI_API bool cimgui::ImGui_InputInt4(const char* label, int v[4], ImGuiInputTextFlags flags)
{
    return ImGui::InputInt4(label, v, flags);
}

CIMGUI_API bool cimgui::ImGui_InputDouble(const char* label, double* v)
{
    return ImGui::InputDouble(label, v);
}

CIMGUI_API bool cimgui::ImGui_InputDoubleEx(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 cimgui::ImGui_InputScalar(const char* label, ImGuiDataType data_type, void* p_data)
{
    return ImGui::InputScalar(label, data_type, p_data);
}

CIMGUI_API bool cimgui::ImGui_InputScalarEx(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 cimgui::ImGui_InputScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components)
{
    return ImGui::InputScalarN(label, data_type, p_data, components);
}

CIMGUI_API bool cimgui::ImGui_InputScalarNEx(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 cimgui::ImGui_ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags)
{
    return ImGui::ColorEdit3(label, col, flags);
}

CIMGUI_API bool cimgui::ImGui_ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags)
{
    return ImGui::ColorEdit4(label, col, flags);
}

CIMGUI_API bool cimgui::ImGui_ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags)
{
    return ImGui::ColorPicker3(label, col, flags);
}

CIMGUI_API bool cimgui::ImGui_ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags, const float* ref_col)
{
    return ImGui::ColorPicker4(label, col, flags, ref_col);
}

CIMGUI_API bool cimgui::ImGui_ColorButton(const char* desc_id, cimgui::ImVec4 col, ImGuiColorEditFlags flags)
{
    return ImGui::ColorButton(desc_id, ConvertToCPP_ImVec4(col), flags);
}

CIMGUI_API bool cimgui::ImGui_ColorButtonEx(const char* desc_id, cimgui::ImVec4 col, ImGuiColorEditFlags flags, cimgui::ImVec2 size)
{
    return ImGui::ColorButton(desc_id, ConvertToCPP_ImVec4(col), flags, ConvertToCPP_ImVec2(size));
}

CIMGUI_API void cimgui::ImGui_SetColorEditOptions(ImGuiColorEditFlags flags)
{
    ImGui::SetColorEditOptions(flags);
}

CIMGUI_API bool  cimgui::ImGui_TreeNode(const char* label)
{
    return ImGui::TreeNode(label);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeStr(const char* str_id, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    return ImGui::TreeNodeV(str_id, fmt, args);
    va_end(args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodePtr(const void* ptr_id, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    return ImGui::TreeNodeV(ptr_id, fmt, args);
    va_end(args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeV(const char* str_id, const char* fmt, va_list args)
{
    return ImGui::TreeNodeV(str_id, fmt, args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeVPtr(const void* ptr_id, const char* fmt, va_list args)
{
    return ImGui::TreeNodeV(ptr_id, fmt, args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags)
{
    return ImGui::TreeNodeEx(label, flags);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeExStr(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    return ImGui::TreeNodeExV(str_id, flags, fmt, args);
    va_end(args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeExPtr(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    return ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
    va_end(args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    return ImGui::TreeNodeExV(str_id, flags, fmt, args);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeExVPtr(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    return ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
}

CIMGUI_API void  cimgui::ImGui_TreePush(const char* str_id)
{
    ImGui::TreePush(str_id);
}

CIMGUI_API void  cimgui::ImGui_TreePushPtr(const void* ptr_id)
{
    ImGui::TreePush(ptr_id);
}

CIMGUI_API void  cimgui::ImGui_TreePop(void)
{
    ImGui::TreePop();
}

CIMGUI_API float cimgui::ImGui_GetTreeNodeToLabelSpacing(void)
{
    return ImGui::GetTreeNodeToLabelSpacing();
}

CIMGUI_API bool  cimgui::ImGui_CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags)
{
    return ImGui::CollapsingHeader(label, flags);
}

CIMGUI_API bool  cimgui::ImGui_CollapsingHeaderBoolPtr(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags)
{
    return ImGui::CollapsingHeader(label, p_visible, flags);
}

CIMGUI_API void  cimgui::ImGui_SetNextItemOpen(bool is_open, ImGuiCond cond)
{
    ImGui::SetNextItemOpen(is_open, cond);
}

CIMGUI_API bool cimgui::ImGui_Selectable(const char* label)
{
    return ImGui::Selectable(label);
}

CIMGUI_API bool cimgui::ImGui_SelectableEx(const char* label, bool selected, ImGuiSelectableFlags flags, cimgui::ImVec2 size)
{
    return ImGui::Selectable(label, selected, flags, ConvertToCPP_ImVec2(size));
}

CIMGUI_API bool cimgui::ImGui_SelectableBoolPtr(const char* label, bool* p_selected, ImGuiSelectableFlags flags)
{
    return ImGui::Selectable(label, p_selected, flags);
}

CIMGUI_API bool cimgui::ImGui_SelectableBoolPtrEx(const char* label, bool* p_selected, ImGuiSelectableFlags flags, cimgui::ImVec2 size)
{
    return ImGui::Selectable(label, p_selected, flags, ConvertToCPP_ImVec2(size));
}

CIMGUI_API bool cimgui::ImGui_BeginListBox(const char* label, cimgui::ImVec2 size)
{
    return ImGui::BeginListBox(label, ConvertToCPP_ImVec2(size));
}

CIMGUI_API void cimgui::ImGui_EndListBox(void)
{
    ImGui::EndListBox();
}

CIMGUI_API bool cimgui::ImGui_ListBox(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 cimgui::ImGui_ListBoxCallback(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count)
{
    return ImGui::ListBox(label, current_item, items_getter, data, items_count);
}

CIMGUI_API bool cimgui::ImGui_ListBoxCallbackEx(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items)
{
    return ImGui::ListBox(label, current_item, items_getter, data, items_count, height_in_items);
}

CIMGUI_API void cimgui::ImGui_PlotLines(const char* label, const float* values, int values_count)
{
    ImGui::PlotLines(label, values, values_count);
}

CIMGUI_API void cimgui::ImGui_PlotLinesEx(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, cimgui::ImVec2 graph_size, int stride)
{
    ImGui::PlotLines(label, values, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(graph_size), stride);
}

CIMGUI_API void cimgui::ImGui_PlotLinesCallback(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count)
{
    ImGui::PlotLines(label, values_getter, data, values_count);
}

CIMGUI_API void cimgui::ImGui_PlotLinesCallbackEx(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, cimgui::ImVec2 graph_size)
{
    ImGui::PlotLines(label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(graph_size));
}

CIMGUI_API void cimgui::ImGui_PlotHistogram(const char* label, const float* values, int values_count)
{
    ImGui::PlotHistogram(label, values, values_count);
}

CIMGUI_API void cimgui::ImGui_PlotHistogramEx(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, cimgui::ImVec2 graph_size, int stride)
{
    ImGui::PlotHistogram(label, values, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(graph_size), stride);
}

CIMGUI_API void cimgui::ImGui_PlotHistogramCallback(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count)
{
    ImGui::PlotHistogram(label, values_getter, data, values_count);
}

CIMGUI_API void cimgui::ImGui_PlotHistogramCallbackEx(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, cimgui::ImVec2 graph_size)
{
    ImGui::PlotHistogram(label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(graph_size));
}

CIMGUI_API bool cimgui::ImGui_BeginMenuBar(void)
{
    return ImGui::BeginMenuBar();
}

CIMGUI_API void cimgui::ImGui_EndMenuBar(void)
{
    ImGui::EndMenuBar();
}

CIMGUI_API bool cimgui::ImGui_BeginMainMenuBar(void)
{
    return ImGui::BeginMainMenuBar();
}

CIMGUI_API void cimgui::ImGui_EndMainMenuBar(void)
{
    ImGui::EndMainMenuBar();
}

CIMGUI_API bool cimgui::ImGui_BeginMenu(const char* label)
{
    return ImGui::BeginMenu(label);
}

CIMGUI_API bool cimgui::ImGui_BeginMenuEx(const char* label, bool enabled)
{
    return ImGui::BeginMenu(label, enabled);
}

CIMGUI_API void cimgui::ImGui_EndMenu(void)
{
    ImGui::EndMenu();
}

CIMGUI_API bool cimgui::ImGui_MenuItem(const char* label)
{
    return ImGui::MenuItem(label);
}

CIMGUI_API bool cimgui::ImGui_MenuItemEx(const char* label, const char* shortcut, bool selected, bool enabled)
{
    return ImGui::MenuItem(label, shortcut, selected, enabled);
}

CIMGUI_API bool cimgui::ImGui_MenuItemBoolPtr(const char* label, const char* shortcut, bool* p_selected, bool enabled)
{
    return ImGui::MenuItem(label, shortcut, p_selected, enabled);
}

CIMGUI_API bool cimgui::ImGui_BeginTooltip(void)
{
    return ImGui::BeginTooltip();
}

CIMGUI_API void cimgui::ImGui_EndTooltip(void)
{
    ImGui::EndTooltip();
}

CIMGUI_API void cimgui::ImGui_SetTooltip(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::SetTooltipV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_SetTooltipV(const char* fmt, va_list args)
{
    ImGui::SetTooltipV(fmt, args);
}

CIMGUI_API bool cimgui::ImGui_BeginItemTooltip(void)
{
    return ImGui::BeginItemTooltip();
}

CIMGUI_API void cimgui::ImGui_SetItemTooltip(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::SetItemTooltipV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_SetItemTooltipV(const char* fmt, va_list args)
{
    ImGui::SetItemTooltipV(fmt, args);
}

CIMGUI_API bool cimgui::ImGui_BeginPopup(const char* str_id, ImGuiWindowFlags flags)
{
    return ImGui::BeginPopup(str_id, flags);
}

CIMGUI_API bool cimgui::ImGui_BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags flags)
{
    return ImGui::BeginPopupModal(name, p_open, flags);
}

CIMGUI_API void cimgui::ImGui_EndPopup(void)
{
    ImGui::EndPopup();
}

CIMGUI_API void cimgui::ImGui_OpenPopup(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGui::OpenPopup(str_id, popup_flags);
}

CIMGUI_API void cimgui::ImGui_OpenPopupID(ImGuiID id, ImGuiPopupFlags popup_flags)
{
    ImGui::OpenPopup(id, popup_flags);
}

CIMGUI_API void cimgui::ImGui_OpenPopupOnItemClick(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGui::OpenPopupOnItemClick(str_id, popup_flags);
}

CIMGUI_API void cimgui::ImGui_CloseCurrentPopup(void)
{
    ImGui::CloseCurrentPopup();
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextItem(void)
{
    return ImGui::BeginPopupContextItem();
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextItemEx(const char* str_id, ImGuiPopupFlags popup_flags)
{
    return ImGui::BeginPopupContextItem(str_id, popup_flags);
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextWindow(void)
{
    return ImGui::BeginPopupContextWindow();
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextWindowEx(const char* str_id, ImGuiPopupFlags popup_flags)
{
    return ImGui::BeginPopupContextWindow(str_id, popup_flags);
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextVoid(void)
{
    return ImGui::BeginPopupContextVoid();
}

CIMGUI_API bool cimgui::ImGui_BeginPopupContextVoidEx(const char* str_id, ImGuiPopupFlags popup_flags)
{
    return ImGui::BeginPopupContextVoid(str_id, popup_flags);
}

CIMGUI_API bool cimgui::ImGui_IsPopupOpen(const char* str_id, ImGuiPopupFlags flags)
{
    return ImGui::IsPopupOpen(str_id, flags);
}

CIMGUI_API bool cimgui::ImGui_BeginTable(const char* str_id, int column, ImGuiTableFlags flags)
{
    return ImGui::BeginTable(str_id, column, flags);
}

CIMGUI_API bool cimgui::ImGui_BeginTableEx(const char* str_id, int column, ImGuiTableFlags flags, cimgui::ImVec2 outer_size, float inner_width)
{
    return ImGui::BeginTable(str_id, column, flags, ConvertToCPP_ImVec2(outer_size), inner_width);
}

CIMGUI_API void cimgui::ImGui_EndTable(void)
{
    ImGui::EndTable();
}

CIMGUI_API void cimgui::ImGui_TableNextRow(void)
{
    ImGui::TableNextRow();
}

CIMGUI_API void cimgui::ImGui_TableNextRowEx(ImGuiTableRowFlags row_flags, float min_row_height)
{
    ImGui::TableNextRow(row_flags, min_row_height);
}

CIMGUI_API bool cimgui::ImGui_TableNextColumn(void)
{
    return ImGui::TableNextColumn();
}

CIMGUI_API bool cimgui::ImGui_TableSetColumnIndex(int column_n)
{
    return ImGui::TableSetColumnIndex(column_n);
}

CIMGUI_API void cimgui::ImGui_TableSetupColumn(const char* label, ImGuiTableColumnFlags flags)
{
    ImGui::TableSetupColumn(label, flags);
}

CIMGUI_API void cimgui::ImGui_TableSetupColumnEx(const char* label, ImGuiTableColumnFlags flags, float init_width_or_weight, ImGuiID user_id)
{
    ImGui::TableSetupColumn(label, flags, init_width_or_weight, user_id);
}

CIMGUI_API void cimgui::ImGui_TableSetupScrollFreeze(int cols, int rows)
{
    ImGui::TableSetupScrollFreeze(cols, rows);
}

CIMGUI_API void cimgui::ImGui_TableHeadersRow(void)
{
    ImGui::TableHeadersRow();
}

CIMGUI_API void cimgui::ImGui_TableHeader(const char* label)
{
    ImGui::TableHeader(label);
}

CIMGUI_API cimgui::ImGuiTableSortSpecs* cimgui::ImGui_TableGetSortSpecs(void)
{
    return reinterpret_cast<::cimgui::ImGuiTableSortSpecs*>(ImGui::TableGetSortSpecs());
}

CIMGUI_API int                   cimgui::ImGui_TableGetColumnCount(void)
{
    return ImGui::TableGetColumnCount();
}

CIMGUI_API int                   cimgui::ImGui_TableGetColumnIndex(void)
{
    return ImGui::TableGetColumnIndex();
}

CIMGUI_API int                   cimgui::ImGui_TableGetRowIndex(void)
{
    return ImGui::TableGetRowIndex();
}

CIMGUI_API const char*           cimgui::ImGui_TableGetColumnName(int column_n)
{
    return ImGui::TableGetColumnName(column_n);
}

CIMGUI_API ImGuiTableColumnFlags cimgui::ImGui_TableGetColumnFlags(int column_n)
{
    return ImGui::TableGetColumnFlags(column_n);
}

CIMGUI_API void                  cimgui::ImGui_TableSetColumnEnabled(int column_n, bool v)
{
    ImGui::TableSetColumnEnabled(column_n, v);
}

CIMGUI_API void                  cimgui::ImGui_TableSetBgColor(ImGuiTableBgTarget target, ImU32 color, int column_n)
{
    ImGui::TableSetBgColor(target, color, column_n);
}

CIMGUI_API void  cimgui::ImGui_Columns(void)
{
    ImGui::Columns();
}

CIMGUI_API void  cimgui::ImGui_ColumnsEx(int count, const char* id, bool border)
{
    ImGui::Columns(count, id, border);
}

CIMGUI_API void  cimgui::ImGui_NextColumn(void)
{
    ImGui::NextColumn();
}

CIMGUI_API int   cimgui::ImGui_GetColumnIndex(void)
{
    return ImGui::GetColumnIndex();
}

CIMGUI_API float cimgui::ImGui_GetColumnWidth(int column_index)
{
    return ImGui::GetColumnWidth(column_index);
}

CIMGUI_API void  cimgui::ImGui_SetColumnWidth(int column_index, float width)
{
    ImGui::SetColumnWidth(column_index, width);
}

CIMGUI_API float cimgui::ImGui_GetColumnOffset(int column_index)
{
    return ImGui::GetColumnOffset(column_index);
}

CIMGUI_API void  cimgui::ImGui_SetColumnOffset(int column_index, float offset_x)
{
    ImGui::SetColumnOffset(column_index, offset_x);
}

CIMGUI_API int   cimgui::ImGui_GetColumnsCount(void)
{
    return ImGui::GetColumnsCount();
}

CIMGUI_API bool cimgui::ImGui_BeginTabBar(const char* str_id, ImGuiTabBarFlags flags)
{
    return ImGui::BeginTabBar(str_id, flags);
}

CIMGUI_API void cimgui::ImGui_EndTabBar(void)
{
    ImGui::EndTabBar();
}

CIMGUI_API bool cimgui::ImGui_BeginTabItem(const char* label, bool* p_open, ImGuiTabItemFlags flags)
{
    return ImGui::BeginTabItem(label, p_open, flags);
}

CIMGUI_API void cimgui::ImGui_EndTabItem(void)
{
    ImGui::EndTabItem();
}

CIMGUI_API bool cimgui::ImGui_TabItemButton(const char* label, ImGuiTabItemFlags flags)
{
    return ImGui::TabItemButton(label, flags);
}

CIMGUI_API void cimgui::ImGui_SetTabItemClosed(const char* tab_or_docked_window_label)
{
    ImGui::SetTabItemClosed(tab_or_docked_window_label);
}

CIMGUI_API ImGuiID cimgui::ImGui_DockSpace(ImGuiID id)
{
    return ImGui::DockSpace(id);
}

CIMGUI_API ImGuiID cimgui::ImGui_DockSpaceEx(ImGuiID id, cimgui::ImVec2 size, ImGuiDockNodeFlags flags, const cimgui::ImGuiWindowClass* window_class)
{
    return ImGui::DockSpace(id, ConvertToCPP_ImVec2(size), flags, reinterpret_cast<const ::ImGuiWindowClass*>(window_class));
}

CIMGUI_API ImGuiID cimgui::ImGui_DockSpaceOverViewport(void)
{
    return ImGui::DockSpaceOverViewport();
}

CIMGUI_API ImGuiID cimgui::ImGui_DockSpaceOverViewportEx(const cimgui::ImGuiViewport* viewport, ImGuiDockNodeFlags flags, const cimgui::ImGuiWindowClass* window_class)
{
    return ImGui::DockSpaceOverViewport(reinterpret_cast<const ::ImGuiViewport*>(viewport), flags, reinterpret_cast<const ::ImGuiWindowClass*>(window_class));
}

CIMGUI_API void    cimgui::ImGui_SetNextWindowDockID(ImGuiID dock_id, ImGuiCond cond)
{
    ImGui::SetNextWindowDockID(dock_id, cond);
}

CIMGUI_API void    cimgui::ImGui_SetNextWindowClass(const cimgui::ImGuiWindowClass* window_class)
{
    ImGui::SetNextWindowClass(reinterpret_cast<const ::ImGuiWindowClass*>(window_class));
}

CIMGUI_API ImGuiID cimgui::ImGui_GetWindowDockID(void)
{
    return ImGui::GetWindowDockID();
}

CIMGUI_API bool    cimgui::ImGui_IsWindowDocked(void)
{
    return ImGui::IsWindowDocked();
}

CIMGUI_API void cimgui::ImGui_LogToTTY(int auto_open_depth)
{
    ImGui::LogToTTY(auto_open_depth);
}

CIMGUI_API void cimgui::ImGui_LogToFile(int auto_open_depth, const char* filename)
{
    ImGui::LogToFile(auto_open_depth, filename);
}

CIMGUI_API void cimgui::ImGui_LogToClipboard(int auto_open_depth)
{
    ImGui::LogToClipboard(auto_open_depth);
}

CIMGUI_API void cimgui::ImGui_LogFinish(void)
{
    ImGui::LogFinish();
}

CIMGUI_API void cimgui::ImGui_LogButtons(void)
{
    ImGui::LogButtons();
}

CIMGUI_API void cimgui::ImGui_LogText(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ImGui::LogTextV(fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_LogTextV(const char* fmt, va_list args)
{
    ImGui::LogTextV(fmt, args);
}

CIMGUI_API bool                cimgui::ImGui_BeginDragDropSource(ImGuiDragDropFlags flags)
{
    return ImGui::BeginDragDropSource(flags);
}

CIMGUI_API bool                cimgui::ImGui_SetDragDropPayload(const char* type, const void* data, size_t sz, ImGuiCond cond)
{
    return ImGui::SetDragDropPayload(type, data, sz, cond);
}

CIMGUI_API void                cimgui::ImGui_EndDragDropSource(void)
{
    ImGui::EndDragDropSource();
}

CIMGUI_API bool                cimgui::ImGui_BeginDragDropTarget(void)
{
    return ImGui::BeginDragDropTarget();
}

CIMGUI_API const cimgui::ImGuiPayload* cimgui::ImGui_AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags)
{
    return reinterpret_cast<const ::cimgui::ImGuiPayload*>(ImGui::AcceptDragDropPayload(type, flags));
}

CIMGUI_API void                cimgui::ImGui_EndDragDropTarget(void)
{
    ImGui::EndDragDropTarget();
}

CIMGUI_API const cimgui::ImGuiPayload* cimgui::ImGui_GetDragDropPayload(void)
{
    return reinterpret_cast<const ::cimgui::ImGuiPayload*>(ImGui::GetDragDropPayload());
}

CIMGUI_API void cimgui::ImGui_BeginDisabled(bool disabled)
{
    ImGui::BeginDisabled(disabled);
}

CIMGUI_API void cimgui::ImGui_EndDisabled(void)
{
    ImGui::EndDisabled();
}

CIMGUI_API void cimgui::ImGui_PushClipRect(cimgui::ImVec2 clip_rect_min, cimgui::ImVec2 clip_rect_max, bool intersect_with_current_clip_rect)
{
    ImGui::PushClipRect(ConvertToCPP_ImVec2(clip_rect_min), ConvertToCPP_ImVec2(clip_rect_max), intersect_with_current_clip_rect);
}

CIMGUI_API void cimgui::ImGui_PopClipRect(void)
{
    ImGui::PopClipRect();
}

CIMGUI_API void cimgui::ImGui_SetItemDefaultFocus(void)
{
    ImGui::SetItemDefaultFocus();
}

CIMGUI_API void cimgui::ImGui_SetKeyboardFocusHere(void)
{
    ImGui::SetKeyboardFocusHere();
}

CIMGUI_API void cimgui::ImGui_SetKeyboardFocusHereEx(int offset)
{
    ImGui::SetKeyboardFocusHere(offset);
}

CIMGUI_API void cimgui::ImGui_SetNextItemAllowOverlap(void)
{
    ImGui::SetNextItemAllowOverlap();
}

CIMGUI_API bool    cimgui::ImGui_IsItemHovered(ImGuiHoveredFlags flags)
{
    return ImGui::IsItemHovered(flags);
}

CIMGUI_API bool    cimgui::ImGui_IsItemActive(void)
{
    return ImGui::IsItemActive();
}

CIMGUI_API bool    cimgui::ImGui_IsItemFocused(void)
{
    return ImGui::IsItemFocused();
}

CIMGUI_API bool    cimgui::ImGui_IsItemClicked(void)
{
    return ImGui::IsItemClicked();
}

CIMGUI_API bool    cimgui::ImGui_IsItemClickedEx(ImGuiMouseButton mouse_button)
{
    return ImGui::IsItemClicked(mouse_button);
}

CIMGUI_API bool    cimgui::ImGui_IsItemVisible(void)
{
    return ImGui::IsItemVisible();
}

CIMGUI_API bool    cimgui::ImGui_IsItemEdited(void)
{
    return ImGui::IsItemEdited();
}

CIMGUI_API bool    cimgui::ImGui_IsItemActivated(void)
{
    return ImGui::IsItemActivated();
}

CIMGUI_API bool    cimgui::ImGui_IsItemDeactivated(void)
{
    return ImGui::IsItemDeactivated();
}

CIMGUI_API bool    cimgui::ImGui_IsItemDeactivatedAfterEdit(void)
{
    return ImGui::IsItemDeactivatedAfterEdit();
}

CIMGUI_API bool    cimgui::ImGui_IsItemToggledOpen(void)
{
    return ImGui::IsItemToggledOpen();
}

CIMGUI_API bool    cimgui::ImGui_IsAnyItemHovered(void)
{
    return ImGui::IsAnyItemHovered();
}

CIMGUI_API bool    cimgui::ImGui_IsAnyItemActive(void)
{
    return ImGui::IsAnyItemActive();
}

CIMGUI_API bool    cimgui::ImGui_IsAnyItemFocused(void)
{
    return ImGui::IsAnyItemFocused();
}

CIMGUI_API ImGuiID cimgui::ImGui_GetItemID(void)
{
    return ImGui::GetItemID();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetItemRectMin(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetItemRectMin());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetItemRectMax(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetItemRectMax());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetItemRectSize(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetItemRectSize());
}

CIMGUI_API cimgui::ImGuiViewport* cimgui::ImGui_GetMainViewport(void)
{
    return reinterpret_cast<::cimgui::ImGuiViewport*>(ImGui::GetMainViewport());
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetBackgroundDrawList(void)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(ImGui::GetBackgroundDrawList());
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetForegroundDrawList(void)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(ImGui::GetForegroundDrawList());
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetBackgroundDrawListImGuiViewportPtr(cimgui::ImGuiViewport* viewport)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(ImGui::GetBackgroundDrawList(reinterpret_cast<::ImGuiViewport*>(viewport)));
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetForegroundDrawListImGuiViewportPtr(cimgui::ImGuiViewport* viewport)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(ImGui::GetForegroundDrawList(reinterpret_cast<::ImGuiViewport*>(viewport)));
}

CIMGUI_API bool                  cimgui::ImGui_IsRectVisibleBySize(cimgui::ImVec2 size)
{
    return ImGui::IsRectVisible(ConvertToCPP_ImVec2(size));
}

CIMGUI_API bool                  cimgui::ImGui_IsRectVisible(cimgui::ImVec2 rect_min, cimgui::ImVec2 rect_max)
{
    return ImGui::IsRectVisible(ConvertToCPP_ImVec2(rect_min), ConvertToCPP_ImVec2(rect_max));
}

CIMGUI_API double                cimgui::ImGui_GetTime(void)
{
    return ImGui::GetTime();
}

CIMGUI_API int                   cimgui::ImGui_GetFrameCount(void)
{
    return ImGui::GetFrameCount();
}

CIMGUI_API cimgui::ImDrawListSharedData* cimgui::ImGui_GetDrawListSharedData(void)
{
    return reinterpret_cast<::cimgui::ImDrawListSharedData*>(ImGui::GetDrawListSharedData());
}

CIMGUI_API const char*           cimgui::ImGui_GetStyleColorName(ImGuiCol idx)
{
    return ImGui::GetStyleColorName(idx);
}

CIMGUI_API void                  cimgui::ImGui_SetStateStorage(cimgui::ImGuiStorage* storage)
{
    ImGui::SetStateStorage(reinterpret_cast<::ImGuiStorage*>(storage));
}

CIMGUI_API cimgui::ImGuiStorage* cimgui::ImGui_GetStateStorage(void)
{
    return reinterpret_cast<::cimgui::ImGuiStorage*>(ImGui::GetStateStorage());
}

CIMGUI_API bool                  cimgui::ImGui_BeginChildFrame(ImGuiID id, cimgui::ImVec2 size, ImGuiWindowFlags flags)
{
    return ImGui::BeginChildFrame(id, ConvertToCPP_ImVec2(size), flags);
}

CIMGUI_API void                  cimgui::ImGui_EndChildFrame(void)
{
    ImGui::EndChildFrame();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_CalcTextSize(const char* text)
{
    return ConvertFromCPP_ImVec2(ImGui::CalcTextSize(text));
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_CalcTextSizeEx(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 cimgui::ImVec4 cimgui::ImGui_ColorConvertU32ToFloat4(ImU32 in)
{
    return ConvertFromCPP_ImVec4(ImGui::ColorConvertU32ToFloat4(in));
}

CIMGUI_API ImU32  cimgui::ImGui_ColorConvertFloat4ToU32(cimgui::ImVec4 in)
{
    return ImGui::ColorConvertFloat4ToU32(ConvertToCPP_ImVec4(in));
}

CIMGUI_API void   cimgui::ImGui_ColorConvertRGBtoHSV(float r, float g, float b, float* out_h, float* out_s, float* out_v)
{
    ImGui::ColorConvertRGBtoHSV(r, g, b, *out_h, *out_s, *out_v);
}

CIMGUI_API void   cimgui::ImGui_ColorConvertHSVtoRGB(float h, float s, float v, float* out_r, float* out_g, float* out_b)
{
    ImGui::ColorConvertHSVtoRGB(h, s, v, *out_r, *out_g, *out_b);
}

CIMGUI_API bool        cimgui::ImGui_IsKeyDown(cimgui::ImGuiKey key)
{
    return ImGui::IsKeyDown(static_cast<::ImGuiKey>(key));
}

CIMGUI_API bool        cimgui::ImGui_IsKeyPressed(cimgui::ImGuiKey key)
{
    return ImGui::IsKeyPressed(static_cast<::ImGuiKey>(key));
}

CIMGUI_API bool        cimgui::ImGui_IsKeyPressedEx(cimgui::ImGuiKey key, bool repeat)
{
    return ImGui::IsKeyPressed(static_cast<::ImGuiKey>(key), repeat);
}

CIMGUI_API bool        cimgui::ImGui_IsKeyReleased(cimgui::ImGuiKey key)
{
    return ImGui::IsKeyReleased(static_cast<::ImGuiKey>(key));
}

CIMGUI_API int         cimgui::ImGui_GetKeyPressedAmount(cimgui::ImGuiKey key, float repeat_delay, float rate)
{
    return ImGui::GetKeyPressedAmount(static_cast<::ImGuiKey>(key), repeat_delay, rate);
}

CIMGUI_API const char* cimgui::ImGui_GetKeyName(cimgui::ImGuiKey key)
{
    return ImGui::GetKeyName(static_cast<::ImGuiKey>(key));
}

CIMGUI_API void        cimgui::ImGui_SetNextFrameWantCaptureKeyboard(bool want_capture_keyboard)
{
    ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseDown(ImGuiMouseButton button)
{
    return ImGui::IsMouseDown(button);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseClicked(ImGuiMouseButton button)
{
    return ImGui::IsMouseClicked(button);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseClickedEx(ImGuiMouseButton button, bool repeat)
{
    return ImGui::IsMouseClicked(button, repeat);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseReleased(ImGuiMouseButton button)
{
    return ImGui::IsMouseReleased(button);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseDoubleClicked(ImGuiMouseButton button)
{
    return ImGui::IsMouseDoubleClicked(button);
}

CIMGUI_API int              cimgui::ImGui_GetMouseClickedCount(ImGuiMouseButton button)
{
    return ImGui::GetMouseClickedCount(button);
}

CIMGUI_API bool             cimgui::ImGui_IsMouseHoveringRect(cimgui::ImVec2 r_min, cimgui::ImVec2 r_max)
{
    return ImGui::IsMouseHoveringRect(ConvertToCPP_ImVec2(r_min), ConvertToCPP_ImVec2(r_max));
}

CIMGUI_API bool             cimgui::ImGui_IsMouseHoveringRectEx(cimgui::ImVec2 r_min, cimgui::ImVec2 r_max, bool clip)
{
    return ImGui::IsMouseHoveringRect(ConvertToCPP_ImVec2(r_min), ConvertToCPP_ImVec2(r_max), clip);
}

CIMGUI_API bool             cimgui::ImGui_IsMousePosValid(const cimgui::ImVec2* mouse_pos)
{
    return ImGui::IsMousePosValid(reinterpret_cast<const ::ImVec2*>(mouse_pos));
}

CIMGUI_API bool             cimgui::ImGui_IsAnyMouseDown(void)
{
    return ImGui::IsAnyMouseDown();
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_GetMousePos(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetMousePos());
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_GetMousePosOnOpeningCurrentPopup(void)
{
    return ConvertFromCPP_ImVec2(ImGui::GetMousePosOnOpeningCurrentPopup());
}

CIMGUI_API bool             cimgui::ImGui_IsMouseDragging(ImGuiMouseButton button, float lock_threshold)
{
    return ImGui::IsMouseDragging(button, lock_threshold);
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
{
    return ConvertFromCPP_ImVec2(ImGui::GetMouseDragDelta(button, lock_threshold));
}

CIMGUI_API void             cimgui::ImGui_ResetMouseDragDelta(void)
{
    ImGui::ResetMouseDragDelta();
}

CIMGUI_API void             cimgui::ImGui_ResetMouseDragDeltaEx(ImGuiMouseButton button)
{
    ImGui::ResetMouseDragDelta(button);
}

CIMGUI_API ImGuiMouseCursor cimgui::ImGui_GetMouseCursor(void)
{
    return ImGui::GetMouseCursor();
}

CIMGUI_API void             cimgui::ImGui_SetMouseCursor(ImGuiMouseCursor cursor_type)
{
    ImGui::SetMouseCursor(cursor_type);
}

CIMGUI_API void             cimgui::ImGui_SetNextFrameWantCaptureMouse(bool want_capture_mouse)
{
    ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse);
}

CIMGUI_API const char* cimgui::ImGui_GetClipboardText(void)
{
    return ImGui::GetClipboardText();
}

CIMGUI_API void        cimgui::ImGui_SetClipboardText(const char* text)
{
    ImGui::SetClipboardText(text);
}

CIMGUI_API void        cimgui::ImGui_LoadIniSettingsFromDisk(const char* ini_filename)
{
    ImGui::LoadIniSettingsFromDisk(ini_filename);
}

CIMGUI_API void        cimgui::ImGui_LoadIniSettingsFromMemory(const char* ini_data, size_t ini_size)
{
    ImGui::LoadIniSettingsFromMemory(ini_data, ini_size);
}

CIMGUI_API void        cimgui::ImGui_SaveIniSettingsToDisk(const char* ini_filename)
{
    ImGui::SaveIniSettingsToDisk(ini_filename);
}

CIMGUI_API const char* cimgui::ImGui_SaveIniSettingsToMemory(size_t* out_ini_size)
{
    return ImGui::SaveIniSettingsToMemory(out_ini_size);
}

CIMGUI_API void cimgui::ImGui_DebugTextEncoding(const char* text)
{
    ImGui::DebugTextEncoding(text);
}

CIMGUI_API bool cimgui::ImGui_DebugCheckVersionAndDataLayout(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  cimgui::ImGui_SetAllocatorFunctions(cimgui::ImGuiMemAllocFunc alloc_func, cimgui::ImGuiMemFreeFunc free_func, void* user_data)
{
    ImGui::SetAllocatorFunctions(reinterpret_cast<::ImGuiMemAllocFunc>(alloc_func), reinterpret_cast<::ImGuiMemFreeFunc>(free_func), user_data);
}

CIMGUI_API void  cimgui::ImGui_GetAllocatorFunctions(cimgui::ImGuiMemAllocFunc* p_alloc_func, cimgui::ImGuiMemFreeFunc* p_free_func, void** p_user_data)
{
    ImGui::GetAllocatorFunctions(reinterpret_cast<::ImGuiMemAllocFunc*>(p_alloc_func), reinterpret_cast<::ImGuiMemFreeFunc*>(p_free_func), p_user_data);
}

CIMGUI_API void* cimgui::ImGui_MemAlloc(size_t size)
{
    return ImGui::MemAlloc(size);
}

CIMGUI_API void  cimgui::ImGui_MemFree(void* ptr)
{
    ImGui::MemFree(ptr);
}

CIMGUI_API cimgui::ImGuiPlatformIO* cimgui::ImGui_GetPlatformIO(void)
{
    return reinterpret_cast<::cimgui::ImGuiPlatformIO*>(&ImGui::GetPlatformIO());
}

CIMGUI_API void             cimgui::ImGui_UpdatePlatformWindows(void)
{
    ImGui::UpdatePlatformWindows();
}

CIMGUI_API void             cimgui::ImGui_RenderPlatformWindowsDefault(void)
{
    ImGui::RenderPlatformWindowsDefault();
}

CIMGUI_API void             cimgui::ImGui_RenderPlatformWindowsDefaultEx(void* platform_render_arg, void* renderer_render_arg)
{
    ImGui::RenderPlatformWindowsDefault(platform_render_arg, renderer_render_arg);
}

CIMGUI_API void             cimgui::ImGui_DestroyPlatformWindows(void)
{
    ImGui::DestroyPlatformWindows();
}

CIMGUI_API cimgui::ImGuiViewport* cimgui::ImGui_FindViewportByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiViewport*>(ImGui::FindViewportByID(id));
}

CIMGUI_API cimgui::ImGuiViewport* cimgui::ImGui_FindViewportByPlatformHandle(void* platform_handle)
{
    return reinterpret_cast<::cimgui::ImGuiViewport*>(ImGui::FindViewportByPlatformHandle(platform_handle));
}

CIMGUI_API void cimgui::ImGuiStyle_ScaleAllSizes(cimgui::ImGuiStyle* self, float scale_factor)
{
    reinterpret_cast<::ImGuiStyle*>(self)->ScaleAllSizes(scale_factor);
}

CIMGUI_API void cimgui::ImGuiIO_AddKeyEvent(cimgui::ImGuiIO* self, cimgui::ImGuiKey key, bool down)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddKeyEvent(static_cast<::ImGuiKey>(key), down);
}

CIMGUI_API void cimgui::ImGuiIO_AddKeyAnalogEvent(cimgui::ImGuiIO* self, cimgui::ImGuiKey key, bool down, float v)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddKeyAnalogEvent(static_cast<::ImGuiKey>(key), down, v);
}

CIMGUI_API void cimgui::ImGuiIO_AddMousePosEvent(cimgui::ImGuiIO* self, float x, float y)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddMousePosEvent(x, y);
}

CIMGUI_API void cimgui::ImGuiIO_AddMouseButtonEvent(cimgui::ImGuiIO* self, int button, bool down)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddMouseButtonEvent(button, down);
}

CIMGUI_API void cimgui::ImGuiIO_AddMouseWheelEvent(cimgui::ImGuiIO* self, float wheel_x, float wheel_y)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddMouseWheelEvent(wheel_x, wheel_y);
}

CIMGUI_API void cimgui::ImGuiIO_AddMouseSourceEvent(cimgui::ImGuiIO* self, cimgui::ImGuiMouseSource source)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddMouseSourceEvent(static_cast<::ImGuiMouseSource>(source));
}

CIMGUI_API void cimgui::ImGuiIO_AddMouseViewportEvent(cimgui::ImGuiIO* self, ImGuiID id)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddMouseViewportEvent(id);
}

CIMGUI_API void cimgui::ImGuiIO_AddFocusEvent(cimgui::ImGuiIO* self, bool focused)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddFocusEvent(focused);
}

CIMGUI_API void cimgui::ImGuiIO_AddInputCharacter(cimgui::ImGuiIO* self, unsigned int c)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddInputCharacter(c);
}

CIMGUI_API void cimgui::ImGuiIO_AddInputCharacterUTF16(cimgui::ImGuiIO* self, ImWchar16 c)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddInputCharacterUTF16(c);
}

CIMGUI_API void cimgui::ImGuiIO_AddInputCharactersUTF8(cimgui::ImGuiIO* self, const char* str)
{
    reinterpret_cast<::ImGuiIO*>(self)->AddInputCharactersUTF8(str);
}

CIMGUI_API void cimgui::ImGuiIO_SetKeyEventNativeData(cimgui::ImGuiIO* self, cimgui::ImGuiKey key, int native_keycode, int native_scancode)
{
    reinterpret_cast<::ImGuiIO*>(self)->SetKeyEventNativeData(static_cast<::ImGuiKey>(key), native_keycode, native_scancode);
}

CIMGUI_API void cimgui::ImGuiIO_SetKeyEventNativeDataEx(cimgui::ImGuiIO* self, cimgui::ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index)
{
    reinterpret_cast<::ImGuiIO*>(self)->SetKeyEventNativeData(static_cast<::ImGuiKey>(key), native_keycode, native_scancode, native_legacy_index);
}

CIMGUI_API void cimgui::ImGuiIO_SetAppAcceptingEvents(cimgui::ImGuiIO* self, bool accepting_events)
{
    reinterpret_cast<::ImGuiIO*>(self)->SetAppAcceptingEvents(accepting_events);
}

CIMGUI_API void cimgui::ImGuiIO_ClearInputCharacters(cimgui::ImGuiIO* self)
{
    reinterpret_cast<::ImGuiIO*>(self)->ClearInputCharacters();
}

CIMGUI_API void cimgui::ImGuiIO_ClearInputKeys(cimgui::ImGuiIO* self)
{
    reinterpret_cast<::ImGuiIO*>(self)->ClearInputKeys();
}

CIMGUI_API void cimgui::ImGuiInputTextCallbackData_DeleteChars(cimgui::ImGuiInputTextCallbackData* self, int pos, int bytes_count)
{
    reinterpret_cast<::ImGuiInputTextCallbackData*>(self)->DeleteChars(pos, bytes_count);
}

CIMGUI_API void cimgui::ImGuiInputTextCallbackData_InsertChars(cimgui::ImGuiInputTextCallbackData* self, int pos, const char* text, const char* text_end)
{
    reinterpret_cast<::ImGuiInputTextCallbackData*>(self)->InsertChars(pos, text, text_end);
}

CIMGUI_API void cimgui::ImGuiInputTextCallbackData_SelectAll(cimgui::ImGuiInputTextCallbackData* self)
{
    reinterpret_cast<::ImGuiInputTextCallbackData*>(self)->SelectAll();
}

CIMGUI_API void cimgui::ImGuiInputTextCallbackData_ClearSelection(cimgui::ImGuiInputTextCallbackData* self)
{
    reinterpret_cast<::ImGuiInputTextCallbackData*>(self)->ClearSelection();
}

CIMGUI_API bool cimgui::ImGuiInputTextCallbackData_HasSelection(const cimgui::ImGuiInputTextCallbackData* self)
{
    return reinterpret_cast<const ::ImGuiInputTextCallbackData*>(self)->HasSelection();
}

CIMGUI_API void cimgui::ImGuiPayload_Clear(cimgui::ImGuiPayload* self)
{
    reinterpret_cast<::ImGuiPayload*>(self)->Clear();
}

CIMGUI_API bool cimgui::ImGuiPayload_IsDataType(const cimgui::ImGuiPayload* self, const char* type)
{
    return reinterpret_cast<const ::ImGuiPayload*>(self)->IsDataType(type);
}

CIMGUI_API bool cimgui::ImGuiPayload_IsPreview(const cimgui::ImGuiPayload* self)
{
    return reinterpret_cast<const ::ImGuiPayload*>(self)->IsPreview();
}

CIMGUI_API bool cimgui::ImGuiPayload_IsDelivery(const cimgui::ImGuiPayload* self)
{
    return reinterpret_cast<const ::ImGuiPayload*>(self)->IsDelivery();
}

CIMGUI_API bool cimgui::ImGuiTextFilter_ImGuiTextRange_empty(const cimgui::ImGuiTextFilter_ImGuiTextRange* self)
{
    return reinterpret_cast<const ::ImGuiTextFilter::ImGuiTextRange*>(self)->empty();
}

CIMGUI_API void cimgui::ImGuiTextFilter_ImGuiTextRange_split(const cimgui::ImGuiTextFilter_ImGuiTextRange* self, char separator, cimgui::ImVector_ImGuiTextFilter_ImGuiTextRange* out)
{
    reinterpret_cast<const ::ImGuiTextFilter::ImGuiTextRange*>(self)->split(separator, reinterpret_cast<::ImVector<::ImGuiTextFilter::ImGuiTextRange>*>(out));
}

CIMGUI_API bool cimgui::ImGuiTextFilter_Draw(cimgui::ImGuiTextFilter* self, const char* label, float width)
{
    return reinterpret_cast<::ImGuiTextFilter*>(self)->Draw(label, width);
}

CIMGUI_API bool cimgui::ImGuiTextFilter_PassFilter(const cimgui::ImGuiTextFilter* self, const char* text, const char* text_end)
{
    return reinterpret_cast<const ::ImGuiTextFilter*>(self)->PassFilter(text, text_end);
}

CIMGUI_API void cimgui::ImGuiTextFilter_Build(cimgui::ImGuiTextFilter* self)
{
    reinterpret_cast<::ImGuiTextFilter*>(self)->Build();
}

CIMGUI_API void cimgui::ImGuiTextFilter_Clear(cimgui::ImGuiTextFilter* self)
{
    reinterpret_cast<::ImGuiTextFilter*>(self)->Clear();
}

CIMGUI_API bool cimgui::ImGuiTextFilter_IsActive(const cimgui::ImGuiTextFilter* self)
{
    return reinterpret_cast<const ::ImGuiTextFilter*>(self)->IsActive();
}

CIMGUI_API const char* cimgui::ImGuiTextBuffer_begin(const cimgui::ImGuiTextBuffer* self)
{
    return reinterpret_cast<const ::ImGuiTextBuffer*>(self)->begin();
}

CIMGUI_API const char* cimgui::ImGuiTextBuffer_end(const cimgui::ImGuiTextBuffer* self)
{
    return reinterpret_cast<const ::ImGuiTextBuffer*>(self)->end();
}

CIMGUI_API int         cimgui::ImGuiTextBuffer_size(const cimgui::ImGuiTextBuffer* self)
{
    return reinterpret_cast<const ::ImGuiTextBuffer*>(self)->size();
}

CIMGUI_API bool        cimgui::ImGuiTextBuffer_empty(const cimgui::ImGuiTextBuffer* self)
{
    return reinterpret_cast<const ::ImGuiTextBuffer*>(self)->empty();
}

CIMGUI_API void        cimgui::ImGuiTextBuffer_clear(cimgui::ImGuiTextBuffer* self)
{
    reinterpret_cast<::ImGuiTextBuffer*>(self)->clear();
}

CIMGUI_API void        cimgui::ImGuiTextBuffer_reserve(cimgui::ImGuiTextBuffer* self, int capacity)
{
    reinterpret_cast<::ImGuiTextBuffer*>(self)->reserve(capacity);
}

CIMGUI_API const char* cimgui::ImGuiTextBuffer_c_str(const cimgui::ImGuiTextBuffer* self)
{
    return reinterpret_cast<const ::ImGuiTextBuffer*>(self)->c_str();
}

CIMGUI_API void        cimgui::ImGuiTextBuffer_append(cimgui::ImGuiTextBuffer* self, const char* str, const char* str_end)
{
    reinterpret_cast<::ImGuiTextBuffer*>(self)->append(str, str_end);
}

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

CIMGUI_API void        cimgui::ImGuiTextBuffer_appendfv(cimgui::ImGuiTextBuffer* self, const char* fmt, va_list args)
{
    reinterpret_cast<::ImGuiTextBuffer*>(self)->appendfv(fmt, args);
}

CIMGUI_API void   cimgui::ImGuiStorage_Clear(cimgui::ImGuiStorage* self)
{
    reinterpret_cast<::ImGuiStorage*>(self)->Clear();
}

CIMGUI_API int    cimgui::ImGuiStorage_GetInt(const cimgui::ImGuiStorage* self, ImGuiID key, int default_val)
{
    return reinterpret_cast<const ::ImGuiStorage*>(self)->GetInt(key, default_val);
}

CIMGUI_API void   cimgui::ImGuiStorage_SetInt(cimgui::ImGuiStorage* self, ImGuiID key, int val)
{
    reinterpret_cast<::ImGuiStorage*>(self)->SetInt(key, val);
}

CIMGUI_API bool   cimgui::ImGuiStorage_GetBool(const cimgui::ImGuiStorage* self, ImGuiID key, bool default_val)
{
    return reinterpret_cast<const ::ImGuiStorage*>(self)->GetBool(key, default_val);
}

CIMGUI_API void   cimgui::ImGuiStorage_SetBool(cimgui::ImGuiStorage* self, ImGuiID key, bool val)
{
    reinterpret_cast<::ImGuiStorage*>(self)->SetBool(key, val);
}

CIMGUI_API float  cimgui::ImGuiStorage_GetFloat(const cimgui::ImGuiStorage* self, ImGuiID key, float default_val)
{
    return reinterpret_cast<const ::ImGuiStorage*>(self)->GetFloat(key, default_val);
}

CIMGUI_API void   cimgui::ImGuiStorage_SetFloat(cimgui::ImGuiStorage* self, ImGuiID key, float val)
{
    reinterpret_cast<::ImGuiStorage*>(self)->SetFloat(key, val);
}

CIMGUI_API void*  cimgui::ImGuiStorage_GetVoidPtr(const cimgui::ImGuiStorage* self, ImGuiID key)
{
    return reinterpret_cast<const ::ImGuiStorage*>(self)->GetVoidPtr(key);
}

CIMGUI_API void   cimgui::ImGuiStorage_SetVoidPtr(cimgui::ImGuiStorage* self, ImGuiID key, void* val)
{
    reinterpret_cast<::ImGuiStorage*>(self)->SetVoidPtr(key, val);
}

CIMGUI_API int*   cimgui::ImGuiStorage_GetIntRef(cimgui::ImGuiStorage* self, ImGuiID key, int default_val)
{
    return reinterpret_cast<::ImGuiStorage*>(self)->GetIntRef(key, default_val);
}

CIMGUI_API bool*  cimgui::ImGuiStorage_GetBoolRef(cimgui::ImGuiStorage* self, ImGuiID key, bool default_val)
{
    return reinterpret_cast<::ImGuiStorage*>(self)->GetBoolRef(key, default_val);
}

CIMGUI_API float* cimgui::ImGuiStorage_GetFloatRef(cimgui::ImGuiStorage* self, ImGuiID key, float default_val)
{
    return reinterpret_cast<::ImGuiStorage*>(self)->GetFloatRef(key, default_val);
}

CIMGUI_API void** cimgui::ImGuiStorage_GetVoidPtrRef(cimgui::ImGuiStorage* self, ImGuiID key, void* default_val)
{
    return reinterpret_cast<::ImGuiStorage*>(self)->GetVoidPtrRef(key, default_val);
}

CIMGUI_API void   cimgui::ImGuiStorage_SetAllInt(cimgui::ImGuiStorage* self, int val)
{
    reinterpret_cast<::ImGuiStorage*>(self)->SetAllInt(val);
}

CIMGUI_API void   cimgui::ImGuiStorage_BuildSortByKey(cimgui::ImGuiStorage* self)
{
    reinterpret_cast<::ImGuiStorage*>(self)->BuildSortByKey();
}

CIMGUI_API void cimgui::ImGuiListClipper_Begin(cimgui::ImGuiListClipper* self, int items_count, float items_height)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->Begin(items_count, items_height);
}

CIMGUI_API void cimgui::ImGuiListClipper_End(cimgui::ImGuiListClipper* self)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->End();
}

CIMGUI_API bool cimgui::ImGuiListClipper_Step(cimgui::ImGuiListClipper* self)
{
    return reinterpret_cast<::ImGuiListClipper*>(self)->Step();
}

CIMGUI_API void cimgui::ImGuiListClipper_IncludeRangeByIndices(cimgui::ImGuiListClipper* self, int item_begin, int item_end)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->IncludeRangeByIndices(item_begin, item_end);
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void cimgui::ImGuiListClipper_ForceDisplayRangeByIndices(cimgui::ImGuiListClipper* self, int item_begin, int item_end)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->ForceDisplayRangeByIndices(item_begin, item_end);
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void    cimgui::ImColor_SetHSV(cimgui::ImColor* self, float h, float s, float v, float a)
{
    reinterpret_cast<::ImColor*>(self)->SetHSV(h, s, v, a);
}

CIMGUI_API cimgui::ImColor cimgui::ImColor_HSV(cimgui::ImColor* self, float h, float s, float v, float a)
{
    return ConvertFromCPP_ImColor(reinterpret_cast<::ImColor*>(self)->ImColor::HSV(h, s, v, a));
}

CIMGUI_API ImTextureID cimgui::ImDrawCmd_GetTexID(const cimgui::ImDrawCmd* self)
{
    return reinterpret_cast<const ::ImDrawCmd*>(self)->GetTexID();
}

CIMGUI_API void cimgui::ImDrawListSplitter_Clear(cimgui::ImDrawListSplitter* self)
{
    reinterpret_cast<::ImDrawListSplitter*>(self)->Clear();
}

CIMGUI_API void cimgui::ImDrawListSplitter_ClearFreeMemory(cimgui::ImDrawListSplitter* self)
{
    reinterpret_cast<::ImDrawListSplitter*>(self)->ClearFreeMemory();
}

CIMGUI_API void cimgui::ImDrawListSplitter_Split(cimgui::ImDrawListSplitter* self, cimgui::ImDrawList* draw_list, int count)
{
    reinterpret_cast<::ImDrawListSplitter*>(self)->Split(reinterpret_cast<::ImDrawList*>(draw_list), count);
}

CIMGUI_API void cimgui::ImDrawListSplitter_Merge(cimgui::ImDrawListSplitter* self, cimgui::ImDrawList* draw_list)
{
    reinterpret_cast<::ImDrawListSplitter*>(self)->Merge(reinterpret_cast<::ImDrawList*>(draw_list));
}

CIMGUI_API void cimgui::ImDrawListSplitter_SetCurrentChannel(cimgui::ImDrawListSplitter* self, cimgui::ImDrawList* draw_list, int channel_idx)
{
    reinterpret_cast<::ImDrawListSplitter*>(self)->SetCurrentChannel(reinterpret_cast<::ImDrawList*>(draw_list), channel_idx);
}

CIMGUI_API void        cimgui::ImDrawList_PushClipRect(cimgui::ImDrawList* self, cimgui::ImVec2 clip_rect_min, cimgui::ImVec2 clip_rect_max, bool intersect_with_current_clip_rect)
{
    reinterpret_cast<::ImDrawList*>(self)->PushClipRect(ConvertToCPP_ImVec2(clip_rect_min), ConvertToCPP_ImVec2(clip_rect_max), intersect_with_current_clip_rect);
}

CIMGUI_API void        cimgui::ImDrawList_PushClipRectFullScreen(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->PushClipRectFullScreen();
}

CIMGUI_API void        cimgui::ImDrawList_PopClipRect(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->PopClipRect();
}

CIMGUI_API void        cimgui::ImDrawList_PushTextureID(cimgui::ImDrawList* self, ImTextureID texture_id)
{
    reinterpret_cast<::ImDrawList*>(self)->PushTextureID(texture_id);
}

CIMGUI_API void        cimgui::ImDrawList_PopTextureID(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->PopTextureID();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImDrawList_GetClipRectMin(const cimgui::ImDrawList* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImDrawList*>(self)->GetClipRectMin());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImDrawList_GetClipRectMax(const cimgui::ImDrawList* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImDrawList*>(self)->GetClipRectMax());
}

CIMGUI_API void        cimgui::ImDrawList_AddLine(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddLine(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddLineEx(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, ImU32 col, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddLine(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), col, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddRect(cimgui::ImDrawList* self, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddRect(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddRectEx(cimgui::ImDrawList* self, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 col, float rounding, ImDrawFlags flags, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddRect(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), col, rounding, flags, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddRectFilled(cimgui::ImDrawList* self, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddRectFilled(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddRectFilledEx(cimgui::ImDrawList* self, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 col, float rounding, ImDrawFlags flags)
{
    reinterpret_cast<::ImDrawList*>(self)->AddRectFilled(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), col, rounding, flags);
}

CIMGUI_API void        cimgui::ImDrawList_AddRectFilledMultiColor(cimgui::ImDrawList* self, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
{
    reinterpret_cast<::ImDrawList*>(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        cimgui::ImDrawList_AddQuad(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddQuad(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddQuadEx(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, ImU32 col, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddQuad(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), col, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddQuadFilled(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddQuadFilled(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddTriangle(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddTriangle(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddTriangleEx(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, ImU32 col, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddTriangle(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), col, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddTriangleFilled(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddTriangleFilled(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddCircle(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddCircle(ConvertToCPP_ImVec2(center), radius, col);
}

CIMGUI_API void        cimgui::ImDrawList_AddCircleEx(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col, int num_segments, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddCircle(ConvertToCPP_ImVec2(center), radius, col, num_segments, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddCircleFilled(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->AddCircleFilled(ConvertToCPP_ImVec2(center), radius, col, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_AddNgon(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->AddNgon(ConvertToCPP_ImVec2(center), radius, col, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_AddNgonEx(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col, int num_segments, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddNgon(ConvertToCPP_ImVec2(center), radius, col, num_segments, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddNgonFilled(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, ImU32 col, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->AddNgonFilled(ConvertToCPP_ImVec2(center), radius, col, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_AddText(cimgui::ImDrawList* self, cimgui::ImVec2 pos, ImU32 col, const char* text_begin)
{
    reinterpret_cast<::ImDrawList*>(self)->AddText(ConvertToCPP_ImVec2(pos), col, text_begin);
}

CIMGUI_API void        cimgui::ImDrawList_AddTextEx(cimgui::ImDrawList* self, cimgui::ImVec2 pos, ImU32 col, const char* text_begin, const char* text_end)
{
    reinterpret_cast<::ImDrawList*>(self)->AddText(ConvertToCPP_ImVec2(pos), col, text_begin, text_end);
}

CIMGUI_API void        cimgui::ImDrawList_AddTextImFontPtr(cimgui::ImDrawList* self, const cimgui::ImFont* font, float font_size, cimgui::ImVec2 pos, ImU32 col, const char* text_begin)
{
    reinterpret_cast<::ImDrawList*>(self)->AddText(reinterpret_cast<const ::ImFont*>(font), font_size, ConvertToCPP_ImVec2(pos), col, text_begin);
}

CIMGUI_API void        cimgui::ImDrawList_AddTextImFontPtrEx(cimgui::ImDrawList* self, const cimgui::ImFont* font, float font_size, cimgui::ImVec2 pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const cimgui::ImVec4* cpu_fine_clip_rect)
{
    reinterpret_cast<::ImDrawList*>(self)->AddText(reinterpret_cast<const ::ImFont*>(font), font_size, ConvertToCPP_ImVec2(pos), col, text_begin, text_end, wrap_width, reinterpret_cast<const ::ImVec4*>(cpu_fine_clip_rect));
}

CIMGUI_API void        cimgui::ImDrawList_AddPolyline(cimgui::ImDrawList* self, const cimgui::ImVec2* points, int num_points, ImU32 col, ImDrawFlags flags, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddPolyline(reinterpret_cast<const ::ImVec2*>(points), num_points, col, flags, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_AddConvexPolyFilled(cimgui::ImDrawList* self, const cimgui::ImVec2* points, int num_points, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddConvexPolyFilled(reinterpret_cast<const ::ImVec2*>(points), num_points, col);
}

CIMGUI_API void        cimgui::ImDrawList_AddBezierCubic(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, ImU32 col, float thickness, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->AddBezierCubic(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), col, thickness, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_AddBezierQuadratic(cimgui::ImDrawList* self, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, ImU32 col, float thickness, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->AddBezierQuadratic(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), col, thickness, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_AddImage(cimgui::ImDrawList* self, ImTextureID user_texture_id, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImage(user_texture_id, ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max));
}

CIMGUI_API void        cimgui::ImDrawList_AddImageEx(cimgui::ImDrawList* self, ImTextureID user_texture_id, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, cimgui::ImVec2 uv_min, cimgui::ImVec2 uv_max, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImage(user_texture_id, ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), ConvertToCPP_ImVec2(uv_min), ConvertToCPP_ImVec2(uv_max), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddImageQuad(cimgui::ImDrawList* self, ImTextureID user_texture_id, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImageQuad(user_texture_id, ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4));
}

CIMGUI_API void        cimgui::ImDrawList_AddImageQuadEx(cimgui::ImDrawList* self, ImTextureID user_texture_id, cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, cimgui::ImVec2 uv1, cimgui::ImVec2 uv2, cimgui::ImVec2 uv3, cimgui::ImVec2 uv4, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImageQuad(user_texture_id, 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        cimgui::ImDrawList_AddImageRounded(cimgui::ImDrawList* self, ImTextureID user_texture_id, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, cimgui::ImVec2 uv_min, cimgui::ImVec2 uv_max, ImU32 col, float rounding, ImDrawFlags flags)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImageRounded(user_texture_id, ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), ConvertToCPP_ImVec2(uv_min), ConvertToCPP_ImVec2(uv_max), col, rounding, flags);
}

CIMGUI_API void        cimgui::ImDrawList_PathClear(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->PathClear();
}

CIMGUI_API void        cimgui::ImDrawList_PathLineTo(cimgui::ImDrawList* self, cimgui::ImVec2 pos)
{
    reinterpret_cast<::ImDrawList*>(self)->PathLineTo(ConvertToCPP_ImVec2(pos));
}

CIMGUI_API void        cimgui::ImDrawList_PathLineToMergeDuplicate(cimgui::ImDrawList* self, cimgui::ImVec2 pos)
{
    reinterpret_cast<::ImDrawList*>(self)->PathLineToMergeDuplicate(ConvertToCPP_ImVec2(pos));
}

CIMGUI_API void        cimgui::ImDrawList_PathFillConvex(cimgui::ImDrawList* self, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PathFillConvex(col);
}

CIMGUI_API void        cimgui::ImDrawList_PathStroke(cimgui::ImDrawList* self, ImU32 col, ImDrawFlags flags, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->PathStroke(col, flags, thickness);
}

CIMGUI_API void        cimgui::ImDrawList_PathArcTo(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, float a_min, float a_max, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->PathArcTo(ConvertToCPP_ImVec2(center), radius, a_min, a_max, num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_PathArcToFast(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, int a_min_of_12, int a_max_of_12)
{
    reinterpret_cast<::ImDrawList*>(self)->PathArcToFast(ConvertToCPP_ImVec2(center), radius, a_min_of_12, a_max_of_12);
}

CIMGUI_API void        cimgui::ImDrawList_PathBezierCubicCurveTo(cimgui::ImDrawList* self, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->PathBezierCubicCurveTo(ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_PathBezierQuadraticCurveTo(cimgui::ImDrawList* self, cimgui::ImVec2 p2, cimgui::ImVec2 p3, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->PathBezierQuadraticCurveTo(ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), num_segments);
}

CIMGUI_API void        cimgui::ImDrawList_PathRect(cimgui::ImDrawList* self, cimgui::ImVec2 rect_min, cimgui::ImVec2 rect_max, float rounding, ImDrawFlags flags)
{
    reinterpret_cast<::ImDrawList*>(self)->PathRect(ConvertToCPP_ImVec2(rect_min), ConvertToCPP_ImVec2(rect_max), rounding, flags);
}

CIMGUI_API void        cimgui::ImDrawList_AddCallback(cimgui::ImDrawList* self, cimgui::ImDrawCallback callback, void* callback_data)
{
    reinterpret_cast<::ImDrawList*>(self)->AddCallback(reinterpret_cast<::ImDrawCallback>(callback), callback_data);
}

CIMGUI_API void        cimgui::ImDrawList_AddDrawCmd(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->AddDrawCmd();
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImDrawList_CloneOutput(const cimgui::ImDrawList* self)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(reinterpret_cast<const ::ImDrawList*>(self)->CloneOutput());
}

CIMGUI_API void        cimgui::ImDrawList_ChannelsSplit(cimgui::ImDrawList* self, int count)
{
    reinterpret_cast<::ImDrawList*>(self)->ChannelsSplit(count);
}

CIMGUI_API void        cimgui::ImDrawList_ChannelsMerge(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->ChannelsMerge();
}

CIMGUI_API void        cimgui::ImDrawList_ChannelsSetCurrent(cimgui::ImDrawList* self, int n)
{
    reinterpret_cast<::ImDrawList*>(self)->ChannelsSetCurrent(n);
}

CIMGUI_API void        cimgui::ImDrawList_PrimReserve(cimgui::ImDrawList* self, int idx_count, int vtx_count)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimReserve(idx_count, vtx_count);
}

CIMGUI_API void        cimgui::ImDrawList_PrimUnreserve(cimgui::ImDrawList* self, int idx_count, int vtx_count)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimUnreserve(idx_count, vtx_count);
}

CIMGUI_API void        cimgui::ImDrawList_PrimRect(cimgui::ImDrawList* self, cimgui::ImVec2 a, cimgui::ImVec2 b, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimRect(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), col);
}

CIMGUI_API void        cimgui::ImDrawList_PrimRectUV(cimgui::ImDrawList* self, cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 uv_a, cimgui::ImVec2 uv_b, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimRectUV(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(uv_a), ConvertToCPP_ImVec2(uv_b), col);
}

CIMGUI_API void        cimgui::ImDrawList_PrimQuadUV(cimgui::ImDrawList* self, cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 d, cimgui::ImVec2 uv_a, cimgui::ImVec2 uv_b, cimgui::ImVec2 uv_c, cimgui::ImVec2 uv_d, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(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        cimgui::ImDrawList_PrimWriteVtx(cimgui::ImDrawList* self, cimgui::ImVec2 pos, cimgui::ImVec2 uv, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimWriteVtx(ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(uv), col);
}

CIMGUI_API void        cimgui::ImDrawList_PrimWriteIdx(cimgui::ImDrawList* self, ImDrawIdx idx)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimWriteIdx(idx);
}

CIMGUI_API void        cimgui::ImDrawList_PrimVtx(cimgui::ImDrawList* self, cimgui::ImVec2 pos, cimgui::ImVec2 uv, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PrimVtx(ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(uv), col);
}

CIMGUI_API void        cimgui::ImDrawList__ResetForNewFrame(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_ResetForNewFrame();
}

CIMGUI_API void        cimgui::ImDrawList__ClearFreeMemory(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_ClearFreeMemory();
}

CIMGUI_API void        cimgui::ImDrawList__PopUnusedDrawCmd(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_PopUnusedDrawCmd();
}

CIMGUI_API void        cimgui::ImDrawList__TryMergeDrawCmds(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_TryMergeDrawCmds();
}

CIMGUI_API void        cimgui::ImDrawList__OnChangedClipRect(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_OnChangedClipRect();
}

CIMGUI_API void        cimgui::ImDrawList__OnChangedTextureID(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_OnChangedTextureID();
}

CIMGUI_API void        cimgui::ImDrawList__OnChangedVtxOffset(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_OnChangedVtxOffset();
}

CIMGUI_API int         cimgui::ImDrawList__CalcCircleAutoSegmentCount(const cimgui::ImDrawList* self, float radius)
{
    return reinterpret_cast<const ::ImDrawList*>(self)->_CalcCircleAutoSegmentCount(radius);
}

CIMGUI_API void        cimgui::ImDrawList__PathArcToFastEx(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, int a_min_sample, int a_max_sample, int a_step)
{
    reinterpret_cast<::ImDrawList*>(self)->_PathArcToFastEx(ConvertToCPP_ImVec2(center), radius, a_min_sample, a_max_sample, a_step);
}

CIMGUI_API void        cimgui::ImDrawList__PathArcToN(cimgui::ImDrawList* self, cimgui::ImVec2 center, float radius, float a_min, float a_max, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->_PathArcToN(ConvertToCPP_ImVec2(center), radius, a_min, a_max, num_segments);
}

CIMGUI_API void cimgui::ImDrawData_Clear(cimgui::ImDrawData* self)
{
    reinterpret_cast<::ImDrawData*>(self)->Clear();
}

CIMGUI_API void cimgui::ImDrawData_DeIndexAllBuffers(cimgui::ImDrawData* self)
{
    reinterpret_cast<::ImDrawData*>(self)->DeIndexAllBuffers();
}

CIMGUI_API void cimgui::ImDrawData_ScaleClipRects(cimgui::ImDrawData* self, cimgui::ImVec2 fb_scale)
{
    reinterpret_cast<::ImDrawData*>(self)->ScaleClipRects(ConvertToCPP_ImVec2(fb_scale));
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_Clear(cimgui::ImFontGlyphRangesBuilder* self)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->Clear();
}

CIMGUI_API bool cimgui::ImFontGlyphRangesBuilder_GetBit(const cimgui::ImFontGlyphRangesBuilder* self, size_t n)
{
    return reinterpret_cast<const ::ImFontGlyphRangesBuilder*>(self)->GetBit(n);
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_SetBit(cimgui::ImFontGlyphRangesBuilder* self, size_t n)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->SetBit(n);
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_AddChar(cimgui::ImFontGlyphRangesBuilder* self, ImWchar c)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->AddChar(c);
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_AddText(cimgui::ImFontGlyphRangesBuilder* self, const char* text, const char* text_end)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->AddText(text, text_end);
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_AddRanges(cimgui::ImFontGlyphRangesBuilder* self, const ImWchar* ranges)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->AddRanges(ranges);
}

CIMGUI_API void cimgui::ImFontGlyphRangesBuilder_BuildRanges(cimgui::ImFontGlyphRangesBuilder* self, cimgui::ImVector_ImWchar* out_ranges)
{
    reinterpret_cast<::ImFontGlyphRangesBuilder*>(self)->BuildRanges(reinterpret_cast<::ImVector<::ImWchar>*>(out_ranges));
}

CIMGUI_API bool cimgui::ImFontAtlasCustomRect_IsPacked(const cimgui::ImFontAtlasCustomRect* self)
{
    return reinterpret_cast<const ::ImFontAtlasCustomRect*>(self)->IsPacked();
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFont(cimgui::ImFontAtlas* self, const cimgui::ImFontConfig* font_cfg)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFont(reinterpret_cast<const ::ImFontConfig*>(font_cfg)));
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFontDefault(cimgui::ImFontAtlas* self, const cimgui::ImFontConfig* font_cfg)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontDefault(reinterpret_cast<const ::ImFontConfig*>(font_cfg)));
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFontFromFileTTF(cimgui::ImFontAtlas* self, const char* filename, float size_pixels, const cimgui::ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontFromFileTTF(filename, size_pixels, reinterpret_cast<const ::ImFontConfig*>(font_cfg), glyph_ranges));
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFontFromMemoryTTF(cimgui::ImFontAtlas* self, void* font_data, int font_size, float size_pixels, const cimgui::ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontFromMemoryTTF(font_data, font_size, size_pixels, reinterpret_cast<const ::ImFontConfig*>(font_cfg), glyph_ranges));
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFontFromMemoryCompressedTTF(cimgui::ImFontAtlas* self, const void* compressed_font_data, int compressed_font_size, float size_pixels, const cimgui::ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontFromMemoryCompressedTTF(compressed_font_data, compressed_font_size, size_pixels, reinterpret_cast<const ::ImFontConfig*>(font_cfg), glyph_ranges));
}

CIMGUI_API cimgui::ImFont*        cimgui::ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(cimgui::ImFontAtlas* self, const char* compressed_font_data_base85, float size_pixels, const cimgui::ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85, size_pixels, reinterpret_cast<const ::ImFontConfig*>(font_cfg), glyph_ranges));
}

CIMGUI_API void                   cimgui::ImFontAtlas_ClearInputData(cimgui::ImFontAtlas* self)
{
    reinterpret_cast<::ImFontAtlas*>(self)->ClearInputData();
}

CIMGUI_API void                   cimgui::ImFontAtlas_ClearTexData(cimgui::ImFontAtlas* self)
{
    reinterpret_cast<::ImFontAtlas*>(self)->ClearTexData();
}

CIMGUI_API void                   cimgui::ImFontAtlas_ClearFonts(cimgui::ImFontAtlas* self)
{
    reinterpret_cast<::ImFontAtlas*>(self)->ClearFonts();
}

CIMGUI_API void                   cimgui::ImFontAtlas_Clear(cimgui::ImFontAtlas* self)
{
    reinterpret_cast<::ImFontAtlas*>(self)->Clear();
}

CIMGUI_API bool                   cimgui::ImFontAtlas_Build(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->Build();
}

CIMGUI_API void                   cimgui::ImFontAtlas_GetTexDataAsAlpha8(cimgui::ImFontAtlas* self, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    reinterpret_cast<::ImFontAtlas*>(self)->GetTexDataAsAlpha8(out_pixels, out_width, out_height, out_bytes_per_pixel);
}

CIMGUI_API void                   cimgui::ImFontAtlas_GetTexDataAsRGBA32(cimgui::ImFontAtlas* self, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    reinterpret_cast<::ImFontAtlas*>(self)->GetTexDataAsRGBA32(out_pixels, out_width, out_height, out_bytes_per_pixel);
}

CIMGUI_API bool                   cimgui::ImFontAtlas_IsBuilt(const cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<const ::ImFontAtlas*>(self)->IsBuilt();
}

CIMGUI_API void                   cimgui::ImFontAtlas_SetTexID(cimgui::ImFontAtlas* self, ImTextureID id)
{
    reinterpret_cast<::ImFontAtlas*>(self)->SetTexID(id);
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesDefault(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesDefault();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesGreek(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesGreek();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesKorean(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesKorean();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesJapanese(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesJapanese();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesChineseFull(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesChineseFull();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesChineseSimplifiedCommon();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesCyrillic(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesCyrillic();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesThai(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesThai();
}

CIMGUI_API const ImWchar*         cimgui::ImFontAtlas_GetGlyphRangesVietnamese(cimgui::ImFontAtlas* self)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->GetGlyphRangesVietnamese();
}

CIMGUI_API int                    cimgui::ImFontAtlas_AddCustomRectRegular(cimgui::ImFontAtlas* self, int width, int height)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->AddCustomRectRegular(width, height);
}

CIMGUI_API int                    cimgui::ImFontAtlas_AddCustomRectFontGlyph(cimgui::ImFontAtlas* self, cimgui::ImFont* font, ImWchar id, int width, int height, float advance_x, cimgui::ImVec2 offset)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->AddCustomRectFontGlyph(reinterpret_cast<::ImFont*>(font), id, width, height, advance_x, ConvertToCPP_ImVec2(offset));
}

CIMGUI_API cimgui::ImFontAtlasCustomRect* cimgui::ImFontAtlas_GetCustomRectByIndex(cimgui::ImFontAtlas* self, int index)
{
    return reinterpret_cast<::cimgui::ImFontAtlasCustomRect*>(reinterpret_cast<::ImFontAtlas*>(self)->GetCustomRectByIndex(index));
}

CIMGUI_API void                   cimgui::ImFontAtlas_CalcCustomRectUV(const cimgui::ImFontAtlas* self, const cimgui::ImFontAtlasCustomRect* rect, cimgui::ImVec2* out_uv_min, cimgui::ImVec2* out_uv_max)
{
    reinterpret_cast<const ::ImFontAtlas*>(self)->CalcCustomRectUV(reinterpret_cast<const ::ImFontAtlasCustomRect*>(rect), reinterpret_cast<::ImVec2*>(out_uv_min), reinterpret_cast<::ImVec2*>(out_uv_max));
}

CIMGUI_API bool                   cimgui::ImFontAtlas_GetMouseCursorTexData(cimgui::ImFontAtlas* self, ImGuiMouseCursor cursor, cimgui::ImVec2* out_offset, cimgui::ImVec2* out_size, cimgui::ImVec2 out_uv_border[2], cimgui::ImVec2 out_uv_fill[2])
{
    ::ImVec2 out_uv_border_converted_array[2];
    for (int i=0; i<2; i++)
        out_uv_border_converted_array[i] = ConvertToCPP_ImVec2(out_uv_border[i]);
    ::ImVec2 out_uv_fill_converted_array[2];
    for (int i=0; i<2; i++)
        out_uv_fill_converted_array[i] = ConvertToCPP_ImVec2(out_uv_fill[i]);
    return reinterpret_cast<::ImFontAtlas*>(self)->GetMouseCursorTexData(cursor, reinterpret_cast<::ImVec2*>(out_offset), reinterpret_cast<::ImVec2*>(out_size), out_uv_border_converted_array, out_uv_fill_converted_array);
}

CIMGUI_API const cimgui::ImFontGlyph* cimgui::ImFont_FindGlyph(const cimgui::ImFont* self, ImWchar c)
{
    return reinterpret_cast<const ::cimgui::ImFontGlyph*>(reinterpret_cast<const ::ImFont*>(self)->FindGlyph(c));
}

CIMGUI_API const cimgui::ImFontGlyph* cimgui::ImFont_FindGlyphNoFallback(const cimgui::ImFont* self, ImWchar c)
{
    return reinterpret_cast<const ::cimgui::ImFontGlyph*>(reinterpret_cast<const ::ImFont*>(self)->FindGlyphNoFallback(c));
}

CIMGUI_API float              cimgui::ImFont_GetCharAdvance(const cimgui::ImFont* self, ImWchar c)
{
    return reinterpret_cast<const ::ImFont*>(self)->GetCharAdvance(c);
}

CIMGUI_API bool               cimgui::ImFont_IsLoaded(const cimgui::ImFont* self)
{
    return reinterpret_cast<const ::ImFont*>(self)->IsLoaded();
}

CIMGUI_API const char*        cimgui::ImFont_GetDebugName(const cimgui::ImFont* self)
{
    return reinterpret_cast<const ::ImFont*>(self)->GetDebugName();
}

CIMGUI_API cimgui::ImVec2     cimgui::ImFont_CalcTextSizeA(const cimgui::ImFont* self, float size, float max_width, float wrap_width, const char* text_begin)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImFont*>(self)->CalcTextSizeA(size, max_width, wrap_width, text_begin));
}

CIMGUI_API cimgui::ImVec2     cimgui::ImFont_CalcTextSizeAEx(const cimgui::ImFont* self, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end, const char** remaining)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImFont*>(self)->CalcTextSizeA(size, max_width, wrap_width, text_begin, text_end, remaining));
}

CIMGUI_API const char*        cimgui::ImFont_CalcWordWrapPositionA(const cimgui::ImFont* self, float scale, const char* text, const char* text_end, float wrap_width)
{
    return reinterpret_cast<const ::ImFont*>(self)->CalcWordWrapPositionA(scale, text, text_end, wrap_width);
}

CIMGUI_API void               cimgui::ImFont_RenderChar(const cimgui::ImFont* self, cimgui::ImDrawList* draw_list, float size, cimgui::ImVec2 pos, ImU32 col, ImWchar c)
{
    reinterpret_cast<const ::ImFont*>(self)->RenderChar(reinterpret_cast<::ImDrawList*>(draw_list), size, ConvertToCPP_ImVec2(pos), col, c);
}

CIMGUI_API void               cimgui::ImFont_RenderText(const cimgui::ImFont* self, cimgui::ImDrawList* draw_list, float size, cimgui::ImVec2 pos, ImU32 col, cimgui::ImVec4 clip_rect, const char* text_begin, const char* text_end, float wrap_width, bool cpu_fine_clip)
{
    reinterpret_cast<const ::ImFont*>(self)->RenderText(reinterpret_cast<::ImDrawList*>(draw_list), size, ConvertToCPP_ImVec2(pos), col, ConvertToCPP_ImVec4(clip_rect), text_begin, text_end, wrap_width, cpu_fine_clip);
}

CIMGUI_API void               cimgui::ImFont_BuildLookupTable(cimgui::ImFont* self)
{
    reinterpret_cast<::ImFont*>(self)->BuildLookupTable();
}

CIMGUI_API void               cimgui::ImFont_ClearOutputData(cimgui::ImFont* self)
{
    reinterpret_cast<::ImFont*>(self)->ClearOutputData();
}

CIMGUI_API void               cimgui::ImFont_GrowIndex(cimgui::ImFont* self, int new_size)
{
    reinterpret_cast<::ImFont*>(self)->GrowIndex(new_size);
}

CIMGUI_API void               cimgui::ImFont_AddGlyph(cimgui::ImFont* self, const cimgui::ImFontConfig* src_cfg, ImWchar c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
{
    reinterpret_cast<::ImFont*>(self)->AddGlyph(reinterpret_cast<const ::ImFontConfig*>(src_cfg), c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
}

CIMGUI_API void               cimgui::ImFont_AddRemapChar(cimgui::ImFont* self, ImWchar dst, ImWchar src, bool overwrite_dst)
{
    reinterpret_cast<::ImFont*>(self)->AddRemapChar(dst, src, overwrite_dst);
}

CIMGUI_API void               cimgui::ImFont_SetGlyphVisible(cimgui::ImFont* self, ImWchar c, bool visible)
{
    reinterpret_cast<::ImFont*>(self)->SetGlyphVisible(c, visible);
}

CIMGUI_API bool               cimgui::ImFont_IsGlyphRangeUnused(cimgui::ImFont* self, unsigned int c_begin, unsigned int c_last)
{
    return reinterpret_cast<::ImFont*>(self)->IsGlyphRangeUnused(c_begin, c_last);
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewport_GetCenter(const cimgui::ImGuiViewport* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImGuiViewport*>(self)->GetCenter());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewport_GetWorkCenter(const cimgui::ImGuiViewport* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImGuiViewport*>(self)->GetWorkCenter());
}

#ifndef IMGUI_DISABLE_OBSOLETE_KEYIO

CIMGUI_API cimgui::ImGuiKey cimgui::GetKeyIndex(cimgui::ImGuiKey key)
{
    return static_cast<::cimgui::ImGuiKey>(ImGui::GetKeyIndex(static_cast<::ImGuiKey>(key)));
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_KEYIO

#ifdef IMGUI_DISABLE_OBSOLETE_KEYIO

CIMGUI_API cimgui::ImGuiKey cimgui::GetKeyIndex(cimgui::ImGuiKey key)
{
    return static_cast<::cimgui::ImGuiKey>(ImGui::GetKeyIndex(static_cast<::ImGuiKey>(key)));
}

#endif // #ifdef IMGUI_DISABLE_OBSOLETE_KEYIO

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void  cimgui::ImGui_SetItemAllowOverlap(void)
{
    ImGui::SetItemAllowOverlap();
}

CIMGUI_API void  cimgui::ImGui_PushAllowKeyboardFocus(bool tab_stop)
{
    ImGui::PushAllowKeyboardFocus(tab_stop);
}

CIMGUI_API void  cimgui::ImGui_PopAllowKeyboardFocus(void)
{
    ImGui::PopAllowKeyboardFocus();
}

CIMGUI_API bool  cimgui::ImGui_ImageButtonImTextureID(ImTextureID user_texture_id, cimgui::ImVec2 size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, int frame_padding, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col)
{
    return ImGui::ImageButton(user_texture_id, ConvertToCPP_ImVec2(size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), frame_padding, ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col));
}

CIMGUI_API void  cimgui::ImGui_CaptureKeyboardFromApp(bool want_capture_keyboard)
{
    ImGui::CaptureKeyboardFromApp(want_capture_keyboard);
}

CIMGUI_API void  cimgui::ImGui_CaptureMouseFromApp(bool want_capture_mouse)
{
    ImGui::CaptureMouseFromApp(want_capture_mouse);
}

CIMGUI_API void  cimgui::ImGui_CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
    ImGui::CalcListClipping(items_count, items_height, out_items_display_start, out_items_display_end);
}

CIMGUI_API float cimgui::ImGui_GetWindowContentRegionWidth(void)
{
    return ImGui::GetWindowContentRegionWidth();
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
#endif // #ifndef IMGUI_DISABLE