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

// API for exported functions
#ifndef CIMGUI_API
#define CIMGUI_API extern "C"
#endif

#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
{
extern "C"
{
#include "dcimgui_nodefaultargfunctions.h"
#include "dcimgui_nodefaultargfunctions_internal.h"
}
}
#undef DEAR_BINDINGS_INTERNAL_GLUE_CODE// 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;
}

static inline cimgui::ImVec1 ConvertFromCPP_ImVec1(const ::ImVec1& src)
{
    cimgui::ImVec1 dest;
    dest.x = src.x;
    return dest;
}

static inline ::ImVec1 ConvertToCPP_ImVec1(const cimgui::ImVec1& src)
{
    ::ImVec1 dest;
    dest.x = src.x;
    return dest;
}

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

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

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

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

static inline cimgui::ImRect ConvertFromCPP_ImRect(const ::ImRect& src)
{
    cimgui::ImRect dest;
    dest.Min.x = src.Min.x;
    dest.Min.y = src.Min.y;
    dest.Max.x = src.Max.x;
    dest.Max.y = src.Max.y;
    return dest;
}

static inline ::ImRect ConvertToCPP_ImRect(const cimgui::ImRect& src)
{
    ::ImRect dest;
    dest.Min.x = src.Min.x;
    dest.Min.y = src.Min.y;
    dest.Max.x = src.Max.x;
    dest.Max.y = src.Max.y;
    return dest;
}

static inline cimgui::ImGuiListClipperRange ConvertFromCPP_ImGuiListClipperRange(const ::ImGuiListClipperRange& src)
{
    cimgui::ImGuiListClipperRange dest;
    dest.Min = src.Min;
    dest.Max = src.Max;
    dest.PosToIndexConvert = src.PosToIndexConvert;
    dest.PosToIndexOffsetMin = src.PosToIndexOffsetMin;
    dest.PosToIndexOffsetMax = src.PosToIndexOffsetMax;
    return dest;
}

static inline ::ImGuiListClipperRange ConvertToCPP_ImGuiListClipperRange(const cimgui::ImGuiListClipperRange& src)
{
    ::ImGuiListClipperRange dest;
    dest.Min = src.Min;
    dest.Max = src.Max;
    dest.PosToIndexConvert = src.PosToIndexConvert;
    dest.PosToIndexOffsetMin = src.PosToIndexOffsetMin;
    dest.PosToIndexOffsetMax = src.PosToIndexOffsetMax;
    return dest;
}

// Function stubs

#ifndef IMGUI_DISABLE

CIMGUI_API ImGuiID     cimgui::cImHashData(const void* data, size_t data_size, ImGuiID seed)
{
    return ::ImHashData(data, data_size, seed);
}

CIMGUI_API ImGuiID     cimgui::cImHashStr(const char* data, size_t data_size, ImGuiID seed)
{
    return ::ImHashStr(data, data_size, seed);
}

CIMGUI_API const char* cimgui::cImHashSkipUncontributingPrefix(const char* label)
{
    return ::ImHashSkipUncontributingPrefix(label);
}

CIMGUI_API ImU32 cimgui::cImAlphaBlendColors(ImU32 col_a, ImU32 col_b)
{
    return ::ImAlphaBlendColors(col_a, col_b);
}

CIMGUI_API bool         cimgui::cImIsPowerOfTwo(int v)
{
    return ::ImIsPowerOfTwo(v);
}

CIMGUI_API bool         cimgui::cImIsPowerOfTwoImU64(ImU64 v)
{
    return ::ImIsPowerOfTwo(v);
}

CIMGUI_API int          cimgui::cImUpperPowerOfTwo(int v)
{
    return ::ImUpperPowerOfTwo(v);
}

CIMGUI_API unsigned int cimgui::cImCountSetBits(unsigned int v)
{
    return ::ImCountSetBits(v);
}

CIMGUI_API int         cimgui::cImStricmp(const char* str1, const char* str2)
{
    return ::ImStricmp(str1, str2);
}

CIMGUI_API int         cimgui::cImStrnicmp(const char* str1, const char* str2, size_t count)
{
    return ::ImStrnicmp(str1, str2, count);
}

CIMGUI_API void        cimgui::cImStrncpy(char* dst, const char* src, size_t count)
{
    ::ImStrncpy(dst, src, count);
}

CIMGUI_API char*       cimgui::cImStrdup(const char* str)
{
    return ::ImStrdup(str);
}

CIMGUI_API void*       cimgui::cImMemdup(const void* src, size_t size)
{
    return ::ImMemdup(src, size);
}

CIMGUI_API char*       cimgui::cImStrdupcpy(char* dst, size_t* p_dst_size, const char* str)
{
    return ::ImStrdupcpy(dst, p_dst_size, str);
}

CIMGUI_API const char* cimgui::cImStrchrRange(const char* str_begin, const char* str_end, char c)
{
    return ::ImStrchrRange(str_begin, str_end, c);
}

CIMGUI_API const char* cimgui::cImStreolRange(const char* str, const char* str_end)
{
    return ::ImStreolRange(str, str_end);
}

CIMGUI_API const char* cimgui::cImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end)
{
    return ::ImStristr(haystack, haystack_end, needle, needle_end);
}

CIMGUI_API void        cimgui::cImStrTrimBlanks(char* str)
{
    ::ImStrTrimBlanks(str);
}

CIMGUI_API const char* cimgui::cImStrSkipBlank(const char* str)
{
    return ::ImStrSkipBlank(str);
}

CIMGUI_API int         cimgui::cImStrlenW(const ImWchar* str)
{
    return ::ImStrlenW(str);
}

CIMGUI_API const char* cimgui::cImStrbol(const char* buf_mid_line, const char* buf_begin)
{
    return ::ImStrbol(buf_mid_line, buf_begin);
}

CIMGUI_API char        cimgui::cImToUpper(char c)
{
    return ::ImToUpper(c);
}

CIMGUI_API bool        cimgui::cImCharIsBlankA(char c)
{
    return ::ImCharIsBlankA(c);
}

CIMGUI_API bool        cimgui::cImCharIsBlankW(unsigned int c)
{
    return ::ImCharIsBlankW(c);
}

CIMGUI_API bool        cimgui::cImCharIsXdigitA(char c)
{
    return ::ImCharIsXdigitA(c);
}

CIMGUI_API int         cimgui::cImFormatString(char* buf, size_t buf_size, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    auto temp_result = ::ImFormatStringV(buf, buf_size, fmt, args);
    va_end(args);
    return temp_result;
}

CIMGUI_API int         cimgui::cImFormatStringUnformatted(char* buf, size_t buf_size, const char* text)
{
    return ::ImFormatString(buf, buf_size, "%s", text);
}

CIMGUI_API int         cimgui::cImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args)
{
    return ::ImFormatStringV(buf, buf_size, fmt, args);
}

CIMGUI_API void        cimgui::cImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
    va_end(args);
}

CIMGUI_API void        cimgui::cImFormatStringToTempBufferUnformatted(const char** out_buf, const char** out_buf_end, const char* text)
{
    ::ImFormatStringToTempBuffer(out_buf, out_buf_end, "%s", text);
}

CIMGUI_API void        cimgui::cImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args)
{
    ::ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
}

CIMGUI_API const char* cimgui::cImParseFormatFindStart(const char* format)
{
    return ::ImParseFormatFindStart(format);
}

CIMGUI_API const char* cimgui::cImParseFormatFindEnd(const char* format)
{
    return ::ImParseFormatFindEnd(format);
}

CIMGUI_API const char* cimgui::cImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size)
{
    return ::ImParseFormatTrimDecorations(format, buf, buf_size);
}

CIMGUI_API void        cimgui::cImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size)
{
    ::ImParseFormatSanitizeForPrinting(fmt_in, fmt_out, fmt_out_size);
}

CIMGUI_API const char* cimgui::cImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size)
{
    return ::ImParseFormatSanitizeForScanning(fmt_in, fmt_out, fmt_out_size);
}

CIMGUI_API int         cimgui::cImParseFormatPrecision(const char* format, int default_value)
{
    return ::ImParseFormatPrecision(format, default_value);
}

CIMGUI_API int         cimgui::cImTextCharToUtf8(char out_buf[5], unsigned int c)
{
    return ::ImTextCharToUtf8(out_buf, c);
}

CIMGUI_API int         cimgui::cImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
    return ::ImTextStrToUtf8(out_buf, out_buf_size, in_text, in_text_end);
}

CIMGUI_API int         cimgui::cImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end)
{
    return ::ImTextCharFromUtf8(out_char, in_text, in_text_end);
}

CIMGUI_API int         cimgui::cImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining)
{
    return ::ImTextStrFromUtf8(out_buf, out_buf_size, in_text, in_text_end, in_remaining);
}

CIMGUI_API int         cimgui::cImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)
{
    return ::ImTextCountCharsFromUtf8(in_text, in_text_end);
}

CIMGUI_API int         cimgui::cImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end)
{
    return ::ImTextCountUtf8BytesFromChar(in_text, in_text_end);
}

CIMGUI_API int         cimgui::cImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end)
{
    return ::ImTextCountUtf8BytesFromStr(in_text, in_text_end);
}

CIMGUI_API const char* cimgui::cImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_p)
{
    return ::ImTextFindPreviousUtf8Codepoint(in_text_start, in_p);
}

CIMGUI_API const char* cimgui::cImTextFindValidUtf8CodepointEnd(const char* in_text_start, const char* in_text_end, const char* in_p)
{
    return ::ImTextFindValidUtf8CodepointEnd(in_text_start, in_text_end, in_p);
}

CIMGUI_API int         cimgui::cImTextCountLines(const char* in_text, const char* in_text_end)
{
    return ::ImTextCountLines(in_text, in_text_end);
}

CIMGUI_API cimgui::ImVec2 cimgui::cImFontCalcTextSizeEx(cimgui::ImFont* font, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining, cimgui::ImVec2* out_offset, ImDrawTextFlags flags)
{
    return ConvertFromCPP_ImVec2(::ImFontCalcTextSizeEx(reinterpret_cast<::ImFont*>(font), size, max_width, wrap_width, text_begin, text_end_display, text_end, out_remaining, reinterpret_cast<::ImVec2*>(out_offset), flags));
}

CIMGUI_API const char* cimgui::cImFontCalcWordWrapPositionEx(cimgui::ImFont* font, float size, const char* text, const char* text_end, float wrap_width, ImDrawTextFlags flags)
{
    return ::ImFontCalcWordWrapPositionEx(reinterpret_cast<::ImFont*>(font), size, text, text_end, wrap_width, flags);
}

CIMGUI_API const char* cimgui::cImTextCalcWordWrapNextLineStart(const char* text, const char* text_end, ImDrawTextFlags flags)
{
    return ::ImTextCalcWordWrapNextLineStart(text, text_end, flags);
}

CIMGUI_API void cimgui::cImTextInitClassifiers(void)
{
    ::ImTextInitClassifiers();
}

CIMGUI_API void cimgui::cImTextClassifierClear(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, cimgui::ImWcharClass char_class)
{
    ::ImTextClassifierClear(bits, codepoint_min, codepoint_end, static_cast<::ImWcharClass>(char_class));
}

CIMGUI_API void cimgui::cImTextClassifierSetCharClass(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, cimgui::ImWcharClass char_class, unsigned int c)
{
    ::ImTextClassifierSetCharClass(bits, codepoint_min, codepoint_end, static_cast<::ImWcharClass>(char_class), c);
}

CIMGUI_API void cimgui::cImTextClassifierSetCharClassFromStr(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, cimgui::ImWcharClass char_class, const char* s)
{
    ::ImTextClassifierSetCharClassFromStr(bits, codepoint_min, codepoint_end, static_cast<::ImWcharClass>(char_class), s);
}

#ifdef IMGUI_DISABLE_FILE_FUNCTIONS

CIMGUI_API ImFileHandle cimgui::cImFileOpen(const char* __unnamed_arg0__, const char* __unnamed_arg1__)
{
    return ::ImFileOpen(__unnamed_arg0__, __unnamed_arg1__);
}

CIMGUI_API bool         cimgui::cImFileClose(ImFileHandle __unnamed_arg0__)
{
    return ::ImFileClose(__unnamed_arg0__);
}

CIMGUI_API ImU64        cimgui::cImFileGetSize(ImFileHandle __unnamed_arg0__)
{
    return ::ImFileGetSize(__unnamed_arg0__);
}

CIMGUI_API ImU64        cimgui::cImFileRead(void* __unnamed_arg0__, ImU64 __unnamed_arg1__, ImU64 __unnamed_arg2__, ImFileHandle __unnamed_arg3__)
{
    return ::ImFileRead(__unnamed_arg0__, __unnamed_arg1__, __unnamed_arg2__, __unnamed_arg3__);
}

CIMGUI_API ImU64        cimgui::cImFileWrite(const void* __unnamed_arg0__, ImU64 __unnamed_arg1__, ImU64 __unnamed_arg2__, ImFileHandle __unnamed_arg3__)
{
    return ::ImFileWrite(__unnamed_arg0__, __unnamed_arg1__, __unnamed_arg2__, __unnamed_arg3__);
}

#endif // #ifdef IMGUI_DISABLE_FILE_FUNCTIONS

#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

CIMGUI_API ImFileHandle cimgui::cImFileOpen(const char* filename, const char* mode)
{
    return ::ImFileOpen(filename, mode);
}

CIMGUI_API bool         cimgui::cImFileClose(ImFileHandle file)
{
    return ::ImFileClose(file);
}

CIMGUI_API ImU64        cimgui::cImFileGetSize(ImFileHandle file)
{
    return ::ImFileGetSize(file);
}

CIMGUI_API ImU64        cimgui::cImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file)
{
    return ::ImFileRead(data, size, count, file);
}

CIMGUI_API ImU64        cimgui::cImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file)
{
    return ::ImFileWrite(data, size, count, file);
}

#endif // #ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

CIMGUI_API void* cimgui::cImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size, int padding_bytes)
{
    return ::ImFileLoadToMemory(filename, mode, out_file_size, padding_bytes);
}

#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

CIMGUI_API float  cimgui::cImPow(float x, float y)
{
    return ::ImPow(x, y);
}

CIMGUI_API double cimgui::cImPowDouble(double x, double y)
{
    return ::ImPow(x, y);
}

CIMGUI_API float  cimgui::cImLog(float x)
{
    return ::ImLog(x);
}

CIMGUI_API double cimgui::cImLogDouble(double x)
{
    return ::ImLog(x);
}

CIMGUI_API int    cimgui::cImAbs(int x)
{
    return ::ImAbs(x);
}

CIMGUI_API float  cimgui::cImAbsFloat(float x)
{
    return ::ImAbs(x);
}

CIMGUI_API double cimgui::cImAbsDouble(double x)
{
    return ::ImAbs(x);
}

CIMGUI_API float  cimgui::cImSign(float x)
{
    return ::ImSign(x);
}

CIMGUI_API double cimgui::cImSignDouble(double x)
{
    return ::ImSign(x);
}

#ifdef IMGUI_ENABLE_SSE

CIMGUI_API float cimgui::cImRsqrt(float x)
{
    return ::ImRsqrt(x);
}

#endif // #ifdef IMGUI_ENABLE_SSE

#ifndef IMGUI_ENABLE_SSE

CIMGUI_API float cimgui::cImRsqrtFloat(float x)
{
    return ::ImRsqrt(x);
}

#endif // #ifndef IMGUI_ENABLE_SSE

CIMGUI_API double cimgui::cImRsqrtDouble(double x)
{
    return ::ImRsqrt(x);
}

#endif // #ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

CIMGUI_API cimgui::ImVec2 cimgui::cImMin(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs)
{
    return ConvertFromCPP_ImVec2(::ImMin(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs)));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImMax(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs)
{
    return ConvertFromCPP_ImVec2(::ImMax(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs)));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImClamp(cimgui::ImVec2 v, cimgui::ImVec2 mn, cimgui::ImVec2 mx)
{
    return ConvertFromCPP_ImVec2(::ImClamp(ConvertToCPP_ImVec2(v), ConvertToCPP_ImVec2(mn), ConvertToCPP_ImVec2(mx)));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImLerp(cimgui::ImVec2 a, cimgui::ImVec2 b, float t)
{
    return ConvertFromCPP_ImVec2(::ImLerp(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), t));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImLerpImVec2(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 t)
{
    return ConvertFromCPP_ImVec2(::ImLerp(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(t)));
}

CIMGUI_API cimgui::ImVec4 cimgui::cImLerpImVec4(cimgui::ImVec4 a, cimgui::ImVec4 b, float t)
{
    return ConvertFromCPP_ImVec4(::ImLerp(ConvertToCPP_ImVec4(a), ConvertToCPP_ImVec4(b), t));
}

CIMGUI_API float  cimgui::cImSaturate(float f)
{
    return ::ImSaturate(f);
}

CIMGUI_API float  cimgui::cImLengthSqr(cimgui::ImVec2 lhs)
{
    return ::ImLengthSqr(ConvertToCPP_ImVec2(lhs));
}

CIMGUI_API float  cimgui::cImLengthSqrImVec4(cimgui::ImVec4 lhs)
{
    return ::ImLengthSqr(ConvertToCPP_ImVec4(lhs));
}

CIMGUI_API float  cimgui::cImInvLength(cimgui::ImVec2 lhs, float fail_value)
{
    return ::ImInvLength(ConvertToCPP_ImVec2(lhs), fail_value);
}

CIMGUI_API float  cimgui::cImTrunc(float f)
{
    return ::ImTrunc(f);
}

CIMGUI_API cimgui::ImVec2 cimgui::cImTruncImVec2(cimgui::ImVec2 v)
{
    return ConvertFromCPP_ImVec2(::ImTrunc(ConvertToCPP_ImVec2(v)));
}

CIMGUI_API float  cimgui::cImFloor(float f)
{
    return ::ImFloor(f);
}

CIMGUI_API cimgui::ImVec2 cimgui::cImFloorImVec2(cimgui::ImVec2 v)
{
    return ConvertFromCPP_ImVec2(::ImFloor(ConvertToCPP_ImVec2(v)));
}

CIMGUI_API float  cimgui::cImTrunc64(float f)
{
    return ::ImTrunc64(f);
}

CIMGUI_API float  cimgui::cImRound64(float f)
{
    return ::ImRound64(f);
}

CIMGUI_API int    cimgui::cImModPositive(int a, int b)
{
    return ::ImModPositive(a, b);
}

CIMGUI_API float  cimgui::cImDot(cimgui::ImVec2 a, cimgui::ImVec2 b)
{
    return ::ImDot(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImRotate(cimgui::ImVec2 v, float cos_a, float sin_a)
{
    return ConvertFromCPP_ImVec2(::ImRotate(ConvertToCPP_ImVec2(v), cos_a, sin_a));
}

CIMGUI_API float  cimgui::cImLinearSweep(float current, float target, float speed)
{
    return ::ImLinearSweep(current, target, speed);
}

CIMGUI_API float  cimgui::cImLinearRemapClamp(float s0, float s1, float d0, float d1, float x)
{
    return ::ImLinearRemapClamp(s0, s1, d0, d1, x);
}

CIMGUI_API cimgui::ImVec2 cimgui::cImMul(cimgui::ImVec2 lhs, cimgui::ImVec2 rhs)
{
    return ConvertFromCPP_ImVec2(::ImMul(ConvertToCPP_ImVec2(lhs), ConvertToCPP_ImVec2(rhs)));
}

CIMGUI_API bool   cimgui::cImIsFloatAboveGuaranteedIntegerPrecision(float f)
{
    return ::ImIsFloatAboveGuaranteedIntegerPrecision(f);
}

CIMGUI_API float  cimgui::cImExponentialMovingAverage(float avg, float sample, int n)
{
    return ::ImExponentialMovingAverage(avg, sample, n);
}

CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicCalc(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, float t)
{
    return ConvertFromCPP_ImVec2(::ImBezierCubicCalc(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), t));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicClosestPoint(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, cimgui::ImVec2 p, int num_segments)
{
    return ConvertFromCPP_ImVec2(::ImBezierCubicClosestPoint(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), ConvertToCPP_ImVec2(p), num_segments));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImBezierCubicClosestPointCasteljau(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, cimgui::ImVec2 p4, cimgui::ImVec2 p, float tess_tol)
{
    return ConvertFromCPP_ImVec2(::ImBezierCubicClosestPointCasteljau(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), ConvertToCPP_ImVec2(p4), ConvertToCPP_ImVec2(p), tess_tol));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImBezierQuadraticCalc(cimgui::ImVec2 p1, cimgui::ImVec2 p2, cimgui::ImVec2 p3, float t)
{
    return ConvertFromCPP_ImVec2(::ImBezierQuadraticCalc(ConvertToCPP_ImVec2(p1), ConvertToCPP_ImVec2(p2), ConvertToCPP_ImVec2(p3), t));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImLineClosestPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 p)
{
    return ConvertFromCPP_ImVec2(::ImLineClosestPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(p)));
}

CIMGUI_API bool   cimgui::cImTriangleContainsPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p)
{
    return ::ImTriangleContainsPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p));
}

CIMGUI_API cimgui::ImVec2 cimgui::cImTriangleClosestPoint(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p)
{
    return ConvertFromCPP_ImVec2(::ImTriangleClosestPoint(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p)));
}

CIMGUI_API void   cimgui::cImTriangleBarycentricCoords(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c, cimgui::ImVec2 p, float* out_u, float* out_v, float* out_w)
{
    ::ImTriangleBarycentricCoords(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c), ConvertToCPP_ImVec2(p), *out_u, *out_v, *out_w);
}

CIMGUI_API float  cimgui::cImTriangleArea(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c)
{
    return ::ImTriangleArea(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c));
}

CIMGUI_API bool   cimgui::cImTriangleIsClockwise(cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 c)
{
    return ::ImTriangleIsClockwise(ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(c));
}

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

CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetSize(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImRect*>(self)->GetSize());
}

CIMGUI_API float  cimgui::ImRect_GetWidth(const cimgui::ImRect* self)
{
    return reinterpret_cast<const ::ImRect*>(self)->GetWidth();
}

CIMGUI_API float  cimgui::ImRect_GetHeight(const cimgui::ImRect* self)
{
    return reinterpret_cast<const ::ImRect*>(self)->GetHeight();
}

CIMGUI_API float  cimgui::ImRect_GetArea(const cimgui::ImRect* self)
{
    return reinterpret_cast<const ::ImRect*>(self)->GetArea();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetTL(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImRect*>(self)->GetTL());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetTR(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImRect*>(self)->GetTR());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetBL(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImRect*>(self)->GetBL());
}

CIMGUI_API cimgui::ImVec2 cimgui::ImRect_GetBR(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImRect*>(self)->GetBR());
}

CIMGUI_API bool   cimgui::ImRect_Contains(const cimgui::ImRect* self, cimgui::ImVec2 p)
{
    return reinterpret_cast<const ::ImRect*>(self)->Contains(ConvertToCPP_ImVec2(p));
}

CIMGUI_API bool   cimgui::ImRect_ContainsImRect(const cimgui::ImRect* self, cimgui::ImRect r)
{
    return reinterpret_cast<const ::ImRect*>(self)->Contains(ConvertToCPP_ImRect(r));
}

CIMGUI_API bool   cimgui::ImRect_ContainsWithPad(const cimgui::ImRect* self, cimgui::ImVec2 p, cimgui::ImVec2 pad)
{
    return reinterpret_cast<const ::ImRect*>(self)->ContainsWithPad(ConvertToCPP_ImVec2(p), ConvertToCPP_ImVec2(pad));
}

CIMGUI_API bool   cimgui::ImRect_Overlaps(const cimgui::ImRect* self, cimgui::ImRect r)
{
    return reinterpret_cast<const ::ImRect*>(self)->Overlaps(ConvertToCPP_ImRect(r));
}

CIMGUI_API void   cimgui::ImRect_Add(cimgui::ImRect* self, cimgui::ImVec2 p)
{
    reinterpret_cast<::ImRect*>(self)->Add(ConvertToCPP_ImVec2(p));
}

CIMGUI_API void   cimgui::ImRect_AddImRect(cimgui::ImRect* self, cimgui::ImRect r)
{
    reinterpret_cast<::ImRect*>(self)->Add(ConvertToCPP_ImRect(r));
}

CIMGUI_API void   cimgui::ImRect_Expand(cimgui::ImRect* self, const float amount)
{
    reinterpret_cast<::ImRect*>(self)->Expand(amount);
}

CIMGUI_API void   cimgui::ImRect_ExpandImVec2(cimgui::ImRect* self, cimgui::ImVec2 amount)
{
    reinterpret_cast<::ImRect*>(self)->Expand(ConvertToCPP_ImVec2(amount));
}

CIMGUI_API void   cimgui::ImRect_Translate(cimgui::ImRect* self, cimgui::ImVec2 d)
{
    reinterpret_cast<::ImRect*>(self)->Translate(ConvertToCPP_ImVec2(d));
}

CIMGUI_API void   cimgui::ImRect_TranslateX(cimgui::ImRect* self, float dx)
{
    reinterpret_cast<::ImRect*>(self)->TranslateX(dx);
}

CIMGUI_API void   cimgui::ImRect_TranslateY(cimgui::ImRect* self, float dy)
{
    reinterpret_cast<::ImRect*>(self)->TranslateY(dy);
}

CIMGUI_API void   cimgui::ImRect_ClipWith(cimgui::ImRect* self, cimgui::ImRect r)
{
    reinterpret_cast<::ImRect*>(self)->ClipWith(ConvertToCPP_ImRect(r));
}

CIMGUI_API void   cimgui::ImRect_ClipWithFull(cimgui::ImRect* self, cimgui::ImRect r)
{
    reinterpret_cast<::ImRect*>(self)->ClipWithFull(ConvertToCPP_ImRect(r));
}

CIMGUI_API bool   cimgui::ImRect_IsInverted(const cimgui::ImRect* self)
{
    return reinterpret_cast<const ::ImRect*>(self)->IsInverted();
}

CIMGUI_API cimgui::ImVec4 cimgui::ImRect_ToVec4(const cimgui::ImRect* self)
{
    return ConvertFromCPP_ImVec4(reinterpret_cast<const ::ImRect*>(self)->ToVec4());
}

CIMGUI_API size_t cimgui::cImBitArrayGetStorageSizeInBytes(int bitcount)
{
    return ::ImBitArrayGetStorageSizeInBytes(bitcount);
}

CIMGUI_API void   cimgui::cImBitArrayClearAllBits(ImU32* arr, int bitcount)
{
    ::ImBitArrayClearAllBits(arr, bitcount);
}

CIMGUI_API bool   cimgui::cImBitArrayTestBit(const ImU32* arr, int n)
{
    return ::ImBitArrayTestBit(arr, n);
}

CIMGUI_API void   cimgui::cImBitArrayClearBit(ImU32* arr, int n)
{
    ::ImBitArrayClearBit(arr, n);
}

CIMGUI_API void   cimgui::cImBitArraySetBit(ImU32* arr, int n)
{
    ::ImBitArraySetBit(arr, n);
}

CIMGUI_API void   cimgui::cImBitArraySetBitRange(ImU32* arr, int n, int n2)
{
    ::ImBitArraySetBitRange(arr, n, n2);
}

CIMGUI_API void cimgui::ImBitVector_Create(cimgui::ImBitVector* self, int sz)
{
    reinterpret_cast<::ImBitVector*>(self)->Create(sz);
}

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

CIMGUI_API bool cimgui::ImBitVector_TestBit(const cimgui::ImBitVector* self, int n)
{
    return reinterpret_cast<const ::ImBitVector*>(self)->TestBit(n);
}

CIMGUI_API void cimgui::ImBitVector_SetBit(cimgui::ImBitVector* self, int n)
{
    reinterpret_cast<::ImBitVector*>(self)->SetBit(n);
}

CIMGUI_API void cimgui::ImBitVector_ClearBit(cimgui::ImBitVector* self, int n)
{
    reinterpret_cast<::ImBitVector*>(self)->ClearBit(n);
}

CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_clear(cimgui::ImStableVector_ImFontBaked_32* self)
{
    reinterpret_cast<ImStableVector<ImFontBaked, 32>*>(self)->clear();
}

CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_resize(cimgui::ImStableVector_ImFontBaked_32* self, int new_size)
{
    reinterpret_cast<ImStableVector<ImFontBaked, 32>*>(self)->resize(new_size);
}

CIMGUI_API void cimgui::ImStableVector_ImFontBaked_32_reserve(cimgui::ImStableVector_ImFontBaked_32* self, int new_cap)
{
    reinterpret_cast<ImStableVector<ImFontBaked, 32>*>(self)->reserve(new_cap);
}

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

CIMGUI_API int         cimgui::ImGuiTextIndex_size(cimgui::ImGuiTextIndex* self)
{
    return reinterpret_cast<::ImGuiTextIndex*>(self)->size();
}

CIMGUI_API const char* cimgui::ImGuiTextIndex_get_line_begin(cimgui::ImGuiTextIndex* self, const char* base, int n)
{
    return reinterpret_cast<::ImGuiTextIndex*>(self)->get_line_begin(base, n);
}

CIMGUI_API const char* cimgui::ImGuiTextIndex_get_line_end(cimgui::ImGuiTextIndex* self, const char* base, int n)
{
    return reinterpret_cast<::ImGuiTextIndex*>(self)->get_line_end(base, n);
}

CIMGUI_API void        cimgui::ImGuiTextIndex_append(cimgui::ImGuiTextIndex* self, const char* base, int old_size, int new_size)
{
    reinterpret_cast<::ImGuiTextIndex*>(self)->append(base, old_size, new_size);
}

CIMGUI_API cimgui::ImGuiStoragePair* cimgui::cImLowerBound(cimgui::ImGuiStoragePair* in_begin, cimgui::ImGuiStoragePair* in_end, ImGuiID key)
{
    return reinterpret_cast<::cimgui::ImGuiStoragePair*>(::ImLowerBound(reinterpret_cast<::ImGuiStoragePair*>(in_begin), reinterpret_cast<::ImGuiStoragePair*>(in_end), key));
}

CIMGUI_API void cimgui::ImDrawListSharedData_SetCircleTessellationMaxError(cimgui::ImDrawListSharedData* self, float max_error)
{
    reinterpret_cast<::ImDrawListSharedData*>(self)->SetCircleTessellationMaxError(max_error);
}

CIMGUI_API void* cimgui::ImGuiStyleVarInfo_GetVarPtr(const cimgui::ImGuiStyleVarInfo* self, void* parent)
{
    return reinterpret_cast<const ::ImGuiStyleVarInfo*>(self)->GetVarPtr(parent);
}

CIMGUI_API void  cimgui::ImGuiMenuColumns_Update(cimgui::ImGuiMenuColumns* self, float spacing, bool window_reappearing)
{
    reinterpret_cast<::ImGuiMenuColumns*>(self)->Update(spacing, window_reappearing);
}

CIMGUI_API float cimgui::ImGuiMenuColumns_DeclColumns(cimgui::ImGuiMenuColumns* self, float w_icon, float w_label, float w_shortcut, float w_mark)
{
    return reinterpret_cast<::ImGuiMenuColumns*>(self)->DeclColumns(w_icon, w_label, w_shortcut, w_mark);
}

CIMGUI_API void  cimgui::ImGuiMenuColumns_CalcNextTotalWidth(cimgui::ImGuiMenuColumns* self, bool update_offsets)
{
    reinterpret_cast<::ImGuiMenuColumns*>(self)->CalcNextTotalWidth(update_offsets);
}

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

CIMGUI_API void        cimgui::ImGuiInputTextState_ClearText(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->ClearText();
}

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

CIMGUI_API void        cimgui::ImGuiInputTextState_OnKeyPressed(cimgui::ImGuiInputTextState* self, int key)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->OnKeyPressed(key);
}

CIMGUI_API void        cimgui::ImGuiInputTextState_OnCharPressed(cimgui::ImGuiInputTextState* self, unsigned int c)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->OnCharPressed(c);
}

CIMGUI_API float       cimgui::ImGuiInputTextState_GetPreferredOffsetX(const cimgui::ImGuiInputTextState* self)
{
    return reinterpret_cast<const ::ImGuiInputTextState*>(self)->GetPreferredOffsetX();
}

CIMGUI_API const char* cimgui::ImGuiInputTextState_GetText(cimgui::ImGuiInputTextState* self)
{
    return reinterpret_cast<::ImGuiInputTextState*>(self)->GetText();
}

CIMGUI_API void        cimgui::ImGuiInputTextState_CursorAnimReset(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->CursorAnimReset();
}

CIMGUI_API void        cimgui::ImGuiInputTextState_CursorClamp(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->CursorClamp();
}

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

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

CIMGUI_API int         cimgui::ImGuiInputTextState_GetCursorPos(const cimgui::ImGuiInputTextState* self)
{
    return reinterpret_cast<const ::ImGuiInputTextState*>(self)->GetCursorPos();
}

CIMGUI_API int         cimgui::ImGuiInputTextState_GetSelectionStart(const cimgui::ImGuiInputTextState* self)
{
    return reinterpret_cast<const ::ImGuiInputTextState*>(self)->GetSelectionStart();
}

CIMGUI_API int         cimgui::ImGuiInputTextState_GetSelectionEnd(const cimgui::ImGuiInputTextState* self)
{
    return reinterpret_cast<const ::ImGuiInputTextState*>(self)->GetSelectionEnd();
}

CIMGUI_API void        cimgui::ImGuiInputTextState_SetSelection(cimgui::ImGuiInputTextState* self, int start, int end)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->SetSelection(start, end);
}

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

CIMGUI_API void        cimgui::ImGuiInputTextState_ReloadUserBufAndSelectAll(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndSelectAll();
}

CIMGUI_API void        cimgui::ImGuiInputTextState_ReloadUserBufAndKeepSelection(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndKeepSelection();
}

CIMGUI_API void        cimgui::ImGuiInputTextState_ReloadUserBufAndMoveToEnd(cimgui::ImGuiInputTextState* self)
{
    reinterpret_cast<::ImGuiInputTextState*>(self)->ReloadUserBufAndMoveToEnd();
}

CIMGUI_API void cimgui::ImGuiNextWindowData_ClearFlags(cimgui::ImGuiNextWindowData* self)
{
    reinterpret_cast<::ImGuiNextWindowData*>(self)->ClearFlags();
}

CIMGUI_API void cimgui::ImGuiNextItemData_ClearFlags(cimgui::ImGuiNextItemData* self)
{
    reinterpret_cast<::ImGuiNextItemData*>(self)->ClearFlags();
}

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

CIMGUI_API cimgui::ImGuiListClipperRange cimgui::ImGuiListClipperRange_FromIndices(int min, int max)
{
    return ConvertFromCPP_ImGuiListClipperRange(::ImGuiListClipperRange::FromIndices(min, max));
}

CIMGUI_API cimgui::ImGuiListClipperRange cimgui::ImGuiListClipperRange_FromPositions(float y1, float y2, int off_min, int off_max)
{
    return ConvertFromCPP_ImGuiListClipperRange(::ImGuiListClipperRange::FromPositions(y1, y2, off_min, off_max));
}

CIMGUI_API void cimgui::ImGuiListClipperData_Reset(cimgui::ImGuiListClipperData* self, cimgui::ImGuiListClipper* clipper)
{
    reinterpret_cast<::ImGuiListClipperData*>(self)->Reset(reinterpret_cast<::ImGuiListClipper*>(clipper));
}

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

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

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

CIMGUI_API void cimgui::ImGuiMultiSelectTempData_ClearIO(cimgui::ImGuiMultiSelectTempData* self)
{
    reinterpret_cast<::ImGuiMultiSelectTempData*>(self)->ClearIO();
}

#ifdef IMGUI_HAS_DOCK

CIMGUI_API bool   cimgui::ImGuiDockNode_IsRootNode(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsRootNode();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsDockSpace(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsDockSpace();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsFloatingNode(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsFloatingNode();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsCentralNode(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsCentralNode();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsHiddenTabBar(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsHiddenTabBar();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsNoTabBar(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsNoTabBar();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsSplitNode(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsSplitNode();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsLeafNode(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsLeafNode();
}

CIMGUI_API bool   cimgui::ImGuiDockNode_IsEmpty(const cimgui::ImGuiDockNode* self)
{
    return reinterpret_cast<const ::ImGuiDockNode*>(self)->IsEmpty();
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiDockNode_Rect(const cimgui::ImGuiDockNode* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiDockNode*>(self)->Rect());
}

CIMGUI_API void   cimgui::ImGuiDockNode_SetLocalFlags(cimgui::ImGuiDockNode* self, ImGuiDockNodeFlags flags)
{
    reinterpret_cast<::ImGuiDockNode*>(self)->SetLocalFlags(flags);
}

CIMGUI_API void   cimgui::ImGuiDockNode_UpdateMergedFlags(cimgui::ImGuiDockNode* self)
{
    reinterpret_cast<::ImGuiDockNode*>(self)->UpdateMergedFlags();
}

#endif // #ifdef IMGUI_HAS_DOCK

CIMGUI_API void   cimgui::ImGuiViewportP_ClearRequestFlags(cimgui::ImGuiViewportP* self)
{
    reinterpret_cast<::ImGuiViewportP*>(self)->ClearRequestFlags();
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewportP_CalcWorkRectPos(const cimgui::ImGuiViewportP* self, cimgui::ImVec2 inset_min)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImGuiViewportP*>(self)->CalcWorkRectPos(ConvertToCPP_ImVec2(inset_min)));
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGuiViewportP_CalcWorkRectSize(const cimgui::ImGuiViewportP* self, cimgui::ImVec2 inset_min, cimgui::ImVec2 inset_max)
{
    return ConvertFromCPP_ImVec2(reinterpret_cast<const ::ImGuiViewportP*>(self)->CalcWorkRectSize(ConvertToCPP_ImVec2(inset_min), ConvertToCPP_ImVec2(inset_max)));
}

CIMGUI_API void   cimgui::ImGuiViewportP_UpdateWorkRect(cimgui::ImGuiViewportP* self)
{
    reinterpret_cast<::ImGuiViewportP*>(self)->UpdateWorkRect();
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetMainRect(const cimgui::ImGuiViewportP* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiViewportP*>(self)->GetMainRect());
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetWorkRect(const cimgui::ImGuiViewportP* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiViewportP*>(self)->GetWorkRect());
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiViewportP_GetBuildWorkRect(const cimgui::ImGuiViewportP* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiViewportP*>(self)->GetBuildWorkRect());
}

CIMGUI_API char* cimgui::ImGuiWindowSettings_GetName(cimgui::ImGuiWindowSettings* self)
{
    return reinterpret_cast<::ImGuiWindowSettings*>(self)->GetName();
}

CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDStr(cimgui::ImGuiWindow* self, const char* str, const char* str_end)
{
    return reinterpret_cast<::ImGuiWindow*>(self)->GetID(str, str_end);
}

CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetID(cimgui::ImGuiWindow* self, const void* ptr)
{
    return reinterpret_cast<::ImGuiWindow*>(self)->GetID(ptr);
}

CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDInt(cimgui::ImGuiWindow* self, int n)
{
    return reinterpret_cast<::ImGuiWindow*>(self)->GetID(n);
}

CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDFromPos(cimgui::ImGuiWindow* self, cimgui::ImVec2 p_abs)
{
    return reinterpret_cast<::ImGuiWindow*>(self)->GetIDFromPos(ConvertToCPP_ImVec2(p_abs));
}

CIMGUI_API ImGuiID cimgui::ImGuiWindow_GetIDFromRectangle(cimgui::ImGuiWindow* self, cimgui::ImRect r_abs)
{
    return reinterpret_cast<::ImGuiWindow*>(self)->GetIDFromRectangle(ConvertToCPP_ImRect(r_abs));
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_Rect(const cimgui::ImGuiWindow* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiWindow*>(self)->Rect());
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_TitleBarRect(const cimgui::ImGuiWindow* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiWindow*>(self)->TitleBarRect());
}

CIMGUI_API cimgui::ImRect cimgui::ImGuiWindow_MenuBarRect(const cimgui::ImGuiWindow* self)
{
    return ConvertFromCPP_ImRect(reinterpret_cast<const ::ImGuiWindow*>(self)->MenuBarRect());
}

CIMGUI_API cimgui::ImGuiTableColumnSettings* cimgui::ImGuiTableSettings_GetColumnSettings(cimgui::ImGuiTableSettings* self)
{
    return reinterpret_cast<::cimgui::ImGuiTableColumnSettings*>(reinterpret_cast<::ImGuiTableSettings*>(self)->GetColumnSettings());
}

CIMGUI_API cimgui::ImGuiIO* cimgui::ImGui_GetIOImGuiContextPtr(cimgui::ImGuiContext* ctx)
{
    return reinterpret_cast<::cimgui::ImGuiIO*>(&::ImGui::GetIO(reinterpret_cast<::ImGuiContext*>(ctx)));
}

CIMGUI_API cimgui::ImGuiPlatformIO* cimgui::ImGui_GetPlatformIOImGuiContextPtr(cimgui::ImGuiContext* ctx)
{
    return reinterpret_cast<::cimgui::ImGuiPlatformIO*>(&::ImGui::GetPlatformIO(reinterpret_cast<::ImGuiContext*>(ctx)));
}

CIMGUI_API float            cimgui::ImGui_GetScale(void)
{
    return ::ImGui::GetScale();
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetCurrentWindowRead(void)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetCurrentWindowRead());
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetCurrentWindow(void)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetCurrentWindow());
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindWindowByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindWindowByID(id));
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindWindowByName(const char* name)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindWindowByName(name));
}

CIMGUI_API void             cimgui::ImGui_UpdateWindowParentAndRootLinks(cimgui::ImGuiWindow* window, ImGuiWindowFlags flags, cimgui::ImGuiWindow* parent_window)
{
    ::ImGui::UpdateWindowParentAndRootLinks(reinterpret_cast<::ImGuiWindow*>(window), flags, reinterpret_cast<::ImGuiWindow*>(parent_window));
}

CIMGUI_API void             cimgui::ImGui_UpdateWindowSkipRefresh(cimgui::ImGuiWindow* window)
{
    ::ImGui::UpdateWindowSkipRefresh(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_CalcWindowNextAutoFitSize(cimgui::ImGuiWindow* window)
{
    return ConvertFromCPP_ImVec2(::ImGui::CalcWindowNextAutoFitSize(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API bool             cimgui::ImGui_IsWindowChildOf(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* potential_parent, bool popup_hierarchy, bool dock_hierarchy)
{
    return ::ImGui::IsWindowChildOf(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(potential_parent), popup_hierarchy, dock_hierarchy);
}

CIMGUI_API bool             cimgui::ImGui_IsWindowInBeginStack(cimgui::ImGuiWindow* window)
{
    return ::ImGui::IsWindowInBeginStack(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API bool             cimgui::ImGui_IsWindowWithinBeginStackOf(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* potential_parent)
{
    return ::ImGui::IsWindowWithinBeginStackOf(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(potential_parent));
}

CIMGUI_API bool             cimgui::ImGui_IsWindowAbove(cimgui::ImGuiWindow* potential_above, cimgui::ImGuiWindow* potential_below)
{
    return ::ImGui::IsWindowAbove(reinterpret_cast<::ImGuiWindow*>(potential_above), reinterpret_cast<::ImGuiWindow*>(potential_below));
}

CIMGUI_API bool             cimgui::ImGui_IsWindowNavFocusable(cimgui::ImGuiWindow* window)
{
    return ::ImGui::IsWindowNavFocusable(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void             cimgui::ImGui_SetWindowPosImGuiWindowPtr(cimgui::ImGuiWindow* window, cimgui::ImVec2 pos, ImGuiCond cond)
{
    ::ImGui::SetWindowPos(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(pos), cond);
}

CIMGUI_API void             cimgui::ImGui_SetWindowSizeImGuiWindowPtr(cimgui::ImGuiWindow* window, cimgui::ImVec2 size, ImGuiCond cond)
{
    ::ImGui::SetWindowSize(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(size), cond);
}

CIMGUI_API void             cimgui::ImGui_SetWindowCollapsedImGuiWindowPtr(cimgui::ImGuiWindow* window, bool collapsed, ImGuiCond cond)
{
    ::ImGui::SetWindowCollapsed(reinterpret_cast<::ImGuiWindow*>(window), collapsed, cond);
}

CIMGUI_API void             cimgui::ImGui_SetWindowHitTestHole(cimgui::ImGuiWindow* window, cimgui::ImVec2 pos, cimgui::ImVec2 size)
{
    ::ImGui::SetWindowHitTestHole(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(size));
}

CIMGUI_API void             cimgui::ImGui_SetWindowHiddenAndSkipItemsForCurrentFrame(cimgui::ImGuiWindow* window)
{
    ::ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void             cimgui::ImGui_SetWindowParentWindowForFocusRoute(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* parent_window)
{
    ::ImGui::SetWindowParentWindowForFocusRoute(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(parent_window));
}

CIMGUI_API cimgui::ImRect   cimgui::ImGui_WindowRectAbsToRel(cimgui::ImGuiWindow* window, cimgui::ImRect r)
{
    return ConvertFromCPP_ImRect(::ImGui::WindowRectAbsToRel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(r)));
}

CIMGUI_API cimgui::ImRect   cimgui::ImGui_WindowRectRelToAbs(cimgui::ImGuiWindow* window, cimgui::ImRect r)
{
    return ConvertFromCPP_ImRect(::ImGui::WindowRectRelToAbs(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(r)));
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_WindowPosAbsToRel(cimgui::ImGuiWindow* window, cimgui::ImVec2 p)
{
    return ConvertFromCPP_ImVec2(::ImGui::WindowPosAbsToRel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(p)));
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_WindowPosRelToAbs(cimgui::ImGuiWindow* window, cimgui::ImVec2 p)
{
    return ConvertFromCPP_ImVec2(::ImGui::WindowPosRelToAbs(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImVec2(p)));
}

CIMGUI_API void         cimgui::ImGui_FocusWindow(cimgui::ImGuiWindow* window, ImGuiFocusRequestFlags flags)
{
    ::ImGui::FocusWindow(reinterpret_cast<::ImGuiWindow*>(window), flags);
}

CIMGUI_API void         cimgui::ImGui_FocusTopMostWindowUnderOne(cimgui::ImGuiWindow* under_this_window, cimgui::ImGuiWindow* ignore_window, cimgui::ImGuiViewport* filter_viewport, ImGuiFocusRequestFlags flags)
{
    ::ImGui::FocusTopMostWindowUnderOne(reinterpret_cast<::ImGuiWindow*>(under_this_window), reinterpret_cast<::ImGuiWindow*>(ignore_window), reinterpret_cast<::ImGuiViewport*>(filter_viewport), flags);
}

CIMGUI_API void         cimgui::ImGui_BringWindowToFocusFront(cimgui::ImGuiWindow* window)
{
    ::ImGui::BringWindowToFocusFront(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void         cimgui::ImGui_BringWindowToDisplayFront(cimgui::ImGuiWindow* window)
{
    ::ImGui::BringWindowToDisplayFront(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void         cimgui::ImGui_BringWindowToDisplayBack(cimgui::ImGuiWindow* window)
{
    ::ImGui::BringWindowToDisplayBack(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void         cimgui::ImGui_BringWindowToDisplayBehind(cimgui::ImGuiWindow* window, cimgui::ImGuiWindow* above_window)
{
    ::ImGui::BringWindowToDisplayBehind(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiWindow*>(above_window));
}

CIMGUI_API int          cimgui::ImGui_FindWindowDisplayIndex(cimgui::ImGuiWindow* window)
{
    return ::ImGui::FindWindowDisplayIndex(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindBottomMostVisibleWindowWithinBeginStack(cimgui::ImGuiWindow* window)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindBottomMostVisibleWindowWithinBeginStack(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API void cimgui::ImGui_SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags)
{
    ::ImGui::SetNextWindowRefreshPolicy(flags);
}

CIMGUI_API void        cimgui::ImGui_RegisterUserTexture(cimgui::ImTextureData* tex)
{
    ::ImGui::RegisterUserTexture(reinterpret_cast<::ImTextureData*>(tex));
}

CIMGUI_API void        cimgui::ImGui_UnregisterUserTexture(cimgui::ImTextureData* tex)
{
    ::ImGui::UnregisterUserTexture(reinterpret_cast<::ImTextureData*>(tex));
}

CIMGUI_API void        cimgui::ImGui_RegisterFontAtlas(cimgui::ImFontAtlas* atlas)
{
    ::ImGui::RegisterFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void        cimgui::ImGui_UnregisterFontAtlas(cimgui::ImFontAtlas* atlas)
{
    ::ImGui::UnregisterFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void        cimgui::ImGui_SetCurrentFont(cimgui::ImFont* font, float font_size_before_scaling, float font_size_after_scaling)
{
    ::ImGui::SetCurrentFont(reinterpret_cast<::ImFont*>(font), font_size_before_scaling, font_size_after_scaling);
}

CIMGUI_API void        cimgui::ImGui_UpdateCurrentFontSize(float restore_font_size_after_scaling)
{
    ::ImGui::UpdateCurrentFontSize(restore_font_size_after_scaling);
}

CIMGUI_API void        cimgui::ImGui_SetFontRasterizerDensity(float rasterizer_density)
{
    ::ImGui::SetFontRasterizerDensity(rasterizer_density);
}

CIMGUI_API float       cimgui::ImGui_GetFontRasterizerDensity(void)
{
    return ::ImGui::GetFontRasterizerDensity();
}

CIMGUI_API float       cimgui::ImGui_GetRoundedFontSize(float size)
{
    return ::ImGui::GetRoundedFontSize(size);
}

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

CIMGUI_API void        cimgui::ImGui_PushPasswordFont(void)
{
    ::ImGui::PushPasswordFont();
}

CIMGUI_API void        cimgui::ImGui_PopPasswordFont(void)
{
    ::ImGui::PopPasswordFont();
}

CIMGUI_API cimgui::ImDrawList* cimgui::ImGui_GetForegroundDrawListImGuiWindowPtr(cimgui::ImGuiWindow* window)
{
    return reinterpret_cast<::cimgui::ImDrawList*>(::ImGui::GetForegroundDrawList(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API void        cimgui::ImGui_AddDrawListToDrawDataEx(cimgui::ImDrawData* draw_data, cimgui::ImVector_ImDrawListPtr* out_list, cimgui::ImDrawList* draw_list)
{
    ::ImGui::AddDrawListToDrawDataEx(reinterpret_cast<::ImDrawData*>(draw_data), reinterpret_cast<::ImVector<::ImDrawList*>*>(out_list), reinterpret_cast<::ImDrawList*>(draw_list));
}

CIMGUI_API void cimgui::ImGui_Initialize(void)
{
    ::ImGui::Initialize();
}

CIMGUI_API void cimgui::ImGui_Shutdown(void)
{
    ::ImGui::Shutdown();
}

CIMGUI_API void    cimgui::ImGui_SetContextName(cimgui::ImGuiContext* ctx, const char* name)
{
    ::ImGui::SetContextName(reinterpret_cast<::ImGuiContext*>(ctx), name);
}

CIMGUI_API ImGuiID cimgui::ImGui_AddContextHook(cimgui::ImGuiContext* ctx, const cimgui::ImGuiContextHook* hook)
{
    return ::ImGui::AddContextHook(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<const ::ImGuiContextHook*>(hook));
}

CIMGUI_API void    cimgui::ImGui_RemoveContextHook(cimgui::ImGuiContext* ctx, ImGuiID hook_to_remove)
{
    ::ImGui::RemoveContextHook(reinterpret_cast<::ImGuiContext*>(ctx), hook_to_remove);
}

CIMGUI_API void    cimgui::ImGui_CallContextHooks(cimgui::ImGuiContext* ctx, cimgui::ImGuiContextHookType type)
{
    ::ImGui::CallContextHooks(reinterpret_cast<::ImGuiContext*>(ctx), static_cast<::ImGuiContextHookType>(type));
}

CIMGUI_API void cimgui::ImGui_UpdateInputEvents(bool trickle_fast_inputs)
{
    ::ImGui::UpdateInputEvents(trickle_fast_inputs);
}

CIMGUI_API void cimgui::ImGui_UpdateHoveredWindowAndCaptureFlags(cimgui::ImVec2 mouse_pos)
{
    ::ImGui::UpdateHoveredWindowAndCaptureFlags(ConvertToCPP_ImVec2(mouse_pos));
}

CIMGUI_API void cimgui::ImGui_FindHoveredWindowEx(cimgui::ImVec2 pos, bool find_first_and_in_any_viewport, cimgui::ImGuiWindow** out_hovered_window, cimgui::ImGuiWindow** out_hovered_window_under_moving_window)
{
    ::ImGui::FindHoveredWindowEx(ConvertToCPP_ImVec2(pos), find_first_and_in_any_viewport, reinterpret_cast<::ImGuiWindow**>(out_hovered_window), reinterpret_cast<::ImGuiWindow**>(out_hovered_window_under_moving_window));
}

CIMGUI_API void cimgui::ImGui_StartMouseMovingWindow(cimgui::ImGuiWindow* window)
{
    ::ImGui::StartMouseMovingWindow(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void cimgui::ImGui_StartMouseMovingWindowOrNode(cimgui::ImGuiWindow* window, cimgui::ImGuiDockNode* node, bool undock)
{
    ::ImGui::StartMouseMovingWindowOrNode(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiDockNode*>(node), undock);
}

CIMGUI_API void cimgui::ImGui_StopMouseMovingWindow(void)
{
    ::ImGui::StopMouseMovingWindow();
}

CIMGUI_API void cimgui::ImGui_UpdateMouseMovingWindowNewFrame(void)
{
    ::ImGui::UpdateMouseMovingWindowNewFrame();
}

CIMGUI_API void cimgui::ImGui_UpdateMouseMovingWindowEndFrame(void)
{
    ::ImGui::UpdateMouseMovingWindowEndFrame();
}

CIMGUI_API void                        cimgui::ImGui_TranslateWindowsInViewport(cimgui::ImGuiViewportP* viewport, cimgui::ImVec2 old_pos, cimgui::ImVec2 new_pos, cimgui::ImVec2 old_size, cimgui::ImVec2 new_size)
{
    ::ImGui::TranslateWindowsInViewport(reinterpret_cast<::ImGuiViewportP*>(viewport), ConvertToCPP_ImVec2(old_pos), ConvertToCPP_ImVec2(new_pos), ConvertToCPP_ImVec2(old_size), ConvertToCPP_ImVec2(new_size));
}

CIMGUI_API void                        cimgui::ImGui_ScaleWindowsInViewport(cimgui::ImGuiViewportP* viewport, float scale)
{
    ::ImGui::ScaleWindowsInViewport(reinterpret_cast<::ImGuiViewportP*>(viewport), scale);
}

CIMGUI_API void                        cimgui::ImGui_DestroyPlatformWindow(cimgui::ImGuiViewportP* viewport)
{
    ::ImGui::DestroyPlatformWindow(reinterpret_cast<::ImGuiViewportP*>(viewport));
}

CIMGUI_API void                        cimgui::ImGui_SetWindowViewport(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport)
{
    ::ImGui::SetWindowViewport(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport));
}

CIMGUI_API void                        cimgui::ImGui_SetCurrentViewport(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport)
{
    ::ImGui::SetCurrentViewport(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport));
}

CIMGUI_API const cimgui::ImGuiPlatformMonitor* cimgui::ImGui_GetViewportPlatformMonitor(cimgui::ImGuiViewport* viewport)
{
    return reinterpret_cast<const ::cimgui::ImGuiPlatformMonitor*>(::ImGui::GetViewportPlatformMonitor(reinterpret_cast<::ImGuiViewport*>(viewport)));
}

CIMGUI_API cimgui::ImGuiViewportP*     cimgui::ImGui_FindHoveredViewportFromPlatformWindowStack(cimgui::ImVec2 mouse_platform_pos)
{
    return reinterpret_cast<::cimgui::ImGuiViewportP*>(::ImGui::FindHoveredViewportFromPlatformWindowStack(ConvertToCPP_ImVec2(mouse_platform_pos)));
}

CIMGUI_API void                  cimgui::ImGui_MarkIniSettingsDirty(void)
{
    ::ImGui::MarkIniSettingsDirty();
}

CIMGUI_API void                  cimgui::ImGui_MarkIniSettingsDirtyImGuiWindowPtr(cimgui::ImGuiWindow* window)
{
    ::ImGui::MarkIniSettingsDirty(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void                  cimgui::ImGui_ClearIniSettings(void)
{
    ::ImGui::ClearIniSettings();
}

CIMGUI_API void                  cimgui::ImGui_AddSettingsHandler(const cimgui::ImGuiSettingsHandler* handler)
{
    ::ImGui::AddSettingsHandler(reinterpret_cast<const ::ImGuiSettingsHandler*>(handler));
}

CIMGUI_API void                  cimgui::ImGui_RemoveSettingsHandler(const char* type_name)
{
    ::ImGui::RemoveSettingsHandler(type_name);
}

CIMGUI_API cimgui::ImGuiSettingsHandler* cimgui::ImGui_FindSettingsHandler(const char* type_name)
{
    return reinterpret_cast<::cimgui::ImGuiSettingsHandler*>(::ImGui::FindSettingsHandler(type_name));
}

CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_CreateNewWindowSettings(const char* name)
{
    return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::CreateNewWindowSettings(name));
}

CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_FindWindowSettingsByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::FindWindowSettingsByID(id));
}

CIMGUI_API cimgui::ImGuiWindowSettings* cimgui::ImGui_FindWindowSettingsByWindow(cimgui::ImGuiWindow* window)
{
    return reinterpret_cast<::cimgui::ImGuiWindowSettings*>(::ImGui::FindWindowSettingsByWindow(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API void                 cimgui::ImGui_ClearWindowSettings(const char* name)
{
    ::ImGui::ClearWindowSettings(name);
}

CIMGUI_API void        cimgui::ImGui_LocalizeRegisterEntries(const cimgui::ImGuiLocEntry* entries, int count)
{
    ::ImGui::LocalizeRegisterEntries(reinterpret_cast<const ::ImGuiLocEntry*>(entries), count);
}

CIMGUI_API const char* cimgui::ImGui_LocalizeGetMsg(cimgui::ImGuiLocKey key)
{
    return ::ImGui::LocalizeGetMsg(static_cast<::ImGuiLocKey>(key));
}

CIMGUI_API void cimgui::ImGui_SetScrollXImGuiWindowPtr(cimgui::ImGuiWindow* window, float scroll_x)
{
    ::ImGui::SetScrollX(reinterpret_cast<::ImGuiWindow*>(window), scroll_x);
}

CIMGUI_API void cimgui::ImGui_SetScrollYImGuiWindowPtr(cimgui::ImGuiWindow* window, float scroll_y)
{
    ::ImGui::SetScrollY(reinterpret_cast<::ImGuiWindow*>(window), scroll_y);
}

CIMGUI_API void cimgui::ImGui_SetScrollFromPosXImGuiWindowPtr(cimgui::ImGuiWindow* window, float local_x, float center_x_ratio)
{
    ::ImGui::SetScrollFromPosX(reinterpret_cast<::ImGuiWindow*>(window), local_x, center_x_ratio);
}

CIMGUI_API void cimgui::ImGui_SetScrollFromPosYImGuiWindowPtr(cimgui::ImGuiWindow* window, float local_y, float center_y_ratio)
{
    ::ImGui::SetScrollFromPosY(reinterpret_cast<::ImGuiWindow*>(window), local_y, center_y_ratio);
}

CIMGUI_API void   cimgui::ImGui_ScrollToItem(ImGuiScrollFlags flags)
{
    ::ImGui::ScrollToItem(flags);
}

CIMGUI_API void   cimgui::ImGui_ScrollToRect(cimgui::ImGuiWindow* window, cimgui::ImRect rect, ImGuiScrollFlags flags)
{
    ::ImGui::ScrollToRect(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect), flags);
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_ScrollToRectEx(cimgui::ImGuiWindow* window, cimgui::ImRect rect, ImGuiScrollFlags flags)
{
    return ConvertFromCPP_ImVec2(::ImGui::ScrollToRectEx(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect), flags));
}

CIMGUI_API void   cimgui::ImGui_ScrollToBringRectIntoView(cimgui::ImGuiWindow* window, cimgui::ImRect rect)
{
    ::ImGui::ScrollToBringRectIntoView(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(rect));
}

CIMGUI_API ImGuiItemStatusFlags cimgui::ImGui_GetItemStatusFlags(void)
{
    return ::ImGui::GetItemStatusFlags();
}

CIMGUI_API ImGuiID              cimgui::ImGui_GetActiveID(void)
{
    return ::ImGui::GetActiveID();
}

CIMGUI_API ImGuiID              cimgui::ImGui_GetFocusID(void)
{
    return ::ImGui::GetFocusID();
}

CIMGUI_API void                 cimgui::ImGui_SetActiveID(ImGuiID id, cimgui::ImGuiWindow* window)
{
    ::ImGui::SetActiveID(id, reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void                 cimgui::ImGui_SetFocusID(ImGuiID id, cimgui::ImGuiWindow* window)
{
    ::ImGui::SetFocusID(id, reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void                 cimgui::ImGui_ClearActiveID(void)
{
    ::ImGui::ClearActiveID();
}

CIMGUI_API ImGuiID              cimgui::ImGui_GetHoveredID(void)
{
    return ::ImGui::GetHoveredID();
}

CIMGUI_API void                 cimgui::ImGui_SetHoveredID(ImGuiID id)
{
    ::ImGui::SetHoveredID(id);
}

CIMGUI_API void                 cimgui::ImGui_KeepAliveID(ImGuiID id)
{
    ::ImGui::KeepAliveID(id);
}

CIMGUI_API void                 cimgui::ImGui_MarkItemEdited(ImGuiID id)
{
    ::ImGui::MarkItemEdited(id);
}

CIMGUI_API void                 cimgui::ImGui_PushOverrideID(ImGuiID id)
{
    ::ImGui::PushOverrideID(id);
}

CIMGUI_API ImGuiID              cimgui::ImGui_GetIDWithSeedStr(const char* str_id_begin, const char* str_id_end, ImGuiID seed)
{
    return ::ImGui::GetIDWithSeed(str_id_begin, str_id_end, seed);
}

CIMGUI_API ImGuiID              cimgui::ImGui_GetIDWithSeed(int n, ImGuiID seed)
{
    return ::ImGui::GetIDWithSeed(n, seed);
}

CIMGUI_API void   cimgui::ImGui_ItemSize(cimgui::ImVec2 size, float text_baseline_y)
{
    ::ImGui::ItemSize(ConvertToCPP_ImVec2(size), text_baseline_y);
}

CIMGUI_API void   cimgui::ImGui_ItemSizeImRect(cimgui::ImRect bb, float text_baseline_y)
{
    ::ImGui::ItemSize(ConvertToCPP_ImRect(bb), text_baseline_y);
}

CIMGUI_API bool   cimgui::ImGui_ItemAdd(cimgui::ImRect bb, ImGuiID id, const cimgui::ImRect* nav_bb, ImGuiItemFlags extra_flags)
{
    return ::ImGui::ItemAdd(ConvertToCPP_ImRect(bb), id, reinterpret_cast<const ::ImRect*>(nav_bb), extra_flags);
}

CIMGUI_API bool   cimgui::ImGui_ItemHoverable(cimgui::ImRect bb, ImGuiID id, ImGuiItemFlags item_flags)
{
    return ::ImGui::ItemHoverable(ConvertToCPP_ImRect(bb), id, item_flags);
}

CIMGUI_API bool   cimgui::ImGui_IsWindowContentHoverable(cimgui::ImGuiWindow* window, ImGuiHoveredFlags flags)
{
    return ::ImGui::IsWindowContentHoverable(reinterpret_cast<::ImGuiWindow*>(window), flags);
}

CIMGUI_API bool   cimgui::ImGui_IsClippedEx(cimgui::ImRect bb, ImGuiID id)
{
    return ::ImGui::IsClippedEx(ConvertToCPP_ImRect(bb), id);
}

CIMGUI_API void   cimgui::ImGui_SetLastItemData(ImGuiID item_id, ImGuiItemFlags item_flags, ImGuiItemStatusFlags status_flags, cimgui::ImRect item_rect)
{
    ::ImGui::SetLastItemData(item_id, item_flags, status_flags, ConvertToCPP_ImRect(item_rect));
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_CalcItemSize(cimgui::ImVec2 size, float default_w, float default_h)
{
    return ConvertFromCPP_ImVec2(::ImGui::CalcItemSize(ConvertToCPP_ImVec2(size), default_w, default_h));
}

CIMGUI_API float  cimgui::ImGui_CalcWrapWidthForPos(cimgui::ImVec2 pos, float wrap_pos_x)
{
    return ::ImGui::CalcWrapWidthForPos(ConvertToCPP_ImVec2(pos), wrap_pos_x);
}

CIMGUI_API void   cimgui::ImGui_PushMultiItemsWidths(int components, float width_full)
{
    ::ImGui::PushMultiItemsWidths(components, width_full);
}

CIMGUI_API void   cimgui::ImGui_ShrinkWidths(cimgui::ImGuiShrinkWidthItem* items, int count, float width_excess, float width_min)
{
    ::ImGui::ShrinkWidths(reinterpret_cast<::ImGuiShrinkWidthItem*>(items), count, width_excess, width_min);
}

CIMGUI_API void   cimgui::ImGui_CalcClipRectVisibleItemsY(cimgui::ImRect clip_rect, cimgui::ImVec2 pos, float items_height, int* out_visible_start, int* out_visible_end)
{
    ::ImGui::CalcClipRectVisibleItemsY(ConvertToCPP_ImRect(clip_rect), ConvertToCPP_ImVec2(pos), items_height, out_visible_start, out_visible_end);
}

CIMGUI_API const cimgui::ImGuiStyleVarInfo* cimgui::ImGui_GetStyleVarInfo(ImGuiStyleVar idx)
{
    return reinterpret_cast<const ::cimgui::ImGuiStyleVarInfo*>(::ImGui::GetStyleVarInfo(idx));
}

CIMGUI_API void                     cimgui::ImGui_BeginDisabledOverrideReenable(void)
{
    ::ImGui::BeginDisabledOverrideReenable();
}

CIMGUI_API void                     cimgui::ImGui_EndDisabledOverrideReenable(void)
{
    ::ImGui::EndDisabledOverrideReenable();
}

CIMGUI_API void cimgui::ImGui_LogBegin(ImGuiLogFlags flags, int auto_open_depth)
{
    ::ImGui::LogBegin(flags, auto_open_depth);
}

CIMGUI_API void cimgui::ImGui_LogToBuffer(int auto_open_depth)
{
    ::ImGui::LogToBuffer(auto_open_depth);
}

CIMGUI_API void cimgui::ImGui_LogRenderedText(const cimgui::ImVec2* ref_pos, const char* text, const char* text_end)
{
    ::ImGui::LogRenderedText(reinterpret_cast<const ::ImVec2*>(ref_pos), text, text_end);
}

CIMGUI_API void cimgui::ImGui_LogSetNextTextDecoration(const char* prefix, const char* suffix)
{
    ::ImGui::LogSetNextTextDecoration(prefix, suffix);
}

CIMGUI_API bool cimgui::ImGui_BeginChildEx(const char* name, ImGuiID id, cimgui::ImVec2 size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
{
    return ::ImGui::BeginChildEx(name, id, ConvertToCPP_ImVec2(size_arg), child_flags, window_flags);
}

CIMGUI_API bool             cimgui::ImGui_BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_window_flags)
{
    return ::ImGui::BeginPopupEx(id, extra_window_flags);
}

CIMGUI_API bool             cimgui::ImGui_BeginPopupMenuEx(ImGuiID id, const char* label, ImGuiWindowFlags extra_window_flags)
{
    return ::ImGui::BeginPopupMenuEx(id, label, extra_window_flags);
}

CIMGUI_API void             cimgui::ImGui_OpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags)
{
    ::ImGui::OpenPopupEx(id, popup_flags);
}

CIMGUI_API void             cimgui::ImGui_ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
    ::ImGui::ClosePopupToLevel(remaining, restore_focus_to_window_under_popup);
}

CIMGUI_API void             cimgui::ImGui_ClosePopupsOverWindow(cimgui::ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup)
{
    ::ImGui::ClosePopupsOverWindow(reinterpret_cast<::ImGuiWindow*>(ref_window), restore_focus_to_window_under_popup);
}

CIMGUI_API void             cimgui::ImGui_ClosePopupsExceptModals(void)
{
    ::ImGui::ClosePopupsExceptModals();
}

CIMGUI_API bool             cimgui::ImGui_IsPopupOpenID(ImGuiID id, ImGuiPopupFlags popup_flags)
{
    return ::ImGui::IsPopupOpen(id, popup_flags);
}

CIMGUI_API cimgui::ImRect   cimgui::ImGui_GetPopupAllowedExtentRect(cimgui::ImGuiWindow* window)
{
    return ConvertFromCPP_ImRect(::ImGui::GetPopupAllowedExtentRect(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetTopMostPopupModal(void)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetTopMostPopupModal());
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_GetTopMostAndVisiblePopupModal(void)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::GetTopMostAndVisiblePopupModal());
}

CIMGUI_API cimgui::ImGuiWindow* cimgui::ImGui_FindBlockingModal(cimgui::ImGuiWindow* window)
{
    return reinterpret_cast<::cimgui::ImGuiWindow*>(::ImGui::FindBlockingModal(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_FindBestWindowPosForPopup(cimgui::ImGuiWindow* window)
{
    return ConvertFromCPP_ImVec2(::ImGui::FindBestWindowPosForPopup(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API cimgui::ImVec2   cimgui::ImGui_FindBestWindowPosForPopupEx(cimgui::ImVec2 ref_pos, cimgui::ImVec2 size, cimgui::ImGuiDir* last_dir, cimgui::ImRect r_outer, cimgui::ImRect r_avoid, cimgui::ImGuiPopupPositionPolicy policy)
{
    return ConvertFromCPP_ImVec2(::ImGui::FindBestWindowPosForPopupEx(ConvertToCPP_ImVec2(ref_pos), ConvertToCPP_ImVec2(size), reinterpret_cast<::ImGuiDir*>(last_dir), ConvertToCPP_ImRect(r_outer), ConvertToCPP_ImRect(r_avoid), static_cast<::ImGuiPopupPositionPolicy>(policy)));
}

CIMGUI_API ImGuiMouseButton cimgui::ImGui_GetMouseButtonFromPopupFlags(ImGuiPopupFlags flags)
{
    return ::ImGui::GetMouseButtonFromPopupFlags(flags);
}

CIMGUI_API bool             cimgui::ImGui_IsPopupOpenRequestForItem(ImGuiPopupFlags flags, ImGuiID id)
{
    return ::ImGui::IsPopupOpenRequestForItem(flags, id);
}

CIMGUI_API bool             cimgui::ImGui_IsPopupOpenRequestForWindow(ImGuiPopupFlags flags)
{
    return ::ImGui::IsPopupOpenRequestForWindow(flags);
}

CIMGUI_API bool cimgui::ImGui_BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags extra_window_flags)
{
    return ::ImGui::BeginTooltipEx(tooltip_flags, extra_window_flags);
}

CIMGUI_API bool cimgui::ImGui_BeginTooltipHidden(void)
{
    return ::ImGui::BeginTooltipHidden();
}

CIMGUI_API bool cimgui::ImGui_BeginViewportSideBar(const char* name, cimgui::ImGuiViewport* viewport, cimgui::ImGuiDir dir, float size, ImGuiWindowFlags window_flags)
{
    return ::ImGui::BeginViewportSideBar(name, reinterpret_cast<::ImGuiViewport*>(viewport), static_cast<::ImGuiDir>(dir), size, window_flags);
}

CIMGUI_API bool cimgui::ImGui_BeginMenuWithIcon(const char* label, const char* icon, bool enabled)
{
    return ::ImGui::BeginMenuEx(label, icon, enabled);
}

CIMGUI_API bool cimgui::ImGui_MenuItemWithIcon(const char* label, const char* icon, const char* shortcut, bool selected, bool enabled)
{
    return ::ImGui::MenuItemEx(label, icon, shortcut, selected, enabled);
}

CIMGUI_API bool cimgui::ImGui_BeginComboPopup(ImGuiID popup_id, cimgui::ImRect bb, ImGuiComboFlags flags)
{
    return ::ImGui::BeginComboPopup(popup_id, ConvertToCPP_ImRect(bb), flags);
}

CIMGUI_API bool cimgui::ImGui_BeginComboPreview(void)
{
    return ::ImGui::BeginComboPreview();
}

CIMGUI_API void cimgui::ImGui_EndComboPreview(void)
{
    ::ImGui::EndComboPreview();
}

CIMGUI_API void cimgui::ImGui_NavInitWindow(cimgui::ImGuiWindow* window, bool force_reinit)
{
    ::ImGui::NavInitWindow(reinterpret_cast<::ImGuiWindow*>(window), force_reinit);
}

CIMGUI_API void cimgui::ImGui_NavInitRequestApplyResult(void)
{
    ::ImGui::NavInitRequestApplyResult();
}

CIMGUI_API bool cimgui::ImGui_NavMoveRequestButNoResultYet(void)
{
    return ::ImGui::NavMoveRequestButNoResultYet();
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestSubmit(cimgui::ImGuiDir move_dir, cimgui::ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags)
{
    ::ImGui::NavMoveRequestSubmit(static_cast<::ImGuiDir>(move_dir), static_cast<::ImGuiDir>(clip_dir), move_flags, scroll_flags);
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestForward(cimgui::ImGuiDir move_dir, cimgui::ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags)
{
    ::ImGui::NavMoveRequestForward(static_cast<::ImGuiDir>(move_dir), static_cast<::ImGuiDir>(clip_dir), move_flags, scroll_flags);
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestResolveWithLastItem(cimgui::ImGuiNavItemData* result)
{
    ::ImGui::NavMoveRequestResolveWithLastItem(reinterpret_cast<::ImGuiNavItemData*>(result));
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestResolveWithPastTreeNode(cimgui::ImGuiNavItemData* result, const cimgui::ImGuiTreeNodeStackData* tree_node_data)
{
    ::ImGui::NavMoveRequestResolveWithPastTreeNode(reinterpret_cast<::ImGuiNavItemData*>(result), reinterpret_cast<const ::ImGuiTreeNodeStackData*>(tree_node_data));
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestCancel(void)
{
    ::ImGui::NavMoveRequestCancel();
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestApplyResult(void)
{
    ::ImGui::NavMoveRequestApplyResult();
}

CIMGUI_API void cimgui::ImGui_NavMoveRequestTryWrapping(cimgui::ImGuiWindow* window, ImGuiNavMoveFlags move_flags)
{
    ::ImGui::NavMoveRequestTryWrapping(reinterpret_cast<::ImGuiWindow*>(window), move_flags);
}

CIMGUI_API void cimgui::ImGui_NavHighlightActivated(ImGuiID id)
{
    ::ImGui::NavHighlightActivated(id);
}

CIMGUI_API void cimgui::ImGui_NavClearPreferredPosForAxis(cimgui::ImGuiAxis axis)
{
    ::ImGui::NavClearPreferredPosForAxis(static_cast<::ImGuiAxis>(axis));
}

CIMGUI_API void cimgui::ImGui_SetNavCursorVisibleAfterMove(void)
{
    ::ImGui::SetNavCursorVisibleAfterMove();
}

CIMGUI_API void cimgui::ImGui_NavUpdateCurrentWindowIsScrollPushableX(void)
{
    ::ImGui::NavUpdateCurrentWindowIsScrollPushableX();
}

CIMGUI_API void cimgui::ImGui_SetNavWindow(cimgui::ImGuiWindow* window)
{
    ::ImGui::SetNavWindow(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void cimgui::ImGui_SetNavID(ImGuiID id, cimgui::ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, cimgui::ImRect rect_rel)
{
    ::ImGui::SetNavID(id, static_cast<::ImGuiNavLayer>(nav_layer), focus_scope_id, ConvertToCPP_ImRect(rect_rel));
}

CIMGUI_API void cimgui::ImGui_SetNavFocusScope(ImGuiID focus_scope_id)
{
    ::ImGui::SetNavFocusScope(focus_scope_id);
}

CIMGUI_API void cimgui::ImGui_FocusItem(void)
{
    ::ImGui::FocusItem();
}

CIMGUI_API void cimgui::ImGui_ActivateItemByID(ImGuiID id)
{
    ::ImGui::ActivateItemByID(id);
}

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

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

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

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

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

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

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

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

CIMGUI_API ImGuiKeyChord cimgui::ImGui_FixupKeyChord(ImGuiKeyChord key_chord)
{
    return ::ImGui::FixupKeyChord(key_chord);
}

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

CIMGUI_API cimgui::ImGuiKeyData* cimgui::ImGui_GetKeyDataImGuiContextPtr(cimgui::ImGuiContext* ctx, cimgui::ImGuiKey key)
{
    return reinterpret_cast<::cimgui::ImGuiKeyData*>(::ImGui::GetKeyData(reinterpret_cast<::ImGuiContext*>(ctx), static_cast<::ImGuiKey>(key)));
}

CIMGUI_API cimgui::ImGuiKeyData* cimgui::ImGui_GetKeyData(cimgui::ImGuiKey key)
{
    return reinterpret_cast<::cimgui::ImGuiKeyData*>(::ImGui::GetKeyData(static_cast<::ImGuiKey>(key)));
}

CIMGUI_API const char*   cimgui::ImGui_GetKeyChordName(ImGuiKeyChord key_chord)
{
    return ::ImGui::GetKeyChordName(key_chord);
}

CIMGUI_API cimgui::ImGuiKey cimgui::ImGui_MouseButtonToKey(ImGuiMouseButton button)
{
    return static_cast<::cimgui::ImGuiKey>(::ImGui::MouseButtonToKey(button));
}

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

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_GetKeyMagnitude2d(cimgui::ImGuiKey key_left, cimgui::ImGuiKey key_right, cimgui::ImGuiKey key_up, cimgui::ImGuiKey key_down)
{
    return ConvertFromCPP_ImVec2(::ImGui::GetKeyMagnitude2d(static_cast<::ImGuiKey>(key_left), static_cast<::ImGuiKey>(key_right), static_cast<::ImGuiKey>(key_up), static_cast<::ImGuiKey>(key_down)));
}

CIMGUI_API float         cimgui::ImGui_GetNavTweakPressedAmount(cimgui::ImGuiAxis axis)
{
    return ::ImGui::GetNavTweakPressedAmount(static_cast<::ImGuiAxis>(axis));
}

CIMGUI_API int           cimgui::ImGui_CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate)
{
    return ::ImGui::CalcTypematicRepeatAmount(t0, t1, repeat_delay, repeat_rate);
}

CIMGUI_API void          cimgui::ImGui_GetTypematicRepeatRate(ImGuiInputFlags flags, float* repeat_delay, float* repeat_rate)
{
    ::ImGui::GetTypematicRepeatRate(flags, repeat_delay, repeat_rate);
}

CIMGUI_API void          cimgui::ImGui_TeleportMousePos(cimgui::ImVec2 pos)
{
    ::ImGui::TeleportMousePos(ConvertToCPP_ImVec2(pos));
}

CIMGUI_API void          cimgui::ImGui_SetActiveIdUsingAllKeyboardKeys(void)
{
    ::ImGui::SetActiveIdUsingAllKeyboardKeys();
}

CIMGUI_API bool          cimgui::ImGui_IsActiveIdUsingNavDir(cimgui::ImGuiDir dir)
{
    return ::ImGui::IsActiveIdUsingNavDir(static_cast<::ImGuiDir>(dir));
}

CIMGUI_API ImGuiID            cimgui::ImGui_GetKeyOwner(cimgui::ImGuiKey key)
{
    return ::ImGui::GetKeyOwner(static_cast<::ImGuiKey>(key));
}

CIMGUI_API void               cimgui::ImGui_SetKeyOwner(cimgui::ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags)
{
    ::ImGui::SetKeyOwner(static_cast<::ImGuiKey>(key), owner_id, flags);
}

CIMGUI_API void               cimgui::ImGui_SetKeyOwnersForKeyChord(ImGuiKeyChord key, ImGuiID owner_id, ImGuiInputFlags flags)
{
    ::ImGui::SetKeyOwnersForKeyChord(key, owner_id, flags);
}

CIMGUI_API void               cimgui::ImGui_SetItemKeyOwnerImGuiInputFlags(cimgui::ImGuiKey key, ImGuiInputFlags flags)
{
    ::ImGui::SetItemKeyOwner(static_cast<::ImGuiKey>(key), flags);
}

CIMGUI_API bool               cimgui::ImGui_TestKeyOwner(cimgui::ImGuiKey key, ImGuiID owner_id)
{
    return ::ImGui::TestKeyOwner(static_cast<::ImGuiKey>(key), owner_id);
}

CIMGUI_API cimgui::ImGuiKeyOwnerData* cimgui::ImGui_GetKeyOwnerData(cimgui::ImGuiContext* ctx, cimgui::ImGuiKey key)
{
    return reinterpret_cast<::cimgui::ImGuiKeyOwnerData*>(::ImGui::GetKeyOwnerData(reinterpret_cast<::ImGuiContext*>(ctx), static_cast<::ImGuiKey>(key)));
}

CIMGUI_API bool cimgui::ImGui_IsKeyDownID(cimgui::ImGuiKey key, ImGuiID owner_id)
{
    return ::ImGui::IsKeyDown(static_cast<::ImGuiKey>(key), owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsKeyPressedImGuiInputFlags(cimgui::ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id)
{
    return ::ImGui::IsKeyPressed(static_cast<::ImGuiKey>(key), flags, owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsKeyReleasedID(cimgui::ImGuiKey key, ImGuiID owner_id)
{
    return ::ImGui::IsKeyReleased(static_cast<::ImGuiKey>(key), owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsKeyChordPressedImGuiInputFlags(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id)
{
    return ::ImGui::IsKeyChordPressed(key_chord, flags, owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsMouseDownID(ImGuiMouseButton button, ImGuiID owner_id)
{
    return ::ImGui::IsMouseDown(button, owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsMouseClickedImGuiInputFlags(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id)
{
    return ::ImGui::IsMouseClicked(button, flags, owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsMouseReleasedID(ImGuiMouseButton button, ImGuiID owner_id)
{
    return ::ImGui::IsMouseReleased(button, owner_id);
}

CIMGUI_API bool cimgui::ImGui_IsMouseDoubleClickedID(ImGuiMouseButton button, ImGuiID owner_id)
{
    return ::ImGui::IsMouseDoubleClicked(button, owner_id);
}

CIMGUI_API bool                 cimgui::ImGui_ShortcutID(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id)
{
    return ::ImGui::Shortcut(key_chord, flags, owner_id);
}

CIMGUI_API bool                 cimgui::ImGui_SetShortcutRouting(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id)
{
    return ::ImGui::SetShortcutRouting(key_chord, flags, owner_id);
}

CIMGUI_API bool                 cimgui::ImGui_TestShortcutRouting(ImGuiKeyChord key_chord, ImGuiID owner_id)
{
    return ::ImGui::TestShortcutRouting(key_chord, owner_id);
}

CIMGUI_API cimgui::ImGuiKeyRoutingData* cimgui::ImGui_GetShortcutRoutingData(ImGuiKeyChord key_chord)
{
    return reinterpret_cast<::cimgui::ImGuiKeyRoutingData*>(::ImGui::GetShortcutRoutingData(key_chord));
}

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

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

CIMGUI_API void           cimgui::ImGui_DockContextClearNodes(cimgui::ImGuiContext* ctx, ImGuiID root_id, bool clear_settings_refs)
{
    ::ImGui::DockContextClearNodes(reinterpret_cast<::ImGuiContext*>(ctx), root_id, clear_settings_refs);
}

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

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

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

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

CIMGUI_API ImGuiID        cimgui::ImGui_DockContextGenNodeID(cimgui::ImGuiContext* ctx)
{
    return ::ImGui::DockContextGenNodeID(reinterpret_cast<::ImGuiContext*>(ctx));
}

CIMGUI_API void           cimgui::ImGui_DockContextQueueDock(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* target, cimgui::ImGuiDockNode* target_node, cimgui::ImGuiWindow* payload, cimgui::ImGuiDir split_dir, float split_ratio, bool split_outer)
{
    ::ImGui::DockContextQueueDock(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(target), reinterpret_cast<::ImGuiDockNode*>(target_node), reinterpret_cast<::ImGuiWindow*>(payload), static_cast<::ImGuiDir>(split_dir), split_ratio, split_outer);
}

CIMGUI_API void           cimgui::ImGui_DockContextQueueUndockWindow(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* window)
{
    ::ImGui::DockContextQueueUndockWindow(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void           cimgui::ImGui_DockContextQueueUndockNode(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node)
{
    ::ImGui::DockContextQueueUndockNode(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node));
}

CIMGUI_API void           cimgui::ImGui_DockContextProcessUndockWindow(cimgui::ImGuiContext* ctx, cimgui::ImGuiWindow* window, bool clear_persistent_docking_ref)
{
    ::ImGui::DockContextProcessUndockWindow(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiWindow*>(window), clear_persistent_docking_ref);
}

CIMGUI_API void           cimgui::ImGui_DockContextProcessUndockNode(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node)
{
    ::ImGui::DockContextProcessUndockNode(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node));
}

CIMGUI_API bool           cimgui::ImGui_DockContextCalcDropPosForDocking(cimgui::ImGuiWindow* target, cimgui::ImGuiDockNode* target_node, cimgui::ImGuiWindow* payload_window, cimgui::ImGuiDockNode* payload_node, cimgui::ImGuiDir split_dir, bool split_outer, cimgui::ImVec2* out_pos)
{
    return ::ImGui::DockContextCalcDropPosForDocking(reinterpret_cast<::ImGuiWindow*>(target), reinterpret_cast<::ImGuiDockNode*>(target_node), reinterpret_cast<::ImGuiWindow*>(payload_window), reinterpret_cast<::ImGuiDockNode*>(payload_node), static_cast<::ImGuiDir>(split_dir), split_outer, reinterpret_cast<::ImVec2*>(out_pos));
}

CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockContextFindNodeByID(cimgui::ImGuiContext* ctx, ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockContextFindNodeByID(reinterpret_cast<::ImGuiContext*>(ctx), id));
}

CIMGUI_API void           cimgui::ImGui_DockNodeWindowMenuHandler_Default(cimgui::ImGuiContext* ctx, cimgui::ImGuiDockNode* node, cimgui::ImGuiTabBar* tab_bar)
{
    ::ImGui::DockNodeWindowMenuHandler_Default(reinterpret_cast<::ImGuiContext*>(ctx), reinterpret_cast<::ImGuiDockNode*>(node), reinterpret_cast<::ImGuiTabBar*>(tab_bar));
}

CIMGUI_API bool           cimgui::ImGui_DockNodeBeginAmendTabBar(cimgui::ImGuiDockNode* node)
{
    return ::ImGui::DockNodeBeginAmendTabBar(reinterpret_cast<::ImGuiDockNode*>(node));
}

CIMGUI_API void           cimgui::ImGui_DockNodeEndAmendTabBar(void)
{
    ::ImGui::DockNodeEndAmendTabBar();
}

CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockNodeGetRootNode(cimgui::ImGuiDockNode* node)
{
    return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockNodeGetRootNode(reinterpret_cast<::ImGuiDockNode*>(node)));
}

CIMGUI_API bool           cimgui::ImGui_DockNodeIsInHierarchyOf(cimgui::ImGuiDockNode* node, cimgui::ImGuiDockNode* parent)
{
    return ::ImGui::DockNodeIsInHierarchyOf(reinterpret_cast<::ImGuiDockNode*>(node), reinterpret_cast<::ImGuiDockNode*>(parent));
}

CIMGUI_API int            cimgui::ImGui_DockNodeGetDepth(const cimgui::ImGuiDockNode* node)
{
    return ::ImGui::DockNodeGetDepth(reinterpret_cast<const ::ImGuiDockNode*>(node));
}

CIMGUI_API ImGuiID        cimgui::ImGui_DockNodeGetWindowMenuButtonId(const cimgui::ImGuiDockNode* node)
{
    return ::ImGui::DockNodeGetWindowMenuButtonId(reinterpret_cast<const ::ImGuiDockNode*>(node));
}

CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_GetWindowDockNode(void)
{
    return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::GetWindowDockNode());
}

CIMGUI_API bool           cimgui::ImGui_GetWindowAlwaysWantOwnTabBar(cimgui::ImGuiWindow* window)
{
    return ::ImGui::GetWindowAlwaysWantOwnTabBar(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void           cimgui::ImGui_BeginDocked(cimgui::ImGuiWindow* window, bool* p_open)
{
    ::ImGui::BeginDocked(reinterpret_cast<::ImGuiWindow*>(window), p_open);
}

CIMGUI_API void           cimgui::ImGui_BeginDockableDragDropSource(cimgui::ImGuiWindow* window)
{
    ::ImGui::BeginDockableDragDropSource(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void           cimgui::ImGui_BeginDockableDragDropTarget(cimgui::ImGuiWindow* window)
{
    ::ImGui::BeginDockableDragDropTarget(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void           cimgui::ImGui_SetWindowDock(cimgui::ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond)
{
    ::ImGui::SetWindowDock(reinterpret_cast<::ImGuiWindow*>(window), dock_id, cond);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderDockWindow(const char* window_name, ImGuiID node_id)
{
    ::ImGui::DockBuilderDockWindow(window_name, node_id);
}

CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockBuilderGetNode(ImGuiID node_id)
{
    return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockBuilderGetNode(node_id));
}

CIMGUI_API cimgui::ImGuiDockNode* cimgui::ImGui_DockBuilderGetCentralNode(ImGuiID node_id)
{
    return reinterpret_cast<::cimgui::ImGuiDockNode*>(::ImGui::DockBuilderGetCentralNode(node_id));
}

CIMGUI_API ImGuiID        cimgui::ImGui_DockBuilderAddNode(ImGuiID node_id, ImGuiDockNodeFlags flags)
{
    return ::ImGui::DockBuilderAddNode(node_id, flags);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderRemoveNode(ImGuiID node_id)
{
    ::ImGui::DockBuilderRemoveNode(node_id);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderRemoveNodeDockedWindows(ImGuiID node_id, bool clear_settings_refs)
{
    ::ImGui::DockBuilderRemoveNodeDockedWindows(node_id, clear_settings_refs);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderRemoveNodeChildNodes(ImGuiID node_id)
{
    ::ImGui::DockBuilderRemoveNodeChildNodes(node_id);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderSetNodePos(ImGuiID node_id, cimgui::ImVec2 pos)
{
    ::ImGui::DockBuilderSetNodePos(node_id, ConvertToCPP_ImVec2(pos));
}

CIMGUI_API void           cimgui::ImGui_DockBuilderSetNodeSize(ImGuiID node_id, cimgui::ImVec2 size)
{
    ::ImGui::DockBuilderSetNodeSize(node_id, ConvertToCPP_ImVec2(size));
}

CIMGUI_API ImGuiID        cimgui::ImGui_DockBuilderSplitNode(ImGuiID node_id, cimgui::ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir)
{
    return ::ImGui::DockBuilderSplitNode(node_id, static_cast<::ImGuiDir>(split_dir), size_ratio_for_node_at_dir, out_id_at_dir, out_id_at_opposite_dir);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, cimgui::ImVector_const_charPtr* in_window_remap_pairs)
{
    ::ImGui::DockBuilderCopyDockSpace(src_dockspace_id, dst_dockspace_id, reinterpret_cast<::ImVector<const char*>*>(in_window_remap_pairs));
}

CIMGUI_API void           cimgui::ImGui_DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id, cimgui::ImVector_ImGuiID* out_node_remap_pairs)
{
    ::ImGui::DockBuilderCopyNode(src_node_id, dst_node_id, reinterpret_cast<::ImVector<::ImGuiID>*>(out_node_remap_pairs));
}

CIMGUI_API void           cimgui::ImGui_DockBuilderCopyWindowSettings(const char* src_name, const char* dst_name)
{
    ::ImGui::DockBuilderCopyWindowSettings(src_name, dst_name);
}

CIMGUI_API void           cimgui::ImGui_DockBuilderFinish(ImGuiID node_id)
{
    ::ImGui::DockBuilderFinish(node_id);
}

CIMGUI_API void    cimgui::ImGui_PushFocusScope(ImGuiID id)
{
    ::ImGui::PushFocusScope(id);
}

CIMGUI_API void    cimgui::ImGui_PopFocusScope(void)
{
    ::ImGui::PopFocusScope();
}

CIMGUI_API ImGuiID cimgui::ImGui_GetCurrentFocusScope(void)
{
    return ::ImGui::GetCurrentFocusScope();
}

CIMGUI_API bool cimgui::ImGui_IsDragDropActive(void)
{
    return ::ImGui::IsDragDropActive();
}

CIMGUI_API bool cimgui::ImGui_BeginDragDropTargetCustom(cimgui::ImRect bb, ImGuiID id)
{
    return ::ImGui::BeginDragDropTargetCustom(ConvertToCPP_ImRect(bb), id);
}

CIMGUI_API bool cimgui::ImGui_BeginDragDropTargetViewport(cimgui::ImGuiViewport* viewport, const cimgui::ImRect* p_bb)
{
    return ::ImGui::BeginDragDropTargetViewport(reinterpret_cast<::ImGuiViewport*>(viewport), reinterpret_cast<const ::ImRect*>(p_bb));
}

CIMGUI_API void cimgui::ImGui_ClearDragDrop(void)
{
    ::ImGui::ClearDragDrop();
}

CIMGUI_API bool cimgui::ImGui_IsDragDropPayloadBeingAccepted(void)
{
    return ::ImGui::IsDragDropPayloadBeingAccepted();
}

CIMGUI_API void cimgui::ImGui_RenderDragDropTargetRectForItem(cimgui::ImRect bb)
{
    ::ImGui::RenderDragDropTargetRectForItem(ConvertToCPP_ImRect(bb));
}

CIMGUI_API void cimgui::ImGui_RenderDragDropTargetRectEx(cimgui::ImDrawList* draw_list, cimgui::ImRect bb)
{
    ::ImGui::RenderDragDropTargetRectEx(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(bb));
}

CIMGUI_API cimgui::ImGuiTypingSelectRequest* cimgui::ImGui_GetTypingSelectRequest(ImGuiTypingSelectFlags flags)
{
    return reinterpret_cast<::cimgui::ImGuiTypingSelectRequest*>(::ImGui::GetTypingSelectRequest(flags));
}

CIMGUI_API int                       cimgui::ImGui_TypingSelectFindMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx)
{
    return ::ImGui::TypingSelectFindMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data, nav_item_idx);
}

CIMGUI_API int                       cimgui::ImGui_TypingSelectFindNextSingleCharMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx)
{
    return ::ImGui::TypingSelectFindNextSingleCharMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data, nav_item_idx);
}

CIMGUI_API int                       cimgui::ImGui_TypingSelectFindBestLeadingMatch(cimgui::ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data)
{
    return ::ImGui::TypingSelectFindBestLeadingMatch(reinterpret_cast<::ImGuiTypingSelectRequest*>(req), items_count, get_item_name_func, user_data);
}

CIMGUI_API bool cimgui::ImGui_BeginBoxSelect(cimgui::ImRect scope_rect, cimgui::ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags)
{
    return ::ImGui::BeginBoxSelect(ConvertToCPP_ImRect(scope_rect), reinterpret_cast<::ImGuiWindow*>(window), box_select_id, ms_flags);
}

CIMGUI_API void cimgui::ImGui_EndBoxSelect(cimgui::ImRect scope_rect, ImGuiMultiSelectFlags ms_flags)
{
    ::ImGui::EndBoxSelect(ConvertToCPP_ImRect(scope_rect), ms_flags);
}

CIMGUI_API void                   cimgui::ImGui_MultiSelectItemHeader(ImGuiID id, bool* p_selected, ImGuiButtonFlags* p_button_flags)
{
    ::ImGui::MultiSelectItemHeader(id, p_selected, p_button_flags);
}

CIMGUI_API void                   cimgui::ImGui_MultiSelectItemFooter(ImGuiID id, bool* p_selected, bool* p_pressed)
{
    ::ImGui::MultiSelectItemFooter(id, p_selected, p_pressed);
}

CIMGUI_API void                   cimgui::ImGui_MultiSelectAddSetAll(cimgui::ImGuiMultiSelectTempData* ms, bool selected)
{
    ::ImGui::MultiSelectAddSetAll(reinterpret_cast<::ImGuiMultiSelectTempData*>(ms), selected);
}

CIMGUI_API void                   cimgui::ImGui_MultiSelectAddSetRange(cimgui::ImGuiMultiSelectTempData* ms, bool selected, int range_dir, ImGuiSelectionUserData first_item, ImGuiSelectionUserData last_item)
{
    ::ImGui::MultiSelectAddSetRange(reinterpret_cast<::ImGuiMultiSelectTempData*>(ms), selected, range_dir, first_item, last_item);
}

CIMGUI_API cimgui::ImGuiBoxSelectState* cimgui::ImGui_GetBoxSelectState(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiBoxSelectState*>(::ImGui::GetBoxSelectState(id));
}

CIMGUI_API cimgui::ImGuiMultiSelectState* cimgui::ImGui_GetMultiSelectState(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiMultiSelectState*>(::ImGui::GetMultiSelectState(id));
}

CIMGUI_API void             cimgui::ImGui_SetWindowClipRectBeforeSetChannel(cimgui::ImGuiWindow* window, cimgui::ImRect clip_rect)
{
    ::ImGui::SetWindowClipRectBeforeSetChannel(reinterpret_cast<::ImGuiWindow*>(window), ConvertToCPP_ImRect(clip_rect));
}

CIMGUI_API void             cimgui::ImGui_BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags)
{
    ::ImGui::BeginColumns(str_id, count, flags);
}

CIMGUI_API void             cimgui::ImGui_EndColumns(void)
{
    ::ImGui::EndColumns();
}

CIMGUI_API void             cimgui::ImGui_PushColumnClipRect(int column_index)
{
    ::ImGui::PushColumnClipRect(column_index);
}

CIMGUI_API void             cimgui::ImGui_PushColumnsBackground(void)
{
    ::ImGui::PushColumnsBackground();
}

CIMGUI_API void             cimgui::ImGui_PopColumnsBackground(void)
{
    ::ImGui::PopColumnsBackground();
}

CIMGUI_API ImGuiID          cimgui::ImGui_GetColumnsID(const char* str_id, int count)
{
    return ::ImGui::GetColumnsID(str_id, count);
}

CIMGUI_API cimgui::ImGuiOldColumns* cimgui::ImGui_FindOrCreateColumns(cimgui::ImGuiWindow* window, ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiOldColumns*>(::ImGui::FindOrCreateColumns(reinterpret_cast<::ImGuiWindow*>(window), id));
}

CIMGUI_API float            cimgui::ImGui_GetColumnOffsetFromNorm(const cimgui::ImGuiOldColumns* columns, float offset_norm)
{
    return ::ImGui::GetColumnOffsetFromNorm(reinterpret_cast<const ::ImGuiOldColumns*>(columns), offset_norm);
}

CIMGUI_API float            cimgui::ImGui_GetColumnNormFromOffset(const cimgui::ImGuiOldColumns* columns, float offset)
{
    return ::ImGui::GetColumnNormFromOffset(reinterpret_cast<const ::ImGuiOldColumns*>(columns), offset);
}

CIMGUI_API void  cimgui::ImGui_TableOpenContextMenu(int column_n)
{
    ::ImGui::TableOpenContextMenu(column_n);
}

CIMGUI_API void  cimgui::ImGui_TableSetColumnWidth(int column_n, float width)
{
    ::ImGui::TableSetColumnWidth(column_n, width);
}

CIMGUI_API void  cimgui::ImGui_TableSetColumnSortDirection(int column_n, cimgui::ImGuiSortDirection sort_direction, bool append_to_sort_specs)
{
    ::ImGui::TableSetColumnSortDirection(column_n, static_cast<::ImGuiSortDirection>(sort_direction), append_to_sort_specs);
}

CIMGUI_API int   cimgui::ImGui_TableGetHoveredRow(void)
{
    return ::ImGui::TableGetHoveredRow();
}

CIMGUI_API float cimgui::ImGui_TableGetHeaderRowHeight(void)
{
    return ::ImGui::TableGetHeaderRowHeight();
}

CIMGUI_API float cimgui::ImGui_TableGetHeaderAngledMaxLabelWidth(void)
{
    return ::ImGui::TableGetHeaderAngledMaxLabelWidth();
}

CIMGUI_API void  cimgui::ImGui_TablePushBackgroundChannel(void)
{
    ::ImGui::TablePushBackgroundChannel();
}

CIMGUI_API void  cimgui::ImGui_TablePopBackgroundChannel(void)
{
    ::ImGui::TablePopBackgroundChannel();
}

CIMGUI_API void  cimgui::ImGui_TablePushColumnChannel(int column_n)
{
    ::ImGui::TablePushColumnChannel(column_n);
}

CIMGUI_API void  cimgui::ImGui_TablePopColumnChannel(void)
{
    ::ImGui::TablePopColumnChannel();
}

CIMGUI_API void  cimgui::ImGui_TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const cimgui::ImGuiTableHeaderData* data, int data_count)
{
    ::ImGui::TableAngledHeadersRowEx(row_id, angle, max_label_width, reinterpret_cast<const ::ImGuiTableHeaderData*>(data), data_count);
}

CIMGUI_API cimgui::ImGuiTable*     cimgui::ImGui_GetCurrentTable(void)
{
    return reinterpret_cast<::cimgui::ImGuiTable*>(::ImGui::GetCurrentTable());
}

CIMGUI_API cimgui::ImGuiTable*     cimgui::ImGui_TableFindByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiTable*>(::ImGui::TableFindByID(id));
}

CIMGUI_API bool                    cimgui::ImGui_BeginTableWithID(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, cimgui::ImVec2 outer_size, float inner_width)
{
    return ::ImGui::BeginTableEx(name, id, columns_count, flags, ConvertToCPP_ImVec2(outer_size), inner_width);
}

CIMGUI_API void                    cimgui::ImGui_TableBeginInitMemory(cimgui::ImGuiTable* table, int columns_count)
{
    ::ImGui::TableBeginInitMemory(reinterpret_cast<::ImGuiTable*>(table), columns_count);
}

CIMGUI_API void                    cimgui::ImGui_TableBeginApplyRequests(cimgui::ImGuiTable* table)
{
    ::ImGui::TableBeginApplyRequests(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableSetupDrawChannels(cimgui::ImGuiTable* table)
{
    ::ImGui::TableSetupDrawChannels(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableUpdateLayout(cimgui::ImGuiTable* table)
{
    ::ImGui::TableUpdateLayout(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableUpdateBorders(cimgui::ImGuiTable* table)
{
    ::ImGui::TableUpdateBorders(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableUpdateColumnsWeightFromWidth(cimgui::ImGuiTable* table)
{
    ::ImGui::TableUpdateColumnsWeightFromWidth(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableDrawBorders(cimgui::ImGuiTable* table)
{
    ::ImGui::TableDrawBorders(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableDrawDefaultContextMenu(cimgui::ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display)
{
    ::ImGui::TableDrawDefaultContextMenu(reinterpret_cast<::ImGuiTable*>(table), flags_for_section_to_display);
}

CIMGUI_API bool                    cimgui::ImGui_TableBeginContextMenuPopup(cimgui::ImGuiTable* table)
{
    return ::ImGui::TableBeginContextMenuPopup(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableMergeDrawChannels(cimgui::ImGuiTable* table)
{
    ::ImGui::TableMergeDrawChannels(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API cimgui::ImGuiTableInstanceData* cimgui::ImGui_TableGetInstanceData(cimgui::ImGuiTable* table, int instance_no)
{
    return reinterpret_cast<::cimgui::ImGuiTableInstanceData*>(::ImGui::TableGetInstanceData(reinterpret_cast<::ImGuiTable*>(table), instance_no));
}

CIMGUI_API ImGuiID                 cimgui::ImGui_TableGetInstanceID(cimgui::ImGuiTable* table, int instance_no)
{
    return ::ImGui::TableGetInstanceID(reinterpret_cast<::ImGuiTable*>(table), instance_no);
}

CIMGUI_API void                    cimgui::ImGui_TableFixDisplayOrder(cimgui::ImGuiTable* table)
{
    ::ImGui::TableFixDisplayOrder(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableSortSpecsSanitize(cimgui::ImGuiTable* table)
{
    ::ImGui::TableSortSpecsSanitize(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableSortSpecsBuild(cimgui::ImGuiTable* table)
{
    ::ImGui::TableSortSpecsBuild(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API cimgui::ImGuiSortDirection cimgui::ImGui_TableGetColumnNextSortDirection(cimgui::ImGuiTableColumn* column)
{
    return static_cast<::cimgui::ImGuiSortDirection>(::ImGui::TableGetColumnNextSortDirection(reinterpret_cast<::ImGuiTableColumn*>(column)));
}

CIMGUI_API void                    cimgui::ImGui_TableFixColumnSortDirection(cimgui::ImGuiTable* table, cimgui::ImGuiTableColumn* column)
{
    ::ImGui::TableFixColumnSortDirection(reinterpret_cast<::ImGuiTable*>(table), reinterpret_cast<::ImGuiTableColumn*>(column));
}

CIMGUI_API float                   cimgui::ImGui_TableGetColumnWidthAuto(cimgui::ImGuiTable* table, cimgui::ImGuiTableColumn* column)
{
    return ::ImGui::TableGetColumnWidthAuto(reinterpret_cast<::ImGuiTable*>(table), reinterpret_cast<::ImGuiTableColumn*>(column));
}

CIMGUI_API void                    cimgui::ImGui_TableBeginRow(cimgui::ImGuiTable* table)
{
    ::ImGui::TableBeginRow(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableEndRow(cimgui::ImGuiTable* table)
{
    ::ImGui::TableEndRow(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableBeginCell(cimgui::ImGuiTable* table, int column_n)
{
    ::ImGui::TableBeginCell(reinterpret_cast<::ImGuiTable*>(table), column_n);
}

CIMGUI_API void                    cimgui::ImGui_TableEndCell(cimgui::ImGuiTable* table)
{
    ::ImGui::TableEndCell(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API cimgui::ImRect          cimgui::ImGui_TableGetCellBgRect(const cimgui::ImGuiTable* table, int column_n)
{
    return ConvertFromCPP_ImRect(::ImGui::TableGetCellBgRect(reinterpret_cast<const ::ImGuiTable*>(table), column_n));
}

CIMGUI_API const char*             cimgui::ImGui_TableGetColumnNameImGuiTablePtr(const cimgui::ImGuiTable* table, int column_n)
{
    return ::ImGui::TableGetColumnName(reinterpret_cast<const ::ImGuiTable*>(table), column_n);
}

CIMGUI_API ImGuiID                 cimgui::ImGui_TableGetColumnResizeID(cimgui::ImGuiTable* table, int column_n, int instance_no)
{
    return ::ImGui::TableGetColumnResizeID(reinterpret_cast<::ImGuiTable*>(table), column_n, instance_no);
}

CIMGUI_API float                   cimgui::ImGui_TableCalcMaxColumnWidth(const cimgui::ImGuiTable* table, int column_n)
{
    return ::ImGui::TableCalcMaxColumnWidth(reinterpret_cast<const ::ImGuiTable*>(table), column_n);
}

CIMGUI_API void                    cimgui::ImGui_TableSetColumnWidthAutoSingle(cimgui::ImGuiTable* table, int column_n)
{
    ::ImGui::TableSetColumnWidthAutoSingle(reinterpret_cast<::ImGuiTable*>(table), column_n);
}

CIMGUI_API void                    cimgui::ImGui_TableSetColumnWidthAutoAll(cimgui::ImGuiTable* table)
{
    ::ImGui::TableSetColumnWidthAutoAll(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableSetColumnDisplayOrder(cimgui::ImGuiTable* table, int column_n, int dst_order)
{
    ::ImGui::TableSetColumnDisplayOrder(reinterpret_cast<::ImGuiTable*>(table), column_n, dst_order);
}

CIMGUI_API void                    cimgui::ImGui_TableQueueSetColumnDisplayOrder(cimgui::ImGuiTable* table, int column_n, int dst_order)
{
    ::ImGui::TableQueueSetColumnDisplayOrder(reinterpret_cast<::ImGuiTable*>(table), column_n, dst_order);
}

CIMGUI_API void                    cimgui::ImGui_TableRemove(cimgui::ImGuiTable* table)
{
    ::ImGui::TableRemove(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableGcCompactTransientBuffers(cimgui::ImGuiTable* table)
{
    ::ImGui::TableGcCompactTransientBuffers(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableGcCompactTransientBuffersImGuiTableTempDataPtr(cimgui::ImGuiTableTempData* table)
{
    ::ImGui::TableGcCompactTransientBuffers(reinterpret_cast<::ImGuiTableTempData*>(table));
}

CIMGUI_API void                    cimgui::ImGui_TableGcCompactSettings(void)
{
    ::ImGui::TableGcCompactSettings();
}

CIMGUI_API void                cimgui::ImGui_TableLoadSettings(cimgui::ImGuiTable* table)
{
    ::ImGui::TableLoadSettings(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                cimgui::ImGui_TableSaveSettings(cimgui::ImGuiTable* table)
{
    ::ImGui::TableSaveSettings(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void                cimgui::ImGui_TableResetSettings(cimgui::ImGuiTable* table)
{
    ::ImGui::TableResetSettings(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableGetBoundSettings(cimgui::ImGuiTable* table)
{
    return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableGetBoundSettings(reinterpret_cast<::ImGuiTable*>(table)));
}

CIMGUI_API void                cimgui::ImGui_TableSettingsAddSettingsHandler(void)
{
    ::ImGui::TableSettingsAddSettingsHandler();
}

CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableSettingsCreate(ImGuiID id, int columns_count)
{
    return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableSettingsCreate(id, columns_count));
}

CIMGUI_API cimgui::ImGuiTableSettings* cimgui::ImGui_TableSettingsFindByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiTableSettings*>(::ImGui::TableSettingsFindByID(id));
}

CIMGUI_API cimgui::ImGuiTabBar* cimgui::ImGui_GetCurrentTabBar(void)
{
    return reinterpret_cast<::cimgui::ImGuiTabBar*>(::ImGui::GetCurrentTabBar());
}

CIMGUI_API cimgui::ImGuiTabBar* cimgui::ImGui_TabBarFindByID(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiTabBar*>(::ImGui::TabBarFindByID(id));
}

CIMGUI_API void          cimgui::ImGui_TabBarRemove(cimgui::ImGuiTabBar* tab_bar)
{
    ::ImGui::TabBarRemove(reinterpret_cast<::ImGuiTabBar*>(tab_bar));
}

CIMGUI_API bool          cimgui::ImGui_BeginTabBarEx(cimgui::ImGuiTabBar* tab_bar, cimgui::ImRect bb, ImGuiTabBarFlags flags)
{
    return ::ImGui::BeginTabBarEx(reinterpret_cast<::ImGuiTabBar*>(tab_bar), ConvertToCPP_ImRect(bb), flags);
}

CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindTabByID(cimgui::ImGuiTabBar* tab_bar, ImGuiID tab_id)
{
    return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindTabByID(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_id));
}

CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindTabByOrder(cimgui::ImGuiTabBar* tab_bar, int order)
{
    return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindTabByOrder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), order));
}

CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarFindMostRecentlySelectedTabForActiveWindow(cimgui::ImGuiTabBar* tab_bar)
{
    return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(reinterpret_cast<::ImGuiTabBar*>(tab_bar)));
}

CIMGUI_API cimgui::ImGuiTabItem* cimgui::ImGui_TabBarGetCurrentTab(cimgui::ImGuiTabBar* tab_bar)
{
    return reinterpret_cast<::cimgui::ImGuiTabItem*>(::ImGui::TabBarGetCurrentTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar)));
}

CIMGUI_API int           cimgui::ImGui_TabBarGetTabOrder(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab)
{
    return ::ImGui::TabBarGetTabOrder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab));
}

CIMGUI_API const char*   cimgui::ImGui_TabBarGetTabName(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab)
{
    return ::ImGui::TabBarGetTabName(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab));
}

CIMGUI_API void          cimgui::ImGui_TabBarAddTab(cimgui::ImGuiTabBar* tab_bar, ImGuiTabItemFlags tab_flags, cimgui::ImGuiWindow* window)
{
    ::ImGui::TabBarAddTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_flags, reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void          cimgui::ImGui_TabBarRemoveTab(cimgui::ImGuiTabBar* tab_bar, ImGuiID tab_id)
{
    ::ImGui::TabBarRemoveTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_id);
}

CIMGUI_API void          cimgui::ImGui_TabBarCloseTab(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab)
{
    ::ImGui::TabBarCloseTab(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab));
}

CIMGUI_API void          cimgui::ImGui_TabBarQueueFocus(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab)
{
    ::ImGui::TabBarQueueFocus(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab));
}

CIMGUI_API void          cimgui::ImGui_TabBarQueueFocusStr(cimgui::ImGuiTabBar* tab_bar, const char* tab_name)
{
    ::ImGui::TabBarQueueFocus(reinterpret_cast<::ImGuiTabBar*>(tab_bar), tab_name);
}

CIMGUI_API void          cimgui::ImGui_TabBarQueueReorder(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab, int offset)
{
    ::ImGui::TabBarQueueReorder(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab), offset);
}

CIMGUI_API void          cimgui::ImGui_TabBarQueueReorderFromMousePos(cimgui::ImGuiTabBar* tab_bar, cimgui::ImGuiTabItem* tab, cimgui::ImVec2 mouse_pos)
{
    ::ImGui::TabBarQueueReorderFromMousePos(reinterpret_cast<::ImGuiTabBar*>(tab_bar), reinterpret_cast<::ImGuiTabItem*>(tab), ConvertToCPP_ImVec2(mouse_pos));
}

CIMGUI_API bool          cimgui::ImGui_TabBarProcessReorder(cimgui::ImGuiTabBar* tab_bar)
{
    return ::ImGui::TabBarProcessReorder(reinterpret_cast<::ImGuiTabBar*>(tab_bar));
}

CIMGUI_API bool          cimgui::ImGui_TabItemEx(cimgui::ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, cimgui::ImGuiWindow* docked_window)
{
    return ::ImGui::TabItemEx(reinterpret_cast<::ImGuiTabBar*>(tab_bar), label, p_open, flags, reinterpret_cast<::ImGuiWindow*>(docked_window));
}

CIMGUI_API void          cimgui::ImGui_TabItemSpacing(const char* str_id, ImGuiTabItemFlags flags, float width)
{
    ::ImGui::TabItemSpacing(str_id, flags, width);
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_TabItemCalcSizeStr(const char* label, bool has_close_button_or_unsaved_marker)
{
    return ConvertFromCPP_ImVec2(::ImGui::TabItemCalcSize(label, has_close_button_or_unsaved_marker));
}

CIMGUI_API cimgui::ImVec2 cimgui::ImGui_TabItemCalcSize(cimgui::ImGuiWindow* window)
{
    return ConvertFromCPP_ImVec2(::ImGui::TabItemCalcSize(reinterpret_cast<::ImGuiWindow*>(window)));
}

CIMGUI_API void          cimgui::ImGui_TabItemBackground(cimgui::ImDrawList* draw_list, cimgui::ImRect bb, ImGuiTabItemFlags flags, ImU32 col)
{
    ::ImGui::TabItemBackground(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(bb), flags, col);
}

CIMGUI_API void          cimgui::ImGui_TabItemLabelAndCloseButton(cimgui::ImDrawList* draw_list, cimgui::ImRect bb, ImGuiTabItemFlags flags, cimgui::ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped)
{
    ::ImGui::TabItemLabelAndCloseButton(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(bb), flags, ConvertToCPP_ImVec2(frame_padding), label, tab_id, close_button_id, is_contents_visible, out_just_closed, out_text_clipped);
}

CIMGUI_API void        cimgui::ImGui_RenderText(cimgui::ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ::ImGui::RenderText(ConvertToCPP_ImVec2(pos), text, text_end, hide_text_after_hash);
}

CIMGUI_API void        cimgui::ImGui_RenderTextWrapped(cimgui::ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ::ImGui::RenderTextWrapped(ConvertToCPP_ImVec2(pos), text, text_end, wrap_width);
}

CIMGUI_API void        cimgui::ImGui_RenderTextClipped(cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known, cimgui::ImVec2 align, const cimgui::ImRect* clip_rect)
{
    ::ImGui::RenderTextClipped(ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast<const ::ImVec2*>(text_size_if_known), ConvertToCPP_ImVec2(align), reinterpret_cast<const ::ImRect*>(clip_rect));
}

CIMGUI_API void        cimgui::ImGui_RenderTextClippedWithDrawList(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known, cimgui::ImVec2 align, const cimgui::ImRect* clip_rect)
{
    ::ImGui::RenderTextClippedEx(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), text, text_end, reinterpret_cast<const ::ImVec2*>(text_size_if_known), ConvertToCPP_ImVec2(align), reinterpret_cast<const ::ImRect*>(clip_rect));
}

CIMGUI_API void        cimgui::ImGui_RenderTextEllipsis(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos_min, cimgui::ImVec2 pos_max, float ellipsis_max_x, const char* text, const char* text_end, const cimgui::ImVec2* text_size_if_known)
{
    ::ImGui::RenderTextEllipsis(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos_min), ConvertToCPP_ImVec2(pos_max), ellipsis_max_x, text, text_end, reinterpret_cast<const ::ImVec2*>(text_size_if_known));
}

CIMGUI_API void        cimgui::ImGui_RenderFrame(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col, bool borders, float rounding)
{
    ::ImGui::RenderFrame(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col, borders, rounding);
}

CIMGUI_API void        cimgui::ImGui_RenderFrameBorder(cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, float rounding)
{
    ::ImGui::RenderFrameBorder(ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), rounding);
}

CIMGUI_API void        cimgui::ImGui_RenderColorComponentMarker(cimgui::ImRect bb, ImU32 col, float rounding)
{
    ::ImGui::RenderColorComponentMarker(ConvertToCPP_ImRect(bb), col, rounding);
}

CIMGUI_API void        cimgui::ImGui_RenderColorRectWithAlphaCheckerboard(cimgui::ImDrawList* draw_list, cimgui::ImVec2 p_min, cimgui::ImVec2 p_max, ImU32 fill_col, float grid_step, cimgui::ImVec2 grid_off, float rounding, ImDrawFlags flags)
{
    ::ImGui::RenderColorRectWithAlphaCheckerboard(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(p_min), ConvertToCPP_ImVec2(p_max), fill_col, grid_step, ConvertToCPP_ImVec2(grid_off), rounding, flags);
}

CIMGUI_API void        cimgui::ImGui_RenderNavCursor(cimgui::ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags)
{
    ::ImGui::RenderNavCursor(ConvertToCPP_ImRect(bb), id, flags);
}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API void cimgui::ImGui_RenderNavHighlight(cimgui::ImRect bb, ImGuiID id, ImGuiNavRenderCursorFlags flags)
{
    ::ImGui::RenderNavHighlight(ConvertToCPP_ImRect(bb), id, flags);
}

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

CIMGUI_API const char* cimgui::ImGui_FindRenderedTextEnd(const char* text, const char* text_end)
{
    return ::ImGui::FindRenderedTextEnd(text, text_end);
}

CIMGUI_API void        cimgui::ImGui_RenderMouseCursor(cimgui::ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow)
{
    ::ImGui::RenderMouseCursor(ConvertToCPP_ImVec2(pos), scale, mouse_cursor, col_fill, col_border, col_shadow);
}

CIMGUI_API void        cimgui::ImGui_RenderArrow(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col, cimgui::ImGuiDir dir, float scale)
{
    ::ImGui::RenderArrow(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col, static_cast<::ImGuiDir>(dir), scale);
}

CIMGUI_API void        cimgui::ImGui_RenderBullet(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col)
{
    ::ImGui::RenderBullet(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col);
}

CIMGUI_API void        cimgui::ImGui_RenderCheckMark(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, ImU32 col, float sz)
{
    ::ImGui::RenderCheckMark(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), col, sz);
}

CIMGUI_API void        cimgui::ImGui_RenderArrowPointingAt(cimgui::ImDrawList* draw_list, cimgui::ImVec2 pos, cimgui::ImVec2 half_sz, cimgui::ImGuiDir direction, ImU32 col)
{
    ::ImGui::RenderArrowPointingAt(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(pos), ConvertToCPP_ImVec2(half_sz), static_cast<::ImGuiDir>(direction), col);
}

CIMGUI_API void        cimgui::ImGui_RenderArrowDockMenu(cimgui::ImDrawList* draw_list, cimgui::ImVec2 p_min, float sz, ImU32 col)
{
    ::ImGui::RenderArrowDockMenu(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImVec2(p_min), sz, col);
}

CIMGUI_API void        cimgui::ImGui_RenderRectFilledInRangeH(cimgui::ImDrawList* draw_list, cimgui::ImRect rect, ImU32 col, float fill_x0, float fill_x1, float rounding)
{
    ::ImGui::RenderRectFilledInRangeH(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(rect), col, fill_x0, fill_x1, rounding);
}

CIMGUI_API void        cimgui::ImGui_RenderRectFilledWithHole(cimgui::ImDrawList* draw_list, cimgui::ImRect outer, cimgui::ImRect inner, ImU32 col, float rounding)
{
    ::ImGui::RenderRectFilledWithHole(reinterpret_cast<::ImDrawList*>(draw_list), ConvertToCPP_ImRect(outer), ConvertToCPP_ImRect(inner), col, rounding);
}

CIMGUI_API ImDrawFlags cimgui::ImGui_CalcRoundingFlagsForRectInRect(cimgui::ImRect r_in, cimgui::ImRect r_outer, float threshold)
{
    return ::ImGui::CalcRoundingFlagsForRectInRect(ConvertToCPP_ImRect(r_in), ConvertToCPP_ImRect(r_outer), threshold);
}

CIMGUI_API void cimgui::ImGui_TextEx(const char* text, const char* text_end, ImGuiTextFlags flags)
{
    ::ImGui::TextEx(text, text_end, flags);
}

CIMGUI_API void cimgui::ImGui_TextAligned(float align_x, float size_x, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImGui::TextAlignedV(align_x, size_x, fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImGui_TextAlignedV(float align_x, float size_x, const char* fmt, va_list args)
{
    ::ImGui::TextAlignedV(align_x, size_x, fmt, args);
}

CIMGUI_API bool cimgui::ImGui_ButtonWithFlags(const char* label, cimgui::ImVec2 size_arg, ImGuiButtonFlags flags)
{
    return ::ImGui::ButtonEx(label, ConvertToCPP_ImVec2(size_arg), flags);
}

CIMGUI_API bool cimgui::ImGui_ArrowButtonEx(const char* str_id, cimgui::ImGuiDir dir, cimgui::ImVec2 size_arg, ImGuiButtonFlags flags)
{
    return ::ImGui::ArrowButtonEx(str_id, static_cast<::ImGuiDir>(dir), ConvertToCPP_ImVec2(size_arg), flags);
}

CIMGUI_API bool cimgui::ImGui_ImageButtonWithFlags(ImGuiID id, cimgui::ImTextureRef tex_ref, cimgui::ImVec2 image_size, cimgui::ImVec2 uv0, cimgui::ImVec2 uv1, cimgui::ImVec4 bg_col, cimgui::ImVec4 tint_col, ImGuiButtonFlags flags)
{
    return ::ImGui::ImageButtonEx(id, ConvertToCPP_ImTextureRef(tex_ref), ConvertToCPP_ImVec2(image_size), ConvertToCPP_ImVec2(uv0), ConvertToCPP_ImVec2(uv1), ConvertToCPP_ImVec4(bg_col), ConvertToCPP_ImVec4(tint_col), flags);
}

CIMGUI_API void cimgui::ImGui_SeparatorEx(ImGuiSeparatorFlags flags, float thickness)
{
    ::ImGui::SeparatorEx(flags, thickness);
}

CIMGUI_API void cimgui::ImGui_SeparatorTextEx(ImGuiID id, const char* label, const char* label_end, float extra_width)
{
    ::ImGui::SeparatorTextEx(id, label, label_end, extra_width);
}

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

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

CIMGUI_API bool    cimgui::ImGui_CloseButton(ImGuiID id, cimgui::ImVec2 pos)
{
    return ::ImGui::CloseButton(id, ConvertToCPP_ImVec2(pos));
}

CIMGUI_API bool    cimgui::ImGui_CollapseButton(ImGuiID id, cimgui::ImVec2 pos, cimgui::ImGuiDockNode* dock_node)
{
    return ::ImGui::CollapseButton(id, ConvertToCPP_ImVec2(pos), reinterpret_cast<::ImGuiDockNode*>(dock_node));
}

CIMGUI_API void    cimgui::ImGui_Scrollbar(cimgui::ImGuiAxis axis)
{
    ::ImGui::Scrollbar(static_cast<::ImGuiAxis>(axis));
}

CIMGUI_API bool    cimgui::ImGui_ScrollbarEx(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags draw_rounding_flags)
{
    return ::ImGui::ScrollbarEx(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), p_scroll_v, avail_v, contents_v, draw_rounding_flags);
}

CIMGUI_API cimgui::ImRect cimgui::ImGui_GetWindowScrollbarRect(cimgui::ImGuiWindow* window, cimgui::ImGuiAxis axis)
{
    return ConvertFromCPP_ImRect(::ImGui::GetWindowScrollbarRect(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiAxis>(axis)));
}

CIMGUI_API ImGuiID cimgui::ImGui_GetWindowScrollbarID(cimgui::ImGuiWindow* window, cimgui::ImGuiAxis axis)
{
    return ::ImGui::GetWindowScrollbarID(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiAxis>(axis));
}

CIMGUI_API ImGuiID cimgui::ImGui_GetWindowResizeCornerID(cimgui::ImGuiWindow* window, int n)
{
    return ::ImGui::GetWindowResizeCornerID(reinterpret_cast<::ImGuiWindow*>(window), n);
}

CIMGUI_API ImGuiID cimgui::ImGui_GetWindowResizeBorderID(cimgui::ImGuiWindow* window, cimgui::ImGuiDir dir)
{
    return ::ImGui::GetWindowResizeBorderID(reinterpret_cast<::ImGuiWindow*>(window), static_cast<::ImGuiDir>(dir));
}

CIMGUI_API void    cimgui::ImGui_ExtendHitBoxWhenNearViewportEdge(cimgui::ImGuiWindow* window, cimgui::ImRect* bb, float threshold, cimgui::ImGuiAxis axis)
{
    ::ImGui::ExtendHitBoxWhenNearViewportEdge(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImRect*>(bb), threshold, static_cast<::ImGuiAxis>(axis));
}

CIMGUI_API bool cimgui::ImGui_ButtonBehavior(cimgui::ImRect bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags)
{
    return ::ImGui::ButtonBehavior(ConvertToCPP_ImRect(bb), id, out_hovered, out_held, flags);
}

CIMGUI_API bool cimgui::ImGui_DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)
{
    return ::ImGui::DragBehavior(id, data_type, p_v, v_speed, p_min, p_max, format, flags);
}

CIMGUI_API bool cimgui::ImGui_SliderBehavior(cimgui::ImRect bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, cimgui::ImRect* out_grab_bb)
{
    return ::ImGui::SliderBehavior(ConvertToCPP_ImRect(bb), id, data_type, p_v, p_min, p_max, format, flags, reinterpret_cast<::ImRect*>(out_grab_bb));
}

CIMGUI_API bool cimgui::ImGui_SplitterBehavior(cimgui::ImRect bb, ImGuiID id, cimgui::ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend, float hover_visibility_delay, ImU32 bg_col)
{
    return ::ImGui::SplitterBehavior(ConvertToCPP_ImRect(bb), id, static_cast<::ImGuiAxis>(axis), size1, size2, min_size1, min_size2, hover_extend, hover_visibility_delay, bg_col);
}

CIMGUI_API bool cimgui::ImGui_TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end)
{
    return ::ImGui::TreeNodeBehavior(id, flags, label, label_end);
}

CIMGUI_API void cimgui::ImGui_TreeNodeDrawLineToChildNode(cimgui::ImVec2 target_pos)
{
    ::ImGui::TreeNodeDrawLineToChildNode(ConvertToCPP_ImVec2(target_pos));
}

CIMGUI_API void cimgui::ImGui_TreeNodeDrawLineToTreePop(const cimgui::ImGuiTreeNodeStackData* data)
{
    ::ImGui::TreeNodeDrawLineToTreePop(reinterpret_cast<const ::ImGuiTreeNodeStackData*>(data));
}

CIMGUI_API void cimgui::ImGui_TreePushOverrideID(ImGuiID id)
{
    ::ImGui::TreePushOverrideID(id);
}

CIMGUI_API void cimgui::ImGui_TreeNodeSetOpen(ImGuiID storage_id, bool open)
{
    ::ImGui::TreeNodeSetOpen(storage_id, open);
}

CIMGUI_API bool cimgui::ImGui_TreeNodeUpdateNextOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags)
{
    return ::ImGui::TreeNodeUpdateNextOpen(storage_id, flags);
}

CIMGUI_API const cimgui::ImGuiDataTypeInfo* cimgui::ImGui_DataTypeGetInfo(ImGuiDataType data_type)
{
    return reinterpret_cast<const ::cimgui::ImGuiDataTypeInfo*>(::ImGui::DataTypeGetInfo(data_type));
}

CIMGUI_API int                      cimgui::ImGui_DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format)
{
    return ::ImGui::DataTypeFormatString(buf, buf_size, data_type, p_data, format);
}

CIMGUI_API void                     cimgui::ImGui_DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2)
{
    ::ImGui::DataTypeApplyOp(data_type, op, output, arg_1, arg_2);
}

CIMGUI_API bool                     cimgui::ImGui_DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty)
{
    return ::ImGui::DataTypeApplyFromText(buf, data_type, p_data, format, p_data_when_empty);
}

CIMGUI_API int                      cimgui::ImGui_DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2)
{
    return ::ImGui::DataTypeCompare(data_type, arg_1, arg_2);
}

CIMGUI_API bool                     cimgui::ImGui_DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max)
{
    return ::ImGui::DataTypeClamp(data_type, p_data, p_min, p_max);
}

CIMGUI_API bool                     cimgui::ImGui_DataTypeIsZero(ImGuiDataType data_type, const void* p_data)
{
    return ::ImGui::DataTypeIsZero(data_type, p_data);
}

CIMGUI_API bool                 cimgui::ImGui_InputTextWithHintAndSize(const char* label, const char* hint, char* buf, int buf_size, cimgui::ImVec2 size_arg, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data)
{
    return ::ImGui::InputTextEx(label, hint, buf, buf_size, ConvertToCPP_ImVec2(size_arg), flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data);
}

CIMGUI_API void                 cimgui::ImGui_InputTextDeactivateHook(ImGuiID id)
{
    ::ImGui::InputTextDeactivateHook(id);
}

CIMGUI_API bool                 cimgui::ImGui_TempInputText(cimgui::ImRect bb, ImGuiID id, const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, cimgui::ImGuiInputTextCallback callback, void* user_data)
{
    return ::ImGui::TempInputText(ConvertToCPP_ImRect(bb), id, label, buf, buf_size, flags, reinterpret_cast<::ImGuiInputTextCallback>(callback), user_data);
}

CIMGUI_API bool                 cimgui::ImGui_TempInputScalar(cimgui::ImRect bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min, const void* p_clamp_max)
{
    return ::ImGui::TempInputScalar(ConvertToCPP_ImRect(bb), id, label, data_type, p_data, format, p_clamp_min, p_clamp_max);
}

CIMGUI_API bool                 cimgui::ImGui_TempInputIsActive(ImGuiID id)
{
    return ::ImGui::TempInputIsActive(id);
}

CIMGUI_API cimgui::ImGuiInputTextState* cimgui::ImGui_GetInputTextState(ImGuiID id)
{
    return reinterpret_cast<::cimgui::ImGuiInputTextState*>(::ImGui::GetInputTextState(id));
}

CIMGUI_API void                 cimgui::ImGui_SetNextItemRefVal(ImGuiDataType data_type, void* p_data)
{
    ::ImGui::SetNextItemRefVal(data_type, p_data);
}

CIMGUI_API bool                 cimgui::ImGui_IsItemActiveAsInputText(void)
{
    return ::ImGui::IsItemActiveAsInputText();
}

CIMGUI_API void cimgui::ImGui_ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags)
{
    ::ImGui::ColorTooltip(text, col, flags);
}

CIMGUI_API void cimgui::ImGui_ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags)
{
    ::ImGui::ColorEditOptionsPopup(col, flags);
}

CIMGUI_API void cimgui::ImGui_ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags)
{
    ::ImGui::ColorPickerOptionsPopup(ref_col, flags);
}

CIMGUI_API void cimgui::ImGui_SetNextItemColorMarker(ImU32 col)
{
    ::ImGui::SetNextItemColorMarker(col);
}

CIMGUI_API int cimgui::ImGui_PlotEx(cimgui::ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, cimgui::ImVec2 size_arg)
{
    return ::ImGui::PlotEx(static_cast<::ImGuiPlotType>(plot_type), label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, ConvertToCPP_ImVec2(size_arg));
}

CIMGUI_API void cimgui::ImGui_ShadeVertsLinearColorGradientKeepAlpha(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 gradient_p0, cimgui::ImVec2 gradient_p1, ImU32 col0, ImU32 col1)
{
    ::ImGui::ShadeVertsLinearColorGradientKeepAlpha(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(gradient_p0), ConvertToCPP_ImVec2(gradient_p1), col0, col1);
}

CIMGUI_API void cimgui::ImGui_ShadeVertsLinearUV(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 a, cimgui::ImVec2 b, cimgui::ImVec2 uv_a, cimgui::ImVec2 uv_b, bool clamp)
{
    ::ImGui::ShadeVertsLinearUV(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(a), ConvertToCPP_ImVec2(b), ConvertToCPP_ImVec2(uv_a), ConvertToCPP_ImVec2(uv_b), clamp);
}

CIMGUI_API void cimgui::ImGui_ShadeVertsTransformPos(cimgui::ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, cimgui::ImVec2 pivot_in, float cos_a, float sin_a, cimgui::ImVec2 pivot_out)
{
    ::ImGui::ShadeVertsTransformPos(reinterpret_cast<::ImDrawList*>(draw_list), vert_start_idx, vert_end_idx, ConvertToCPP_ImVec2(pivot_in), cos_a, sin_a, ConvertToCPP_ImVec2(pivot_out));
}

CIMGUI_API void cimgui::ImGui_GcCompactTransientMiscBuffers(void)
{
    ::ImGui::GcCompactTransientMiscBuffers();
}

CIMGUI_API void cimgui::ImGui_GcCompactTransientWindowBuffers(cimgui::ImGuiWindow* window)
{
    ::ImGui::GcCompactTransientWindowBuffers(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API void cimgui::ImGui_GcAwakeTransientWindowBuffers(cimgui::ImGuiWindow* window)
{
    ::ImGui::GcAwakeTransientWindowBuffers(reinterpret_cast<::ImGuiWindow*>(window));
}

CIMGUI_API bool cimgui::ImGui_ErrorLog(const char* msg)
{
    return ::ImGui::ErrorLog(msg);
}

CIMGUI_API void cimgui::ImGui_ErrorRecoveryStoreState(cimgui::ImGuiErrorRecoveryState* state_out)
{
    ::ImGui::ErrorRecoveryStoreState(reinterpret_cast<::ImGuiErrorRecoveryState*>(state_out));
}

CIMGUI_API void cimgui::ImGui_ErrorRecoveryTryToRecoverState(const cimgui::ImGuiErrorRecoveryState* state_in)
{
    ::ImGui::ErrorRecoveryTryToRecoverState(reinterpret_cast<const ::ImGuiErrorRecoveryState*>(state_in));
}

CIMGUI_API void cimgui::ImGui_ErrorRecoveryTryToRecoverWindowState(const cimgui::ImGuiErrorRecoveryState* state_in)
{
    ::ImGui::ErrorRecoveryTryToRecoverWindowState(reinterpret_cast<const ::ImGuiErrorRecoveryState*>(state_in));
}

CIMGUI_API void cimgui::ImGui_ErrorCheckUsingSetCursorPosToExtendParentBoundaries(void)
{
    ::ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
}

CIMGUI_API void cimgui::ImGui_ErrorCheckEndFrameFinalizeErrorTooltip(void)
{
    ::ImGui::ErrorCheckEndFrameFinalizeErrorTooltip();
}

CIMGUI_API bool cimgui::ImGui_BeginErrorTooltip(void)
{
    return ::ImGui::BeginErrorTooltip();
}

CIMGUI_API void cimgui::ImGui_EndErrorTooltip(void)
{
    ::ImGui::EndErrorTooltip();
}

CIMGUI_API void cimgui::ImGui_DemoMarker(const char* file, int line, const char* section)
{
    ::ImGui::DemoMarker(file, line, section);
}

CIMGUI_API void  cimgui::ImGui_DebugAllocHook(cimgui::ImGuiDebugAllocInfo* info, int frame_count, void* ptr, size_t size)
{
    ::ImGui::DebugAllocHook(reinterpret_cast<::ImGuiDebugAllocInfo*>(info), frame_count, ptr, size);
}

CIMGUI_API void  cimgui::ImGui_DebugDrawCursorPos(ImU32 col)
{
    ::ImGui::DebugDrawCursorPos(col);
}

CIMGUI_API void  cimgui::ImGui_DebugDrawLineExtents(ImU32 col)
{
    ::ImGui::DebugDrawLineExtents(col);
}

CIMGUI_API void  cimgui::ImGui_DebugDrawItemRect(ImU32 col)
{
    ::ImGui::DebugDrawItemRect(col);
}

CIMGUI_API void  cimgui::ImGui_DebugTextUnformattedWithLocateItem(const char* line_begin, const char* line_end)
{
    ::ImGui::DebugTextUnformattedWithLocateItem(line_begin, line_end);
}

CIMGUI_API void  cimgui::ImGui_DebugLocateItem(ImGuiID target_id)
{
    ::ImGui::DebugLocateItem(target_id);
}

CIMGUI_API void  cimgui::ImGui_DebugLocateItemOnHover(ImGuiID target_id)
{
    ::ImGui::DebugLocateItemOnHover(target_id);
}

CIMGUI_API void  cimgui::ImGui_DebugLocateItemResolveWithLastItem(void)
{
    ::ImGui::DebugLocateItemResolveWithLastItem();
}

CIMGUI_API void  cimgui::ImGui_DebugBreakClearData(void)
{
    ::ImGui::DebugBreakClearData();
}

CIMGUI_API bool  cimgui::ImGui_DebugBreakButton(const char* label, const char* description_of_location)
{
    return ::ImGui::DebugBreakButton(label, description_of_location);
}

CIMGUI_API void  cimgui::ImGui_DebugBreakButtonTooltip(bool keyboard_only, const char* description_of_location)
{
    ::ImGui::DebugBreakButtonTooltip(keyboard_only, description_of_location);
}

CIMGUI_API void  cimgui::ImGui_ShowFontAtlas(cimgui::ImFontAtlas* atlas)
{
    ::ImGui::ShowFontAtlas(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API ImU64 cimgui::ImGui_DebugTextureIDToU64(ImTextureID tex_id)
{
    return ::ImGui::DebugTextureIDToU64(tex_id);
}

CIMGUI_API void  cimgui::ImGui_DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end)
{
    ::ImGui::DebugHookIdInfo(id, data_type, data_id, data_id_end);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeColumns(cimgui::ImGuiOldColumns* columns)
{
    ::ImGui::DebugNodeColumns(reinterpret_cast<::ImGuiOldColumns*>(columns));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeDockNode(cimgui::ImGuiDockNode* node, const char* label)
{
    ::ImGui::DebugNodeDockNode(reinterpret_cast<::ImGuiDockNode*>(node), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeDrawList(cimgui::ImGuiWindow* window, cimgui::ImGuiViewportP* viewport, const cimgui::ImDrawList* draw_list, const char* label)
{
    ::ImGui::DebugNodeDrawList(reinterpret_cast<::ImGuiWindow*>(window), reinterpret_cast<::ImGuiViewportP*>(viewport), reinterpret_cast<const ::ImDrawList*>(draw_list), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeDrawCmdShowMeshAndBoundingBox(cimgui::ImDrawList* out_draw_list, const cimgui::ImDrawList* draw_list, const cimgui::ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb)
{
    ::ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(reinterpret_cast<::ImDrawList*>(out_draw_list), reinterpret_cast<const ::ImDrawList*>(draw_list), reinterpret_cast<const ::ImDrawCmd*>(draw_cmd), show_mesh, show_aabb);
}

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

CIMGUI_API void  cimgui::ImGui_DebugNodeFontGlyphsForSrcMask(cimgui::ImFont* font, cimgui::ImFontBaked* baked, int src_mask)
{
    ::ImGui::DebugNodeFontGlyphsForSrcMask(reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked), src_mask);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeFontGlyph(cimgui::ImFont* font, const cimgui::ImFontGlyph* glyph)
{
    ::ImGui::DebugNodeFontGlyph(reinterpret_cast<::ImFont*>(font), reinterpret_cast<const ::ImFontGlyph*>(glyph));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeTexture(cimgui::ImTextureData* tex, int int_id, const cimgui::ImFontAtlasRect* highlight_rect)
{
    ::ImGui::DebugNodeTexture(reinterpret_cast<::ImTextureData*>(tex), int_id, reinterpret_cast<const ::ImFontAtlasRect*>(highlight_rect));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeStorage(cimgui::ImGuiStorage* storage, const char* label)
{
    ::ImGui::DebugNodeStorage(reinterpret_cast<::ImGuiStorage*>(storage), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeTabBar(cimgui::ImGuiTabBar* tab_bar, const char* label)
{
    ::ImGui::DebugNodeTabBar(reinterpret_cast<::ImGuiTabBar*>(tab_bar), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeTable(cimgui::ImGuiTable* table)
{
    ::ImGui::DebugNodeTable(reinterpret_cast<::ImGuiTable*>(table));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeTableSettings(cimgui::ImGuiTableSettings* settings)
{
    ::ImGui::DebugNodeTableSettings(reinterpret_cast<::ImGuiTableSettings*>(settings));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeInputTextState(cimgui::ImGuiInputTextState* state)
{
    ::ImGui::DebugNodeInputTextState(reinterpret_cast<::ImGuiInputTextState*>(state));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeTypingSelectState(cimgui::ImGuiTypingSelectState* state)
{
    ::ImGui::DebugNodeTypingSelectState(reinterpret_cast<::ImGuiTypingSelectState*>(state));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeMultiSelectState(cimgui::ImGuiMultiSelectState* state)
{
    ::ImGui::DebugNodeMultiSelectState(reinterpret_cast<::ImGuiMultiSelectState*>(state));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeWindow(cimgui::ImGuiWindow* window, const char* label)
{
    ::ImGui::DebugNodeWindow(reinterpret_cast<::ImGuiWindow*>(window), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeWindowSettings(cimgui::ImGuiWindowSettings* settings)
{
    ::ImGui::DebugNodeWindowSettings(reinterpret_cast<::ImGuiWindowSettings*>(settings));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeWindowsList(cimgui::ImVector_ImGuiWindowPtr* windows, const char* label)
{
    ::ImGui::DebugNodeWindowsList(reinterpret_cast<::ImVector<::ImGuiWindow*>*>(windows), label);
}

CIMGUI_API void  cimgui::ImGui_DebugNodeWindowsListByBeginStackParent(cimgui::ImGuiWindow** windows, int windows_size, cimgui::ImGuiWindow* parent_in_begin_stack)
{
    ::ImGui::DebugNodeWindowsListByBeginStackParent(reinterpret_cast<::ImGuiWindow**>(windows), windows_size, reinterpret_cast<::ImGuiWindow*>(parent_in_begin_stack));
}

CIMGUI_API void  cimgui::ImGui_DebugNodeViewport(cimgui::ImGuiViewportP* viewport)
{
    ::ImGui::DebugNodeViewport(reinterpret_cast<::ImGuiViewportP*>(viewport));
}

CIMGUI_API void  cimgui::ImGui_DebugNodePlatformMonitor(cimgui::ImGuiPlatformMonitor* monitor, const char* label, int idx)
{
    ::ImGui::DebugNodePlatformMonitor(reinterpret_cast<::ImGuiPlatformMonitor*>(monitor), label, idx);
}

CIMGUI_API void  cimgui::ImGui_DebugRenderKeyboardPreview(cimgui::ImDrawList* draw_list)
{
    ::ImGui::DebugRenderKeyboardPreview(reinterpret_cast<::ImDrawList*>(draw_list));
}

CIMGUI_API void  cimgui::ImGui_DebugRenderViewportThumbnail(cimgui::ImDrawList* draw_list, cimgui::ImGuiViewportP* viewport, cimgui::ImRect bb)
{
    ::ImGui::DebugRenderViewportThumbnail(reinterpret_cast<::ImDrawList*>(draw_list), reinterpret_cast<::ImGuiViewportP*>(viewport), ConvertToCPP_ImRect(bb));
}

#ifdef IMGUI_ENABLE_STB_TRUETYPE

CIMGUI_API const cimgui::ImFontLoader* cimgui::cImFontAtlasGetFontLoaderForStbTruetype(void)
{
    return reinterpret_cast<const ::cimgui::ImFontLoader*>(::ImFontAtlasGetFontLoaderForStbTruetype());
}

#endif // #ifdef IMGUI_ENABLE_STB_TRUETYPE

CIMGUI_API int               cimgui::cImFontAtlasRectId_GetIndex(ImFontAtlasRectId id)
{
    return ::ImFontAtlasRectId_GetIndex(id);
}

CIMGUI_API unsigned int      cimgui::cImFontAtlasRectId_GetGeneration(ImFontAtlasRectId id)
{
    return ::ImFontAtlasRectId_GetGeneration(id);
}

CIMGUI_API ImFontAtlasRectId cimgui::cImFontAtlasRectId_Make(int index_idx, int gen_idx)
{
    return ::ImFontAtlasRectId_Make(index_idx, gen_idx);
}

CIMGUI_API void cimgui::cImFontAtlasBuildInit(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildInit(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasBuildDestroy(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildDestroy(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasBuildMain(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildMain(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasBuildSetupFontLoader(cimgui::ImFontAtlas* atlas, const cimgui::ImFontLoader* font_loader)
{
    ::ImFontAtlasBuildSetupFontLoader(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<const ::ImFontLoader*>(font_loader));
}

CIMGUI_API void cimgui::cImFontAtlasBuildNotifySetFont(cimgui::ImFontAtlas* atlas, cimgui::ImFont* old_font, cimgui::ImFont* new_font)
{
    ::ImFontAtlasBuildNotifySetFont(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(old_font), reinterpret_cast<::ImFont*>(new_font));
}

CIMGUI_API void cimgui::cImFontAtlasBuildUpdatePointers(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildUpdatePointers(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasBuildRenderBitmapFromString(cimgui::ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char)
{
    ::ImFontAtlasBuildRenderBitmapFromString(reinterpret_cast<::ImFontAtlas*>(atlas), x, y, w, h, in_str, in_marker_char);
}

CIMGUI_API void cimgui::cImFontAtlasBuildClear(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildClear(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API cimgui::ImTextureData* cimgui::cImFontAtlasTextureAdd(cimgui::ImFontAtlas* atlas, int w, int h)
{
    return reinterpret_cast<::cimgui::ImTextureData*>(::ImFontAtlasTextureAdd(reinterpret_cast<::ImFontAtlas*>(atlas), w, h));
}

CIMGUI_API void           cimgui::cImFontAtlasTextureMakeSpace(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasTextureMakeSpace(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void           cimgui::cImFontAtlasTextureRepack(cimgui::ImFontAtlas* atlas, int w, int h)
{
    ::ImFontAtlasTextureRepack(reinterpret_cast<::ImFontAtlas*>(atlas), w, h);
}

CIMGUI_API void           cimgui::cImFontAtlasTextureGrow(cimgui::ImFontAtlas* atlas, int old_w, int old_h)
{
    ::ImFontAtlasTextureGrow(reinterpret_cast<::ImFontAtlas*>(atlas), old_w, old_h);
}

CIMGUI_API void           cimgui::cImFontAtlasTextureCompact(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasTextureCompact(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API cimgui::ImVec2i cimgui::cImFontAtlasTextureGetSizeEstimate(cimgui::ImFontAtlas* atlas)
{
    return ConvertFromCPP_ImVec2i(::ImFontAtlasTextureGetSizeEstimate(reinterpret_cast<::ImFontAtlas*>(atlas)));
}

CIMGUI_API void cimgui::cImFontAtlasBuildSetupFontSpecialGlyphs(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontConfig* src)
{
    ::ImFontAtlasBuildSetupFontSpecialGlyphs(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontConfig*>(src));
}

CIMGUI_API void cimgui::cImFontAtlasBuildLegacyPreloadAllGlyphRanges(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasBuildLegacyPreloadAllGlyphRanges(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasBuildGetOversampleFactors(cimgui::ImFontConfig* src, cimgui::ImFontBaked* baked, int* out_oversample_h, int* out_oversample_v)
{
    ::ImFontAtlasBuildGetOversampleFactors(reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast<::ImFontBaked*>(baked), out_oversample_h, out_oversample_v);
}

CIMGUI_API void cimgui::cImFontAtlasBuildDiscardBakes(cimgui::ImFontAtlas* atlas, int unused_frames)
{
    ::ImFontAtlasBuildDiscardBakes(reinterpret_cast<::ImFontAtlas*>(atlas), unused_frames);
}

CIMGUI_API bool cimgui::cImFontAtlasFontSourceInit(cimgui::ImFontAtlas* atlas, cimgui::ImFontConfig* src)
{
    return ::ImFontAtlasFontSourceInit(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontConfig*>(src));
}

CIMGUI_API void cimgui::cImFontAtlasFontSourceAddToFont(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontConfig* src)
{
    ::ImFontAtlasFontSourceAddToFont(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontConfig*>(src));
}

CIMGUI_API void cimgui::cImFontAtlasFontDestroySourceData(cimgui::ImFontAtlas* atlas, cimgui::ImFontConfig* src)
{
    ::ImFontAtlasFontDestroySourceData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontConfig*>(src));
}

CIMGUI_API bool cimgui::cImFontAtlasFontInitOutput(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font)
{
    return ::ImFontAtlasFontInitOutput(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font));
}

CIMGUI_API void cimgui::cImFontAtlasFontDestroyOutput(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font)
{
    ::ImFontAtlasFontDestroyOutput(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font));
}

CIMGUI_API void cimgui::cImFontAtlasFontRebuildOutput(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font)
{
    ::ImFontAtlasFontRebuildOutput(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font));
}

CIMGUI_API void cimgui::cImFontAtlasFontDiscardBakes(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, int unused_frames)
{
    ::ImFontAtlasFontDiscardBakes(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), unused_frames);
}

CIMGUI_API ImGuiID      cimgui::cImFontAtlasBakedGetId(ImGuiID font_id, float baked_size, float rasterizer_density)
{
    return ::ImFontAtlasBakedGetId(font_id, baked_size, rasterizer_density);
}

CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedGetOrAdd(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density)
{
    return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedGetOrAdd(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density));
}

CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedGetClosestMatch(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density)
{
    return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedGetClosestMatch(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density));
}

CIMGUI_API cimgui::ImFontBaked* cimgui::cImFontAtlasBakedAdd(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, float font_size, float font_rasterizer_density, ImGuiID baked_id)
{
    return reinterpret_cast<::cimgui::ImFontBaked*>(::ImFontAtlasBakedAdd(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), font_size, font_rasterizer_density, baked_id));
}

CIMGUI_API void         cimgui::cImFontAtlasBakedDiscard(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontBaked* baked)
{
    ::ImFontAtlasBakedDiscard(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked));
}

CIMGUI_API cimgui::ImFontGlyph* cimgui::cImFontAtlasBakedAddFontGlyph(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, const cimgui::ImFontGlyph* in_glyph)
{
    return reinterpret_cast<::cimgui::ImFontGlyph*>(::ImFontAtlasBakedAddFontGlyph(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast<const ::ImFontGlyph*>(in_glyph)));
}

CIMGUI_API void         cimgui::cImFontAtlasBakedAddFontGlyphAdvancedX(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, ImWchar codepoint, float advance_x)
{
    ::ImFontAtlasBakedAddFontGlyphAdvancedX(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), codepoint, advance_x);
}

CIMGUI_API void         cimgui::cImFontAtlasBakedDiscardFontGlyph(cimgui::ImFontAtlas* atlas, cimgui::ImFont* font, cimgui::ImFontBaked* baked, cimgui::ImFontGlyph* glyph)
{
    ::ImFontAtlasBakedDiscardFontGlyph(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFont*>(font), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontGlyph*>(glyph));
}

CIMGUI_API void         cimgui::cImFontAtlasBakedSetFontGlyphBitmap(cimgui::ImFontAtlas* atlas, cimgui::ImFontBaked* baked, cimgui::ImFontConfig* src, cimgui::ImFontGlyph* glyph, cimgui::ImTextureRect* r, const unsigned char* src_pixels, cimgui::ImTextureFormat src_fmt, int src_pitch)
{
    ::ImFontAtlasBakedSetFontGlyphBitmap(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImFontBaked*>(baked), reinterpret_cast<::ImFontConfig*>(src), reinterpret_cast<::ImFontGlyph*>(glyph), reinterpret_cast<::ImTextureRect*>(r), src_pixels, static_cast<::ImTextureFormat>(src_fmt), src_pitch);
}

CIMGUI_API void              cimgui::cImFontAtlasPackInit(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasPackInit(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API ImFontAtlasRectId cimgui::cImFontAtlasPackAddRect(cimgui::ImFontAtlas* atlas, int w, int h, cimgui::ImFontAtlasRectEntry* overwrite_entry)
{
    return ::ImFontAtlasPackAddRect(reinterpret_cast<::ImFontAtlas*>(atlas), w, h, reinterpret_cast<::ImFontAtlasRectEntry*>(overwrite_entry));
}

CIMGUI_API cimgui::ImTextureRect* cimgui::cImFontAtlasPackGetRect(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id)
{
    return reinterpret_cast<::cimgui::ImTextureRect*>(::ImFontAtlasPackGetRect(reinterpret_cast<::ImFontAtlas*>(atlas), id));
}

CIMGUI_API cimgui::ImTextureRect* cimgui::cImFontAtlasPackGetRectSafe(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id)
{
    return reinterpret_cast<::cimgui::ImTextureRect*>(::ImFontAtlasPackGetRectSafe(reinterpret_cast<::ImFontAtlas*>(atlas), id));
}

CIMGUI_API void              cimgui::cImFontAtlasPackDiscardRect(cimgui::ImFontAtlas* atlas, ImFontAtlasRectId id)
{
    ::ImFontAtlasPackDiscardRect(reinterpret_cast<::ImFontAtlas*>(atlas), id);
}

CIMGUI_API void cimgui::cImFontAtlasUpdateNewFrame(cimgui::ImFontAtlas* atlas, int frame_count, bool renderer_has_textures)
{
    ::ImFontAtlasUpdateNewFrame(reinterpret_cast<::ImFontAtlas*>(atlas), frame_count, renderer_has_textures);
}

CIMGUI_API void cimgui::cImFontAtlasAddDrawListSharedData(cimgui::ImFontAtlas* atlas, cimgui::ImDrawListSharedData* data)
{
    ::ImFontAtlasAddDrawListSharedData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImDrawListSharedData*>(data));
}

CIMGUI_API void cimgui::cImFontAtlasRemoveDrawListSharedData(cimgui::ImFontAtlas* atlas, cimgui::ImDrawListSharedData* data)
{
    ::ImFontAtlasRemoveDrawListSharedData(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImDrawListSharedData*>(data));
}

CIMGUI_API void cimgui::cImFontAtlasUpdateDrawListsTextures(cimgui::ImFontAtlas* atlas, cimgui::ImTextureRef old_tex, cimgui::ImTextureRef new_tex)
{
    ::ImFontAtlasUpdateDrawListsTextures(reinterpret_cast<::ImFontAtlas*>(atlas), ConvertToCPP_ImTextureRef(old_tex), ConvertToCPP_ImTextureRef(new_tex));
}

CIMGUI_API void cimgui::cImFontAtlasUpdateDrawListsSharedData(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasUpdateDrawListsSharedData(reinterpret_cast<::ImFontAtlas*>(atlas));
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, cimgui::ImTextureFormat src_fmt, int src_pitch, unsigned char* dst_pixels, cimgui::ImTextureFormat dst_fmt, int dst_pitch, int w, int h)
{
    ::ImFontAtlasTextureBlockConvert(src_pixels, static_cast<::ImTextureFormat>(src_fmt), src_pitch, dst_pixels, static_cast<::ImTextureFormat>(dst_fmt), dst_pitch, w, h);
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockPostProcess(cimgui::ImFontAtlasPostProcessData* data)
{
    ::ImFontAtlasTextureBlockPostProcess(reinterpret_cast<::ImFontAtlasPostProcessData*>(data));
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockPostProcessMultiply(cimgui::ImFontAtlasPostProcessData* data, float multiply_factor)
{
    ::ImFontAtlasTextureBlockPostProcessMultiply(reinterpret_cast<::ImFontAtlasPostProcessData*>(data), multiply_factor);
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockFill(cimgui::ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h, ImU32 col)
{
    ::ImFontAtlasTextureBlockFill(reinterpret_cast<::ImTextureData*>(dst_tex), dst_x, dst_y, w, h, col);
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockCopy(cimgui::ImTextureData* src_tex, int src_x, int src_y, cimgui::ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h)
{
    ::ImFontAtlasTextureBlockCopy(reinterpret_cast<::ImTextureData*>(src_tex), src_x, src_y, reinterpret_cast<::ImTextureData*>(dst_tex), dst_x, dst_y, w, h);
}

CIMGUI_API void cimgui::cImFontAtlasTextureBlockQueueUpload(cimgui::ImFontAtlas* atlas, cimgui::ImTextureData* tex, int x, int y, int w, int h)
{
    ::ImFontAtlasTextureBlockQueueUpload(reinterpret_cast<::ImFontAtlas*>(atlas), reinterpret_cast<::ImTextureData*>(tex), x, y, w, h);
}

CIMGUI_API int         cimgui::cImTextureDataGetFormatBytesPerPixel(cimgui::ImTextureFormat format)
{
    return ::ImTextureDataGetFormatBytesPerPixel(static_cast<::ImTextureFormat>(format));
}

CIMGUI_API const char* cimgui::cImTextureDataGetStatusName(cimgui::ImTextureStatus status)
{
    return ::ImTextureDataGetStatusName(static_cast<::ImTextureStatus>(status));
}

CIMGUI_API const char* cimgui::cImTextureDataGetFormatName(cimgui::ImTextureFormat format)
{
    return ::ImTextureDataGetFormatName(static_cast<::ImTextureFormat>(format));
}

#ifndef IMGUI_DISABLE_DEBUG_TOOLS

CIMGUI_API void cimgui::cImFontAtlasDebugLogTextureRequests(cimgui::ImFontAtlas* atlas)
{
    ::ImFontAtlasDebugLogTextureRequests(reinterpret_cast<::ImFontAtlas*>(atlas));
}

#endif // #ifndef IMGUI_DISABLE_DEBUG_TOOLS

CIMGUI_API bool cimgui::cImFontAtlasGetMouseCursorTexData(cimgui::ImFontAtlas* atlas, ImGuiMouseCursor cursor_type, cimgui::ImVec2* out_offset, cimgui::ImVec2* out_size, cimgui::ImVec2 out_uv_border[2], cimgui::ImVec2 out_uv_fill[2])
{
    ::ImVec2 out_uv_border_converted_array[2];
    for (int i=0; i<2; i++)
        out_uv_border_converted_array[i] = ConvertToCPP_ImVec2(out_uv_border[i]);
    ::ImVec2 out_uv_fill_converted_array[2];
    for (int i=0; i<2; i++)
        out_uv_fill_converted_array[i] = ConvertToCPP_ImVec2(out_uv_fill[i]);
    return ::ImFontAtlasGetMouseCursorTexData(reinterpret_cast<::ImFontAtlas*>(atlas), cursor_type, reinterpret_cast<::ImVec2*>(out_offset), reinterpret_cast<::ImVec2*>(out_size), out_uv_border_converted_array, out_uv_fill_converted_array);
}

#ifdef IMGUI_ENABLE_TEST_ENGINE

CIMGUI_API void        cimgui::cImGuiTestEngineHook_ItemAdd(cimgui::ImGuiContext* ctx, ImGuiID id, cimgui::ImRect bb, const cimgui::ImGuiLastItemData* item_data)
{
    ::ImGuiTestEngineHook_ItemAdd(reinterpret_cast<::ImGuiContext*>(ctx), id, ConvertToCPP_ImRect(bb), reinterpret_cast<const ::ImGuiLastItemData*>(item_data));
}

CIMGUI_API void        cimgui::cImGuiTestEngineHook_ItemInfo(cimgui::ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags)
{
    ::ImGuiTestEngineHook_ItemInfo(reinterpret_cast<::ImGuiContext*>(ctx), id, label, flags);
}

CIMGUI_API void        cimgui::cImGuiTestEngineHook_Log(cimgui::ImGuiContext* ctx, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImGuiTestEngineHook_LogV(reinterpret_cast<::ImGuiContext*>(ctx), fmt, args);
    va_end(args);
}

CIMGUI_API const char* cimgui::cImGuiTestEngine_FindItemDebugLabel(cimgui::ImGuiContext* ctx, ImGuiID id)
{
    return ::ImGuiTestEngine_FindItemDebugLabel(reinterpret_cast<::ImGuiContext*>(ctx), id);
}

#endif // #ifdef IMGUI_ENABLE_TEST_ENGINE
#endif // #ifndef IMGUI_DISABLE