// 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>

// Wrap this in a namespace to keep it separate from the C++ API

// This define prevents #defines in the header getting defined again (as they are already in the normal header above),
// and thus generating redefinition warnings
#define DEAR_BINDINGS_INTERNAL_GLUE_CODE
namespace cimgui
{
#include "dcimgui_nodefaultargfunctions.h"
}
#undef DEAR_BINDINGS_INTERNAL_GLUE_CODE

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

// Helpers for setting callbacks that return complex structures in PlatformIO
// These require a thunk in C++-land to work correctly, which is implemented here
// Because some of the functions involved are relatively new, we can't assume they exist and thus we make use
// of some #defines set during the generation process to decide if we want to include the code or not

#if defined(IMGUI_HAS_DOCK)

namespace
{
    // Data we use in the thunk to convert these from C++-style callbacks to C-style callbacks
    struct ImGui_DearBindingsThunkData
    {
        void(*PlatformIO_GetWindowPos_ThunkTarget)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result);
        void(*PlatformIO_GetWindowSize_ThunkTarget)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result);
#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWFRAMEBUFFERSCALE
        void(*PlatformIO_GetWindowFramebufferScale_ThunkTarget)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result);
#endif
#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWWORKAREAINSETS
        void(*PlatformIO_GetWindowWorkAreaInsets_ThunkTarget)(cimgui::ImGuiViewport* vp, cimgui::ImVec4* result);
#endif
    };

    // Get our thunk data for the current ImGui context, creating it if necessary
    ImGui_DearBindingsThunkData* ImGui_GetDearBindingsThunkData()
    {
        ImGuiIO& io = ImGui::GetIO();
        if (!io.BackendLanguageUserData)
        {
            io.BackendLanguageUserData = IM_NEW(ImGui_DearBindingsThunkData);
            memset(io.BackendLanguageUserData, 0, sizeof(ImGui_DearBindingsThunkData));
        }
        return reinterpret_cast<ImGui_DearBindingsThunkData*>(io.BackendLanguageUserData);
    }

    // Tidy up our thunk data, deleting it if all the target pointers are null (i.e. it is unused)
    void ImGui_TidyDearBindingsThunkData()
    {
        ImGuiIO& io = ImGui::GetIO();
        if (io.BackendLanguageUserData)
        {
            ImGui_DearBindingsThunkData* thunkData = reinterpret_cast<ImGui_DearBindingsThunkData*>(io.BackendLanguageUserData);
            if ((!thunkData->PlatformIO_GetWindowPos_ThunkTarget) &&
                (!thunkData->PlatformIO_GetWindowSize_ThunkTarget)
#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWFRAMEBUFFERSCALE
                && (!thunkData->PlatformIO_GetWindowFramebufferScale_ThunkTarget)
#endif
#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWWORKAREAINSETS
                &&(!thunkData->PlatformIO_GetWindowWorkAreaInsets_ThunkTarget)
#endif
                )
            {
                // Thunk data is unused and can be freed
                io.BackendLanguageUserData = nullptr;
                IM_DELETE(thunkData);
            }
        }
    }

    // Copies of the conversion stubs in order to deal with the fact that they are declared later in the file
    // Fixme: This is a little messy, but reordering things is also fiddly to do

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

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

    // Thunks for callbacks that need them

    ImVec2 ImGuiPlatformIO_GetWindowPos_Thunk(ImGuiViewport* vp)
    {
        ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
        cimgui::ImVec2 result;
        thunkData->PlatformIO_GetWindowPos_ThunkTarget(reinterpret_cast<cimgui::ImGuiViewport*>(vp), &result);
        return ConvertToCPP_ImVec2_ForThunks(result);
    }

    ImVec2 ImGuiPlatformIO_GetWindowSize_Thunk(ImGuiViewport* vp)
    {
        ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
        cimgui::ImVec2 result;
        thunkData->PlatformIO_GetWindowSize_ThunkTarget(reinterpret_cast<cimgui::ImGuiViewport*>(vp), &result);
        return ConvertToCPP_ImVec2_ForThunks(result);
    }

#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWFRAMEBUFFERSCALE
    ImVec2 ImGuiPlatformIO_GetWindowFramebufferScale_Thunk(ImGuiViewport* vp)
    {
        ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
        cimgui::ImVec2 result;
        thunkData->PlatformIO_GetWindowFramebufferScale_ThunkTarget(reinterpret_cast<cimgui::ImGuiViewport*>(vp), &result);
        return ConvertToCPP_ImVec2_ForThunks(result);
    }
#endif

#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWWORKAREAINSETS
    ImVec4 ImGuiPlatformIO_GetWindowWorkAreaInsets_Thunk(ImGuiViewport* vp)
    {
        ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
        cimgui::ImVec4 result;
        thunkData->PlatformIO_GetWindowWorkAreaInsets_ThunkTarget(reinterpret_cast<cimgui::ImGuiViewport*>(vp), &result);
        return ConvertToCPP_ImVec4_ForThunks(result);
    }
#endif
} // Anonymous namespace

CIMGUI_API void cimgui::ImGuiPlatformIO_SetPlatform_GetWindowPos(void(*func)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result))
{
    ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
    thunkData->PlatformIO_GetWindowPos_ThunkTarget = func;
    ::ImGui::GetPlatformIO().Platform_GetWindowPos = (func != nullptr) ? ImGuiPlatformIO_GetWindowPos_Thunk : nullptr;
    if (!func)
    {
        ImGui_TidyDearBindingsThunkData(); // Try to release thunk data if no longer required
    }
}

CIMGUI_API void cimgui::ImGuiPlatformIO_SetPlatform_GetWindowSize(void(*func)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result))
{
    ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
    thunkData->PlatformIO_GetWindowSize_ThunkTarget = func;
    ::ImGui::GetPlatformIO().Platform_GetWindowSize = (func != nullptr) ? ImGuiPlatformIO_GetWindowSize_Thunk : nullptr;
    if (!func)
    {
        ImGui_TidyDearBindingsThunkData(); // Try to release thunk data if no longer required
    }
}

#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWFRAMEBUFFERSCALE
CIMGUI_API void cimgui::ImGuiPlatformIO_SetPlatform_GetWindowFramebufferScale(void(*func)(cimgui::ImGuiViewport* vp, cimgui::ImVec2* result))
{
    ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
    thunkData->PlatformIO_GetWindowFramebufferScale_ThunkTarget = func;
    ::ImGui::GetPlatformIO().Platform_GetWindowFramebufferScale = (func != nullptr) ? ImGuiPlatformIO_GetWindowFramebufferScale_Thunk : nullptr;
    if (!func)
    {
        ImGui_TidyDearBindingsThunkData(); // Try to release thunk data if no longer required
    }
}
#endif

#ifdef IMGUI_DEAR_BINDINGS_HAS_GETWINDOWWORKAREAINSETS
CIMGUI_API void cimgui::ImGuiPlatformIO_SetPlatform_GetWindowWorkAreaInsets(void(*func)(cimgui::ImGuiViewport* vp, cimgui::ImVec4* result))
{
    ImGui_DearBindingsThunkData* thunkData = ImGui_GetDearBindingsThunkData();
    thunkData->PlatformIO_GetWindowWorkAreaInsets_ThunkTarget = func;
    ::ImGui::GetPlatformIO().Platform_GetWindowWorkAreaInsets = (func != nullptr) ? ImGuiPlatformIO_GetWindowWorkAreaInsets_Thunk : nullptr;
    if (!func)
    {
        ImGui_TidyDearBindingsThunkData(); // Try to release thunk data if no longer required
    }
}
#endif

#endif // defined(IMGUI_HAS_DOCK)
// 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::ImTextureRef ConvertFromCPP_ImTextureRef(const ::ImTextureRef& src)
{
    cimgui::ImTextureRef dest;
    dest._TexData = reinterpret_cast<cimgui::ImTextureData*>(src._TexData);
    dest._TexID = src._TexID;
    return dest;
}

static inline ::ImTextureRef ConvertToCPP_ImTextureRef(const cimgui::ImTextureRef& src)
{
    ::ImTextureRef dest;
    dest._TexData = reinterpret_cast<::ImTextureData*>(src._TexData);
    dest._TexID = src._TexID;
    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 ImTextureID cimgui::ImTextureRef_GetTexID(const cimgui::ImTextureRef* self)
{
    return reinterpret_cast<const ::ImTextureRef*>(self)->GetTexID();
}

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::ImGuiPlatformIO* cimgui::ImGui_GetPlatformIO(void)
{
    return reinterpret_cast<::cimgui::ImGuiPlatformIO*>(&::ImGui::GetPlatformIO());
}

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_ShowIDStackToolWindow(bool* p_open)
{
    ::ImGui::ShowIDStackToolWindow(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, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
{
    return ::ImGui::BeginChild(str_id, ConvertToCPP_ImVec2(size), child_flags, window_flags);
}

CIMGUI_API bool cimgui::ImGui_BeginChildID(ImGuiID id, cimgui::ImVec2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
{
    return ::ImGui::BeginChild(id, ConvertToCPP_ImVec2(size), child_flags, window_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, 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_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 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_PushFontFloat(cimgui::ImFont* font, float font_size_base_unscaled)
{
    ::ImGui::PushFont(reinterpret_cast<::ImFont*>(font), font_size_base_unscaled);
}

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

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::ImFontBaked* cimgui::ImGui_GetFontBaked(void)
{
    return reinterpret_cast<::cimgui::ImFontBaked*>(::ImGui::GetFontBaked());
}

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(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_PushStyleVarX(ImGuiStyleVar idx, float val_x)
{
    ::ImGui::PushStyleVarX(idx, val_x);
}

CIMGUI_API void cimgui::ImGui_PushStyleVarY(ImGuiStyleVar idx, float val_y)
{
    ::ImGui::PushStyleVarY(idx, val_y);
}

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

CIMGUI_API void cimgui::ImGui_PushItemFlag(ImGuiItemFlags option, bool enabled)
{
    ::ImGui::PushItemFlag(option, enabled);
}

CIMGUI_API void cimgui::ImGui_PopItemFlag(void)
{
    ::ImGui::PopItemFlag();
}

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::ImVec2 cimgui::ImGui_GetFontTexUvWhitePixel(void)
{
    return ConvertFromCPP_ImVec2(::ImGui::GetFontTexUvWhitePixel());
}

CIMGUI_API ImU32         cimgui::ImGui_GetColorU32(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, float alpha_mul)
{
    return ::ImGui::GetColorU32(col, alpha_mul);
}

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

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 cimgui::ImVec2 cimgui::ImGui_GetContentRegionAvail(void)
{
    return ConvertFromCPP_ImVec2(::ImGui::GetContentRegionAvail());
}

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 void  cimgui::ImGui_Separator(void)
{
    ::ImGui::Separator();
}

CIMGUI_API void  cimgui::ImGui_SameLine(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(float indent_w)
{
    ::ImGui::Indent(indent_w);
}

CIMGUI_API void  cimgui::ImGui_Unindent(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 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 ImGuiID cimgui::ImGui_GetIDInt(int int_id)
{
    return ::ImGui::GetID(int_id);
}

CIMGUI_API void cimgui::ImGui_TextUnformatted(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_TextColoredUnformatted(cimgui::ImVec4 col, const char* text)
{
    ::ImGui::TextColored(ConvertToCPP_ImVec4(col), "%s", text);
}

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_TextDisabledUnformatted(const char* text)
{
    ::ImGui::TextDisabled("%s", text);
}

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_TextWrappedUnformatted(const char* text)
{
    ::ImGui::TextWrapped("%s", text);
}

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_LabelTextUnformatted(const char* label, const char* text)
{
    ::ImGui::LabelText(label, "%s", text);
}

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_BulletTextUnformatted(const char* text)
{
    ::ImGui::BulletText("%s", text);
}

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, 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, cimgui::ImGuiDir dir)
{
    return ::ImGui::ArrowButton(str_id, static_cast<::ImGuiDir>(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 bool cimgui::ImGui_TextLink(const char* label)
{
    return ::ImGui::TextLink(label);
}

CIMGUI_API bool cimgui::ImGui_TextLinkOpenURL(const char* label, const char* url)
{
    return ::ImGui::TextLinkOpenURL(label, url);
}

CIMGUI_API void cimgui::ImGui_Image(cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1)
{
    ::ImGui::Image(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1));
}

CIMGUI_API void cimgui::ImGui_ImageWithBg(cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col)
{
    ::ImGui::ImageWithBg(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col));
}

CIMGUI_API bool cimgui::ImGui_ImageButton(const char* str_id, cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col)
{
    return ::ImGui::ImageButton(str_id, ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col));
}

CIMGUI_API bool 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, 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, 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, const char* (*getter)(void* user_data, int idx), void* user_data, int items_count, int popup_max_height_in_items)
{
    return ::ImGui::Combo(label, current_item, getter, user_data, items_count, popup_max_height_in_items);
}

CIMGUI_API bool cimgui::ImGui_DragFloat(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], 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], 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], 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, 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, 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], 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], 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], 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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], const char* format, ImGuiInputTextFlags flags)
{
    return ::ImGui::InputFloat2(label, v, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputFloat3(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], const char* format, ImGuiInputTextFlags flags)
{
    return ::ImGui::InputFloat4(label, v, format, flags);
}

CIMGUI_API bool cimgui::ImGui_InputInt(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, 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, 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, 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, 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);
    auto temp_result = ::ImGui::TreeNodeV(str_id, fmt, args);
    va_end(args);
    return temp_result;
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeStrUnformatted(const char* str_id, const char* text)
{
    return ::ImGui::TreeNode(str_id, "%s", text);
}

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

CIMGUI_API bool  cimgui::ImGui_TreeNodePtrUnformatted(const void* ptr_id, const char* text)
{
    return ::ImGui::TreeNode(ptr_id, "%s", text);
}

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);
    auto temp_result = ::ImGui::TreeNodeExV(str_id, flags, fmt, args);
    va_end(args);
    return temp_result;
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeExStrUnformatted(const char* str_id, ImGuiTreeNodeFlags flags, const char* text)
{
    return ::ImGui::TreeNodeEx(str_id, flags, "%s", text);
}

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

CIMGUI_API bool  cimgui::ImGui_TreeNodeExPtrUnformatted(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* text)
{
    return ::ImGui::TreeNodeEx(ptr_id, flags, "%s", text);
}

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 void  cimgui::ImGui_SetNextItemStorageID(ImGuiID storage_id)
{
    ::ImGui::SetNextItemStorageID(storage_id);
}

CIMGUI_API bool  cimgui::ImGui_TreeNodeGetOpen(ImGuiID storage_id)
{
    return ::ImGui::TreeNodeGetOpen(storage_id);
}

CIMGUI_API bool cimgui::ImGui_Selectable(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, cimgui::ImVec2 size)
{
    return ::ImGui::Selectable(label, p_selected, flags, ConvertToCPP_ImVec2(size));
}

CIMGUI_API cimgui::ImGuiMultiSelectIO* cimgui::ImGui_BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count)
{
    return reinterpret_cast<::cimgui::ImGuiMultiSelectIO*>(::ImGui::BeginMultiSelect(flags, selection_size, items_count));
}

CIMGUI_API cimgui::ImGuiMultiSelectIO* cimgui::ImGui_EndMultiSelect(void)
{
    return reinterpret_cast<::cimgui::ImGuiMultiSelectIO*>(::ImGui::EndMultiSelect());
}

CIMGUI_API void                cimgui::ImGui_SetNextItemSelectionUserData(ImGuiSelectionUserData selection_user_data)
{
    ::ImGui::SetNextItemSelectionUserData(selection_user_data);
}

CIMGUI_API bool                cimgui::ImGui_IsItemToggledSelection(void)
{
    return ::ImGui::IsItemToggledSelection();
}

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, const char* (*getter)(void* user_data, int idx), void* user_data, int items_count, int height_in_items)
{
    return ::ImGui::ListBox(label, current_item, getter, user_data, items_count, height_in_items);
}

CIMGUI_API void cimgui::ImGui_PlotLines(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, 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, 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, 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, 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, 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_SetTooltipUnformatted(const char* text)
{
    ::ImGui::SetTooltip("%s", text);
}

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_SetItemTooltipUnformatted(const char* text)
{
    ::ImGui::SetItemTooltip("%s", text);
}

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(const char* str_id, ImGuiPopupFlags popup_flags)
{
    return ::ImGui::BeginPopupContextItem(str_id, popup_flags);
}

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

CIMGUI_API bool cimgui::ImGui_BeginPopupContextVoid(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 columns, ImGuiTableFlags flags, cimgui::ImVec2 outer_size, float inner_width)
{
    return ::ImGui::BeginTable(str_id, columns, flags, ConvertToCPP_ImVec2(outer_size), inner_width);
}

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

CIMGUI_API void cimgui::ImGui_TableNextRow(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, 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_TableHeader(const char* label)
{
    ::ImGui::TableHeader(label);
}

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

CIMGUI_API void cimgui::ImGui_TableAngledHeadersRow(void)
{
    ::ImGui::TableAngledHeadersRow();
}

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 int                   cimgui::ImGui_TableGetHoveredColumn(void)
{
    return ::ImGui::TableGetHoveredColumn();
}

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(int count, const char* id, bool borders)
{
    ::ImGui::Columns(count, id, borders);
}

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 dockspace_id, cimgui::ImVec2 size, ImGuiDockNodeFlags flags, const cimgui::ImGuiWindowClass* window_class)
{
    return ::ImGui::DockSpace(dockspace_id, ConvertToCPP_ImVec2(size), flags, reinterpret_cast<const ::ImGuiWindowClass*>(window_class));
}

CIMGUI_API ImGuiID cimgui::ImGui_DockSpaceOverViewport(ImGuiID dockspace_id, const cimgui::ImGuiViewport* viewport, ImGuiDockNodeFlags flags, const cimgui::ImGuiWindowClass* window_class)
{
    return ::ImGui::DockSpaceOverViewport(dockspace_id, 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_LogTextUnformatted(const char* text)
{
    ::ImGui::LogText("%s", text);
}

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(int offset)
{
    ::ImGui::SetKeyboardFocusHere(offset);
}

CIMGUI_API void cimgui::ImGui_SetNavCursorVisible(bool visible)
{
    ::ImGui::SetNavCursorVisible(visible);
}

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(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 ImGuiItemFlags cimgui::ImGui_GetItemFlags(void)
{
    return ::ImGui::GetItemFlags();
}

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

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

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetForegroundDrawList(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 cimgui::ImVec2 cimgui::ImGui_CalcTextSize(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, 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 bool        cimgui::ImGui_IsKeyChordPressed(ImGuiKeyChord key_chord)
{
    return ::ImGui::IsKeyChordPressed(key_chord);
}

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_Shortcut(ImGuiKeyChord key_chord, ImGuiInputFlags flags)
{
    return ::ImGui::Shortcut(key_chord, flags);
}

CIMGUI_API void cimgui::ImGui_SetNextItemShortcut(ImGuiKeyChord key_chord, ImGuiInputFlags flags)
{
    ::ImGui::SetNextItemShortcut(key_chord, flags);
}

CIMGUI_API void cimgui::ImGui_SetItemKeyOwner(cimgui::ImGuiKey key)
{
    ::ImGui::SetItemKeyOwner(static_cast<::ImGuiKey>(key));
}

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

CIMGUI_API bool             cimgui::ImGui_IsMouseClicked(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 bool             cimgui::ImGui_IsMouseReleasedWithDelay(ImGuiMouseButton button, float delay)
{
    return ::ImGui::IsMouseReleasedWithDelay(button, delay);
}

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, 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(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 void  cimgui::ImGui_DebugFlashStyleColor(ImGuiCol idx)
{
    ::ImGui::DebugFlashStyleColor(idx);
}

CIMGUI_API void  cimgui::ImGui_DebugStartItemPicker(void)
{
    ::ImGui::DebugStartItemPicker();
}

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);
}

#ifndef IMGUI_DISABLE_DEBUG_TOOLS

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

CIMGUI_API void cimgui::ImGui_DebugLogUnformatted(const char* text)
{
    ::ImGui::DebugLog("%s", text);
}

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

#endif // #ifndef IMGUI_DISABLE_DEBUG_TOOLS

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 void           cimgui::ImGui_UpdatePlatformWindows(void)
{
    ::ImGui::UpdatePlatformWindows();
}

CIMGUI_API void           cimgui::ImGui_RenderPlatformWindowsDefault(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 viewport_id)
{
    return reinterpret_cast<::cimgui::ImGuiViewport*>(::ImGui::FindViewportByID(viewport_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, 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_ClearEventsQueue(cimgui::ImGuiIO* self)
{
    reinterpret_cast<::ImGuiIO*>(self)->ClearEventsQueue();
}

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

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

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_SetSelection(cimgui::ImGuiInputTextCallbackData* self, int s, int e)
{
    reinterpret_cast<::ImGuiInputTextCallbackData*>(self)->SetSelection(s, e);
}

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_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_resize(cimgui::ImGuiTextBuffer* self, int size)
{
    reinterpret_cast<::ImGuiTextBuffer*>(self)->resize(size);
}

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_BuildSortByKey(cimgui::ImGuiStorage* self)
{
    reinterpret_cast<::ImGuiStorage*>(self)->BuildSortByKey();
}

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

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_IncludeItemByIndex(cimgui::ImGuiListClipper* self, int item_index)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->IncludeItemByIndex(item_index);
}

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

CIMGUI_API void cimgui::ImGuiListClipper_SeekCursorForItem(cimgui::ImGuiListClipper* self, int item_index)
{
    reinterpret_cast<::ImGuiListClipper*>(self)->SeekCursorForItem(item_index);
}

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(float h, float s, float v, float a)
{
    return ConvertFromCPP_ImColor(::ImColor::HSV(h, s, v, a));
}

CIMGUI_API void    cimgui::ImGuiSelectionBasicStorage_ApplyRequests(cimgui::ImGuiSelectionBasicStorage* self, cimgui::ImGuiMultiSelectIO* ms_io)
{
    reinterpret_cast<::ImGuiSelectionBasicStorage*>(self)->ApplyRequests(reinterpret_cast<::ImGuiMultiSelectIO*>(ms_io));
}

CIMGUI_API bool    cimgui::ImGuiSelectionBasicStorage_Contains(const cimgui::ImGuiSelectionBasicStorage* self, ImGuiID id)
{
    return reinterpret_cast<const ::ImGuiSelectionBasicStorage*>(self)->Contains(id);
}

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

CIMGUI_API void    cimgui::ImGuiSelectionBasicStorage_Swap(cimgui::ImGuiSelectionBasicStorage* self, cimgui::ImGuiSelectionBasicStorage* r)
{
    reinterpret_cast<::ImGuiSelectionBasicStorage*>(self)->Swap(reinterpret_cast<::ImGuiSelectionBasicStorage&>(*r));
}

CIMGUI_API void    cimgui::ImGuiSelectionBasicStorage_SetItemSelected(cimgui::ImGuiSelectionBasicStorage* self, ImGuiID id, bool selected)
{
    reinterpret_cast<::ImGuiSelectionBasicStorage*>(self)->SetItemSelected(id, selected);
}

CIMGUI_API bool    cimgui::ImGuiSelectionBasicStorage_GetNextSelectedItem(cimgui::ImGuiSelectionBasicStorage* self, void** opaque_it, ImGuiID* out_id)
{
    return reinterpret_cast<::ImGuiSelectionBasicStorage*>(self)->GetNextSelectedItem(opaque_it, out_id);
}

CIMGUI_API ImGuiID cimgui::ImGuiSelectionBasicStorage_GetStorageIdFromIndex(cimgui::ImGuiSelectionBasicStorage* self, int idx)
{
    return reinterpret_cast<::ImGuiSelectionBasicStorage*>(self)->GetStorageIdFromIndex(idx);
}

CIMGUI_API void cimgui::ImGuiSelectionExternalStorage_ApplyRequests(cimgui::ImGuiSelectionExternalStorage* self, cimgui::ImGuiMultiSelectIO* ms_io)
{
    reinterpret_cast<::ImGuiSelectionExternalStorage*>(self)->ApplyRequests(reinterpret_cast<::ImGuiMultiSelectIO*>(ms_io));
}

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_PushTexture(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref)
{
    reinterpret_cast<::ImDrawList*>(self)->PushTexture(ConvertToCPP_ImTextureRef(tex_ref));
}

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

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, 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, 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, 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, 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, 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, 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, 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_AddEllipse(cimgui::ImDrawList* self, cimgui::ImVec2 center, cimgui::ImVec2 radius, ImU32 col, float rot, int num_segments, float thickness)
{
    reinterpret_cast<::ImDrawList*>(self)->AddEllipse(ConvertToCPP_ImVec2(center), ConvertToCPP_ImVec2(radius), col, rot, num_segments, thickness);
}

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

CIMGUI_API void        cimgui::ImDrawList_AddText(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, 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<::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_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_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_AddConcavePolyFilled(cimgui::ImDrawList* self, const cimgui::ImVec2* points, int num_points, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddConcavePolyFilled(reinterpret_cast<const ::ImVec2*>(points), num_points, col);
}

CIMGUI_API void        cimgui::ImDrawList_AddImage(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, cimgui::ImVec2 uv_min, cimgui::ImVec2 uv_max, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->AddImage(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), ConvertToCPP_ImVec2(uv_min), ConvertToCPP_ImVec2(uv_max), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddImageQuad(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref, 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(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec2(uv2), ConvertToCPP_ImVec2(uv3), ConvertToCPP_ImVec2(uv4), col);
}

CIMGUI_API void        cimgui::ImDrawList_AddImageRounded(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref, 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(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), ConvertToCPP_ImVec2(uv_min), ConvertToCPP_ImVec2(uv_max), col, rounding, flags);
}

CIMGUI_API void        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_PathFillConcave(cimgui::ImDrawList* self, ImU32 col)
{
    reinterpret_cast<::ImDrawList*>(self)->PathFillConcave(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_PathEllipticalArcTo(cimgui::ImDrawList* self, cimgui::ImVec2 center, cimgui::ImVec2 radius, float rot, float a_min, float a_max, int num_segments)
{
    reinterpret_cast<::ImDrawList*>(self)->PathEllipticalArcTo(ConvertToCPP_ImVec2(center), ConvertToCPP_ImVec2(radius), rot, a_min, a_max, num_segments);
}

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* userdata, size_t userdata_size)
{
    reinterpret_cast<::ImDrawList*>(self)->AddCallback(reinterpret_cast<::ImDrawCallback>(callback), userdata, userdata_size);
}

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);
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void cimgui::ImDrawList_PushTextureID(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref)
{
    reinterpret_cast<::ImDrawList*>(self)->PushTextureID(ConvertToCPP_ImTextureRef(tex_ref));
}

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

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void        cimgui::ImDrawList__SetDrawListSharedData(cimgui::ImDrawList* self, cimgui::ImDrawListSharedData* data)
{
    reinterpret_cast<::ImDrawList*>(self)->_SetDrawListSharedData(reinterpret_cast<::ImDrawListSharedData*>(data));
}

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__OnChangedTexture(cimgui::ImDrawList* self)
{
    reinterpret_cast<::ImDrawList*>(self)->_OnChangedTexture();
}

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

CIMGUI_API void        cimgui::ImDrawList__SetTexture(cimgui::ImDrawList* self, cimgui::ImTextureRef tex_ref)
{
    reinterpret_cast<::ImDrawList*>(self)->_SetTexture(ConvertToCPP_ImTextureRef(tex_ref));
}

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_AddDrawList(cimgui::ImDrawData* self, cimgui::ImDrawList* draw_list)
{
    reinterpret_cast<::ImDrawData*>(self)->AddDrawList(reinterpret_cast<::ImDrawList*>(draw_list));
}

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::ImTextureData_Create(cimgui::ImTextureData* self, cimgui::ImTextureFormat format, int w, int h)
{
    reinterpret_cast<::ImTextureData*>(self)->Create(static_cast<::ImTextureFormat>(format), w, h);
}

CIMGUI_API void         cimgui::ImTextureData_DestroyPixels(cimgui::ImTextureData* self)
{
    reinterpret_cast<::ImTextureData*>(self)->DestroyPixels();
}

CIMGUI_API void*        cimgui::ImTextureData_GetPixels(cimgui::ImTextureData* self)
{
    return reinterpret_cast<::ImTextureData*>(self)->GetPixels();
}

CIMGUI_API void*        cimgui::ImTextureData_GetPixelsAt(cimgui::ImTextureData* self, int x, int y)
{
    return reinterpret_cast<::ImTextureData*>(self)->GetPixelsAt(x, y);
}

CIMGUI_API int          cimgui::ImTextureData_GetSizeInBytes(const cimgui::ImTextureData* self)
{
    return reinterpret_cast<const ::ImTextureData*>(self)->GetSizeInBytes();
}

CIMGUI_API int          cimgui::ImTextureData_GetPitch(const cimgui::ImTextureData* self)
{
    return reinterpret_cast<const ::ImTextureData*>(self)->GetPitch();
}

CIMGUI_API cimgui::ImTextureRef cimgui::ImTextureData_GetTexRef(cimgui::ImTextureData* self)
{
    return ConvertFromCPP_ImTextureRef(reinterpret_cast<::ImTextureData*>(self)->GetTexRef());
}

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

CIMGUI_API void         cimgui::ImTextureData_SetTexID(cimgui::ImTextureData* self, ImTextureID tex_id)
{
    reinterpret_cast<::ImTextureData*>(self)->SetTexID(tex_id);
}

CIMGUI_API void         cimgui::ImTextureData_SetStatus(cimgui::ImTextureData* self, cimgui::ImTextureStatus status)
{
    reinterpret_cast<::ImTextureData*>(self)->SetStatus(static_cast<::ImTextureStatus>(status));
}

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 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_AddFontDefaultVector(cimgui::ImFontAtlas* self, const cimgui::ImFontConfig* font_cfg)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontDefaultVector(reinterpret_cast<const ::ImFontConfig*>(font_cfg)));
}

CIMGUI_API cimgui::ImFont*   cimgui::ImFontAtlas_AddFontDefaultBitmap(cimgui::ImFontAtlas* self, const cimgui::ImFontConfig* font_cfg)
{
    return reinterpret_cast<::cimgui::ImFont*>(reinterpret_cast<::ImFontAtlas*>(self)->AddFontDefaultBitmap(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_data_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_data_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_data_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_data_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_RemoveFont(cimgui::ImFontAtlas* self, cimgui::ImFont* font)
{
    reinterpret_cast<::ImFontAtlas*>(self)->RemoveFont(reinterpret_cast<::ImFont*>(font));
}

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

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

CIMGUI_API void              cimgui::ImFontAtlas_SetFontLoader(cimgui::ImFontAtlas* self, const cimgui::ImFontLoader* font_loader)
{
    reinterpret_cast<::ImFontAtlas*>(self)->SetFontLoader(reinterpret_cast<const ::ImFontLoader*>(font_loader));
}

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

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

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

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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 void cimgui::ImFontAtlas_SetTexID(cimgui::ImFontAtlas* self, ImTextureID id)
{
    reinterpret_cast<::ImFontAtlas*>(self)->SetTexID(id);
}

CIMGUI_API void cimgui::ImFontAtlas_SetTexIDImTextureRef(cimgui::ImFontAtlas* self, cimgui::ImTextureRef id)
{
    reinterpret_cast<::ImFontAtlas*>(self)->SetTexID(ConvertToCPP_ImTextureRef(id));
}

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

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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();
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API ImFontAtlasRectId cimgui::ImFontAtlas_AddCustomRect(cimgui::ImFontAtlas* self, int width, int height, cimgui::ImFontAtlasRect* out_r)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->AddCustomRect(width, height, reinterpret_cast<::ImFontAtlasRect*>(out_r));
}

CIMGUI_API void              cimgui::ImFontAtlas_RemoveCustomRect(cimgui::ImFontAtlas* self, ImFontAtlasRectId id)
{
    reinterpret_cast<::ImFontAtlas*>(self)->RemoveCustomRect(id);
}

CIMGUI_API bool              cimgui::ImFontAtlas_GetCustomRect(const cimgui::ImFontAtlas* self, ImFontAtlasRectId id, cimgui::ImFontAtlasRect* out_r)
{
    return reinterpret_cast<const ::ImFontAtlas*>(self)->GetCustomRect(id, reinterpret_cast<::ImFontAtlasRect*>(out_r));
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

CIMGUI_API const cimgui::ImFontAtlasRect* cimgui::ImFontAtlas_GetCustomRectByIndex(cimgui::ImFontAtlas* self, ImFontAtlasRectId id)
{
    return reinterpret_cast<const ::cimgui::ImFontAtlasRect*>(reinterpret_cast<::ImFontAtlas*>(self)->GetCustomRectByIndex(id));
}

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

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

CIMGUI_API ImFontAtlasRectId      cimgui::ImFontAtlas_AddCustomRectFontGlyphForSize(cimgui::ImFontAtlas* self, cimgui::ImFont* font, float font_size, ImWchar codepoint, int w, int h, float advance_x, cimgui::ImVec2 offset)
{
    return reinterpret_cast<::ImFontAtlas*>(self)->AddCustomRectFontGlyphForSize(reinterpret_cast<::ImFont*>(font), font_size, codepoint, w, h, advance_x, ConvertToCPP_ImVec2(offset));
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

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

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

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

CIMGUI_API bool         cimgui::ImFontBaked_IsGlyphLoaded(cimgui::ImFontBaked* self, ImWchar c)
{
    return reinterpret_cast<::ImFontBaked*>(self)->IsGlyphLoaded(c);
}

CIMGUI_API bool         cimgui::ImFont_IsGlyphInFont(cimgui::ImFont* self, ImWchar c)
{
    return reinterpret_cast<::ImFont*>(self)->IsGlyphInFont(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::ImFontBaked* cimgui::ImFont_GetFontBaked(cimgui::ImFont* self, float font_size, float density)
{
    return reinterpret_cast<::cimgui::ImFontBaked*>(reinterpret_cast<::ImFont*>(self)->GetFontBaked(font_size, density));
}

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

CIMGUI_API const char*  cimgui::ImFont_CalcWordWrapPosition(cimgui::ImFont* self, float size, const char* text, const char* text_end, float wrap_width)
{
    return reinterpret_cast<::ImFont*>(self)->CalcWordWrapPosition(size, text, text_end, wrap_width);
}

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

CIMGUI_API void         cimgui::ImFont_RenderText(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, ImDrawTextFlags flags)
{
    reinterpret_cast<::ImFont*>(self)->RenderText(reinterpret_cast<::ImDrawList*>(draw_list), size, ConvertToCPP_ImVec2(pos), col, ConvertToCPP_ImVec4(clip_rect), text_begin, text_end, wrap_width, flags);
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

CIMGUI_API void         cimgui::ImFont_AddRemapChar(cimgui::ImFont* self, ImWchar from_codepoint, ImWchar to_codepoint)
{
    reinterpret_cast<::ImFont*>(self)->AddRemapChar(from_codepoint, to_codepoint);
}

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());
}

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

CIMGUI_API void cimgui::ImGuiPlatformIO_ClearPlatformHandlers(cimgui::ImGuiPlatformIO* self)
{
    reinterpret_cast<::ImGuiPlatformIO*>(self)->ClearPlatformHandlers();
}

CIMGUI_API void cimgui::ImGuiPlatformIO_ClearRendererHandlers(cimgui::ImGuiPlatformIO* self)
{
    reinterpret_cast<::ImGuiPlatformIO*>(self)->ClearRendererHandlers();
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

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

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

CIMGUI_API void   cimgui::ImGui_ImageImVec4(cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 tint_col, cimgui::ImVec4 border_col)
{
    ::ImGui::Image(ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(tint_col), ConvertToCPP_ImVec4(border_col));
}

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_PushTabStop(bool tab_stop)
{
    ::ImGui::PushTabStop(tab_stop);
}

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

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());
}

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