diff --git a/mimgui/cdefs.lua b/mimgui/cdefs.lua new file mode 100644 index 0000000..94407bd --- /dev/null +++ b/mimgui/cdefs.lua @@ -0,0 +1,1961 @@ +--[[ BEGIN AUTOGENERATED SEGMENT ]] +local cdecl = [[ +typedef struct ImVec2_Simple { float x; float y; } ImVec2_Simple; +typedef struct ImVec4_Simple { float x; float y; float z; float w;} ImVec4_Simple; +typedef struct ImColor_Simple { ImVec4_Simple Value;} ImColor_Simple; +typedef struct ImGuiStoragePair ImGuiStoragePair; +typedef struct ImGuiTextRange ImGuiTextRange; +typedef struct ImFontAtlasCustomRect ImFontAtlasCustomRect; +typedef struct ImVec4 ImVec4; +typedef struct ImVec2 ImVec2; +typedef struct ImGuiTextFilter ImGuiTextFilter; +typedef struct ImGuiTextBuffer ImGuiTextBuffer; +typedef struct ImGuiStyle ImGuiStyle; +typedef struct ImGuiStorage ImGuiStorage; +typedef struct ImGuiSizeCallbackData ImGuiSizeCallbackData; +typedef struct ImGuiPayload ImGuiPayload; +typedef struct ImGuiOnceUponAFrame ImGuiOnceUponAFrame; +typedef struct ImGuiListClipper ImGuiListClipper; +typedef struct ImGuiInputTextCallbackData ImGuiInputTextCallbackData; +typedef struct ImGuiIO ImGuiIO; +typedef struct ImGuiContext ImGuiContext; +typedef struct ImColor ImColor; +typedef struct ImFontGlyphRangesBuilder ImFontGlyphRangesBuilder; +typedef struct ImFontGlyph ImFontGlyph; +typedef struct ImFontConfig ImFontConfig; +typedef struct ImFontAtlas ImFontAtlas; +typedef struct ImFont ImFont; +typedef struct ImDrawVert ImDrawVert; +typedef struct ImDrawListSplitter ImDrawListSplitter; +typedef struct ImDrawListSharedData ImDrawListSharedData; +typedef struct ImDrawList ImDrawList; +typedef struct ImDrawData ImDrawData; +typedef struct ImDrawCmd ImDrawCmd; +typedef struct ImDrawChannel ImDrawChannel; +struct ImDrawChannel; +struct ImDrawCmd; +struct ImDrawData; +struct ImDrawList; +struct ImDrawListSharedData; +struct ImDrawListSplitter; +struct ImDrawVert; +struct ImFont; +struct ImFontAtlas; +struct ImFontConfig; +struct ImFontGlyph; +struct ImFontGlyphRangesBuilder; +struct ImColor; +struct ImGuiContext; +struct ImGuiIO; +struct ImGuiInputTextCallbackData; +struct ImGuiListClipper; +struct ImGuiOnceUponAFrame; +struct ImGuiPayload; +struct ImGuiSizeCallbackData; +struct ImGuiStorage; +struct ImGuiStyle; +struct ImGuiTextBuffer; +struct ImGuiTextFilter; +typedef void* ImTextureID; +typedef unsigned int ImGuiID; +typedef unsigned short ImWchar; +typedef int ImGuiCol; +typedef int ImGuiCond; +typedef int ImGuiDataType; +typedef int ImGuiDir; +typedef int ImGuiKey; +typedef int ImGuiNavInput; +typedef int ImGuiMouseCursor; +typedef int ImGuiStyleVar; +typedef int ImDrawCornerFlags; +typedef int ImDrawListFlags; +typedef int ImFontAtlasFlags; +typedef int ImGuiBackendFlags; +typedef int ImGuiColorEditFlags; +typedef int ImGuiConfigFlags; +typedef int ImGuiComboFlags; +typedef int ImGuiDragDropFlags; +typedef int ImGuiFocusedFlags; +typedef int ImGuiHoveredFlags; +typedef int ImGuiInputTextFlags; +typedef int ImGuiSelectableFlags; +typedef int ImGuiTabBarFlags; +typedef int ImGuiTabItemFlags; +typedef int ImGuiTreeNodeFlags; +typedef int ImGuiWindowFlags; +typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data); +typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data); +typedef signed char ImS8; +typedef unsigned char ImU8; +typedef signed short ImS16; +typedef unsigned short ImU16; +typedef signed int ImS32; +typedef unsigned int ImU32; +typedef int64_t ImS64; +typedef uint64_t ImU64; +typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd); +typedef unsigned short ImDrawIdx;typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector; +typedef struct ImVector_float {int Size;int Capacity;float* Data;} ImVector_float; +typedef struct ImVector_ImWchar {int Size;int Capacity;ImWchar* Data;} ImVector_ImWchar; +typedef struct ImVector_ImDrawVert {int Size;int Capacity;ImDrawVert* Data;} ImVector_ImDrawVert; +typedef struct ImVector_ImFontGlyph {int Size;int Capacity;ImFontGlyph* Data;} ImVector_ImFontGlyph; +typedef struct ImVector_ImGuiTextRange {int Size;int Capacity;ImGuiTextRange* Data;} ImVector_ImGuiTextRange; +typedef struct ImVector_ImGuiStoragePair {int Size;int Capacity;ImGuiStoragePair* Data;} ImVector_ImGuiStoragePair; +typedef struct ImVector_ImDrawChannel {int Size;int Capacity;ImDrawChannel* Data;} ImVector_ImDrawChannel; +typedef struct ImVector_char {int Size;int Capacity;char* Data;} ImVector_char; +typedef struct ImVector_ImU32 {int Size;int Capacity;ImU32* Data;} ImVector_ImU32; +typedef struct ImVector_ImFontAtlasCustomRect {int Size;int Capacity;ImFontAtlasCustomRect* Data;} ImVector_ImFontAtlasCustomRect; +typedef struct ImVector_ImTextureID {int Size;int Capacity;ImTextureID* Data;} ImVector_ImTextureID; +typedef struct ImVector_ImFontConfig {int Size;int Capacity;ImFontConfig* Data;} ImVector_ImFontConfig; +typedef struct ImVector_ImFontPtr {int Size;int Capacity;ImFont** Data;} ImVector_ImFontPtr; +typedef struct ImVector_ImDrawCmd {int Size;int Capacity;ImDrawCmd* Data;} ImVector_ImDrawCmd; +typedef struct ImVector_ImVec4 {int Size;int Capacity;ImVec4* Data;} ImVector_ImVec4; +typedef struct ImVector_ImDrawIdx {int Size;int Capacity;ImDrawIdx* Data;} ImVector_ImDrawIdx; +typedef struct ImVector_ImVec2 {int Size;int Capacity;ImVec2* Data;} ImVector_ImVec2; +struct ImVec2 +{ + float x, y; +}; +struct ImVec4 +{ + float x, y, z, w; +}; +enum ImGuiWindowFlags_ +{ + ImGuiWindowFlags_None = 0, + ImGuiWindowFlags_NoTitleBar = 1 << 0, + ImGuiWindowFlags_NoResize = 1 << 1, + ImGuiWindowFlags_NoMove = 1 << 2, + ImGuiWindowFlags_NoScrollbar = 1 << 3, + ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, + ImGuiWindowFlags_NoCollapse = 1 << 5, + ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, + ImGuiWindowFlags_NoBackground = 1 << 7, + ImGuiWindowFlags_NoSavedSettings = 1 << 8, + ImGuiWindowFlags_NoMouseInputs = 1 << 9, + ImGuiWindowFlags_MenuBar = 1 << 10, + ImGuiWindowFlags_HorizontalScrollbar = 1 << 11, + ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12, + ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, + ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14, + ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15, + ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16, + ImGuiWindowFlags_NoNavInputs = 1 << 18, + ImGuiWindowFlags_NoNavFocus = 1 << 19, + ImGuiWindowFlags_UnsavedDocument = 1 << 20, + ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse, + ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NavFlattened = 1 << 23, + ImGuiWindowFlags_ChildWindow = 1 << 24, + ImGuiWindowFlags_Tooltip = 1 << 25, + ImGuiWindowFlags_Popup = 1 << 26, + ImGuiWindowFlags_Modal = 1 << 27, + ImGuiWindowFlags_ChildMenu = 1 << 28 +}; +enum ImGuiInputTextFlags_ +{ + ImGuiInputTextFlags_None = 0, + ImGuiInputTextFlags_CharsDecimal = 1 << 0, + ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, + ImGuiInputTextFlags_CharsUppercase = 1 << 2, + ImGuiInputTextFlags_CharsNoBlank = 1 << 3, + ImGuiInputTextFlags_AutoSelectAll = 1 << 4, + ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, + ImGuiInputTextFlags_CallbackCompletion = 1 << 6, + ImGuiInputTextFlags_CallbackHistory = 1 << 7, + ImGuiInputTextFlags_CallbackAlways = 1 << 8, + ImGuiInputTextFlags_CallbackCharFilter = 1 << 9, + ImGuiInputTextFlags_AllowTabInput = 1 << 10, + ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11, + ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12, + ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13, + ImGuiInputTextFlags_ReadOnly = 1 << 14, + ImGuiInputTextFlags_Password = 1 << 15, + ImGuiInputTextFlags_NoUndoRedo = 1 << 16, + ImGuiInputTextFlags_CharsScientific = 1 << 17, + ImGuiInputTextFlags_CallbackResize = 1 << 18, + ImGuiInputTextFlags_Multiline = 1 << 20, + ImGuiInputTextFlags_NoMarkEdited = 1 << 21 +}; +enum ImGuiTreeNodeFlags_ +{ + ImGuiTreeNodeFlags_None = 0, + ImGuiTreeNodeFlags_Selected = 1 << 0, + ImGuiTreeNodeFlags_Framed = 1 << 1, + ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2, + ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, + ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, + ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, + ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6, + ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7, + ImGuiTreeNodeFlags_Leaf = 1 << 8, + ImGuiTreeNodeFlags_Bullet = 1 << 9, + ImGuiTreeNodeFlags_FramePadding = 1 << 10, + ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13, + ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog +}; +enum ImGuiSelectableFlags_ +{ + ImGuiSelectableFlags_None = 0, + ImGuiSelectableFlags_DontClosePopups = 1 << 0, + ImGuiSelectableFlags_SpanAllColumns = 1 << 1, + ImGuiSelectableFlags_AllowDoubleClick = 1 << 2, + ImGuiSelectableFlags_Disabled = 1 << 3 +}; +enum ImGuiComboFlags_ +{ + ImGuiComboFlags_None = 0, + ImGuiComboFlags_PopupAlignLeft = 1 << 0, + ImGuiComboFlags_HeightSmall = 1 << 1, + ImGuiComboFlags_HeightRegular = 1 << 2, + ImGuiComboFlags_HeightLarge = 1 << 3, + ImGuiComboFlags_HeightLargest = 1 << 4, + ImGuiComboFlags_NoArrowButton = 1 << 5, + ImGuiComboFlags_NoPreview = 1 << 6, + ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest +}; +enum ImGuiTabBarFlags_ +{ + ImGuiTabBarFlags_None = 0, + ImGuiTabBarFlags_Reorderable = 1 << 0, + ImGuiTabBarFlags_AutoSelectNewTabs = 1 << 1, + ImGuiTabBarFlags_TabListPopupButton = 1 << 2, + ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = 1 << 3, + ImGuiTabBarFlags_NoTabListScrollingButtons = 1 << 4, + ImGuiTabBarFlags_NoTooltip = 1 << 5, + ImGuiTabBarFlags_FittingPolicyResizeDown = 1 << 6, + ImGuiTabBarFlags_FittingPolicyScroll = 1 << 7, + ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll, + ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_FittingPolicyResizeDown +}; +enum ImGuiTabItemFlags_ +{ + ImGuiTabItemFlags_None = 0, + ImGuiTabItemFlags_UnsavedDocument = 1 << 0, + ImGuiTabItemFlags_SetSelected = 1 << 1, + ImGuiTabItemFlags_NoCloseWithMiddleMouseButton = 1 << 2, + ImGuiTabItemFlags_NoPushId = 1 << 3 +}; +enum ImGuiFocusedFlags_ +{ + ImGuiFocusedFlags_None = 0, + ImGuiFocusedFlags_ChildWindows = 1 << 0, + ImGuiFocusedFlags_RootWindow = 1 << 1, + ImGuiFocusedFlags_AnyWindow = 1 << 2, + ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows +}; +enum ImGuiHoveredFlags_ +{ + ImGuiHoveredFlags_None = 0, + ImGuiHoveredFlags_ChildWindows = 1 << 0, + ImGuiHoveredFlags_RootWindow = 1 << 1, + ImGuiHoveredFlags_AnyWindow = 1 << 2, + ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3, + ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5, + ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6, + ImGuiHoveredFlags_AllowWhenDisabled = 1 << 7, + ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped, + ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows +}; +enum ImGuiDragDropFlags_ +{ + ImGuiDragDropFlags_None = 0, + ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0, + ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1, + ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2, + ImGuiDragDropFlags_SourceAllowNullID = 1 << 3, + ImGuiDragDropFlags_SourceExtern = 1 << 4, + ImGuiDragDropFlags_SourceAutoExpirePayload = 1 << 5, + ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10, + ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11, + ImGuiDragDropFlags_AcceptNoPreviewTooltip = 1 << 12, + ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect +}; +enum ImGuiDataType_ +{ + ImGuiDataType_S8, + ImGuiDataType_U8, + ImGuiDataType_S16, + ImGuiDataType_U16, + ImGuiDataType_S32, + ImGuiDataType_U32, + ImGuiDataType_S64, + ImGuiDataType_U64, + ImGuiDataType_Float, + ImGuiDataType_Double, + ImGuiDataType_COUNT +}; +enum ImGuiDir_ +{ + ImGuiDir_None = -1, + ImGuiDir_Left = 0, + ImGuiDir_Right = 1, + ImGuiDir_Up = 2, + ImGuiDir_Down = 3, + ImGuiDir_COUNT +}; +enum ImGuiKey_ +{ + ImGuiKey_Tab, + ImGuiKey_LeftArrow, + ImGuiKey_RightArrow, + ImGuiKey_UpArrow, + ImGuiKey_DownArrow, + ImGuiKey_PageUp, + ImGuiKey_PageDown, + ImGuiKey_Home, + ImGuiKey_End, + ImGuiKey_Insert, + ImGuiKey_Delete, + ImGuiKey_Backspace, + ImGuiKey_Space, + ImGuiKey_Enter, + ImGuiKey_Escape, + ImGuiKey_KeyPadEnter, + ImGuiKey_A, + ImGuiKey_C, + ImGuiKey_V, + ImGuiKey_X, + ImGuiKey_Y, + ImGuiKey_Z, + ImGuiKey_COUNT +}; +enum ImGuiNavInput_ +{ + ImGuiNavInput_Activate, + ImGuiNavInput_Cancel, + ImGuiNavInput_Input, + ImGuiNavInput_Menu, + ImGuiNavInput_DpadLeft, + ImGuiNavInput_DpadRight, + ImGuiNavInput_DpadUp, + ImGuiNavInput_DpadDown, + ImGuiNavInput_LStickLeft, + ImGuiNavInput_LStickRight, + ImGuiNavInput_LStickUp, + ImGuiNavInput_LStickDown, + ImGuiNavInput_FocusPrev, + ImGuiNavInput_FocusNext, + ImGuiNavInput_TweakSlow, + ImGuiNavInput_TweakFast, + ImGuiNavInput_KeyMenu_, + ImGuiNavInput_KeyTab_, + ImGuiNavInput_KeyLeft_, + ImGuiNavInput_KeyRight_, + ImGuiNavInput_KeyUp_, + ImGuiNavInput_KeyDown_, + ImGuiNavInput_COUNT, + ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_ +}; +enum ImGuiConfigFlags_ +{ + ImGuiConfigFlags_None = 0, + ImGuiConfigFlags_NavEnableKeyboard = 1 << 0, + ImGuiConfigFlags_NavEnableGamepad = 1 << 1, + ImGuiConfigFlags_NavEnableSetMousePos = 1 << 2, + ImGuiConfigFlags_NavNoCaptureKeyboard = 1 << 3, + ImGuiConfigFlags_NoMouse = 1 << 4, + ImGuiConfigFlags_NoMouseCursorChange = 1 << 5, + ImGuiConfigFlags_IsSRGB = 1 << 20, + ImGuiConfigFlags_IsTouchScreen = 1 << 21 +}; +enum ImGuiBackendFlags_ +{ + ImGuiBackendFlags_None = 0, + ImGuiBackendFlags_HasGamepad = 1 << 0, + ImGuiBackendFlags_HasMouseCursors = 1 << 1, + ImGuiBackendFlags_HasSetMousePos = 1 << 2, + ImGuiBackendFlags_RendererHasVtxOffset = 1 << 3 +}; +enum ImGuiCol_ +{ + ImGuiCol_Text, + ImGuiCol_TextDisabled, + ImGuiCol_WindowBg, + ImGuiCol_ChildBg, + ImGuiCol_PopupBg, + ImGuiCol_Border, + ImGuiCol_BorderShadow, + ImGuiCol_FrameBg, + ImGuiCol_FrameBgHovered, + ImGuiCol_FrameBgActive, + ImGuiCol_TitleBg, + ImGuiCol_TitleBgActive, + ImGuiCol_TitleBgCollapsed, + ImGuiCol_MenuBarBg, + ImGuiCol_ScrollbarBg, + ImGuiCol_ScrollbarGrab, + ImGuiCol_ScrollbarGrabHovered, + ImGuiCol_ScrollbarGrabActive, + ImGuiCol_CheckMark, + ImGuiCol_SliderGrab, + ImGuiCol_SliderGrabActive, + ImGuiCol_Button, + ImGuiCol_ButtonHovered, + ImGuiCol_ButtonActive, + ImGuiCol_Header, + ImGuiCol_HeaderHovered, + ImGuiCol_HeaderActive, + ImGuiCol_Separator, + ImGuiCol_SeparatorHovered, + ImGuiCol_SeparatorActive, + ImGuiCol_ResizeGrip, + ImGuiCol_ResizeGripHovered, + ImGuiCol_ResizeGripActive, + ImGuiCol_Tab, + ImGuiCol_TabHovered, + ImGuiCol_TabActive, + ImGuiCol_TabUnfocused, + ImGuiCol_TabUnfocusedActive, + ImGuiCol_PlotLines, + ImGuiCol_PlotLinesHovered, + ImGuiCol_PlotHistogram, + ImGuiCol_PlotHistogramHovered, + ImGuiCol_TextSelectedBg, + ImGuiCol_DragDropTarget, + ImGuiCol_NavHighlight, + ImGuiCol_NavWindowingHighlight, + ImGuiCol_NavWindowingDimBg, + ImGuiCol_ModalWindowDimBg, + ImGuiCol_COUNT +}; +enum ImGuiStyleVar_ +{ + ImGuiStyleVar_Alpha, + ImGuiStyleVar_WindowPadding, + ImGuiStyleVar_WindowRounding, + ImGuiStyleVar_WindowBorderSize, + ImGuiStyleVar_WindowMinSize, + ImGuiStyleVar_WindowTitleAlign, + ImGuiStyleVar_ChildRounding, + ImGuiStyleVar_ChildBorderSize, + ImGuiStyleVar_PopupRounding, + ImGuiStyleVar_PopupBorderSize, + ImGuiStyleVar_FramePadding, + ImGuiStyleVar_FrameRounding, + ImGuiStyleVar_FrameBorderSize, + ImGuiStyleVar_ItemSpacing, + ImGuiStyleVar_ItemInnerSpacing, + ImGuiStyleVar_IndentSpacing, + ImGuiStyleVar_ScrollbarSize, + ImGuiStyleVar_ScrollbarRounding, + ImGuiStyleVar_GrabMinSize, + ImGuiStyleVar_GrabRounding, + ImGuiStyleVar_TabRounding, + ImGuiStyleVar_ButtonTextAlign, + ImGuiStyleVar_SelectableTextAlign, + ImGuiStyleVar_COUNT +}; +enum ImGuiColorEditFlags_ +{ + ImGuiColorEditFlags_None = 0, + ImGuiColorEditFlags_NoAlpha = 1 << 1, + ImGuiColorEditFlags_NoPicker = 1 << 2, + ImGuiColorEditFlags_NoOptions = 1 << 3, + ImGuiColorEditFlags_NoSmallPreview = 1 << 4, + ImGuiColorEditFlags_NoInputs = 1 << 5, + ImGuiColorEditFlags_NoTooltip = 1 << 6, + ImGuiColorEditFlags_NoLabel = 1 << 7, + ImGuiColorEditFlags_NoSidePreview = 1 << 8, + ImGuiColorEditFlags_NoDragDrop = 1 << 9, + ImGuiColorEditFlags_AlphaBar = 1 << 16, + ImGuiColorEditFlags_AlphaPreview = 1 << 17, + ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18, + ImGuiColorEditFlags_HDR = 1 << 19, + ImGuiColorEditFlags_DisplayRGB = 1 << 20, + ImGuiColorEditFlags_DisplayHSV = 1 << 21, + ImGuiColorEditFlags_DisplayHex = 1 << 22, + ImGuiColorEditFlags_Uint8 = 1 << 23, + ImGuiColorEditFlags_Float = 1 << 24, + ImGuiColorEditFlags_PickerHueBar = 1 << 25, + ImGuiColorEditFlags_PickerHueWheel = 1 << 26, + ImGuiColorEditFlags_InputRGB = 1 << 27, + ImGuiColorEditFlags_InputHSV = 1 << 28, + ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__DisplayMask = ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_DisplayHSV|ImGuiColorEditFlags_DisplayHex, + ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float, + ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__InputMask = ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_InputHSV +}; +enum ImGuiMouseCursor_ +{ + ImGuiMouseCursor_None = -1, + ImGuiMouseCursor_Arrow = 0, + ImGuiMouseCursor_TextInput, + ImGuiMouseCursor_ResizeAll, + ImGuiMouseCursor_ResizeNS, + ImGuiMouseCursor_ResizeEW, + ImGuiMouseCursor_ResizeNESW, + ImGuiMouseCursor_ResizeNWSE, + ImGuiMouseCursor_Hand, + ImGuiMouseCursor_COUNT +}; +enum ImGuiCond_ +{ + ImGuiCond_Always = 1 << 0, + ImGuiCond_Once = 1 << 1, + ImGuiCond_FirstUseEver = 1 << 2, + ImGuiCond_Appearing = 1 << 3 +}; +struct ImGuiStyle +{ + float Alpha; + ImVec2 WindowPadding; + float WindowRounding; + float WindowBorderSize; + ImVec2 WindowMinSize; + ImVec2 WindowTitleAlign; + ImGuiDir WindowMenuButtonPosition; + float ChildRounding; + float ChildBorderSize; + float PopupRounding; + float PopupBorderSize; + ImVec2 FramePadding; + float FrameRounding; + float FrameBorderSize; + ImVec2 ItemSpacing; + ImVec2 ItemInnerSpacing; + ImVec2 TouchExtraPadding; + float IndentSpacing; + float ColumnsMinSpacing; + float ScrollbarSize; + float ScrollbarRounding; + float GrabMinSize; + float GrabRounding; + float TabRounding; + float TabBorderSize; + ImGuiDir ColorButtonPosition; + ImVec2 ButtonTextAlign; + ImVec2 SelectableTextAlign; + ImVec2 DisplayWindowPadding; + ImVec2 DisplaySafeAreaPadding; + float MouseCursorScale; + _Bool AntiAliasedLines; + _Bool AntiAliasedFill; + float CurveTessellationTol; + ImVec4 Colors[ImGuiCol_COUNT]; +}; +struct ImGuiIO +{ + ImGuiConfigFlags ConfigFlags; + ImGuiBackendFlags BackendFlags; + ImVec2 DisplaySize; + float DeltaTime; + float IniSavingRate; + const char* IniFilename; + const char* LogFilename; + float MouseDoubleClickTime; + float MouseDoubleClickMaxDist; + float MouseDragThreshold; + int KeyMap[ImGuiKey_COUNT]; + float KeyRepeatDelay; + float KeyRepeatRate; + void* UserData; + ImFontAtlas*Fonts; + float FontGlobalScale; + _Bool FontAllowUserScaling; + ImFont* FontDefault; + ImVec2 DisplayFramebufferScale; + _Bool MouseDrawCursor; + _Bool ConfigMacOSXBehaviors; + _Bool ConfigInputTextCursorBlink; + _Bool ConfigWindowsResizeFromEdges; + _Bool ConfigWindowsMoveFromTitleBarOnly; + const char* BackendPlatformName; + const char* BackendRendererName; + void* BackendPlatformUserData; + void* BackendRendererUserData; + void* BackendLanguageUserData; + const char* (*GetClipboardTextFn)(void* user_data); + void (*SetClipboardTextFn)(void* user_data, const char* text); + void* ClipboardUserData; + void (*ImeSetInputScreenPosFn)(int x, int y); + void* ImeWindowHandle; + void* RenderDrawListsFnUnused; + ImVec2 MousePos; + _Bool MouseDown[5]; + float MouseWheel; + float MouseWheelH; + _Bool KeyCtrl; + _Bool KeyShift; + _Bool KeyAlt; + _Bool KeySuper; + _Bool KeysDown[512]; + float NavInputs[ImGuiNavInput_COUNT]; + _Bool WantCaptureMouse; + _Bool WantCaptureKeyboard; + _Bool WantTextInput; + _Bool WantSetMousePos; + _Bool WantSaveIniSettings; + _Bool NavActive; + _Bool NavVisible; + float Framerate; + int MetricsRenderVertices; + int MetricsRenderIndices; + int MetricsRenderWindows; + int MetricsActiveWindows; + int MetricsActiveAllocations; + ImVec2 MouseDelta; + ImVec2 MousePosPrev; + ImVec2 MouseClickedPos[5]; + double MouseClickedTime[5]; + _Bool MouseClicked[5]; + _Bool MouseDoubleClicked[5]; + _Bool MouseReleased[5]; + _Bool MouseDownOwned[5]; + _Bool MouseDownWasDoubleClick[5]; + float MouseDownDuration[5]; + float MouseDownDurationPrev[5]; + ImVec2 MouseDragMaxDistanceAbs[5]; + float MouseDragMaxDistanceSqr[5]; + float KeysDownDuration[512]; + float KeysDownDurationPrev[512]; + float NavInputsDownDuration[ImGuiNavInput_COUNT]; + float NavInputsDownDurationPrev[ImGuiNavInput_COUNT]; + ImVector_ImWchar InputQueueCharacters; +}; +struct ImGuiInputTextCallbackData +{ + ImGuiInputTextFlags EventFlag; + ImGuiInputTextFlags Flags; + void* UserData; + ImWchar EventChar; + ImGuiKey EventKey; + char* Buf; + int BufTextLen; + int BufSize; + _Bool BufDirty; + int CursorPos; + int SelectionStart; + int SelectionEnd; +}; +struct ImGuiSizeCallbackData +{ + void* UserData; + ImVec2 Pos; + ImVec2 CurrentSize; + ImVec2 DesiredSize; +}; +struct ImGuiPayload +{ + void* Data; + int DataSize; + ImGuiID SourceId; + ImGuiID SourceParentId; + int DataFrameCount; + char DataType[32+1]; + _Bool Preview; + _Bool Delivery; +}; +struct ImGuiOnceUponAFrame +{ + int RefFrame; +}; +struct ImGuiTextFilter +{ + char InputBuf[256]; + ImVector_ImGuiTextRange Filters; + int CountGrep; +}; +struct ImGuiTextBuffer +{ + ImVector_char Buf; +}; +struct ImGuiStorage +{ + ImVector_ImGuiStoragePair Data; +}; +struct ImGuiListClipper +{ + float StartPosY; + float ItemsHeight; + int ItemsCount, StepNo, DisplayStart, DisplayEnd; +}; +struct ImColor +{ + ImVec4 Value; +}; +struct ImDrawCmd +{ + unsigned int ElemCount; + ImVec4 ClipRect; + ImTextureID TextureId; + unsigned int VtxOffset; + unsigned int IdxOffset; + ImDrawCallback UserCallback; + void* UserCallbackData; +}; +struct ImDrawVert +{ + ImVec2 pos; + ImVec2 uv; + ImU32 col; +}; +struct ImDrawChannel +{ + ImVector_ImDrawCmd _CmdBuffer; + ImVector_ImDrawIdx _IdxBuffer; +}; +struct ImDrawListSplitter +{ + int _Current; + int _Count; + ImVector_ImDrawChannel _Channels; +}; +enum ImDrawCornerFlags_ +{ + ImDrawCornerFlags_None = 0, + ImDrawCornerFlags_TopLeft = 1 << 0, + ImDrawCornerFlags_TopRight = 1 << 1, + ImDrawCornerFlags_BotLeft = 1 << 2, + ImDrawCornerFlags_BotRight = 1 << 3, + ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight, + ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft, + ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_All = 0xF +}; +enum ImDrawListFlags_ +{ + ImDrawListFlags_None = 0, + ImDrawListFlags_AntiAliasedLines = 1 << 0, + ImDrawListFlags_AntiAliasedFill = 1 << 1, + ImDrawListFlags_AllowVtxOffset = 1 << 2 +}; +struct ImDrawList +{ + ImVector_ImDrawCmd CmdBuffer; + ImVector_ImDrawIdx IdxBuffer; + ImVector_ImDrawVert VtxBuffer; + ImDrawListFlags Flags; + const ImDrawListSharedData* _Data; + const char* _OwnerName; + unsigned int _VtxCurrentOffset; + unsigned int _VtxCurrentIdx; + ImDrawVert* _VtxWritePtr; + ImDrawIdx* _IdxWritePtr; + ImVector_ImVec4 _ClipRectStack; + ImVector_ImTextureID _TextureIdStack; + ImVector_ImVec2 _Path; + ImDrawListSplitter _Splitter; +}; +struct ImDrawData +{ + _Bool Valid; + ImDrawList** CmdLists; + int CmdListsCount; + int TotalIdxCount; + int TotalVtxCount; + ImVec2 DisplayPos; + ImVec2 DisplaySize; + ImVec2 FramebufferScale; +}; +struct ImFontConfig +{ + void* FontData; + int FontDataSize; + _Bool FontDataOwnedByAtlas; + int FontNo; + float SizePixels; + int OversampleH; + int OversampleV; + _Bool PixelSnapH; + ImVec2 GlyphExtraSpacing; + ImVec2 GlyphOffset; + const ImWchar* GlyphRanges; + float GlyphMinAdvanceX; + float GlyphMaxAdvanceX; + _Bool MergeMode; + unsigned int RasterizerFlags; + float RasterizerMultiply; + char Name[40]; + ImFont* DstFont; +}; +struct ImFontGlyph +{ + ImWchar Codepoint; + float AdvanceX; + float X0, Y0, X1, Y1; + float U0, V0, U1, V1; +}; +struct ImFontGlyphRangesBuilder +{ + ImVector_ImU32 UsedChars; +}; +struct ImFontAtlasCustomRect +{ + unsigned int ID; + unsigned short Width, Height; + unsigned short X, Y; + float GlyphAdvanceX; + ImVec2 GlyphOffset; + ImFont* Font; +}; +enum ImFontAtlasFlags_ +{ + ImFontAtlasFlags_None = 0, + ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0, + ImFontAtlasFlags_NoMouseCursors = 1 << 1 +}; +struct ImFontAtlas +{ + _Bool Locked; + ImFontAtlasFlags Flags; + ImTextureID TexID; + int TexDesiredWidth; + int TexGlyphPadding; + unsigned char* TexPixelsAlpha8; + unsigned int* TexPixelsRGBA32; + int TexWidth; + int TexHeight; + ImVec2 TexUvScale; + ImVec2 TexUvWhitePixel; + ImVector_ImFontPtr Fonts; + ImVector_ImFontAtlasCustomRect CustomRects; + ImVector_ImFontConfig ConfigData; + int CustomRectIds[1]; +}; +struct ImFont +{ + ImVector_float IndexAdvanceX; + float FallbackAdvanceX; + float FontSize; + ImVector_ImWchar IndexLookup; + ImVector_ImFontGlyph Glyphs; + const ImFontGlyph* FallbackGlyph; + ImVec2 DisplayOffset; + ImFontAtlas* ContainerAtlas; + const ImFontConfig* ConfigData; + short ConfigDataCount; + ImWchar FallbackChar; + float Scale; + float Ascent, Descent; + int MetricsTotalSurface; + _Bool DirtyLookupTables; +}; + struct ImGuiTextRange + { + const char* b; + const char* e; +}; + struct ImGuiStoragePair + { + ImGuiID key; + union { int val_i; float val_f; void* val_p; }; +}; +ImVec2* ImVec2_ImVec2(void); +void ImVec2_destroy(ImVec2* self); +ImVec2* ImVec2_ImVec2Float(float _x,float _y); +ImVec4* ImVec4_ImVec4(void); +void ImVec4_destroy(ImVec4* self); +ImVec4* ImVec4_ImVec4Float(float _x,float _y,float _z,float _w); +ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas); +void igDestroyContext(ImGuiContext* ctx); +ImGuiContext* igGetCurrentContext(void); +void igSetCurrentContext(ImGuiContext* ctx); +_Bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx); +ImGuiIO* igGetIO(void); +ImGuiStyle* igGetStyle(void); +void igNewFrame(void); +void igEndFrame(void); +void igRender(void); +ImDrawData* igGetDrawData(void); +void igShowDemoWindow( _Bool * p_open); +void igShowAboutWindow( _Bool * p_open); +void igShowMetricsWindow( _Bool * p_open); +void igShowStyleEditor(ImGuiStyle* ref); +_Bool igShowStyleSelector(const char* label); +void igShowFontSelector(const char* label); +void igShowUserGuide(void); +const char* igGetVersion(void); +void igStyleColorsDark(ImGuiStyle* dst); +void igStyleColorsClassic(ImGuiStyle* dst); +void igStyleColorsLight(ImGuiStyle* dst); +_Bool igBegin(const char* name, _Bool * p_open,ImGuiWindowFlags flags); +void igEnd(void); +_Bool igBeginChild(const char* str_id,const ImVec2 size, _Bool border,ImGuiWindowFlags flags); +_Bool igBeginChildID(ImGuiID id,const ImVec2 size, _Bool border,ImGuiWindowFlags flags); +void igEndChild(void); +_Bool igIsWindowAppearing(void); +_Bool igIsWindowCollapsed(void); +_Bool igIsWindowFocused(ImGuiFocusedFlags flags); +_Bool igIsWindowHovered(ImGuiHoveredFlags flags); +ImDrawList* igGetWindowDrawList(void); +ImVec2 igGetWindowPos(void); +ImVec2 igGetWindowSize(void); +float igGetWindowWidth(void); +float igGetWindowHeight(void); +void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot); +void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond); +void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data); +void igSetNextWindowContentSize(const ImVec2 size); +void igSetNextWindowCollapsed( _Bool collapsed,ImGuiCond cond); +void igSetNextWindowFocus(void); +void igSetNextWindowBgAlpha(float alpha); +void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond); +void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond); +void igSetWindowCollapsedBool( _Bool collapsed,ImGuiCond cond); +void igSetWindowFocus(void); +void igSetWindowFontScale(float scale); +void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond); +void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond); +void igSetWindowCollapsedStr(const char* name, _Bool collapsed,ImGuiCond cond); +void igSetWindowFocusStr(const char* name); +ImVec2 igGetContentRegionMax(void); +ImVec2 igGetContentRegionAvail(void); +ImVec2 igGetWindowContentRegionMin(void); +ImVec2 igGetWindowContentRegionMax(void); +float igGetWindowContentRegionWidth(void); +float igGetScrollX(void); +float igGetScrollY(void); +float igGetScrollMaxX(void); +float igGetScrollMaxY(void); +void igSetScrollX(float scroll_x); +void igSetScrollY(float scroll_y); +void igSetScrollHereX(float center_x_ratio); +void igSetScrollHereY(float center_y_ratio); +void igSetScrollFromPosX(float local_x,float center_x_ratio); +void igSetScrollFromPosY(float local_y,float center_y_ratio); +void igPushFont(ImFont* font); +void igPopFont(void); +void igPushStyleColorU32(ImGuiCol idx,ImU32 col); +void igPushStyleColor(ImGuiCol idx,const ImVec4 col); +void igPopStyleColor(int count); +void igPushStyleVarFloat(ImGuiStyleVar idx,float val); +void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val); +void igPopStyleVar(int count); +const ImVec4* igGetStyleColorVec4(ImGuiCol idx); +ImFont* igGetFont(void); +float igGetFontSize(void); +ImVec2 igGetFontTexUvWhitePixel(void); +ImU32 igGetColorU32(ImGuiCol idx,float alpha_mul); +ImU32 igGetColorU32Vec4(const ImVec4 col); +ImU32 igGetColorU32U32(ImU32 col); +void igPushItemWidth(float item_width); +void igPopItemWidth(void); +void igSetNextItemWidth(float item_width); +float igCalcItemWidth(void); +void igPushTextWrapPos(float wrap_local_pos_x); +void igPopTextWrapPos(void); +void igPushAllowKeyboardFocus( _Bool allow_keyboard_focus); +void igPopAllowKeyboardFocus(void); +void igPushButtonRepeat( _Bool repeat); +void igPopButtonRepeat(void); +void igSeparator(void); +void igSameLine(float offset_from_start_x,float spacing); +void igNewLine(void); +void igSpacing(void); +void igDummy(const ImVec2 size); +void igIndent(float indent_w); +void igUnindent(float indent_w); +void igBeginGroup(void); +void igEndGroup(void); +ImVec2 igGetCursorPos(void); +float igGetCursorPosX(void); +float igGetCursorPosY(void); +void igSetCursorPos(const ImVec2 local_pos); +void igSetCursorPosX(float local_x); +void igSetCursorPosY(float local_y); +ImVec2 igGetCursorStartPos(void); +ImVec2 igGetCursorScreenPos(void); +void igSetCursorScreenPos(const ImVec2 pos); +void igAlignTextToFramePadding(void); +float igGetTextLineHeight(void); +float igGetTextLineHeightWithSpacing(void); +float igGetFrameHeight(void); +float igGetFrameHeightWithSpacing(void); +void igPushIDStr(const char* str_id); +void igPushIDRange(const char* str_id_begin,const char* str_id_end); +void igPushIDPtr(const void* ptr_id); +void igPushIDInt(int int_id); +void igPopID(void); +ImGuiID igGetIDStr(const char* str_id); +ImGuiID igGetIDRange(const char* str_id_begin,const char* str_id_end); +ImGuiID igGetIDPtr(const void* ptr_id); +void igTextUnformatted(const char* text,const char* text_end); +void igText(const char* fmt,...); +void igTextV(const char* fmt,va_list args); +void igTextColored(const ImVec4 col,const char* fmt,...); +void igTextColoredV(const ImVec4 col,const char* fmt,va_list args); +void igTextDisabled(const char* fmt,...); +void igTextDisabledV(const char* fmt,va_list args); +void igTextWrapped(const char* fmt,...); +void igTextWrappedV(const char* fmt,va_list args); +void igLabelText(const char* label,const char* fmt,...); +void igLabelTextV(const char* label,const char* fmt,va_list args); +void igBulletText(const char* fmt,...); +void igBulletTextV(const char* fmt,va_list args); +_Bool igButton(const char* label,const ImVec2 size); +_Bool igSmallButton(const char* label); +_Bool igInvisibleButton(const char* str_id,const ImVec2 size); +_Bool igArrowButton(const char* str_id,ImGuiDir dir); +void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col); +_Bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col); +_Bool igCheckbox(const char* label, _Bool * v); +_Bool igCheckboxFlags(const char* label,unsigned int* flags,unsigned int flags_value); +_Bool igRadioButtonBool(const char* label, _Bool active); +_Bool igRadioButtonIntPtr(const char* label,int* v,int v_button); +void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay); +void igBullet(void); +_Bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags); +void igEndCombo(void); +_Bool igCombo(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items); +_Bool igComboStr(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items); +_Bool igComboFnPtr(const char* label,int* current_item, _Bool (*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items); +_Bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,float power); +_Bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max); +_Bool igDragScalar(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_max,const char* format,float power); +_Bool igDragScalarN(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_max,const char* format,float power); +_Bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,float power); +_Bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format); +_Bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format); +_Bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format); +_Bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format); +_Bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format); +_Bool igSliderScalar(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power); +_Bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_max,const char* format,float power); +_Bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power); +_Bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format); +_Bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power); +_Bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags); +_Bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags); +_Bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags); +_Bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags); +_Bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags); +_Bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags); +_Bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags); +_Bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags); +_Bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col); +_Bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size); +void igSetColorEditOptions(ImGuiColorEditFlags flags); +_Bool igTreeNodeStr(const char* label); +_Bool igTreeNodeStrStr(const char* str_id,const char* fmt,...); +_Bool igTreeNodePtr(const void* ptr_id,const char* fmt,...); +_Bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args); +_Bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args); +_Bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags); +_Bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +_Bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +_Bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +_Bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +void igTreePushStr(const char* str_id); +void igTreePushPtr(const void* ptr_id); +void igTreePop(void); +float igGetTreeNodeToLabelSpacing(void); +_Bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags); +_Bool igCollapsingHeaderBoolPtr(const char* label, _Bool * p_open,ImGuiTreeNodeFlags flags); +void igSetNextItemOpen( _Bool is_open,ImGuiCond cond); +_Bool igSelectable(const char* label, _Bool selected,ImGuiSelectableFlags flags,const ImVec2 size); +_Bool igSelectableBoolPtr(const char* label, _Bool * p_selected,ImGuiSelectableFlags flags,const ImVec2 size); +_Bool igListBoxStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items); +_Bool igListBoxFnPtr(const char* label,int* current_item, _Bool (*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items); +_Bool igListBoxHeaderVec2(const char* label,const ImVec2 size); +_Bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items); +void igListBoxFooter(void); +void igPlotLines(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +void igPlotHistogramFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +void igValueBool(const char* prefix, _Bool b); +void igValueInt(const char* prefix,int v); +void igValueUint(const char* prefix,unsigned int v); +void igValueFloat(const char* prefix,float v,const char* float_format); +_Bool igBeginMainMenuBar(void); +void igEndMainMenuBar(void); +_Bool igBeginMenuBar(void); +void igEndMenuBar(void); +_Bool igBeginMenu(const char* label, _Bool enabled); +void igEndMenu(void); +_Bool igMenuItemBool(const char* label,const char* shortcut, _Bool selected, _Bool enabled); +_Bool igMenuItemBoolPtr(const char* label,const char* shortcut, _Bool * p_selected, _Bool enabled); +void igBeginTooltip(void); +void igEndTooltip(void); +void igSetTooltip(const char* fmt,...); +void igSetTooltipV(const char* fmt,va_list args); +void igOpenPopup(const char* str_id); +_Bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags); +_Bool igBeginPopupContextItem(const char* str_id,int mouse_button); +_Bool igBeginPopupContextWindow(const char* str_id,int mouse_button, _Bool also_over_items); +_Bool igBeginPopupContextVoid(const char* str_id,int mouse_button); +_Bool igBeginPopupModal(const char* name, _Bool * p_open,ImGuiWindowFlags flags); +void igEndPopup(void); +_Bool igOpenPopupOnItemClick(const char* str_id,int mouse_button); +_Bool igIsPopupOpen(const char* str_id); +void igCloseCurrentPopup(void); +void igColumns(int count,const char* id, _Bool border); +void igNextColumn(void); +int igGetColumnIndex(void); +float igGetColumnWidth(int column_index); +void igSetColumnWidth(int column_index,float width); +float igGetColumnOffset(int column_index); +void igSetColumnOffset(int column_index,float offset_x); +int igGetColumnsCount(void); +_Bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags); +void igEndTabBar(void); +_Bool igBeginTabItem(const char* label, _Bool * p_open,ImGuiTabItemFlags flags); +void igEndTabItem(void); +void igSetTabItemClosed(const char* tab_or_docked_window_label); +void igLogToTTY(int auto_open_depth); +void igLogToFile(int auto_open_depth,const char* filename); +void igLogToClipboard(int auto_open_depth); +void igLogFinish(void); +void igLogButtons(void); +_Bool igBeginDragDropSource(ImGuiDragDropFlags flags); +_Bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond); +void igEndDragDropSource(void); +_Bool igBeginDragDropTarget(void); +const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags); +void igEndDragDropTarget(void); +const ImGuiPayload* igGetDragDropPayload(void); +void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max, _Bool intersect_with_current_clip_rect); +void igPopClipRect(void); +void igSetItemDefaultFocus(void); +void igSetKeyboardFocusHere(int offset); +_Bool igIsItemHovered(ImGuiHoveredFlags flags); +_Bool igIsItemActive(void); +_Bool igIsItemFocused(void); +_Bool igIsItemClicked(int mouse_button); +_Bool igIsItemVisible(void); +_Bool igIsItemEdited(void); +_Bool igIsItemActivated(void); +_Bool igIsItemDeactivated(void); +_Bool igIsItemDeactivatedAfterEdit(void); +_Bool igIsAnyItemHovered(void); +_Bool igIsAnyItemActive(void); +_Bool igIsAnyItemFocused(void); +ImVec2 igGetItemRectMin(void); +ImVec2 igGetItemRectMax(void); +ImVec2 igGetItemRectSize(void); +void igSetItemAllowOverlap(void); +_Bool igIsRectVisible(const ImVec2 size); +_Bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max); +double igGetTime(void); +int igGetFrameCount(void); +ImDrawList* igGetBackgroundDrawList(void); +ImDrawList* igGetForegroundDrawList(void); +ImDrawListSharedData* igGetDrawListSharedData(void); +const char* igGetStyleColorName(ImGuiCol idx); +void igSetStateStorage(ImGuiStorage* storage); +ImGuiStorage* igGetStateStorage(void); +ImVec2 igCalcTextSize(const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end); +_Bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags); +void igEndChildFrame(void); +ImVec4 igColorConvertU32ToFloat4(ImU32 in); +ImU32 igColorConvertFloat4ToU32(const ImVec4 in); +int igGetKeyIndex(ImGuiKey imgui_key); +_Bool igIsKeyDown(int user_key_index); +_Bool igIsKeyPressed(int user_key_index, _Bool repeat); +_Bool igIsKeyReleased(int user_key_index); +int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate); +_Bool igIsMouseDown(int button); +_Bool igIsAnyMouseDown(void); +_Bool igIsMouseClicked(int button, _Bool repeat); +_Bool igIsMouseDoubleClicked(int button); +_Bool igIsMouseReleased(int button); +_Bool igIsMouseDragging(int button,float lock_threshold); +_Bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max, _Bool clip); +_Bool igIsMousePosValid(const ImVec2* mouse_pos); +ImVec2 igGetMousePos(void); +ImVec2 igGetMousePosOnOpeningCurrentPopup(void); +ImVec2 igGetMouseDragDelta(int button,float lock_threshold); +void igResetMouseDragDelta(int button); +ImGuiMouseCursor igGetMouseCursor(void); +void igSetMouseCursor(ImGuiMouseCursor type); +void igCaptureKeyboardFromApp( _Bool want_capture_keyboard_value); +void igCaptureMouseFromApp( _Bool want_capture_mouse_value); +const char* igGetClipboardText(void); +void igSetClipboardText(const char* text); +void igLoadIniSettingsFromDisk(const char* ini_filename); +void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size); +void igSaveIniSettingsToDisk(const char* ini_filename); +const char* igSaveIniSettingsToMemory(size_t* out_ini_size); +void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data); +void* igMemAlloc(size_t size); +void igMemFree(void* ptr); +ImGuiStyle* ImGuiStyle_ImGuiStyle(void); +void ImGuiStyle_destroy(ImGuiStyle* self); +void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor); +void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c); +void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str); +void ImGuiIO_ClearInputCharacters(ImGuiIO* self); +ImGuiIO* ImGuiIO_ImGuiIO(void); +void ImGuiIO_destroy(ImGuiIO* self); +ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void); +void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self); +void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count); +void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end); +_Bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self); +ImGuiPayload* ImGuiPayload_ImGuiPayload(void); +void ImGuiPayload_destroy(ImGuiPayload* self); +void ImGuiPayload_Clear(ImGuiPayload* self); +_Bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type); +_Bool ImGuiPayload_IsPreview(ImGuiPayload* self); +_Bool ImGuiPayload_IsDelivery(ImGuiPayload* self); +ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void); +void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self); +ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter); +void ImGuiTextFilter_destroy(ImGuiTextFilter* self); +_Bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width); +_Bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end); +void ImGuiTextFilter_Build(ImGuiTextFilter* self); +void ImGuiTextFilter_Clear(ImGuiTextFilter* self); +_Bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void); +void ImGuiTextRange_destroy(ImGuiTextRange* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e); +_Bool ImGuiTextRange_empty(ImGuiTextRange* self); +void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out); +ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void); +void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self); +const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self); +const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self); +int ImGuiTextBuffer_size(ImGuiTextBuffer* self); +_Bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self); +void ImGuiTextBuffer_clear(ImGuiTextBuffer* self); +void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity); +const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self); +void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end); +void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i); +void ImGuiStoragePair_destroy(ImGuiStoragePair* self); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p); +void ImGuiStorage_Clear(ImGuiStorage* self); +int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val); +void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val); +_Bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key, _Bool default_val); +void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key, _Bool val); +float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val); +void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val); +void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key); +void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val); +int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val); +_Bool * ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key, _Bool default_val); +float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val); +void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val); +void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val); +void ImGuiStorage_BuildSortByKey(ImGuiStorage* self); +ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height); +void ImGuiListClipper_destroy(ImGuiListClipper* self); +_Bool ImGuiListClipper_Step(ImGuiListClipper* self); +void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height); +void ImGuiListClipper_End(ImGuiListClipper* self); +ImColor* ImColor_ImColor(void); +void ImColor_destroy(ImColor* self); +ImColor* ImColor_ImColorInt(int r,int g,int b,int a); +ImColor* ImColor_ImColorU32(ImU32 rgba); +ImColor* ImColor_ImColorFloat(float r,float g,float b,float a); +ImColor* ImColor_ImColorVec4(const ImVec4 col); +void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a); +ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a); +ImDrawCmd* ImDrawCmd_ImDrawCmd(void); +void ImDrawCmd_destroy(ImDrawCmd* self); +ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void); +void ImDrawListSplitter_destroy(ImDrawListSplitter* self); +void ImDrawListSplitter_Clear(ImDrawListSplitter* self); +void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self); +void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count); +void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list); +void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx); +ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data); +void ImDrawList_destroy(ImDrawList* self); +void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max, _Bool intersect_with_current_clip_rect); +void ImDrawList_PushClipRectFullScreen(ImDrawList* self); +void ImDrawList_PopClipRect(ImDrawList* self); +void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id); +void ImDrawList_PopTextureID(ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMin(ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self); +void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness); +void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness); +void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left); +void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness); +void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col); +void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness); +void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col); +void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness); +void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments); +void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end); +void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect); +void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col); +void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col); +void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col, _Bool closed,float thickness); +void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col); +void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments); +void ImDrawList_PathClear(ImDrawList* self); +void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos); +void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos); +void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col); +void ImDrawList_PathStroke(ImDrawList* self,ImU32 col, _Bool closed,float thickness); +void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments); +void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12); +void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments); +void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data); +void ImDrawList_AddDrawCmd(ImDrawList* self); +ImDrawList* ImDrawList_CloneOutput(ImDrawList* self); +void ImDrawList_ChannelsSplit(ImDrawList* self,int count); +void ImDrawList_ChannelsMerge(ImDrawList* self); +void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n); +void ImDrawList_Clear(ImDrawList* self); +void ImDrawList_ClearFreeMemory(ImDrawList* self); +void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count); +void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col); +void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col); +void ImDrawList_PrimQuadUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col); +void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx); +void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +void ImDrawList_UpdateClipRect(ImDrawList* self); +void ImDrawList_UpdateTextureID(ImDrawList* self); +ImDrawData* ImDrawData_ImDrawData(void); +void ImDrawData_destroy(ImDrawData* self); +void ImDrawData_Clear(ImDrawData* self); +void ImDrawData_DeIndexAllBuffers(ImDrawData* self); +void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale); +ImFontConfig* ImFontConfig_ImFontConfig(void); +void ImFontConfig_destroy(ImFontConfig* self); +ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void); +void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self); +void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self); +_Bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n); +void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,int n); +void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c); +void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end); +void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges); +void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges); +ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void); +void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self); +_Bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self); +ImFontAtlas* ImFontAtlas_ImFontAtlas(void); +void ImFontAtlas_destroy(ImFontAtlas* self); +ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg); +ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg); +ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +void ImFontAtlas_ClearInputData(ImFontAtlas* self); +void ImFontAtlas_ClearTexData(ImFontAtlas* self); +void ImFontAtlas_ClearFonts(ImFontAtlas* self); +void ImFontAtlas_Clear(ImFontAtlas* self); +_Bool ImFontAtlas_Build(ImFontAtlas* self); +void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel); +void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel); +_Bool ImFontAtlas_IsBuilt(ImFontAtlas* self); +void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id); +const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self); +int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height); +int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset); +const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index); +void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max); +_Bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2]); +ImFont* ImFont_ImFont(void); +void ImFont_destroy(ImFont* self); +const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c); +const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c); +float ImFont_GetCharAdvance(ImFont* self,ImWchar c); +_Bool ImFont_IsLoaded(ImFont* self); +const char* ImFont_GetDebugName(ImFont* self); +ImVec2 ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width); +void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c); +void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width, _Bool cpu_fine_clip); +void ImFont_BuildLookupTable(ImFont* self); +void ImFont_ClearOutputData(ImFont* self); +void ImFont_GrowIndex(ImFont* self,int new_size); +void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x); +void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src, _Bool overwrite_dst); +void ImFont_SetFallbackChar(ImFont* self,ImWchar c); +void igGetWindowPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowPos_nonUDT2(void); +void igGetWindowSize_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowSize_nonUDT2(void); +void igGetContentRegionMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetContentRegionMax_nonUDT2(void); +void igGetContentRegionAvail_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetContentRegionAvail_nonUDT2(void); +void igGetWindowContentRegionMin_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowContentRegionMin_nonUDT2(void); +void igGetWindowContentRegionMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowContentRegionMax_nonUDT2(void); +void igGetFontTexUvWhitePixel_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetFontTexUvWhitePixel_nonUDT2(void); +void igGetCursorPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorPos_nonUDT2(void); +void igGetCursorStartPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorStartPos_nonUDT2(void); +void igGetCursorScreenPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorScreenPos_nonUDT2(void); +void igGetItemRectMin_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectMin_nonUDT2(void); +void igGetItemRectMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectMax_nonUDT2(void); +void igGetItemRectSize_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectSize_nonUDT2(void); +void igCalcTextSize_nonUDT(ImVec2 *pOut,const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +ImVec2_Simple igCalcTextSize_nonUDT2(const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +void igColorConvertU32ToFloat4_nonUDT(ImVec4 *pOut,ImU32 in); +ImVec4_Simple igColorConvertU32ToFloat4_nonUDT2(ImU32 in); +void igGetMousePos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetMousePos_nonUDT2(void); +void igGetMousePosOnOpeningCurrentPopup_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2(void); +void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,int button,float lock_threshold); +ImVec2_Simple igGetMouseDragDelta_nonUDT2(int button,float lock_threshold); +void ImColor_HSV_nonUDT(ImColor *pOut,ImColor* self,float h,float s,float v,float a); +ImColor_Simple ImColor_HSV_nonUDT2(ImColor* self,float h,float s,float v,float a); +void ImDrawList_GetClipRectMin_nonUDT(ImVec2 *pOut,ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMin_nonUDT2(ImDrawList* self); +void ImDrawList_GetClipRectMax_nonUDT(ImVec2 *pOut,ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMax_nonUDT2(ImDrawList* self); +void ImFont_CalcTextSizeA_nonUDT(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +ImVec2_Simple ImFont_CalcTextSizeA_nonUDT2(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +ImVector_float* ImVector_float_ImVector_float(void); +void ImVector_float_destroy(ImVector_float* self); +ImVector_ImWchar* ImVector_ImWchar_ImVector_ImWchar(void); +void ImVector_ImWchar_destroy(ImVector_ImWchar* self); +ImVector_ImDrawVert* ImVector_ImDrawVert_ImVector_ImDrawVert(void); +void ImVector_ImDrawVert_destroy(ImVector_ImDrawVert* self); +ImVector_ImFontGlyph* ImVector_ImFontGlyph_ImVector_ImFontGlyph(void); +void ImVector_ImFontGlyph_destroy(ImVector_ImFontGlyph* self); +ImVector_ImGuiTextRange* ImVector_ImGuiTextRange_ImVector_ImGuiTextRange(void); +void ImVector_ImGuiTextRange_destroy(ImVector_ImGuiTextRange* self); +ImVector_ImGuiStoragePair* ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePair(void); +void ImVector_ImGuiStoragePair_destroy(ImVector_ImGuiStoragePair* self); +ImVector_ImDrawChannel* ImVector_ImDrawChannel_ImVector_ImDrawChannel(void); +void ImVector_ImDrawChannel_destroy(ImVector_ImDrawChannel* self); +ImVector_char* ImVector_char_ImVector_char(void); +void ImVector_char_destroy(ImVector_char* self); +ImVector_ImU32* ImVector_ImU32_ImVector_ImU32(void); +void ImVector_ImU32_destroy(ImVector_ImU32* self); +ImVector_ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRect(void); +void ImVector_ImFontAtlasCustomRect_destroy(ImVector_ImFontAtlasCustomRect* self); +ImVector_ImTextureID* ImVector_ImTextureID_ImVector_ImTextureID(void); +void ImVector_ImTextureID_destroy(ImVector_ImTextureID* self); +ImVector_ImFontConfig* ImVector_ImFontConfig_ImVector_ImFontConfig(void); +void ImVector_ImFontConfig_destroy(ImVector_ImFontConfig* self); +ImVector_ImFontPtr* ImVector_ImFontPtr_ImVector_ImFontPtr(void); +void ImVector_ImFontPtr_destroy(ImVector_ImFontPtr* self); +ImVector_ImDrawCmd* ImVector_ImDrawCmd_ImVector_ImDrawCmd(void); +void ImVector_ImDrawCmd_destroy(ImVector_ImDrawCmd* self); +ImVector_ImVec4* ImVector_ImVec4_ImVector_ImVec4(void); +void ImVector_ImVec4_destroy(ImVector_ImVec4* self); +ImVector_ImDrawIdx* ImVector_ImDrawIdx_ImVector_ImDrawIdx(void); +void ImVector_ImDrawIdx_destroy(ImVector_ImDrawIdx* self); +ImVector_ImVec2* ImVector_ImVec2_ImVector_ImVec2(void); +void ImVector_ImVec2_destroy(ImVector_ImVec2* self); +ImVector_float* ImVector_float_ImVector_floatVector(const ImVector_float src); +ImVector_ImWchar* ImVector_ImWchar_ImVector_ImWcharVector(const ImVector_ImWchar src); +ImVector_ImDrawVert* ImVector_ImDrawVert_ImVector_ImDrawVertVector(const ImVector_ImDrawVert src); +ImVector_ImFontGlyph* ImVector_ImFontGlyph_ImVector_ImFontGlyphVector(const ImVector_ImFontGlyph src); +ImVector_ImGuiTextRange* ImVector_ImGuiTextRange_ImVector_ImGuiTextRangeVector(const ImVector_ImGuiTextRange src); +ImVector_ImGuiStoragePair* ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePairVector(const ImVector_ImGuiStoragePair src); +ImVector_ImDrawChannel* ImVector_ImDrawChannel_ImVector_ImDrawChannelVector(const ImVector_ImDrawChannel src); +ImVector_char* ImVector_char_ImVector_charVector(const ImVector_char src); +ImVector_ImU32* ImVector_ImU32_ImVector_ImU32Vector(const ImVector_ImU32 src); +ImVector_ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRectVector(const ImVector_ImFontAtlasCustomRect src); +ImVector_ImTextureID* ImVector_ImTextureID_ImVector_ImTextureIDVector(const ImVector_ImTextureID src); +ImVector_ImFontConfig* ImVector_ImFontConfig_ImVector_ImFontConfigVector(const ImVector_ImFontConfig src); +ImVector_ImFontPtr* ImVector_ImFontPtr_ImVector_ImFontPtrVector(const ImVector_ImFontPtr src); +ImVector_ImDrawCmd* ImVector_ImDrawCmd_ImVector_ImDrawCmdVector(const ImVector_ImDrawCmd src); +ImVector_ImVec4* ImVector_ImVec4_ImVector_ImVec4Vector(const ImVector_ImVec4 src); +ImVector_ImDrawIdx* ImVector_ImDrawIdx_ImVector_ImDrawIdxVector(const ImVector_ImDrawIdx src); +ImVector_ImVec2* ImVector_ImVec2_ImVector_ImVec2Vector(const ImVector_ImVec2 src); +_Bool ImVector_float_empty(const ImVector_float* self); +_Bool ImVector_ImWchar_empty(const ImVector_ImWchar* self); +_Bool ImVector_ImDrawVert_empty(const ImVector_ImDrawVert* self); +_Bool ImVector_ImFontGlyph_empty(const ImVector_ImFontGlyph* self); +_Bool ImVector_ImGuiTextRange_empty(const ImVector_ImGuiTextRange* self); +_Bool ImVector_ImGuiStoragePair_empty(const ImVector_ImGuiStoragePair* self); +_Bool ImVector_ImDrawChannel_empty(const ImVector_ImDrawChannel* self); +_Bool ImVector_char_empty(const ImVector_char* self); +_Bool ImVector_ImU32_empty(const ImVector_ImU32* self); +_Bool ImVector_ImFontAtlasCustomRect_empty(const ImVector_ImFontAtlasCustomRect* self); +_Bool ImVector_ImTextureID_empty(const ImVector_ImTextureID* self); +_Bool ImVector_ImFontConfig_empty(const ImVector_ImFontConfig* self); +_Bool ImVector_ImFontPtr_empty(const ImVector_ImFontPtr* self); +_Bool ImVector_ImDrawCmd_empty(const ImVector_ImDrawCmd* self); +_Bool ImVector_ImVec4_empty(const ImVector_ImVec4* self); +_Bool ImVector_ImDrawIdx_empty(const ImVector_ImDrawIdx* self); +_Bool ImVector_ImVec2_empty(const ImVector_ImVec2* self); +int ImVector_float_size(const ImVector_float* self); +int ImVector_ImWchar_size(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_size(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_size(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_size(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_size(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_size(const ImVector_ImDrawChannel* self); +int ImVector_char_size(const ImVector_char* self); +int ImVector_ImU32_size(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_size(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_size(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_size(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_size(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_size(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_size(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_size(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_size(const ImVector_ImVec2* self); +int ImVector_float_size_in_bytes(const ImVector_float* self); +int ImVector_ImWchar_size_in_bytes(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_size_in_bytes(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_size_in_bytes(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_size_in_bytes(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_size_in_bytes(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_size_in_bytes(const ImVector_ImDrawChannel* self); +int ImVector_char_size_in_bytes(const ImVector_char* self); +int ImVector_ImU32_size_in_bytes(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_size_in_bytes(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_size_in_bytes(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_size_in_bytes(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_size_in_bytes(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_size_in_bytes(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_size_in_bytes(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_size_in_bytes(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_size_in_bytes(const ImVector_ImVec2* self); +int ImVector_float_capacity(const ImVector_float* self); +int ImVector_ImWchar_capacity(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_capacity(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_capacity(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_capacity(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_capacity(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_capacity(const ImVector_ImDrawChannel* self); +int ImVector_char_capacity(const ImVector_char* self); +int ImVector_ImU32_capacity(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_capacity(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_capacity(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_capacity(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_capacity(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_capacity(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_capacity(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_capacity(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_capacity(const ImVector_ImVec2* self); +void ImVector_float_clear(ImVector_float* self); +void ImVector_ImWchar_clear(ImVector_ImWchar* self); +void ImVector_ImDrawVert_clear(ImVector_ImDrawVert* self); +void ImVector_ImFontGlyph_clear(ImVector_ImFontGlyph* self); +void ImVector_ImGuiTextRange_clear(ImVector_ImGuiTextRange* self); +void ImVector_ImGuiStoragePair_clear(ImVector_ImGuiStoragePair* self); +void ImVector_ImDrawChannel_clear(ImVector_ImDrawChannel* self); +void ImVector_char_clear(ImVector_char* self); +void ImVector_ImU32_clear(ImVector_ImU32* self); +void ImVector_ImFontAtlasCustomRect_clear(ImVector_ImFontAtlasCustomRect* self); +void ImVector_ImTextureID_clear(ImVector_ImTextureID* self); +void ImVector_ImFontConfig_clear(ImVector_ImFontConfig* self); +void ImVector_ImFontPtr_clear(ImVector_ImFontPtr* self); +void ImVector_ImDrawCmd_clear(ImVector_ImDrawCmd* self); +void ImVector_ImVec4_clear(ImVector_ImVec4* self); +void ImVector_ImDrawIdx_clear(ImVector_ImDrawIdx* self); +void ImVector_ImVec2_clear(ImVector_ImVec2* self); +float* ImVector_float_begin(ImVector_float* self); +ImWchar* ImVector_ImWchar_begin(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_begin(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_begin(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_begin(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_begin(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_begin(ImVector_ImDrawChannel* self); +char* ImVector_char_begin(ImVector_char* self); +ImU32* ImVector_ImU32_begin(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_begin(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_begin(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_begin(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_begin(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_begin(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_begin(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_begin(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_begin(ImVector_ImVec2* self); +float const * ImVector_float_begin_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_begin_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_begin_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_begin_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_begin_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_begin_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_begin_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_begin_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_begin_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_begin_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_begin_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_begin_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_begin_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_begin_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_begin_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_begin_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_begin_const(const ImVector_ImVec2* self); +float* ImVector_float_end(ImVector_float* self); +ImWchar* ImVector_ImWchar_end(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_end(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_end(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_end(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_end(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_end(ImVector_ImDrawChannel* self); +char* ImVector_char_end(ImVector_char* self); +ImU32* ImVector_ImU32_end(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_end(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_end(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_end(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_end(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_end(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_end(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_end(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_end(ImVector_ImVec2* self); +float const * ImVector_float_end_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_end_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_end_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_end_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_end_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_end_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_end_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_end_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_end_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_end_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_end_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_end_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_end_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_end_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_end_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_end_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_end_const(const ImVector_ImVec2* self); +float* ImVector_float_front(ImVector_float* self); +ImWchar* ImVector_ImWchar_front(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_front(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_front(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_front(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_front(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_front(ImVector_ImDrawChannel* self); +char* ImVector_char_front(ImVector_char* self); +ImU32* ImVector_ImU32_front(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_front(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_front(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_front(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_front(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_front(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_front(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_front(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_front(ImVector_ImVec2* self); +float const * ImVector_float_front_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_front_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_front_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_front_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_front_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_front_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_front_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_front_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_front_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_front_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_front_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_front_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_front_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_front_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_front_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_front_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_front_const(const ImVector_ImVec2* self); +float* ImVector_float_back(ImVector_float* self); +ImWchar* ImVector_ImWchar_back(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_back(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_back(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_back(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_back(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_back(ImVector_ImDrawChannel* self); +char* ImVector_char_back(ImVector_char* self); +ImU32* ImVector_ImU32_back(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_back(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_back(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_back(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_back(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_back(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_back(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_back(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_back(ImVector_ImVec2* self); +float const * ImVector_float_back_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_back_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_back_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_back_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_back_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_back_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_back_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_back_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_back_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_back_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_back_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_back_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_back_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_back_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_back_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_back_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_back_const(const ImVector_ImVec2* self); +void ImVector_float_swap(ImVector_float* self,ImVector_float rhs); +void ImVector_ImWchar_swap(ImVector_ImWchar* self,ImVector_ImWchar rhs); +void ImVector_ImDrawVert_swap(ImVector_ImDrawVert* self,ImVector_ImDrawVert rhs); +void ImVector_ImFontGlyph_swap(ImVector_ImFontGlyph* self,ImVector_ImFontGlyph rhs); +void ImVector_ImGuiTextRange_swap(ImVector_ImGuiTextRange* self,ImVector_ImGuiTextRange rhs); +void ImVector_ImGuiStoragePair_swap(ImVector_ImGuiStoragePair* self,ImVector_ImGuiStoragePair rhs); +void ImVector_ImDrawChannel_swap(ImVector_ImDrawChannel* self,ImVector_ImDrawChannel rhs); +void ImVector_char_swap(ImVector_char* self,ImVector_char rhs); +void ImVector_ImU32_swap(ImVector_ImU32* self,ImVector_ImU32 rhs); +void ImVector_ImFontAtlasCustomRect_swap(ImVector_ImFontAtlasCustomRect* self,ImVector_ImFontAtlasCustomRect rhs); +void ImVector_ImTextureID_swap(ImVector_ImTextureID* self,ImVector_ImTextureID rhs); +void ImVector_ImFontConfig_swap(ImVector_ImFontConfig* self,ImVector_ImFontConfig rhs); +void ImVector_ImFontPtr_swap(ImVector_ImFontPtr* self,ImVector_ImFontPtr rhs); +void ImVector_ImDrawCmd_swap(ImVector_ImDrawCmd* self,ImVector_ImDrawCmd rhs); +void ImVector_ImVec4_swap(ImVector_ImVec4* self,ImVector_ImVec4 rhs); +void ImVector_ImDrawIdx_swap(ImVector_ImDrawIdx* self,ImVector_ImDrawIdx rhs); +void ImVector_ImVec2_swap(ImVector_ImVec2* self,ImVector_ImVec2 rhs); +int ImVector_float__grow_capacity(const ImVector_float* self,int sz); +int ImVector_ImWchar__grow_capacity(const ImVector_ImWchar* self,int sz); +int ImVector_ImDrawVert__grow_capacity(const ImVector_ImDrawVert* self,int sz); +int ImVector_ImFontGlyph__grow_capacity(const ImVector_ImFontGlyph* self,int sz); +int ImVector_ImGuiTextRange__grow_capacity(const ImVector_ImGuiTextRange* self,int sz); +int ImVector_ImGuiStoragePair__grow_capacity(const ImVector_ImGuiStoragePair* self,int sz); +int ImVector_ImDrawChannel__grow_capacity(const ImVector_ImDrawChannel* self,int sz); +int ImVector_char__grow_capacity(const ImVector_char* self,int sz); +int ImVector_ImU32__grow_capacity(const ImVector_ImU32* self,int sz); +int ImVector_ImFontAtlasCustomRect__grow_capacity(const ImVector_ImFontAtlasCustomRect* self,int sz); +int ImVector_ImTextureID__grow_capacity(const ImVector_ImTextureID* self,int sz); +int ImVector_ImFontConfig__grow_capacity(const ImVector_ImFontConfig* self,int sz); +int ImVector_ImFontPtr__grow_capacity(const ImVector_ImFontPtr* self,int sz); +int ImVector_ImDrawCmd__grow_capacity(const ImVector_ImDrawCmd* self,int sz); +int ImVector_ImVec4__grow_capacity(const ImVector_ImVec4* self,int sz); +int ImVector_ImDrawIdx__grow_capacity(const ImVector_ImDrawIdx* self,int sz); +int ImVector_ImVec2__grow_capacity(const ImVector_ImVec2* self,int sz); +void ImVector_float_resize(ImVector_float* self,int new_size); +void ImVector_ImWchar_resize(ImVector_ImWchar* self,int new_size); +void ImVector_ImDrawVert_resize(ImVector_ImDrawVert* self,int new_size); +void ImVector_ImFontGlyph_resize(ImVector_ImFontGlyph* self,int new_size); +void ImVector_ImGuiTextRange_resize(ImVector_ImGuiTextRange* self,int new_size); +void ImVector_ImGuiStoragePair_resize(ImVector_ImGuiStoragePair* self,int new_size); +void ImVector_ImDrawChannel_resize(ImVector_ImDrawChannel* self,int new_size); +void ImVector_char_resize(ImVector_char* self,int new_size); +void ImVector_ImU32_resize(ImVector_ImU32* self,int new_size); +void ImVector_ImFontAtlasCustomRect_resize(ImVector_ImFontAtlasCustomRect* self,int new_size); +void ImVector_ImTextureID_resize(ImVector_ImTextureID* self,int new_size); +void ImVector_ImFontConfig_resize(ImVector_ImFontConfig* self,int new_size); +void ImVector_ImFontPtr_resize(ImVector_ImFontPtr* self,int new_size); +void ImVector_ImDrawCmd_resize(ImVector_ImDrawCmd* self,int new_size); +void ImVector_ImVec4_resize(ImVector_ImVec4* self,int new_size); +void ImVector_ImDrawIdx_resize(ImVector_ImDrawIdx* self,int new_size); +void ImVector_ImVec2_resize(ImVector_ImVec2* self,int new_size); +void ImVector_float_resizeT(ImVector_float* self,int new_size,const float v); +void ImVector_ImWchar_resizeT(ImVector_ImWchar* self,int new_size,const ImWchar v); +void ImVector_ImDrawVert_resizeT(ImVector_ImDrawVert* self,int new_size,const ImDrawVert v); +void ImVector_ImFontGlyph_resizeT(ImVector_ImFontGlyph* self,int new_size,const ImFontGlyph v); +void ImVector_ImGuiTextRange_resizeT(ImVector_ImGuiTextRange* self,int new_size,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_resizeT(ImVector_ImGuiStoragePair* self,int new_size,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_resizeT(ImVector_ImDrawChannel* self,int new_size,const ImDrawChannel v); +void ImVector_char_resizeT(ImVector_char* self,int new_size,const char v); +void ImVector_ImU32_resizeT(ImVector_ImU32* self,int new_size,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_resizeT(ImVector_ImFontAtlasCustomRect* self,int new_size,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_resizeT(ImVector_ImTextureID* self,int new_size,const ImTextureID v); +void ImVector_ImFontConfig_resizeT(ImVector_ImFontConfig* self,int new_size,const ImFontConfig v); +void ImVector_ImFontPtr_resizeT(ImVector_ImFontPtr* self,int new_size,ImFont* const v); +void ImVector_ImDrawCmd_resizeT(ImVector_ImDrawCmd* self,int new_size,const ImDrawCmd v); +void ImVector_ImVec4_resizeT(ImVector_ImVec4* self,int new_size,const ImVec4 v); +void ImVector_ImDrawIdx_resizeT(ImVector_ImDrawIdx* self,int new_size,const ImDrawIdx v); +void ImVector_ImVec2_resizeT(ImVector_ImVec2* self,int new_size,const ImVec2 v); +void ImVector_float_reserve(ImVector_float* self,int new_capacity); +void ImVector_ImWchar_reserve(ImVector_ImWchar* self,int new_capacity); +void ImVector_ImDrawVert_reserve(ImVector_ImDrawVert* self,int new_capacity); +void ImVector_ImFontGlyph_reserve(ImVector_ImFontGlyph* self,int new_capacity); +void ImVector_ImGuiTextRange_reserve(ImVector_ImGuiTextRange* self,int new_capacity); +void ImVector_ImGuiStoragePair_reserve(ImVector_ImGuiStoragePair* self,int new_capacity); +void ImVector_ImDrawChannel_reserve(ImVector_ImDrawChannel* self,int new_capacity); +void ImVector_char_reserve(ImVector_char* self,int new_capacity); +void ImVector_ImU32_reserve(ImVector_ImU32* self,int new_capacity); +void ImVector_ImFontAtlasCustomRect_reserve(ImVector_ImFontAtlasCustomRect* self,int new_capacity); +void ImVector_ImTextureID_reserve(ImVector_ImTextureID* self,int new_capacity); +void ImVector_ImFontConfig_reserve(ImVector_ImFontConfig* self,int new_capacity); +void ImVector_ImFontPtr_reserve(ImVector_ImFontPtr* self,int new_capacity); +void ImVector_ImDrawCmd_reserve(ImVector_ImDrawCmd* self,int new_capacity); +void ImVector_ImVec4_reserve(ImVector_ImVec4* self,int new_capacity); +void ImVector_ImDrawIdx_reserve(ImVector_ImDrawIdx* self,int new_capacity); +void ImVector_ImVec2_reserve(ImVector_ImVec2* self,int new_capacity); +void ImVector_float_push_back(ImVector_float* self,const float v); +void ImVector_ImWchar_push_back(ImVector_ImWchar* self,const ImWchar v); +void ImVector_ImDrawVert_push_back(ImVector_ImDrawVert* self,const ImDrawVert v); +void ImVector_ImFontGlyph_push_back(ImVector_ImFontGlyph* self,const ImFontGlyph v); +void ImVector_ImGuiTextRange_push_back(ImVector_ImGuiTextRange* self,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_push_back(ImVector_ImGuiStoragePair* self,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_push_back(ImVector_ImDrawChannel* self,const ImDrawChannel v); +void ImVector_char_push_back(ImVector_char* self,const char v); +void ImVector_ImU32_push_back(ImVector_ImU32* self,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_push_back(ImVector_ImFontAtlasCustomRect* self,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_push_back(ImVector_ImTextureID* self,const ImTextureID v); +void ImVector_ImFontConfig_push_back(ImVector_ImFontConfig* self,const ImFontConfig v); +void ImVector_ImFontPtr_push_back(ImVector_ImFontPtr* self,ImFont* const v); +void ImVector_ImDrawCmd_push_back(ImVector_ImDrawCmd* self,const ImDrawCmd v); +void ImVector_ImVec4_push_back(ImVector_ImVec4* self,const ImVec4 v); +void ImVector_ImDrawIdx_push_back(ImVector_ImDrawIdx* self,const ImDrawIdx v); +void ImVector_ImVec2_push_back(ImVector_ImVec2* self,const ImVec2 v); +void ImVector_float_pop_back(ImVector_float* self); +void ImVector_ImWchar_pop_back(ImVector_ImWchar* self); +void ImVector_ImDrawVert_pop_back(ImVector_ImDrawVert* self); +void ImVector_ImFontGlyph_pop_back(ImVector_ImFontGlyph* self); +void ImVector_ImGuiTextRange_pop_back(ImVector_ImGuiTextRange* self); +void ImVector_ImGuiStoragePair_pop_back(ImVector_ImGuiStoragePair* self); +void ImVector_ImDrawChannel_pop_back(ImVector_ImDrawChannel* self); +void ImVector_char_pop_back(ImVector_char* self); +void ImVector_ImU32_pop_back(ImVector_ImU32* self); +void ImVector_ImFontAtlasCustomRect_pop_back(ImVector_ImFontAtlasCustomRect* self); +void ImVector_ImTextureID_pop_back(ImVector_ImTextureID* self); +void ImVector_ImFontConfig_pop_back(ImVector_ImFontConfig* self); +void ImVector_ImFontPtr_pop_back(ImVector_ImFontPtr* self); +void ImVector_ImDrawCmd_pop_back(ImVector_ImDrawCmd* self); +void ImVector_ImVec4_pop_back(ImVector_ImVec4* self); +void ImVector_ImDrawIdx_pop_back(ImVector_ImDrawIdx* self); +void ImVector_ImVec2_pop_back(ImVector_ImVec2* self); +void ImVector_float_push_front(ImVector_float* self,const float v); +void ImVector_ImWchar_push_front(ImVector_ImWchar* self,const ImWchar v); +void ImVector_ImDrawVert_push_front(ImVector_ImDrawVert* self,const ImDrawVert v); +void ImVector_ImFontGlyph_push_front(ImVector_ImFontGlyph* self,const ImFontGlyph v); +void ImVector_ImGuiTextRange_push_front(ImVector_ImGuiTextRange* self,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_push_front(ImVector_ImGuiStoragePair* self,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_push_front(ImVector_ImDrawChannel* self,const ImDrawChannel v); +void ImVector_char_push_front(ImVector_char* self,const char v); +void ImVector_ImU32_push_front(ImVector_ImU32* self,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_push_front(ImVector_ImFontAtlasCustomRect* self,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_push_front(ImVector_ImTextureID* self,const ImTextureID v); +void ImVector_ImFontConfig_push_front(ImVector_ImFontConfig* self,const ImFontConfig v); +void ImVector_ImFontPtr_push_front(ImVector_ImFontPtr* self,ImFont* const v); +void ImVector_ImDrawCmd_push_front(ImVector_ImDrawCmd* self,const ImDrawCmd v); +void ImVector_ImVec4_push_front(ImVector_ImVec4* self,const ImVec4 v); +void ImVector_ImDrawIdx_push_front(ImVector_ImDrawIdx* self,const ImDrawIdx v); +void ImVector_ImVec2_push_front(ImVector_ImVec2* self,const ImVec2 v); +float* ImVector_float_erase(ImVector_float* self,float const * it); +ImWchar* ImVector_ImWchar_erase(ImVector_ImWchar* self,ImWchar const * it); +ImDrawVert* ImVector_ImDrawVert_erase(ImVector_ImDrawVert* self,ImDrawVert const * it); +ImFontGlyph* ImVector_ImFontGlyph_erase(ImVector_ImFontGlyph* self,ImFontGlyph const * it); +ImGuiTextRange* ImVector_ImGuiTextRange_erase(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +ImGuiStoragePair* ImVector_ImGuiStoragePair_erase(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +ImDrawChannel* ImVector_ImDrawChannel_erase(ImVector_ImDrawChannel* self,ImDrawChannel const * it); +char* ImVector_char_erase(ImVector_char* self,char const * it); +ImU32* ImVector_ImU32_erase(ImVector_ImU32* self,ImU32 const * it); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_erase(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +ImTextureID* ImVector_ImTextureID_erase(ImVector_ImTextureID* self,ImTextureID const * it); +ImFontConfig* ImVector_ImFontConfig_erase(ImVector_ImFontConfig* self,ImFontConfig const * it); +ImFont** ImVector_ImFontPtr_erase(ImVector_ImFontPtr* self,ImFont* const * it); +ImDrawCmd* ImVector_ImDrawCmd_erase(ImVector_ImDrawCmd* self,ImDrawCmd const * it); +ImVec4* ImVector_ImVec4_erase(ImVector_ImVec4* self,ImVec4 const * it); +ImDrawIdx* ImVector_ImDrawIdx_erase(ImVector_ImDrawIdx* self,ImDrawIdx const * it); +ImVec2* ImVector_ImVec2_erase(ImVector_ImVec2* self,ImVec2 const * it); +float* ImVector_float_eraseTPtr(ImVector_float* self,float const * it,float const * it_last); +ImWchar* ImVector_ImWchar_eraseTPtr(ImVector_ImWchar* self,ImWchar const * it,ImWchar const * it_last); +ImDrawVert* ImVector_ImDrawVert_eraseTPtr(ImVector_ImDrawVert* self,ImDrawVert const * it,ImDrawVert const * it_last); +ImFontGlyph* ImVector_ImFontGlyph_eraseTPtr(ImVector_ImFontGlyph* self,ImFontGlyph const * it,ImFontGlyph const * it_last); +ImGuiTextRange* ImVector_ImGuiTextRange_eraseTPtr(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it,ImGuiTextRange const * it_last); +ImGuiStoragePair* ImVector_ImGuiStoragePair_eraseTPtr(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it,ImGuiStoragePair const * it_last); +ImDrawChannel* ImVector_ImDrawChannel_eraseTPtr(ImVector_ImDrawChannel* self,ImDrawChannel const * it,ImDrawChannel const * it_last); +char* ImVector_char_eraseTPtr(ImVector_char* self,char const * it,char const * it_last); +ImU32* ImVector_ImU32_eraseTPtr(ImVector_ImU32* self,ImU32 const * it,ImU32 const * it_last); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_eraseTPtr(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it,ImFontAtlasCustomRect const * it_last); +ImTextureID* ImVector_ImTextureID_eraseTPtr(ImVector_ImTextureID* self,ImTextureID const * it,ImTextureID const * it_last); +ImFontConfig* ImVector_ImFontConfig_eraseTPtr(ImVector_ImFontConfig* self,ImFontConfig const * it,ImFontConfig const * it_last); +ImFont** ImVector_ImFontPtr_eraseTPtr(ImVector_ImFontPtr* self,ImFont* const * it,ImFont* const * it_last); +ImDrawCmd* ImVector_ImDrawCmd_eraseTPtr(ImVector_ImDrawCmd* self,ImDrawCmd const * it,ImDrawCmd const * it_last); +ImVec4* ImVector_ImVec4_eraseTPtr(ImVector_ImVec4* self,ImVec4 const * it,ImVec4 const * it_last); +ImDrawIdx* ImVector_ImDrawIdx_eraseTPtr(ImVector_ImDrawIdx* self,ImDrawIdx const * it,ImDrawIdx const * it_last); +ImVec2* ImVector_ImVec2_eraseTPtr(ImVector_ImVec2* self,ImVec2 const * it,ImVec2 const * it_last); +float* ImVector_float_erase_unsorted(ImVector_float* self,float const * it); +ImWchar* ImVector_ImWchar_erase_unsorted(ImVector_ImWchar* self,ImWchar const * it); +ImDrawVert* ImVector_ImDrawVert_erase_unsorted(ImVector_ImDrawVert* self,ImDrawVert const * it); +ImFontGlyph* ImVector_ImFontGlyph_erase_unsorted(ImVector_ImFontGlyph* self,ImFontGlyph const * it); +ImGuiTextRange* ImVector_ImGuiTextRange_erase_unsorted(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +ImGuiStoragePair* ImVector_ImGuiStoragePair_erase_unsorted(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +ImDrawChannel* ImVector_ImDrawChannel_erase_unsorted(ImVector_ImDrawChannel* self,ImDrawChannel const * it); +char* ImVector_char_erase_unsorted(ImVector_char* self,char const * it); +ImU32* ImVector_ImU32_erase_unsorted(ImVector_ImU32* self,ImU32 const * it); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_erase_unsorted(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +ImTextureID* ImVector_ImTextureID_erase_unsorted(ImVector_ImTextureID* self,ImTextureID const * it); +ImFontConfig* ImVector_ImFontConfig_erase_unsorted(ImVector_ImFontConfig* self,ImFontConfig const * it); +ImFont** ImVector_ImFontPtr_erase_unsorted(ImVector_ImFontPtr* self,ImFont* const * it); +ImDrawCmd* ImVector_ImDrawCmd_erase_unsorted(ImVector_ImDrawCmd* self,ImDrawCmd const * it); +ImVec4* ImVector_ImVec4_erase_unsorted(ImVector_ImVec4* self,ImVec4 const * it); +ImDrawIdx* ImVector_ImDrawIdx_erase_unsorted(ImVector_ImDrawIdx* self,ImDrawIdx const * it); +ImVec2* ImVector_ImVec2_erase_unsorted(ImVector_ImVec2* self,ImVec2 const * it); +float* ImVector_float_insert(ImVector_float* self,float const * it,const float v); +ImWchar* ImVector_ImWchar_insert(ImVector_ImWchar* self,ImWchar const * it,const ImWchar v); +ImDrawVert* ImVector_ImDrawVert_insert(ImVector_ImDrawVert* self,ImDrawVert const * it,const ImDrawVert v); +ImFontGlyph* ImVector_ImFontGlyph_insert(ImVector_ImFontGlyph* self,ImFontGlyph const * it,const ImFontGlyph v); +ImGuiTextRange* ImVector_ImGuiTextRange_insert(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it,const ImGuiTextRange v); +ImGuiStoragePair* ImVector_ImGuiStoragePair_insert(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it,const ImGuiStoragePair v); +ImDrawChannel* ImVector_ImDrawChannel_insert(ImVector_ImDrawChannel* self,ImDrawChannel const * it,const ImDrawChannel v); +char* ImVector_char_insert(ImVector_char* self,char const * it,const char v); +ImU32* ImVector_ImU32_insert(ImVector_ImU32* self,ImU32 const * it,const ImU32 v); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_insert(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it,const ImFontAtlasCustomRect v); +ImTextureID* ImVector_ImTextureID_insert(ImVector_ImTextureID* self,ImTextureID const * it,const ImTextureID v); +ImFontConfig* ImVector_ImFontConfig_insert(ImVector_ImFontConfig* self,ImFontConfig const * it,const ImFontConfig v); +ImFont** ImVector_ImFontPtr_insert(ImVector_ImFontPtr* self,ImFont* const * it,ImFont* const v); +ImDrawCmd* ImVector_ImDrawCmd_insert(ImVector_ImDrawCmd* self,ImDrawCmd const * it,const ImDrawCmd v); +ImVec4* ImVector_ImVec4_insert(ImVector_ImVec4* self,ImVec4 const * it,const ImVec4 v); +ImDrawIdx* ImVector_ImDrawIdx_insert(ImVector_ImDrawIdx* self,ImDrawIdx const * it,const ImDrawIdx v); +ImVec2* ImVector_ImVec2_insert(ImVector_ImVec2* self,ImVec2 const * it,const ImVec2 v); +_Bool ImVector_float_contains(const ImVector_float* self,const float v); +_Bool ImVector_ImWchar_contains(const ImVector_ImWchar* self,const ImWchar v); +_Bool ImVector_char_contains(const ImVector_char* self,const char v); +int ImVector_float_index_from_ptr(const ImVector_float* self,float const * it); +int ImVector_ImWchar_index_from_ptr(const ImVector_ImWchar* self,ImWchar const * it); +int ImVector_ImDrawVert_index_from_ptr(const ImVector_ImDrawVert* self,ImDrawVert const * it); +int ImVector_ImFontGlyph_index_from_ptr(const ImVector_ImFontGlyph* self,ImFontGlyph const * it); +int ImVector_ImGuiTextRange_index_from_ptr(const ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +int ImVector_ImGuiStoragePair_index_from_ptr(const ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +int ImVector_ImDrawChannel_index_from_ptr(const ImVector_ImDrawChannel* self,ImDrawChannel const * it); +int ImVector_char_index_from_ptr(const ImVector_char* self,char const * it); +int ImVector_ImU32_index_from_ptr(const ImVector_ImU32* self,ImU32 const * it); +int ImVector_ImFontAtlasCustomRect_index_from_ptr(const ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +int ImVector_ImTextureID_index_from_ptr(const ImVector_ImTextureID* self,ImTextureID const * it); +int ImVector_ImFontConfig_index_from_ptr(const ImVector_ImFontConfig* self,ImFontConfig const * it); +int ImVector_ImFontPtr_index_from_ptr(const ImVector_ImFontPtr* self,ImFont* const * it); +int ImVector_ImDrawCmd_index_from_ptr(const ImVector_ImDrawCmd* self,ImDrawCmd const * it); +int ImVector_ImVec4_index_from_ptr(const ImVector_ImVec4* self,ImVec4 const * it); +int ImVector_ImDrawIdx_index_from_ptr(const ImVector_ImDrawIdx* self,ImDrawIdx const * it); +int ImVector_ImVec2_index_from_ptr(const ImVector_ImVec2* self,ImVec2 const * it); +void igLogText(const char *fmt, ...); +void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...); +float igGET_FLT_MAX(); +void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v); +void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b); +ImVector_ImWchar* ImVector_ImWchar_create(); +void ImVector_ImWchar_Init(ImVector_ImWchar* p); +void ImVector_ImWchar_UnInit(ImVector_ImWchar* p); +]] +--[[ END AUTOGENERATED SEGMENT ]] +local cdecl = cdecl or '' +cdecl = cdecl..[[ +// Helpers: UTF-8 <> wchar +int igImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count +int igImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count +int igImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining); // return input UTF-8 bytes count +int igImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count) +int igImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string as UTF-8 code-points +]] + +return cdecl \ No newline at end of file diff --git a/mimgui/cimguidx9.dll b/mimgui/cimguidx9.dll new file mode 100644 index 0000000..dd2416a Binary files /dev/null and b/mimgui/cimguidx9.dll differ diff --git a/mimgui/dx9.lua b/mimgui/dx9.lua new file mode 100644 index 0000000..e523039 --- /dev/null +++ b/mimgui/dx9.lua @@ -0,0 +1,171 @@ +-- This file is part of mimgui project +-- Licensed under the MIT License +-- Copyright (c) 2018, FYP + +local imgui = require 'mimgui.imgui' +local lib = imgui.lib +local ffi = require 'ffi' + +ffi.cdef [[ +typedef struct IDirect3DDevice9 *LPDIRECT3DDEVICE9, *PDIRECT3DDEVICE9; +typedef struct IDirect3DVertexBuffer9 *LPDIRECT3DVERTEXBUFFER9, *PDIRECT3DVERTEXBUFFER9; +typedef struct IDirect3DIndexBuffer9 *LPDIRECT3DINDEXBUFFER9, *PDIRECT3DINDEXBUFFER9; +typedef struct IDirect3DTexture9 *LPDIRECT3DTEXTURE9, *PDIRECT3DTEXTURE9; +typedef const char *LPCTSTR; +typedef const void *LPCVOID; +typedef unsigned int UINT; +typedef void *HWND; +typedef signed __int64 INT64, *PINT64; +typedef unsigned int UINT_PTR, *PUINT_PTR; +typedef long LONG_PTR, *PLONG_PTR; +typedef UINT_PTR WPARAM; +typedef LONG_PTR LPARAM; +typedef LONG_PTR LRESULT; +typedef struct ImGui_ImplDX9_Context +{ + LPDIRECT3DDEVICE9 pd3dDevice; + LPDIRECT3DVERTEXBUFFER9 pVB; + LPDIRECT3DINDEXBUFFER9 pIB; + LPDIRECT3DTEXTURE9 FontTexture; + int VertexBufferSize; + int IndexBufferSize; +} ImGui_ImplDX9_Context; + +bool ImGui_ImplWin32_Init(HWND hwnd, INT64* ticksPerSecond, INT64* time); +void ImGui_ImplWin32_NewFrame(HWND hwnd, INT64 ticksPerSecond, INT64* time); +LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); + +ImGui_ImplDX9_Context* ImGui_ImplDX9_Init(LPDIRECT3DDEVICE9 device); +void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); +void ImGui_ImplDX9_NewFrame(ImGui_ImplDX9_Context* context); +void ImGui_ImplDX9_RenderDrawData(ImGui_ImplDX9_Context* context, ImDrawData* draw_data); +void ImGui_ImplDX9_InvalidateDeviceObjects(ImGui_ImplDX9_Context* context); + +bool ImGui_ImplDX9_CreateFontsTexture(ImGui_ImplDX9_Context* context); // replaces ImGui_ImplDX9_CreateDeviceObjects since they are the same +void ImGui_ImplDX9_InvalidateFontsTexture(ImGui_ImplDX9_Context* context); + +LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFile(LPDIRECT3DDEVICE9 device, LPCTSTR path); +LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFileInMemory(LPDIRECT3DDEVICE9 device, LPCVOID src, UINT size); +void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + +int __stdcall MultiByteToWideChar(UINT CodePage, unsigned long dwFlags, const char* lpMultiByteStr, int cbMultiByte, wchar_t* lpWideCharStr, int cchWideChar); +]] + +local ImplDX9 = {} +function ImplDX9.new(device, hwnd) + -- ImGui_ImplDX9_Context* ImGui_ImplDX9_Init(LPDIRECT3DDEVICE9 device); + local obj = {} + local d3dcontext = lib.ImGui_ImplDX9_Init(device) + if d3dcontext == nil then + return nil + end + local context = imgui.CreateContext() + obj.ticksPerSecond = ffi.new('INT64[1]', 0) + obj.time = ffi.new('INT64[1]', 0) + imgui.SetCurrentContext(context) + local imio = imgui.GetIO() + imio.BackendRendererName = 'imgui_impl_dx9_lua' + imio.BackendFlags = bit.bor(imio.BackendFlags, lib.ImGuiBackendFlags_RendererHasVtxOffset) -- We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes. + -- bool ImGui_ImplWin32_Init(HWND hwnd, INT64* ticksPerSecond, INT64* time); + if not lib.ImGui_ImplWin32_Init(hwnd, obj.ticksPerSecond, obj.time) then + -- void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_Shutdown(d3dcontext) + imgui.DestroyContext(context) + return nil + end + obj.context = context + obj.d3dcontext = d3dcontext + obj.d3ddevice = device + obj.hwnd = hwnd + -- set finalizer + ffi.gc(d3dcontext, function(cd) + imgui.SetCurrentContext(context) + -- void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_Shutdown(cd) + imgui.DestroyContext(context) + end) + return setmetatable(obj, {__index = ImplDX9}) +end + +function ImplDX9:SwitchContext() + imgui.SetCurrentContext(self.context) +end + +function ImplDX9:NewFrame() + self:SwitchContext() + -- void ImGui_ImplDX9_NewFrame(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_NewFrame(self.d3dcontext) + -- void ImGui_ImplWin32_NewFrame(HWND hwnd, INT64 ticksPerSecond, INT64* time); + lib.ImGui_ImplWin32_NewFrame(self.hwnd, self.ticksPerSecond[0], self.time) + imgui.NewFrame() +end + +function ImplDX9:EndFrame() + self:SwitchContext() + imgui.Render() + -- void ImGui_ImplDX9_RenderDrawData(ImGui_ImplDX9_Context* context, ImDrawData* draw_data); + lib.ImGui_ImplDX9_RenderDrawData(self.d3dcontext, imgui.GetDrawData()) +end + +function ImplDX9:WindowMessage(msg, wparam, lparam) + self:SwitchContext() + if msg == 0x0102 then -- WM_CHAR + if wparam < 256 then + local char = ffi.new('char[1]', wparam) + local wchar = ffi.new('wchar_t[1]', 0) + if ffi.C.MultiByteToWideChar(0, 0, char, 1, wchar, 1) > 0 then + wparam = wchar[0] + end + end + end + -- LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); + return lib.ImGui_ImplWin32_WndProcHandler(self.hwnd, msg, wparam, lparam) +end + +function ImplDX9:InvalidateDeviceObjects() + self:SwitchContext() + -- void ImGui_ImplDX9_InvalidateDeviceObjects(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_InvalidateDeviceObjects(self.d3dcontext) +end + +function ImplDX9:CreateTextureFromFile(path) + -- LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFile(LPDIRECT3DDEVICE9 device, LPCTSTR path); + local tex = lib.ImGui_ImplDX9_CreateTextureFromFile(self.d3ddevice, path) + if tex == nil then + return nil + end + -- void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + return ffi.gc(tex, lib.ImGui_ImplDX9_ReleaseTexture) +end + +function ImplDX9:CreateTextureFromFileInMemory(src, size) + -- LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFileInMemory(LPDIRECT3DDEVICE9 device, LPCVOID src, UINT size); + if type(src) == 'number' then + src = ffi.cast('LPCVOID', src) + end + local tex = lib.ImGui_ImplDX9_CreateTextureFromFileInMemory(self.d3ddevice, src, size) + if tex == nil then + return nil + end + -- void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + return ffi.gc(tex, lib.ImGui_ImplDX9_ReleaseTexture) +end + +function ImplDX9:ReleaseTexture(tex) + ffi.gc(tex, nil) + lib.ImGui_ImplDX9_ReleaseTexture(tex) +end + +function ImplDX9:CreateFontsTexture() + self:SwitchContext() + -- bool ImGui_ImplDX9_CreateFontsTexture(ImGui_ImplDX9_Context* context); + return lib.ImGui_ImplDX9_CreateFontsTexture(self.d3dcontext) +end + +function ImplDX9:InvalidateFontsTexture() + self:SwitchContext() + -- void ImGui_ImplDX9_InvalidateFontsTexture(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_InvalidateFontsTexture(self.d3dcontext) +end + +return ImplDX9 diff --git a/mimgui/imgui.lua b/mimgui/imgui.lua new file mode 100644 index 0000000..22ffff0 --- /dev/null +++ b/mimgui/imgui.lua @@ -0,0 +1,2231 @@ +local cimguimodule = getWorkingDirectory() .. [[\lib\mimgui\cimguidx9]] +local ffi = require "ffi" +local cdecl = assert(require "mimgui.cdefs", "imgui.lua not properly build") + +ffi.cdef(cdecl) + +--load dll +local lib = ffi.load(cimguimodule) + +-----------ImVec2 definition +local ImVec2 +ImVec2 = ffi.metatype("ImVec2",{ + __add = function(a,b) return ImVec2(a.x + b.x, a.y + b.y) end, + __sub = function(a,b) return ImVec2(a.x - b.x, a.y - b.y) end, + __unm = function(a) return ImVec2(-a.x,-a.y) end, + __mul = function(a, b) --scalar mult + if not ffi.istype(ImVec2, b) then + return ImVec2(a.x * b, a.y * b) end + return ImVec2(a * b.x, a * b.y) + end, + __tostring = function(v) return 'ImVec2<'..v.x..','..v.y..'>' end +}) +local ImVec4= {} +ImVec4.__index = ImVec4 +ImVec4 = ffi.metatype("ImVec4",ImVec4) +--the module +local M = {ImVec2 = ImVec2, ImVec4 = ImVec4 ,lib = lib} + +if jit.os == "Windows" then + function M.ToUTF(unc_str) + local buf_len = lib.igImTextCountUtf8BytesFromStr(unc_str, nil) + 1; + local buf_local = ffi.new("char[?]",buf_len) + lib.igImTextStrToUtf8(buf_local, buf_len, unc_str, nil); + return buf_local + end + + function M.FromUTF(utf_str) + local wbuf_length = lib.igImTextCountCharsFromUtf8(utf_str, nil) + 1; + local buf_local = ffi.new("ImWchar[?]",wbuf_length) + lib.igImTextStrFromUtf8(buf_local, wbuf_length, utf_str, nil,nil); + return buf_local + end +end + +M.FLT_MAX = lib.igGET_FLT_MAX() + +------------convenience function +function M.U32(a,b,c,d) return lib.igGetColorU32Vec4(ImVec4(a,b,c,d or 1)) end +----------BEGIN_AUTOGENERATED_LUA--------------------------- +--------------------------ImVector_ImDrawVert---------------------------- +local ImVector_ImDrawVert= {} +ImVector_ImDrawVert.__index = ImVector_ImDrawVert +function ImVector_ImDrawVert.__new(ctype) + local ptr = lib.ImVector_ImDrawVert_ImVector_ImDrawVert() + return ffi.gc(ptr,lib.ImVector_ImDrawVert_destroy) +end +function ImVector_ImDrawVert.ImVector_ImDrawVertVector(src) + local ptr = lib.ImVector_ImDrawVert_ImVector_ImDrawVertVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawVert_destroy) +end +ImVector_ImDrawVert._grow_capacity = lib.ImVector_ImDrawVert__grow_capacity +ImVector_ImDrawVert.back = lib.ImVector_ImDrawVert_back +ImVector_ImDrawVert.back_const = lib.ImVector_ImDrawVert_back_const +ImVector_ImDrawVert.begin = lib.ImVector_ImDrawVert_begin +ImVector_ImDrawVert.begin_const = lib.ImVector_ImDrawVert_begin_const +ImVector_ImDrawVert.capacity = lib.ImVector_ImDrawVert_capacity +ImVector_ImDrawVert.clear = lib.ImVector_ImDrawVert_clear +ImVector_ImDrawVert.empty = lib.ImVector_ImDrawVert_empty +ImVector_ImDrawVert._end = lib.ImVector_ImDrawVert_end +ImVector_ImDrawVert.end_const = lib.ImVector_ImDrawVert_end_const +ImVector_ImDrawVert.erase = lib.ImVector_ImDrawVert_erase +ImVector_ImDrawVert.eraseTPtr = lib.ImVector_ImDrawVert_eraseTPtr +ImVector_ImDrawVert.erase_unsorted = lib.ImVector_ImDrawVert_erase_unsorted +ImVector_ImDrawVert.front = lib.ImVector_ImDrawVert_front +ImVector_ImDrawVert.front_const = lib.ImVector_ImDrawVert_front_const +ImVector_ImDrawVert.index_from_ptr = lib.ImVector_ImDrawVert_index_from_ptr +ImVector_ImDrawVert.insert = lib.ImVector_ImDrawVert_insert +ImVector_ImDrawVert.pop_back = lib.ImVector_ImDrawVert_pop_back +ImVector_ImDrawVert.push_back = lib.ImVector_ImDrawVert_push_back +ImVector_ImDrawVert.push_front = lib.ImVector_ImDrawVert_push_front +ImVector_ImDrawVert.reserve = lib.ImVector_ImDrawVert_reserve +ImVector_ImDrawVert.resize = lib.ImVector_ImDrawVert_resize +ImVector_ImDrawVert.resizeT = lib.ImVector_ImDrawVert_resizeT +ImVector_ImDrawVert.size = lib.ImVector_ImDrawVert_size +ImVector_ImDrawVert.size_in_bytes = lib.ImVector_ImDrawVert_size_in_bytes +ImVector_ImDrawVert.swap = lib.ImVector_ImDrawVert_swap +M.ImVector_ImDrawVert = ffi.metatype("ImVector_ImDrawVert",ImVector_ImDrawVert) +--------------------------ImFontConfig---------------------------- +local ImFontConfig= {} +ImFontConfig.__index = ImFontConfig +function ImFontConfig.__new(ctype) + local ptr = lib.ImFontConfig_ImFontConfig() + return ffi.gc(ptr,lib.ImFontConfig_destroy) +end +M.ImFontConfig = ffi.metatype("ImFontConfig",ImFontConfig) +--------------------------ImFontGlyphRangesBuilder---------------------------- +local ImFontGlyphRangesBuilder= {} +ImFontGlyphRangesBuilder.__index = ImFontGlyphRangesBuilder +ImFontGlyphRangesBuilder.AddChar = lib.ImFontGlyphRangesBuilder_AddChar +ImFontGlyphRangesBuilder.AddRanges = lib.ImFontGlyphRangesBuilder_AddRanges +function ImFontGlyphRangesBuilder:AddText(text,text_end) + text_end = text_end or nil + return lib.ImFontGlyphRangesBuilder_AddText(self,text,text_end) +end +ImFontGlyphRangesBuilder.BuildRanges = lib.ImFontGlyphRangesBuilder_BuildRanges +ImFontGlyphRangesBuilder.Clear = lib.ImFontGlyphRangesBuilder_Clear +ImFontGlyphRangesBuilder.GetBit = lib.ImFontGlyphRangesBuilder_GetBit +function ImFontGlyphRangesBuilder.__new(ctype) + local ptr = lib.ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder() + return ffi.gc(ptr,lib.ImFontGlyphRangesBuilder_destroy) +end +ImFontGlyphRangesBuilder.SetBit = lib.ImFontGlyphRangesBuilder_SetBit +M.ImFontGlyphRangesBuilder = ffi.metatype("ImFontGlyphRangesBuilder",ImFontGlyphRangesBuilder) +--------------------------ImDrawListSplitter---------------------------- +local ImDrawListSplitter= {} +ImDrawListSplitter.__index = ImDrawListSplitter +ImDrawListSplitter.Clear = lib.ImDrawListSplitter_Clear +ImDrawListSplitter.ClearFreeMemory = lib.ImDrawListSplitter_ClearFreeMemory +function ImDrawListSplitter.__new(ctype) + local ptr = lib.ImDrawListSplitter_ImDrawListSplitter() + return ffi.gc(ptr,lib.ImDrawListSplitter_destroy) +end +ImDrawListSplitter.Merge = lib.ImDrawListSplitter_Merge +ImDrawListSplitter.SetCurrentChannel = lib.ImDrawListSplitter_SetCurrentChannel +ImDrawListSplitter.Split = lib.ImDrawListSplitter_Split +M.ImDrawListSplitter = ffi.metatype("ImDrawListSplitter",ImDrawListSplitter) +--------------------------ImVector_ImFontPtr---------------------------- +local ImVector_ImFontPtr= {} +ImVector_ImFontPtr.__index = ImVector_ImFontPtr +function ImVector_ImFontPtr.__new(ctype) + local ptr = lib.ImVector_ImFontPtr_ImVector_ImFontPtr() + return ffi.gc(ptr,lib.ImVector_ImFontPtr_destroy) +end +function ImVector_ImFontPtr.ImVector_ImFontPtrVector(src) + local ptr = lib.ImVector_ImFontPtr_ImVector_ImFontPtrVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontPtr_destroy) +end +ImVector_ImFontPtr._grow_capacity = lib.ImVector_ImFontPtr__grow_capacity +ImVector_ImFontPtr.back = lib.ImVector_ImFontPtr_back +ImVector_ImFontPtr.back_const = lib.ImVector_ImFontPtr_back_const +ImVector_ImFontPtr.begin = lib.ImVector_ImFontPtr_begin +ImVector_ImFontPtr.begin_const = lib.ImVector_ImFontPtr_begin_const +ImVector_ImFontPtr.capacity = lib.ImVector_ImFontPtr_capacity +ImVector_ImFontPtr.clear = lib.ImVector_ImFontPtr_clear +ImVector_ImFontPtr.empty = lib.ImVector_ImFontPtr_empty +ImVector_ImFontPtr._end = lib.ImVector_ImFontPtr_end +ImVector_ImFontPtr.end_const = lib.ImVector_ImFontPtr_end_const +ImVector_ImFontPtr.erase = lib.ImVector_ImFontPtr_erase +ImVector_ImFontPtr.eraseTPtr = lib.ImVector_ImFontPtr_eraseTPtr +ImVector_ImFontPtr.erase_unsorted = lib.ImVector_ImFontPtr_erase_unsorted +ImVector_ImFontPtr.front = lib.ImVector_ImFontPtr_front +ImVector_ImFontPtr.front_const = lib.ImVector_ImFontPtr_front_const +ImVector_ImFontPtr.index_from_ptr = lib.ImVector_ImFontPtr_index_from_ptr +ImVector_ImFontPtr.insert = lib.ImVector_ImFontPtr_insert +ImVector_ImFontPtr.pop_back = lib.ImVector_ImFontPtr_pop_back +ImVector_ImFontPtr.push_back = lib.ImVector_ImFontPtr_push_back +ImVector_ImFontPtr.push_front = lib.ImVector_ImFontPtr_push_front +ImVector_ImFontPtr.reserve = lib.ImVector_ImFontPtr_reserve +ImVector_ImFontPtr.resize = lib.ImVector_ImFontPtr_resize +ImVector_ImFontPtr.resizeT = lib.ImVector_ImFontPtr_resizeT +ImVector_ImFontPtr.size = lib.ImVector_ImFontPtr_size +ImVector_ImFontPtr.size_in_bytes = lib.ImVector_ImFontPtr_size_in_bytes +ImVector_ImFontPtr.swap = lib.ImVector_ImFontPtr_swap +M.ImVector_ImFontPtr = ffi.metatype("ImVector_ImFontPtr",ImVector_ImFontPtr) +--------------------------ImGuiTextBuffer---------------------------- +local ImGuiTextBuffer= {} +ImGuiTextBuffer.__index = ImGuiTextBuffer +function ImGuiTextBuffer.__new(ctype) + local ptr = lib.ImGuiTextBuffer_ImGuiTextBuffer() + return ffi.gc(ptr,lib.ImGuiTextBuffer_destroy) +end +function ImGuiTextBuffer:append(str,str_end) + str_end = str_end or nil + return lib.ImGuiTextBuffer_append(self,str,str_end) +end +ImGuiTextBuffer.appendf = lib.ImGuiTextBuffer_appendf +ImGuiTextBuffer.appendfv = lib.ImGuiTextBuffer_appendfv +ImGuiTextBuffer.begin = lib.ImGuiTextBuffer_begin +ImGuiTextBuffer.c_str = lib.ImGuiTextBuffer_c_str +ImGuiTextBuffer.clear = lib.ImGuiTextBuffer_clear +ImGuiTextBuffer.empty = lib.ImGuiTextBuffer_empty +ImGuiTextBuffer._end = lib.ImGuiTextBuffer_end +ImGuiTextBuffer.reserve = lib.ImGuiTextBuffer_reserve +ImGuiTextBuffer.size = lib.ImGuiTextBuffer_size +M.ImGuiTextBuffer = ffi.metatype("ImGuiTextBuffer",ImGuiTextBuffer) +--------------------------ImGuiStyle---------------------------- +local ImGuiStyle= {} +ImGuiStyle.__index = ImGuiStyle +function ImGuiStyle.__new(ctype) + local ptr = lib.ImGuiStyle_ImGuiStyle() + return ffi.gc(ptr,lib.ImGuiStyle_destroy) +end +ImGuiStyle.ScaleAllSizes = lib.ImGuiStyle_ScaleAllSizes +M.ImGuiStyle = ffi.metatype("ImGuiStyle",ImGuiStyle) +--------------------------ImDrawData---------------------------- +local ImDrawData= {} +ImDrawData.__index = ImDrawData +ImDrawData.Clear = lib.ImDrawData_Clear +ImDrawData.DeIndexAllBuffers = lib.ImDrawData_DeIndexAllBuffers +function ImDrawData.__new(ctype) + local ptr = lib.ImDrawData_ImDrawData() + return ffi.gc(ptr,lib.ImDrawData_destroy) +end +ImDrawData.ScaleClipRects = lib.ImDrawData_ScaleClipRects +M.ImDrawData = ffi.metatype("ImDrawData",ImDrawData) +--------------------------ImVector_ImVec2---------------------------- +local ImVector_ImVec2= {} +ImVector_ImVec2.__index = ImVector_ImVec2 +function ImVector_ImVec2.__new(ctype) + local ptr = lib.ImVector_ImVec2_ImVector_ImVec2() + return ffi.gc(ptr,lib.ImVector_ImVec2_destroy) +end +function ImVector_ImVec2.ImVector_ImVec2Vector(src) + local ptr = lib.ImVector_ImVec2_ImVector_ImVec2Vector(src) + return ffi.gc(ptr,lib.ImVector_ImVec2_destroy) +end +ImVector_ImVec2._grow_capacity = lib.ImVector_ImVec2__grow_capacity +ImVector_ImVec2.back = lib.ImVector_ImVec2_back +ImVector_ImVec2.back_const = lib.ImVector_ImVec2_back_const +ImVector_ImVec2.begin = lib.ImVector_ImVec2_begin +ImVector_ImVec2.begin_const = lib.ImVector_ImVec2_begin_const +ImVector_ImVec2.capacity = lib.ImVector_ImVec2_capacity +ImVector_ImVec2.clear = lib.ImVector_ImVec2_clear +ImVector_ImVec2.empty = lib.ImVector_ImVec2_empty +ImVector_ImVec2._end = lib.ImVector_ImVec2_end +ImVector_ImVec2.end_const = lib.ImVector_ImVec2_end_const +ImVector_ImVec2.erase = lib.ImVector_ImVec2_erase +ImVector_ImVec2.eraseTPtr = lib.ImVector_ImVec2_eraseTPtr +ImVector_ImVec2.erase_unsorted = lib.ImVector_ImVec2_erase_unsorted +ImVector_ImVec2.front = lib.ImVector_ImVec2_front +ImVector_ImVec2.front_const = lib.ImVector_ImVec2_front_const +ImVector_ImVec2.index_from_ptr = lib.ImVector_ImVec2_index_from_ptr +ImVector_ImVec2.insert = lib.ImVector_ImVec2_insert +ImVector_ImVec2.pop_back = lib.ImVector_ImVec2_pop_back +ImVector_ImVec2.push_back = lib.ImVector_ImVec2_push_back +ImVector_ImVec2.push_front = lib.ImVector_ImVec2_push_front +ImVector_ImVec2.reserve = lib.ImVector_ImVec2_reserve +ImVector_ImVec2.resize = lib.ImVector_ImVec2_resize +ImVector_ImVec2.resizeT = lib.ImVector_ImVec2_resizeT +ImVector_ImVec2.size = lib.ImVector_ImVec2_size +ImVector_ImVec2.size_in_bytes = lib.ImVector_ImVec2_size_in_bytes +ImVector_ImVec2.swap = lib.ImVector_ImVec2_swap +M.ImVector_ImVec2 = ffi.metatype("ImVector_ImVec2",ImVector_ImVec2) +--------------------------ImVector_ImFontAtlasCustomRect---------------------------- +local ImVector_ImFontAtlasCustomRect= {} +ImVector_ImFontAtlasCustomRect.__index = ImVector_ImFontAtlasCustomRect +function ImVector_ImFontAtlasCustomRect.__new(ctype) + local ptr = lib.ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRect() + return ffi.gc(ptr,lib.ImVector_ImFontAtlasCustomRect_destroy) +end +function ImVector_ImFontAtlasCustomRect.ImVector_ImFontAtlasCustomRectVector(src) + local ptr = lib.ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRectVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontAtlasCustomRect_destroy) +end +ImVector_ImFontAtlasCustomRect._grow_capacity = lib.ImVector_ImFontAtlasCustomRect__grow_capacity +ImVector_ImFontAtlasCustomRect.back = lib.ImVector_ImFontAtlasCustomRect_back +ImVector_ImFontAtlasCustomRect.back_const = lib.ImVector_ImFontAtlasCustomRect_back_const +ImVector_ImFontAtlasCustomRect.begin = lib.ImVector_ImFontAtlasCustomRect_begin +ImVector_ImFontAtlasCustomRect.begin_const = lib.ImVector_ImFontAtlasCustomRect_begin_const +ImVector_ImFontAtlasCustomRect.capacity = lib.ImVector_ImFontAtlasCustomRect_capacity +ImVector_ImFontAtlasCustomRect.clear = lib.ImVector_ImFontAtlasCustomRect_clear +ImVector_ImFontAtlasCustomRect.empty = lib.ImVector_ImFontAtlasCustomRect_empty +ImVector_ImFontAtlasCustomRect._end = lib.ImVector_ImFontAtlasCustomRect_end +ImVector_ImFontAtlasCustomRect.end_const = lib.ImVector_ImFontAtlasCustomRect_end_const +ImVector_ImFontAtlasCustomRect.erase = lib.ImVector_ImFontAtlasCustomRect_erase +ImVector_ImFontAtlasCustomRect.eraseTPtr = lib.ImVector_ImFontAtlasCustomRect_eraseTPtr +ImVector_ImFontAtlasCustomRect.erase_unsorted = lib.ImVector_ImFontAtlasCustomRect_erase_unsorted +ImVector_ImFontAtlasCustomRect.front = lib.ImVector_ImFontAtlasCustomRect_front +ImVector_ImFontAtlasCustomRect.front_const = lib.ImVector_ImFontAtlasCustomRect_front_const +ImVector_ImFontAtlasCustomRect.index_from_ptr = lib.ImVector_ImFontAtlasCustomRect_index_from_ptr +ImVector_ImFontAtlasCustomRect.insert = lib.ImVector_ImFontAtlasCustomRect_insert +ImVector_ImFontAtlasCustomRect.pop_back = lib.ImVector_ImFontAtlasCustomRect_pop_back +ImVector_ImFontAtlasCustomRect.push_back = lib.ImVector_ImFontAtlasCustomRect_push_back +ImVector_ImFontAtlasCustomRect.push_front = lib.ImVector_ImFontAtlasCustomRect_push_front +ImVector_ImFontAtlasCustomRect.reserve = lib.ImVector_ImFontAtlasCustomRect_reserve +ImVector_ImFontAtlasCustomRect.resize = lib.ImVector_ImFontAtlasCustomRect_resize +ImVector_ImFontAtlasCustomRect.resizeT = lib.ImVector_ImFontAtlasCustomRect_resizeT +ImVector_ImFontAtlasCustomRect.size = lib.ImVector_ImFontAtlasCustomRect_size +ImVector_ImFontAtlasCustomRect.size_in_bytes = lib.ImVector_ImFontAtlasCustomRect_size_in_bytes +ImVector_ImFontAtlasCustomRect.swap = lib.ImVector_ImFontAtlasCustomRect_swap +M.ImVector_ImFontAtlasCustomRect = ffi.metatype("ImVector_ImFontAtlasCustomRect",ImVector_ImFontAtlasCustomRect) +--------------------------ImColor---------------------------- +local ImColor= {} +ImColor.__index = ImColor +function ImColor:HSV(h,s,v,a) + a = a or 1.0 + local nonUDT_out = ffi.new("ImColor") + lib.ImColor_HSV_nonUDT(nonUDT_out,self,h,s,v,a) + return nonUDT_out +end +function ImColor:HSV_nonUDT2(h,s,v,a) + a = a or 1.0 + return lib.ImColor_HSV_nonUDT2(self,h,s,v,a) +end +function ImColor.__new(ctype) + local ptr = lib.ImColor_ImColor() + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorInt(r,g,b,a) + if a == nil then a = 255 end + local ptr = lib.ImColor_ImColorInt(r,g,b,a) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorU32(rgba) + local ptr = lib.ImColor_ImColorU32(rgba) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorFloat(r,g,b,a) + if a == nil then a = 1.0 end + local ptr = lib.ImColor_ImColorFloat(r,g,b,a) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorVec4(col) + local ptr = lib.ImColor_ImColorVec4(col) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor:SetHSV(h,s,v,a) + a = a or 1.0 + return lib.ImColor_SetHSV(self,h,s,v,a) +end +M.ImColor = ffi.metatype("ImColor",ImColor) +--------------------------ImVector_ImDrawChannel---------------------------- +local ImVector_ImDrawChannel= {} +ImVector_ImDrawChannel.__index = ImVector_ImDrawChannel +function ImVector_ImDrawChannel.__new(ctype) + local ptr = lib.ImVector_ImDrawChannel_ImVector_ImDrawChannel() + return ffi.gc(ptr,lib.ImVector_ImDrawChannel_destroy) +end +function ImVector_ImDrawChannel.ImVector_ImDrawChannelVector(src) + local ptr = lib.ImVector_ImDrawChannel_ImVector_ImDrawChannelVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawChannel_destroy) +end +ImVector_ImDrawChannel._grow_capacity = lib.ImVector_ImDrawChannel__grow_capacity +ImVector_ImDrawChannel.back = lib.ImVector_ImDrawChannel_back +ImVector_ImDrawChannel.back_const = lib.ImVector_ImDrawChannel_back_const +ImVector_ImDrawChannel.begin = lib.ImVector_ImDrawChannel_begin +ImVector_ImDrawChannel.begin_const = lib.ImVector_ImDrawChannel_begin_const +ImVector_ImDrawChannel.capacity = lib.ImVector_ImDrawChannel_capacity +ImVector_ImDrawChannel.clear = lib.ImVector_ImDrawChannel_clear +ImVector_ImDrawChannel.empty = lib.ImVector_ImDrawChannel_empty +ImVector_ImDrawChannel._end = lib.ImVector_ImDrawChannel_end +ImVector_ImDrawChannel.end_const = lib.ImVector_ImDrawChannel_end_const +ImVector_ImDrawChannel.erase = lib.ImVector_ImDrawChannel_erase +ImVector_ImDrawChannel.eraseTPtr = lib.ImVector_ImDrawChannel_eraseTPtr +ImVector_ImDrawChannel.erase_unsorted = lib.ImVector_ImDrawChannel_erase_unsorted +ImVector_ImDrawChannel.front = lib.ImVector_ImDrawChannel_front +ImVector_ImDrawChannel.front_const = lib.ImVector_ImDrawChannel_front_const +ImVector_ImDrawChannel.index_from_ptr = lib.ImVector_ImDrawChannel_index_from_ptr +ImVector_ImDrawChannel.insert = lib.ImVector_ImDrawChannel_insert +ImVector_ImDrawChannel.pop_back = lib.ImVector_ImDrawChannel_pop_back +ImVector_ImDrawChannel.push_back = lib.ImVector_ImDrawChannel_push_back +ImVector_ImDrawChannel.push_front = lib.ImVector_ImDrawChannel_push_front +ImVector_ImDrawChannel.reserve = lib.ImVector_ImDrawChannel_reserve +ImVector_ImDrawChannel.resize = lib.ImVector_ImDrawChannel_resize +ImVector_ImDrawChannel.resizeT = lib.ImVector_ImDrawChannel_resizeT +ImVector_ImDrawChannel.size = lib.ImVector_ImDrawChannel_size +ImVector_ImDrawChannel.size_in_bytes = lib.ImVector_ImDrawChannel_size_in_bytes +ImVector_ImDrawChannel.swap = lib.ImVector_ImDrawChannel_swap +M.ImVector_ImDrawChannel = ffi.metatype("ImVector_ImDrawChannel",ImVector_ImDrawChannel) +--------------------------ImDrawList---------------------------- +local ImDrawList= {} +ImDrawList.__index = ImDrawList +function ImDrawList:AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments) + num_segments = num_segments or 0 + return lib.ImDrawList_AddBezierCurve(self,pos0,cp0,cp1,pos1,col,thickness,num_segments) +end +ImDrawList.AddCallback = lib.ImDrawList_AddCallback +function ImDrawList:AddCircle(centre,radius,col,num_segments,thickness) + num_segments = num_segments or 12 + thickness = thickness or 1.0 + return lib.ImDrawList_AddCircle(self,centre,radius,col,num_segments,thickness) +end +function ImDrawList:AddCircleFilled(centre,radius,col,num_segments) + num_segments = num_segments or 12 + return lib.ImDrawList_AddCircleFilled(self,centre,radius,col,num_segments) +end +ImDrawList.AddConvexPolyFilled = lib.ImDrawList_AddConvexPolyFilled +ImDrawList.AddDrawCmd = lib.ImDrawList_AddDrawCmd +function ImDrawList:AddImage(user_texture_id,a,b,uv_a,uv_b,col) + uv_b = uv_b or ImVec2(1,1) + uv_a = uv_a or ImVec2(0,0) + col = col or 4294967295 + return lib.ImDrawList_AddImage(self,user_texture_id,a,b,uv_a,uv_b,col) +end +function ImDrawList:AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) + uv_c = uv_c or ImVec2(1,1) + uv_a = uv_a or ImVec2(0,0) + col = col or 4294967295 + uv_b = uv_b or ImVec2(1,0) + uv_d = uv_d or ImVec2(0,1) + return lib.ImDrawList_AddImageQuad(self,user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) +end +function ImDrawList:AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners) + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddImageRounded(self,user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners) +end +function ImDrawList:AddLine(a,b,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddLine(self,a,b,col,thickness) +end +ImDrawList.AddPolyline = lib.ImDrawList_AddPolyline +function ImDrawList:AddQuad(a,b,c,d,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddQuad(self,a,b,c,d,col,thickness) +end +ImDrawList.AddQuadFilled = lib.ImDrawList_AddQuadFilled +function ImDrawList:AddRect(a,b,col,rounding,rounding_corners,thickness) + rounding = rounding or 0.0 + thickness = thickness or 1.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddRect(self,a,b,col,rounding,rounding_corners,thickness) +end +function ImDrawList:AddRectFilled(a,b,col,rounding,rounding_corners) + rounding = rounding or 0.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddRectFilled(self,a,b,col,rounding,rounding_corners) +end +ImDrawList.AddRectFilledMultiColor = lib.ImDrawList_AddRectFilledMultiColor +function ImDrawList:AddText(pos,col,text_begin,text_end) + text_end = text_end or nil + return lib.ImDrawList_AddText(self,pos,col,text_begin,text_end) +end +function ImDrawList:AddTextFontPtr(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect) + text_end = text_end or nil + cpu_fine_clip_rect = cpu_fine_clip_rect or nil + wrap_width = wrap_width or 0.0 + return lib.ImDrawList_AddTextFontPtr(self,font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect) +end +function ImDrawList:AddTriangle(a,b,c,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddTriangle(self,a,b,c,col,thickness) +end +ImDrawList.AddTriangleFilled = lib.ImDrawList_AddTriangleFilled +ImDrawList.ChannelsMerge = lib.ImDrawList_ChannelsMerge +ImDrawList.ChannelsSetCurrent = lib.ImDrawList_ChannelsSetCurrent +ImDrawList.ChannelsSplit = lib.ImDrawList_ChannelsSplit +ImDrawList.Clear = lib.ImDrawList_Clear +ImDrawList.ClearFreeMemory = lib.ImDrawList_ClearFreeMemory +ImDrawList.CloneOutput = lib.ImDrawList_CloneOutput +function ImDrawList:GetClipRectMax() + local nonUDT_out = ffi.new("ImVec2") + lib.ImDrawList_GetClipRectMax_nonUDT(nonUDT_out,self) + return nonUDT_out +end +ImDrawList.GetClipRectMax_nonUDT2 = lib.ImDrawList_GetClipRectMax_nonUDT2 +function ImDrawList:GetClipRectMin() + local nonUDT_out = ffi.new("ImVec2") + lib.ImDrawList_GetClipRectMin_nonUDT(nonUDT_out,self) + return nonUDT_out +end +ImDrawList.GetClipRectMin_nonUDT2 = lib.ImDrawList_GetClipRectMin_nonUDT2 +function ImDrawList.__new(ctype,shared_data) + local ptr = lib.ImDrawList_ImDrawList(shared_data) + return ffi.gc(ptr,lib.ImDrawList_destroy) +end +function ImDrawList:PathArcTo(centre,radius,a_min,a_max,num_segments) + num_segments = num_segments or 10 + return lib.ImDrawList_PathArcTo(self,centre,radius,a_min,a_max,num_segments) +end +ImDrawList.PathArcToFast = lib.ImDrawList_PathArcToFast +function ImDrawList:PathBezierCurveTo(p1,p2,p3,num_segments) + num_segments = num_segments or 0 + return lib.ImDrawList_PathBezierCurveTo(self,p1,p2,p3,num_segments) +end +ImDrawList.PathClear = lib.ImDrawList_PathClear +ImDrawList.PathFillConvex = lib.ImDrawList_PathFillConvex +ImDrawList.PathLineTo = lib.ImDrawList_PathLineTo +ImDrawList.PathLineToMergeDuplicate = lib.ImDrawList_PathLineToMergeDuplicate +function ImDrawList:PathRect(rect_min,rect_max,rounding,rounding_corners) + rounding = rounding or 0.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_PathRect(self,rect_min,rect_max,rounding,rounding_corners) +end +function ImDrawList:PathStroke(col,closed,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_PathStroke(self,col,closed,thickness) +end +ImDrawList.PopClipRect = lib.ImDrawList_PopClipRect +ImDrawList.PopTextureID = lib.ImDrawList_PopTextureID +ImDrawList.PrimQuadUV = lib.ImDrawList_PrimQuadUV +ImDrawList.PrimRect = lib.ImDrawList_PrimRect +ImDrawList.PrimRectUV = lib.ImDrawList_PrimRectUV +ImDrawList.PrimReserve = lib.ImDrawList_PrimReserve +ImDrawList.PrimVtx = lib.ImDrawList_PrimVtx +ImDrawList.PrimWriteIdx = lib.ImDrawList_PrimWriteIdx +ImDrawList.PrimWriteVtx = lib.ImDrawList_PrimWriteVtx +function ImDrawList:PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) + intersect_with_current_clip_rect = intersect_with_current_clip_rect or false + return lib.ImDrawList_PushClipRect(self,clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) +end +ImDrawList.PushClipRectFullScreen = lib.ImDrawList_PushClipRectFullScreen +ImDrawList.PushTextureID = lib.ImDrawList_PushTextureID +ImDrawList.UpdateClipRect = lib.ImDrawList_UpdateClipRect +ImDrawList.UpdateTextureID = lib.ImDrawList_UpdateTextureID +M.ImDrawList = ffi.metatype("ImDrawList",ImDrawList) +--------------------------ImGuiTextRange---------------------------- +local ImGuiTextRange= {} +ImGuiTextRange.__index = ImGuiTextRange +function ImGuiTextRange.__new(ctype) + local ptr = lib.ImGuiTextRange_ImGuiTextRange() + return ffi.gc(ptr,lib.ImGuiTextRange_destroy) +end +function ImGuiTextRange.ImGuiTextRangeStr(_b,_e) + local ptr = lib.ImGuiTextRange_ImGuiTextRangeStr(_b,_e) + return ffi.gc(ptr,lib.ImGuiTextRange_destroy) +end +ImGuiTextRange.empty = lib.ImGuiTextRange_empty +ImGuiTextRange.split = lib.ImGuiTextRange_split +M.ImGuiTextRange = ffi.metatype("ImGuiTextRange",ImGuiTextRange) +--------------------------ImVector_ImFontConfig---------------------------- +local ImVector_ImFontConfig= {} +ImVector_ImFontConfig.__index = ImVector_ImFontConfig +function ImVector_ImFontConfig.__new(ctype) + local ptr = lib.ImVector_ImFontConfig_ImVector_ImFontConfig() + return ffi.gc(ptr,lib.ImVector_ImFontConfig_destroy) +end +function ImVector_ImFontConfig.ImVector_ImFontConfigVector(src) + local ptr = lib.ImVector_ImFontConfig_ImVector_ImFontConfigVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontConfig_destroy) +end +ImVector_ImFontConfig._grow_capacity = lib.ImVector_ImFontConfig__grow_capacity +ImVector_ImFontConfig.back = lib.ImVector_ImFontConfig_back +ImVector_ImFontConfig.back_const = lib.ImVector_ImFontConfig_back_const +ImVector_ImFontConfig.begin = lib.ImVector_ImFontConfig_begin +ImVector_ImFontConfig.begin_const = lib.ImVector_ImFontConfig_begin_const +ImVector_ImFontConfig.capacity = lib.ImVector_ImFontConfig_capacity +ImVector_ImFontConfig.clear = lib.ImVector_ImFontConfig_clear +ImVector_ImFontConfig.empty = lib.ImVector_ImFontConfig_empty +ImVector_ImFontConfig._end = lib.ImVector_ImFontConfig_end +ImVector_ImFontConfig.end_const = lib.ImVector_ImFontConfig_end_const +ImVector_ImFontConfig.erase = lib.ImVector_ImFontConfig_erase +ImVector_ImFontConfig.eraseTPtr = lib.ImVector_ImFontConfig_eraseTPtr +ImVector_ImFontConfig.erase_unsorted = lib.ImVector_ImFontConfig_erase_unsorted +ImVector_ImFontConfig.front = lib.ImVector_ImFontConfig_front +ImVector_ImFontConfig.front_const = lib.ImVector_ImFontConfig_front_const +ImVector_ImFontConfig.index_from_ptr = lib.ImVector_ImFontConfig_index_from_ptr +ImVector_ImFontConfig.insert = lib.ImVector_ImFontConfig_insert +ImVector_ImFontConfig.pop_back = lib.ImVector_ImFontConfig_pop_back +ImVector_ImFontConfig.push_back = lib.ImVector_ImFontConfig_push_back +ImVector_ImFontConfig.push_front = lib.ImVector_ImFontConfig_push_front +ImVector_ImFontConfig.reserve = lib.ImVector_ImFontConfig_reserve +ImVector_ImFontConfig.resize = lib.ImVector_ImFontConfig_resize +ImVector_ImFontConfig.resizeT = lib.ImVector_ImFontConfig_resizeT +ImVector_ImFontConfig.size = lib.ImVector_ImFontConfig_size +ImVector_ImFontConfig.size_in_bytes = lib.ImVector_ImFontConfig_size_in_bytes +ImVector_ImFontConfig.swap = lib.ImVector_ImFontConfig_swap +M.ImVector_ImFontConfig = ffi.metatype("ImVector_ImFontConfig",ImVector_ImFontConfig) +--------------------------ImVector_ImU32---------------------------- +local ImVector_ImU32= {} +ImVector_ImU32.__index = ImVector_ImU32 +function ImVector_ImU32.__new(ctype) + local ptr = lib.ImVector_ImU32_ImVector_ImU32() + return ffi.gc(ptr,lib.ImVector_ImU32_destroy) +end +function ImVector_ImU32.ImVector_ImU32Vector(src) + local ptr = lib.ImVector_ImU32_ImVector_ImU32Vector(src) + return ffi.gc(ptr,lib.ImVector_ImU32_destroy) +end +ImVector_ImU32._grow_capacity = lib.ImVector_ImU32__grow_capacity +ImVector_ImU32.back = lib.ImVector_ImU32_back +ImVector_ImU32.back_const = lib.ImVector_ImU32_back_const +ImVector_ImU32.begin = lib.ImVector_ImU32_begin +ImVector_ImU32.begin_const = lib.ImVector_ImU32_begin_const +ImVector_ImU32.capacity = lib.ImVector_ImU32_capacity +ImVector_ImU32.clear = lib.ImVector_ImU32_clear +ImVector_ImU32.empty = lib.ImVector_ImU32_empty +ImVector_ImU32._end = lib.ImVector_ImU32_end +ImVector_ImU32.end_const = lib.ImVector_ImU32_end_const +ImVector_ImU32.erase = lib.ImVector_ImU32_erase +ImVector_ImU32.eraseTPtr = lib.ImVector_ImU32_eraseTPtr +ImVector_ImU32.erase_unsorted = lib.ImVector_ImU32_erase_unsorted +ImVector_ImU32.front = lib.ImVector_ImU32_front +ImVector_ImU32.front_const = lib.ImVector_ImU32_front_const +ImVector_ImU32.index_from_ptr = lib.ImVector_ImU32_index_from_ptr +ImVector_ImU32.insert = lib.ImVector_ImU32_insert +ImVector_ImU32.pop_back = lib.ImVector_ImU32_pop_back +ImVector_ImU32.push_back = lib.ImVector_ImU32_push_back +ImVector_ImU32.push_front = lib.ImVector_ImU32_push_front +ImVector_ImU32.reserve = lib.ImVector_ImU32_reserve +ImVector_ImU32.resize = lib.ImVector_ImU32_resize +ImVector_ImU32.resizeT = lib.ImVector_ImU32_resizeT +ImVector_ImU32.size = lib.ImVector_ImU32_size +ImVector_ImU32.size_in_bytes = lib.ImVector_ImU32_size_in_bytes +ImVector_ImU32.swap = lib.ImVector_ImU32_swap +M.ImVector_ImU32 = ffi.metatype("ImVector_ImU32",ImVector_ImU32) +--------------------------ImGuiListClipper---------------------------- +local ImGuiListClipper= {} +ImGuiListClipper.__index = ImGuiListClipper +function ImGuiListClipper:Begin(items_count,items_height) + items_height = items_height or -1.0 + return lib.ImGuiListClipper_Begin(self,items_count,items_height) +end +ImGuiListClipper.End = lib.ImGuiListClipper_End +function ImGuiListClipper.__new(ctype,items_count,items_height) + if items_height == nil then items_height = -1.0 end + if items_count == nil then items_count = -1 end + local ptr = lib.ImGuiListClipper_ImGuiListClipper(items_count,items_height) + return ffi.gc(ptr,lib.ImGuiListClipper_destroy) +end +ImGuiListClipper.Step = lib.ImGuiListClipper_Step +M.ImGuiListClipper = ffi.metatype("ImGuiListClipper",ImGuiListClipper) +--------------------------ImGuiIO---------------------------- +local ImGuiIO= {} +ImGuiIO.__index = ImGuiIO +ImGuiIO.AddInputCharacter = lib.ImGuiIO_AddInputCharacter +ImGuiIO.AddInputCharactersUTF8 = lib.ImGuiIO_AddInputCharactersUTF8 +ImGuiIO.ClearInputCharacters = lib.ImGuiIO_ClearInputCharacters +function ImGuiIO.__new(ctype) + local ptr = lib.ImGuiIO_ImGuiIO() + return ffi.gc(ptr,lib.ImGuiIO_destroy) +end +M.ImGuiIO = ffi.metatype("ImGuiIO",ImGuiIO) +--------------------------ImVector_ImTextureID---------------------------- +local ImVector_ImTextureID= {} +ImVector_ImTextureID.__index = ImVector_ImTextureID +function ImVector_ImTextureID.__new(ctype) + local ptr = lib.ImVector_ImTextureID_ImVector_ImTextureID() + return ffi.gc(ptr,lib.ImVector_ImTextureID_destroy) +end +function ImVector_ImTextureID.ImVector_ImTextureIDVector(src) + local ptr = lib.ImVector_ImTextureID_ImVector_ImTextureIDVector(src) + return ffi.gc(ptr,lib.ImVector_ImTextureID_destroy) +end +ImVector_ImTextureID._grow_capacity = lib.ImVector_ImTextureID__grow_capacity +ImVector_ImTextureID.back = lib.ImVector_ImTextureID_back +ImVector_ImTextureID.back_const = lib.ImVector_ImTextureID_back_const +ImVector_ImTextureID.begin = lib.ImVector_ImTextureID_begin +ImVector_ImTextureID.begin_const = lib.ImVector_ImTextureID_begin_const +ImVector_ImTextureID.capacity = lib.ImVector_ImTextureID_capacity +ImVector_ImTextureID.clear = lib.ImVector_ImTextureID_clear +ImVector_ImTextureID.empty = lib.ImVector_ImTextureID_empty +ImVector_ImTextureID._end = lib.ImVector_ImTextureID_end +ImVector_ImTextureID.end_const = lib.ImVector_ImTextureID_end_const +ImVector_ImTextureID.erase = lib.ImVector_ImTextureID_erase +ImVector_ImTextureID.eraseTPtr = lib.ImVector_ImTextureID_eraseTPtr +ImVector_ImTextureID.erase_unsorted = lib.ImVector_ImTextureID_erase_unsorted +ImVector_ImTextureID.front = lib.ImVector_ImTextureID_front +ImVector_ImTextureID.front_const = lib.ImVector_ImTextureID_front_const +ImVector_ImTextureID.index_from_ptr = lib.ImVector_ImTextureID_index_from_ptr +ImVector_ImTextureID.insert = lib.ImVector_ImTextureID_insert +ImVector_ImTextureID.pop_back = lib.ImVector_ImTextureID_pop_back +ImVector_ImTextureID.push_back = lib.ImVector_ImTextureID_push_back +ImVector_ImTextureID.push_front = lib.ImVector_ImTextureID_push_front +ImVector_ImTextureID.reserve = lib.ImVector_ImTextureID_reserve +ImVector_ImTextureID.resize = lib.ImVector_ImTextureID_resize +ImVector_ImTextureID.resizeT = lib.ImVector_ImTextureID_resizeT +ImVector_ImTextureID.size = lib.ImVector_ImTextureID_size +ImVector_ImTextureID.size_in_bytes = lib.ImVector_ImTextureID_size_in_bytes +ImVector_ImTextureID.swap = lib.ImVector_ImTextureID_swap +M.ImVector_ImTextureID = ffi.metatype("ImVector_ImTextureID",ImVector_ImTextureID) +--------------------------ImVector_ImDrawCmd---------------------------- +local ImVector_ImDrawCmd= {} +ImVector_ImDrawCmd.__index = ImVector_ImDrawCmd +function ImVector_ImDrawCmd.__new(ctype) + local ptr = lib.ImVector_ImDrawCmd_ImVector_ImDrawCmd() + return ffi.gc(ptr,lib.ImVector_ImDrawCmd_destroy) +end +function ImVector_ImDrawCmd.ImVector_ImDrawCmdVector(src) + local ptr = lib.ImVector_ImDrawCmd_ImVector_ImDrawCmdVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawCmd_destroy) +end +ImVector_ImDrawCmd._grow_capacity = lib.ImVector_ImDrawCmd__grow_capacity +ImVector_ImDrawCmd.back = lib.ImVector_ImDrawCmd_back +ImVector_ImDrawCmd.back_const = lib.ImVector_ImDrawCmd_back_const +ImVector_ImDrawCmd.begin = lib.ImVector_ImDrawCmd_begin +ImVector_ImDrawCmd.begin_const = lib.ImVector_ImDrawCmd_begin_const +ImVector_ImDrawCmd.capacity = lib.ImVector_ImDrawCmd_capacity +ImVector_ImDrawCmd.clear = lib.ImVector_ImDrawCmd_clear +ImVector_ImDrawCmd.empty = lib.ImVector_ImDrawCmd_empty +ImVector_ImDrawCmd._end = lib.ImVector_ImDrawCmd_end +ImVector_ImDrawCmd.end_const = lib.ImVector_ImDrawCmd_end_const +ImVector_ImDrawCmd.erase = lib.ImVector_ImDrawCmd_erase +ImVector_ImDrawCmd.eraseTPtr = lib.ImVector_ImDrawCmd_eraseTPtr +ImVector_ImDrawCmd.erase_unsorted = lib.ImVector_ImDrawCmd_erase_unsorted +ImVector_ImDrawCmd.front = lib.ImVector_ImDrawCmd_front +ImVector_ImDrawCmd.front_const = lib.ImVector_ImDrawCmd_front_const +ImVector_ImDrawCmd.index_from_ptr = lib.ImVector_ImDrawCmd_index_from_ptr +ImVector_ImDrawCmd.insert = lib.ImVector_ImDrawCmd_insert +ImVector_ImDrawCmd.pop_back = lib.ImVector_ImDrawCmd_pop_back +ImVector_ImDrawCmd.push_back = lib.ImVector_ImDrawCmd_push_back +ImVector_ImDrawCmd.push_front = lib.ImVector_ImDrawCmd_push_front +ImVector_ImDrawCmd.reserve = lib.ImVector_ImDrawCmd_reserve +ImVector_ImDrawCmd.resize = lib.ImVector_ImDrawCmd_resize +ImVector_ImDrawCmd.resizeT = lib.ImVector_ImDrawCmd_resizeT +ImVector_ImDrawCmd.size = lib.ImVector_ImDrawCmd_size +ImVector_ImDrawCmd.size_in_bytes = lib.ImVector_ImDrawCmd_size_in_bytes +ImVector_ImDrawCmd.swap = lib.ImVector_ImDrawCmd_swap +M.ImVector_ImDrawCmd = ffi.metatype("ImVector_ImDrawCmd",ImVector_ImDrawCmd) +--------------------------ImGuiStorage---------------------------- +local ImGuiStorage= {} +ImGuiStorage.__index = ImGuiStorage +ImGuiStorage.BuildSortByKey = lib.ImGuiStorage_BuildSortByKey +ImGuiStorage.Clear = lib.ImGuiStorage_Clear +function ImGuiStorage:GetBool(key,default_val) + default_val = default_val or false + return lib.ImGuiStorage_GetBool(self,key,default_val) +end +function ImGuiStorage:GetBoolRef(key,default_val) + default_val = default_val or false + return lib.ImGuiStorage_GetBoolRef(self,key,default_val) +end +function ImGuiStorage:GetFloat(key,default_val) + default_val = default_val or 0.0 + return lib.ImGuiStorage_GetFloat(self,key,default_val) +end +function ImGuiStorage:GetFloatRef(key,default_val) + default_val = default_val or 0.0 + return lib.ImGuiStorage_GetFloatRef(self,key,default_val) +end +function ImGuiStorage:GetInt(key,default_val) + default_val = default_val or 0 + return lib.ImGuiStorage_GetInt(self,key,default_val) +end +function ImGuiStorage:GetIntRef(key,default_val) + default_val = default_val or 0 + return lib.ImGuiStorage_GetIntRef(self,key,default_val) +end +ImGuiStorage.GetVoidPtr = lib.ImGuiStorage_GetVoidPtr +function ImGuiStorage:GetVoidPtrRef(key,default_val) + default_val = default_val or nil + return lib.ImGuiStorage_GetVoidPtrRef(self,key,default_val) +end +ImGuiStorage.SetAllInt = lib.ImGuiStorage_SetAllInt +ImGuiStorage.SetBool = lib.ImGuiStorage_SetBool +ImGuiStorage.SetFloat = lib.ImGuiStorage_SetFloat +ImGuiStorage.SetInt = lib.ImGuiStorage_SetInt +ImGuiStorage.SetVoidPtr = lib.ImGuiStorage_SetVoidPtr +M.ImGuiStorage = ffi.metatype("ImGuiStorage",ImGuiStorage) +--------------------------ImFontAtlasCustomRect---------------------------- +local ImFontAtlasCustomRect= {} +ImFontAtlasCustomRect.__index = ImFontAtlasCustomRect +function ImFontAtlasCustomRect.__new(ctype) + local ptr = lib.ImFontAtlasCustomRect_ImFontAtlasCustomRect() + return ffi.gc(ptr,lib.ImFontAtlasCustomRect_destroy) +end +ImFontAtlasCustomRect.IsPacked = lib.ImFontAtlasCustomRect_IsPacked +M.ImFontAtlasCustomRect = ffi.metatype("ImFontAtlasCustomRect",ImFontAtlasCustomRect) +--------------------------ImVector_ImWchar---------------------------- +local ImVector_ImWchar= {} +ImVector_ImWchar.__index = ImVector_ImWchar +function ImVector_ImWchar.__new(ctype) + local ptr = lib.ImVector_ImWchar_ImVector_ImWchar() + return ffi.gc(ptr,lib.ImVector_ImWchar_destroy) +end +function ImVector_ImWchar.ImVector_ImWcharVector(src) + local ptr = lib.ImVector_ImWchar_ImVector_ImWcharVector(src) + return ffi.gc(ptr,lib.ImVector_ImWchar_destroy) +end +ImVector_ImWchar._grow_capacity = lib.ImVector_ImWchar__grow_capacity +ImVector_ImWchar.back = lib.ImVector_ImWchar_back +ImVector_ImWchar.back_const = lib.ImVector_ImWchar_back_const +ImVector_ImWchar.begin = lib.ImVector_ImWchar_begin +ImVector_ImWchar.begin_const = lib.ImVector_ImWchar_begin_const +ImVector_ImWchar.capacity = lib.ImVector_ImWchar_capacity +ImVector_ImWchar.clear = lib.ImVector_ImWchar_clear +ImVector_ImWchar.contains = lib.ImVector_ImWchar_contains +ImVector_ImWchar.empty = lib.ImVector_ImWchar_empty +ImVector_ImWchar._end = lib.ImVector_ImWchar_end +ImVector_ImWchar.end_const = lib.ImVector_ImWchar_end_const +ImVector_ImWchar.erase = lib.ImVector_ImWchar_erase +ImVector_ImWchar.eraseTPtr = lib.ImVector_ImWchar_eraseTPtr +ImVector_ImWchar.erase_unsorted = lib.ImVector_ImWchar_erase_unsorted +ImVector_ImWchar.front = lib.ImVector_ImWchar_front +ImVector_ImWchar.front_const = lib.ImVector_ImWchar_front_const +ImVector_ImWchar.index_from_ptr = lib.ImVector_ImWchar_index_from_ptr +ImVector_ImWchar.insert = lib.ImVector_ImWchar_insert +ImVector_ImWchar.pop_back = lib.ImVector_ImWchar_pop_back +ImVector_ImWchar.push_back = lib.ImVector_ImWchar_push_back +ImVector_ImWchar.push_front = lib.ImVector_ImWchar_push_front +ImVector_ImWchar.reserve = lib.ImVector_ImWchar_reserve +ImVector_ImWchar.resize = lib.ImVector_ImWchar_resize +ImVector_ImWchar.resizeT = lib.ImVector_ImWchar_resizeT +ImVector_ImWchar.size = lib.ImVector_ImWchar_size +ImVector_ImWchar.size_in_bytes = lib.ImVector_ImWchar_size_in_bytes +ImVector_ImWchar.swap = lib.ImVector_ImWchar_swap +M.ImVector_ImWchar = ffi.metatype("ImVector_ImWchar",ImVector_ImWchar) +--------------------------ImVector_char---------------------------- +local ImVector_char= {} +ImVector_char.__index = ImVector_char +function ImVector_char.__new(ctype) + local ptr = lib.ImVector_char_ImVector_char() + return ffi.gc(ptr,lib.ImVector_char_destroy) +end +function ImVector_char.ImVector_charVector(src) + local ptr = lib.ImVector_char_ImVector_charVector(src) + return ffi.gc(ptr,lib.ImVector_char_destroy) +end +ImVector_char._grow_capacity = lib.ImVector_char__grow_capacity +ImVector_char.back = lib.ImVector_char_back +ImVector_char.back_const = lib.ImVector_char_back_const +ImVector_char.begin = lib.ImVector_char_begin +ImVector_char.begin_const = lib.ImVector_char_begin_const +ImVector_char.capacity = lib.ImVector_char_capacity +ImVector_char.clear = lib.ImVector_char_clear +ImVector_char.contains = lib.ImVector_char_contains +ImVector_char.empty = lib.ImVector_char_empty +ImVector_char._end = lib.ImVector_char_end +ImVector_char.end_const = lib.ImVector_char_end_const +ImVector_char.erase = lib.ImVector_char_erase +ImVector_char.eraseTPtr = lib.ImVector_char_eraseTPtr +ImVector_char.erase_unsorted = lib.ImVector_char_erase_unsorted +ImVector_char.front = lib.ImVector_char_front +ImVector_char.front_const = lib.ImVector_char_front_const +ImVector_char.index_from_ptr = lib.ImVector_char_index_from_ptr +ImVector_char.insert = lib.ImVector_char_insert +ImVector_char.pop_back = lib.ImVector_char_pop_back +ImVector_char.push_back = lib.ImVector_char_push_back +ImVector_char.push_front = lib.ImVector_char_push_front +ImVector_char.reserve = lib.ImVector_char_reserve +ImVector_char.resize = lib.ImVector_char_resize +ImVector_char.resizeT = lib.ImVector_char_resizeT +ImVector_char.size = lib.ImVector_char_size +ImVector_char.size_in_bytes = lib.ImVector_char_size_in_bytes +ImVector_char.swap = lib.ImVector_char_swap +M.ImVector_char = ffi.metatype("ImVector_char",ImVector_char) +--------------------------ImGuiStoragePair---------------------------- +local ImGuiStoragePair= {} +ImGuiStoragePair.__index = ImGuiStoragePair +function ImGuiStoragePair.ImGuiStoragePairInt(_key,_val_i) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairInt(_key,_val_i) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +function ImGuiStoragePair.ImGuiStoragePairFloat(_key,_val_f) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairFloat(_key,_val_f) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +function ImGuiStoragePair.ImGuiStoragePairPtr(_key,_val_p) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairPtr(_key,_val_p) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +M.ImGuiStoragePair = ffi.metatype("ImGuiStoragePair",ImGuiStoragePair) +--------------------------ImFont---------------------------- +local ImFont= {} +ImFont.__index = ImFont +ImFont.AddGlyph = lib.ImFont_AddGlyph +function ImFont:AddRemapChar(dst,src,overwrite_dst) + if overwrite_dst == nil then overwrite_dst = true end + return lib.ImFont_AddRemapChar(self,dst,src,overwrite_dst) +end +ImFont.BuildLookupTable = lib.ImFont_BuildLookupTable +function ImFont:CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining) + text_end = text_end or nil + remaining = remaining or nil + local nonUDT_out = ffi.new("ImVec2") + lib.ImFont_CalcTextSizeA_nonUDT(nonUDT_out,self,size,max_width,wrap_width,text_begin,text_end,remaining) + return nonUDT_out +end +function ImFont:CalcTextSizeA_nonUDT2(size,max_width,wrap_width,text_begin,text_end,remaining) + text_end = text_end or nil + remaining = remaining or nil + return lib.ImFont_CalcTextSizeA_nonUDT2(self,size,max_width,wrap_width,text_begin,text_end,remaining) +end +ImFont.CalcWordWrapPositionA = lib.ImFont_CalcWordWrapPositionA +ImFont.ClearOutputData = lib.ImFont_ClearOutputData +ImFont.FindGlyph = lib.ImFont_FindGlyph +ImFont.FindGlyphNoFallback = lib.ImFont_FindGlyphNoFallback +ImFont.GetCharAdvance = lib.ImFont_GetCharAdvance +ImFont.GetDebugName = lib.ImFont_GetDebugName +ImFont.GrowIndex = lib.ImFont_GrowIndex +function ImFont.__new(ctype) + local ptr = lib.ImFont_ImFont() + return ffi.gc(ptr,lib.ImFont_destroy) +end +ImFont.IsLoaded = lib.ImFont_IsLoaded +ImFont.RenderChar = lib.ImFont_RenderChar +function ImFont:RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip) + wrap_width = wrap_width or 0.0 + cpu_fine_clip = cpu_fine_clip or false + return lib.ImFont_RenderText(self,draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip) +end +ImFont.SetFallbackChar = lib.ImFont_SetFallbackChar +M.ImFont = ffi.metatype("ImFont",ImFont) +--------------------------ImGuiOnceUponAFrame---------------------------- +local ImGuiOnceUponAFrame= {} +ImGuiOnceUponAFrame.__index = ImGuiOnceUponAFrame +function ImGuiOnceUponAFrame.__new(ctype) + local ptr = lib.ImGuiOnceUponAFrame_ImGuiOnceUponAFrame() + return ffi.gc(ptr,lib.ImGuiOnceUponAFrame_destroy) +end +M.ImGuiOnceUponAFrame = ffi.metatype("ImGuiOnceUponAFrame",ImGuiOnceUponAFrame) +--------------------------ImVector_ImVec4---------------------------- +local ImVector_ImVec4= {} +ImVector_ImVec4.__index = ImVector_ImVec4 +function ImVector_ImVec4.__new(ctype) + local ptr = lib.ImVector_ImVec4_ImVector_ImVec4() + return ffi.gc(ptr,lib.ImVector_ImVec4_destroy) +end +function ImVector_ImVec4.ImVector_ImVec4Vector(src) + local ptr = lib.ImVector_ImVec4_ImVector_ImVec4Vector(src) + return ffi.gc(ptr,lib.ImVector_ImVec4_destroy) +end +ImVector_ImVec4._grow_capacity = lib.ImVector_ImVec4__grow_capacity +ImVector_ImVec4.back = lib.ImVector_ImVec4_back +ImVector_ImVec4.back_const = lib.ImVector_ImVec4_back_const +ImVector_ImVec4.begin = lib.ImVector_ImVec4_begin +ImVector_ImVec4.begin_const = lib.ImVector_ImVec4_begin_const +ImVector_ImVec4.capacity = lib.ImVector_ImVec4_capacity +ImVector_ImVec4.clear = lib.ImVector_ImVec4_clear +ImVector_ImVec4.empty = lib.ImVector_ImVec4_empty +ImVector_ImVec4._end = lib.ImVector_ImVec4_end +ImVector_ImVec4.end_const = lib.ImVector_ImVec4_end_const +ImVector_ImVec4.erase = lib.ImVector_ImVec4_erase +ImVector_ImVec4.eraseTPtr = lib.ImVector_ImVec4_eraseTPtr +ImVector_ImVec4.erase_unsorted = lib.ImVector_ImVec4_erase_unsorted +ImVector_ImVec4.front = lib.ImVector_ImVec4_front +ImVector_ImVec4.front_const = lib.ImVector_ImVec4_front_const +ImVector_ImVec4.index_from_ptr = lib.ImVector_ImVec4_index_from_ptr +ImVector_ImVec4.insert = lib.ImVector_ImVec4_insert +ImVector_ImVec4.pop_back = lib.ImVector_ImVec4_pop_back +ImVector_ImVec4.push_back = lib.ImVector_ImVec4_push_back +ImVector_ImVec4.push_front = lib.ImVector_ImVec4_push_front +ImVector_ImVec4.reserve = lib.ImVector_ImVec4_reserve +ImVector_ImVec4.resize = lib.ImVector_ImVec4_resize +ImVector_ImVec4.resizeT = lib.ImVector_ImVec4_resizeT +ImVector_ImVec4.size = lib.ImVector_ImVec4_size +ImVector_ImVec4.size_in_bytes = lib.ImVector_ImVec4_size_in_bytes +ImVector_ImVec4.swap = lib.ImVector_ImVec4_swap +M.ImVector_ImVec4 = ffi.metatype("ImVector_ImVec4",ImVector_ImVec4) +--------------------------ImVector_ImDrawIdx---------------------------- +local ImVector_ImDrawIdx= {} +ImVector_ImDrawIdx.__index = ImVector_ImDrawIdx +function ImVector_ImDrawIdx.__new(ctype) + local ptr = lib.ImVector_ImDrawIdx_ImVector_ImDrawIdx() + return ffi.gc(ptr,lib.ImVector_ImDrawIdx_destroy) +end +function ImVector_ImDrawIdx.ImVector_ImDrawIdxVector(src) + local ptr = lib.ImVector_ImDrawIdx_ImVector_ImDrawIdxVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawIdx_destroy) +end +ImVector_ImDrawIdx._grow_capacity = lib.ImVector_ImDrawIdx__grow_capacity +ImVector_ImDrawIdx.back = lib.ImVector_ImDrawIdx_back +ImVector_ImDrawIdx.back_const = lib.ImVector_ImDrawIdx_back_const +ImVector_ImDrawIdx.begin = lib.ImVector_ImDrawIdx_begin +ImVector_ImDrawIdx.begin_const = lib.ImVector_ImDrawIdx_begin_const +ImVector_ImDrawIdx.capacity = lib.ImVector_ImDrawIdx_capacity +ImVector_ImDrawIdx.clear = lib.ImVector_ImDrawIdx_clear +ImVector_ImDrawIdx.empty = lib.ImVector_ImDrawIdx_empty +ImVector_ImDrawIdx._end = lib.ImVector_ImDrawIdx_end +ImVector_ImDrawIdx.end_const = lib.ImVector_ImDrawIdx_end_const +ImVector_ImDrawIdx.erase = lib.ImVector_ImDrawIdx_erase +ImVector_ImDrawIdx.eraseTPtr = lib.ImVector_ImDrawIdx_eraseTPtr +ImVector_ImDrawIdx.erase_unsorted = lib.ImVector_ImDrawIdx_erase_unsorted +ImVector_ImDrawIdx.front = lib.ImVector_ImDrawIdx_front +ImVector_ImDrawIdx.front_const = lib.ImVector_ImDrawIdx_front_const +ImVector_ImDrawIdx.index_from_ptr = lib.ImVector_ImDrawIdx_index_from_ptr +ImVector_ImDrawIdx.insert = lib.ImVector_ImDrawIdx_insert +ImVector_ImDrawIdx.pop_back = lib.ImVector_ImDrawIdx_pop_back +ImVector_ImDrawIdx.push_back = lib.ImVector_ImDrawIdx_push_back +ImVector_ImDrawIdx.push_front = lib.ImVector_ImDrawIdx_push_front +ImVector_ImDrawIdx.reserve = lib.ImVector_ImDrawIdx_reserve +ImVector_ImDrawIdx.resize = lib.ImVector_ImDrawIdx_resize +ImVector_ImDrawIdx.resizeT = lib.ImVector_ImDrawIdx_resizeT +ImVector_ImDrawIdx.size = lib.ImVector_ImDrawIdx_size +ImVector_ImDrawIdx.size_in_bytes = lib.ImVector_ImDrawIdx_size_in_bytes +ImVector_ImDrawIdx.swap = lib.ImVector_ImDrawIdx_swap +M.ImVector_ImDrawIdx = ffi.metatype("ImVector_ImDrawIdx",ImVector_ImDrawIdx) +--------------------------ImVector_ImGuiTextRange---------------------------- +local ImVector_ImGuiTextRange= {} +ImVector_ImGuiTextRange.__index = ImVector_ImGuiTextRange +function ImVector_ImGuiTextRange.__new(ctype) + local ptr = lib.ImVector_ImGuiTextRange_ImVector_ImGuiTextRange() + return ffi.gc(ptr,lib.ImVector_ImGuiTextRange_destroy) +end +function ImVector_ImGuiTextRange.ImVector_ImGuiTextRangeVector(src) + local ptr = lib.ImVector_ImGuiTextRange_ImVector_ImGuiTextRangeVector(src) + return ffi.gc(ptr,lib.ImVector_ImGuiTextRange_destroy) +end +ImVector_ImGuiTextRange._grow_capacity = lib.ImVector_ImGuiTextRange__grow_capacity +ImVector_ImGuiTextRange.back = lib.ImVector_ImGuiTextRange_back +ImVector_ImGuiTextRange.back_const = lib.ImVector_ImGuiTextRange_back_const +ImVector_ImGuiTextRange.begin = lib.ImVector_ImGuiTextRange_begin +ImVector_ImGuiTextRange.begin_const = lib.ImVector_ImGuiTextRange_begin_const +ImVector_ImGuiTextRange.capacity = lib.ImVector_ImGuiTextRange_capacity +ImVector_ImGuiTextRange.clear = lib.ImVector_ImGuiTextRange_clear +ImVector_ImGuiTextRange.empty = lib.ImVector_ImGuiTextRange_empty +ImVector_ImGuiTextRange._end = lib.ImVector_ImGuiTextRange_end +ImVector_ImGuiTextRange.end_const = lib.ImVector_ImGuiTextRange_end_const +ImVector_ImGuiTextRange.erase = lib.ImVector_ImGuiTextRange_erase +ImVector_ImGuiTextRange.eraseTPtr = lib.ImVector_ImGuiTextRange_eraseTPtr +ImVector_ImGuiTextRange.erase_unsorted = lib.ImVector_ImGuiTextRange_erase_unsorted +ImVector_ImGuiTextRange.front = lib.ImVector_ImGuiTextRange_front +ImVector_ImGuiTextRange.front_const = lib.ImVector_ImGuiTextRange_front_const +ImVector_ImGuiTextRange.index_from_ptr = lib.ImVector_ImGuiTextRange_index_from_ptr +ImVector_ImGuiTextRange.insert = lib.ImVector_ImGuiTextRange_insert +ImVector_ImGuiTextRange.pop_back = lib.ImVector_ImGuiTextRange_pop_back +ImVector_ImGuiTextRange.push_back = lib.ImVector_ImGuiTextRange_push_back +ImVector_ImGuiTextRange.push_front = lib.ImVector_ImGuiTextRange_push_front +ImVector_ImGuiTextRange.reserve = lib.ImVector_ImGuiTextRange_reserve +ImVector_ImGuiTextRange.resize = lib.ImVector_ImGuiTextRange_resize +ImVector_ImGuiTextRange.resizeT = lib.ImVector_ImGuiTextRange_resizeT +ImVector_ImGuiTextRange.size = lib.ImVector_ImGuiTextRange_size +ImVector_ImGuiTextRange.size_in_bytes = lib.ImVector_ImGuiTextRange_size_in_bytes +ImVector_ImGuiTextRange.swap = lib.ImVector_ImGuiTextRange_swap +M.ImVector_ImGuiTextRange = ffi.metatype("ImVector_ImGuiTextRange",ImVector_ImGuiTextRange) +--------------------------ImVector_float---------------------------- +local ImVector_float= {} +ImVector_float.__index = ImVector_float +function ImVector_float.__new(ctype) + local ptr = lib.ImVector_float_ImVector_float() + return ffi.gc(ptr,lib.ImVector_float_destroy) +end +function ImVector_float.ImVector_floatVector(src) + local ptr = lib.ImVector_float_ImVector_floatVector(src) + return ffi.gc(ptr,lib.ImVector_float_destroy) +end +ImVector_float._grow_capacity = lib.ImVector_float__grow_capacity +ImVector_float.back = lib.ImVector_float_back +ImVector_float.back_const = lib.ImVector_float_back_const +ImVector_float.begin = lib.ImVector_float_begin +ImVector_float.begin_const = lib.ImVector_float_begin_const +ImVector_float.capacity = lib.ImVector_float_capacity +ImVector_float.clear = lib.ImVector_float_clear +ImVector_float.contains = lib.ImVector_float_contains +ImVector_float.empty = lib.ImVector_float_empty +ImVector_float._end = lib.ImVector_float_end +ImVector_float.end_const = lib.ImVector_float_end_const +ImVector_float.erase = lib.ImVector_float_erase +ImVector_float.eraseTPtr = lib.ImVector_float_eraseTPtr +ImVector_float.erase_unsorted = lib.ImVector_float_erase_unsorted +ImVector_float.front = lib.ImVector_float_front +ImVector_float.front_const = lib.ImVector_float_front_const +ImVector_float.index_from_ptr = lib.ImVector_float_index_from_ptr +ImVector_float.insert = lib.ImVector_float_insert +ImVector_float.pop_back = lib.ImVector_float_pop_back +ImVector_float.push_back = lib.ImVector_float_push_back +ImVector_float.push_front = lib.ImVector_float_push_front +ImVector_float.reserve = lib.ImVector_float_reserve +ImVector_float.resize = lib.ImVector_float_resize +ImVector_float.resizeT = lib.ImVector_float_resizeT +ImVector_float.size = lib.ImVector_float_size +ImVector_float.size_in_bytes = lib.ImVector_float_size_in_bytes +ImVector_float.swap = lib.ImVector_float_swap +M.ImVector_float = ffi.metatype("ImVector_float",ImVector_float) +--------------------------ImGuiInputTextCallbackData---------------------------- +local ImGuiInputTextCallbackData= {} +ImGuiInputTextCallbackData.__index = ImGuiInputTextCallbackData +ImGuiInputTextCallbackData.DeleteChars = lib.ImGuiInputTextCallbackData_DeleteChars +ImGuiInputTextCallbackData.HasSelection = lib.ImGuiInputTextCallbackData_HasSelection +function ImGuiInputTextCallbackData.__new(ctype) + local ptr = lib.ImGuiInputTextCallbackData_ImGuiInputTextCallbackData() + return ffi.gc(ptr,lib.ImGuiInputTextCallbackData_destroy) +end +function ImGuiInputTextCallbackData:InsertChars(pos,text,text_end) + text_end = text_end or nil + return lib.ImGuiInputTextCallbackData_InsertChars(self,pos,text,text_end) +end +M.ImGuiInputTextCallbackData = ffi.metatype("ImGuiInputTextCallbackData",ImGuiInputTextCallbackData) +--------------------------ImGuiPayload---------------------------- +local ImGuiPayload= {} +ImGuiPayload.__index = ImGuiPayload +ImGuiPayload.Clear = lib.ImGuiPayload_Clear +function ImGuiPayload.__new(ctype) + local ptr = lib.ImGuiPayload_ImGuiPayload() + return ffi.gc(ptr,lib.ImGuiPayload_destroy) +end +ImGuiPayload.IsDataType = lib.ImGuiPayload_IsDataType +ImGuiPayload.IsDelivery = lib.ImGuiPayload_IsDelivery +ImGuiPayload.IsPreview = lib.ImGuiPayload_IsPreview +M.ImGuiPayload = ffi.metatype("ImGuiPayload",ImGuiPayload) +--------------------------ImDrawCmd---------------------------- +local ImDrawCmd= {} +ImDrawCmd.__index = ImDrawCmd +function ImDrawCmd.__new(ctype) + local ptr = lib.ImDrawCmd_ImDrawCmd() + return ffi.gc(ptr,lib.ImDrawCmd_destroy) +end +M.ImDrawCmd = ffi.metatype("ImDrawCmd",ImDrawCmd) +--------------------------ImVector_ImFontGlyph---------------------------- +local ImVector_ImFontGlyph= {} +ImVector_ImFontGlyph.__index = ImVector_ImFontGlyph +function ImVector_ImFontGlyph.__new(ctype) + local ptr = lib.ImVector_ImFontGlyph_ImVector_ImFontGlyph() + return ffi.gc(ptr,lib.ImVector_ImFontGlyph_destroy) +end +function ImVector_ImFontGlyph.ImVector_ImFontGlyphVector(src) + local ptr = lib.ImVector_ImFontGlyph_ImVector_ImFontGlyphVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontGlyph_destroy) +end +ImVector_ImFontGlyph._grow_capacity = lib.ImVector_ImFontGlyph__grow_capacity +ImVector_ImFontGlyph.back = lib.ImVector_ImFontGlyph_back +ImVector_ImFontGlyph.back_const = lib.ImVector_ImFontGlyph_back_const +ImVector_ImFontGlyph.begin = lib.ImVector_ImFontGlyph_begin +ImVector_ImFontGlyph.begin_const = lib.ImVector_ImFontGlyph_begin_const +ImVector_ImFontGlyph.capacity = lib.ImVector_ImFontGlyph_capacity +ImVector_ImFontGlyph.clear = lib.ImVector_ImFontGlyph_clear +ImVector_ImFontGlyph.empty = lib.ImVector_ImFontGlyph_empty +ImVector_ImFontGlyph._end = lib.ImVector_ImFontGlyph_end +ImVector_ImFontGlyph.end_const = lib.ImVector_ImFontGlyph_end_const +ImVector_ImFontGlyph.erase = lib.ImVector_ImFontGlyph_erase +ImVector_ImFontGlyph.eraseTPtr = lib.ImVector_ImFontGlyph_eraseTPtr +ImVector_ImFontGlyph.erase_unsorted = lib.ImVector_ImFontGlyph_erase_unsorted +ImVector_ImFontGlyph.front = lib.ImVector_ImFontGlyph_front +ImVector_ImFontGlyph.front_const = lib.ImVector_ImFontGlyph_front_const +ImVector_ImFontGlyph.index_from_ptr = lib.ImVector_ImFontGlyph_index_from_ptr +ImVector_ImFontGlyph.insert = lib.ImVector_ImFontGlyph_insert +ImVector_ImFontGlyph.pop_back = lib.ImVector_ImFontGlyph_pop_back +ImVector_ImFontGlyph.push_back = lib.ImVector_ImFontGlyph_push_back +ImVector_ImFontGlyph.push_front = lib.ImVector_ImFontGlyph_push_front +ImVector_ImFontGlyph.reserve = lib.ImVector_ImFontGlyph_reserve +ImVector_ImFontGlyph.resize = lib.ImVector_ImFontGlyph_resize +ImVector_ImFontGlyph.resizeT = lib.ImVector_ImFontGlyph_resizeT +ImVector_ImFontGlyph.size = lib.ImVector_ImFontGlyph_size +ImVector_ImFontGlyph.size_in_bytes = lib.ImVector_ImFontGlyph_size_in_bytes +ImVector_ImFontGlyph.swap = lib.ImVector_ImFontGlyph_swap +M.ImVector_ImFontGlyph = ffi.metatype("ImVector_ImFontGlyph",ImVector_ImFontGlyph) +--------------------------ImGuiTextFilter---------------------------- +local ImGuiTextFilter= {} +ImGuiTextFilter.__index = ImGuiTextFilter +ImGuiTextFilter.Build = lib.ImGuiTextFilter_Build +ImGuiTextFilter.Clear = lib.ImGuiTextFilter_Clear +function ImGuiTextFilter:Draw(label,width) + label = label or "Filter(inc,-exc)" + width = width or 0.0 + return lib.ImGuiTextFilter_Draw(self,label,width) +end +function ImGuiTextFilter.__new(ctype,default_filter) + if default_filter == nil then default_filter = "" end + local ptr = lib.ImGuiTextFilter_ImGuiTextFilter(default_filter) + return ffi.gc(ptr,lib.ImGuiTextFilter_destroy) +end +ImGuiTextFilter.IsActive = lib.ImGuiTextFilter_IsActive +function ImGuiTextFilter:PassFilter(text,text_end) + text_end = text_end or nil + return lib.ImGuiTextFilter_PassFilter(self,text,text_end) +end +M.ImGuiTextFilter = ffi.metatype("ImGuiTextFilter",ImGuiTextFilter) +--------------------------ImVector_ImGuiStoragePair---------------------------- +local ImVector_ImGuiStoragePair= {} +ImVector_ImGuiStoragePair.__index = ImVector_ImGuiStoragePair +function ImVector_ImGuiStoragePair.__new(ctype) + local ptr = lib.ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePair() + return ffi.gc(ptr,lib.ImVector_ImGuiStoragePair_destroy) +end +function ImVector_ImGuiStoragePair.ImVector_ImGuiStoragePairVector(src) + local ptr = lib.ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePairVector(src) + return ffi.gc(ptr,lib.ImVector_ImGuiStoragePair_destroy) +end +ImVector_ImGuiStoragePair._grow_capacity = lib.ImVector_ImGuiStoragePair__grow_capacity +ImVector_ImGuiStoragePair.back = lib.ImVector_ImGuiStoragePair_back +ImVector_ImGuiStoragePair.back_const = lib.ImVector_ImGuiStoragePair_back_const +ImVector_ImGuiStoragePair.begin = lib.ImVector_ImGuiStoragePair_begin +ImVector_ImGuiStoragePair.begin_const = lib.ImVector_ImGuiStoragePair_begin_const +ImVector_ImGuiStoragePair.capacity = lib.ImVector_ImGuiStoragePair_capacity +ImVector_ImGuiStoragePair.clear = lib.ImVector_ImGuiStoragePair_clear +ImVector_ImGuiStoragePair.empty = lib.ImVector_ImGuiStoragePair_empty +ImVector_ImGuiStoragePair._end = lib.ImVector_ImGuiStoragePair_end +ImVector_ImGuiStoragePair.end_const = lib.ImVector_ImGuiStoragePair_end_const +ImVector_ImGuiStoragePair.erase = lib.ImVector_ImGuiStoragePair_erase +ImVector_ImGuiStoragePair.eraseTPtr = lib.ImVector_ImGuiStoragePair_eraseTPtr +ImVector_ImGuiStoragePair.erase_unsorted = lib.ImVector_ImGuiStoragePair_erase_unsorted +ImVector_ImGuiStoragePair.front = lib.ImVector_ImGuiStoragePair_front +ImVector_ImGuiStoragePair.front_const = lib.ImVector_ImGuiStoragePair_front_const +ImVector_ImGuiStoragePair.index_from_ptr = lib.ImVector_ImGuiStoragePair_index_from_ptr +ImVector_ImGuiStoragePair.insert = lib.ImVector_ImGuiStoragePair_insert +ImVector_ImGuiStoragePair.pop_back = lib.ImVector_ImGuiStoragePair_pop_back +ImVector_ImGuiStoragePair.push_back = lib.ImVector_ImGuiStoragePair_push_back +ImVector_ImGuiStoragePair.push_front = lib.ImVector_ImGuiStoragePair_push_front +ImVector_ImGuiStoragePair.reserve = lib.ImVector_ImGuiStoragePair_reserve +ImVector_ImGuiStoragePair.resize = lib.ImVector_ImGuiStoragePair_resize +ImVector_ImGuiStoragePair.resizeT = lib.ImVector_ImGuiStoragePair_resizeT +ImVector_ImGuiStoragePair.size = lib.ImVector_ImGuiStoragePair_size +ImVector_ImGuiStoragePair.size_in_bytes = lib.ImVector_ImGuiStoragePair_size_in_bytes +ImVector_ImGuiStoragePair.swap = lib.ImVector_ImGuiStoragePair_swap +M.ImVector_ImGuiStoragePair = ffi.metatype("ImVector_ImGuiStoragePair",ImVector_ImGuiStoragePair) +--------------------------ImFontAtlas---------------------------- +local ImFontAtlas= {} +ImFontAtlas.__index = ImFontAtlas +function ImFontAtlas:AddCustomRectFontGlyph(font,id,width,height,advance_x,offset) + offset = offset or ImVec2(0,0) + return lib.ImFontAtlas_AddCustomRectFontGlyph(self,font,id,width,height,advance_x,offset) +end +ImFontAtlas.AddCustomRectRegular = lib.ImFontAtlas_AddCustomRectRegular +ImFontAtlas.AddFont = lib.ImFontAtlas_AddFont +function ImFontAtlas:AddFontDefault(font_cfg) + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontDefault(self,font_cfg) +end +function ImFontAtlas:AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromFileTTF(self,filename,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(self,compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryCompressedTTF(self,compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryTTF(self,font_data,font_size,size_pixels,font_cfg,glyph_ranges) +end +ImFontAtlas.Build = lib.ImFontAtlas_Build +ImFontAtlas.CalcCustomRectUV = lib.ImFontAtlas_CalcCustomRectUV +ImFontAtlas.Clear = lib.ImFontAtlas_Clear +ImFontAtlas.ClearFonts = lib.ImFontAtlas_ClearFonts +ImFontAtlas.ClearInputData = lib.ImFontAtlas_ClearInputData +ImFontAtlas.ClearTexData = lib.ImFontAtlas_ClearTexData +ImFontAtlas.GetCustomRectByIndex = lib.ImFontAtlas_GetCustomRectByIndex +ImFontAtlas.GetGlyphRangesChineseFull = lib.ImFontAtlas_GetGlyphRangesChineseFull +ImFontAtlas.GetGlyphRangesChineseSimplifiedCommon = lib.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon +ImFontAtlas.GetGlyphRangesCyrillic = lib.ImFontAtlas_GetGlyphRangesCyrillic +ImFontAtlas.GetGlyphRangesDefault = lib.ImFontAtlas_GetGlyphRangesDefault +ImFontAtlas.GetGlyphRangesJapanese = lib.ImFontAtlas_GetGlyphRangesJapanese +ImFontAtlas.GetGlyphRangesKorean = lib.ImFontAtlas_GetGlyphRangesKorean +ImFontAtlas.GetGlyphRangesThai = lib.ImFontAtlas_GetGlyphRangesThai +ImFontAtlas.GetGlyphRangesVietnamese = lib.ImFontAtlas_GetGlyphRangesVietnamese +ImFontAtlas.GetMouseCursorTexData = lib.ImFontAtlas_GetMouseCursorTexData +function ImFontAtlas:GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel) + out_bytes_per_pixel = out_bytes_per_pixel or nil + return lib.ImFontAtlas_GetTexDataAsAlpha8(self,out_pixels,out_width,out_height,out_bytes_per_pixel) +end +function ImFontAtlas:GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel) + out_bytes_per_pixel = out_bytes_per_pixel or nil + return lib.ImFontAtlas_GetTexDataAsRGBA32(self,out_pixels,out_width,out_height,out_bytes_per_pixel) +end +function ImFontAtlas.__new(ctype) + local ptr = lib.ImFontAtlas_ImFontAtlas() + return ffi.gc(ptr,lib.ImFontAtlas_destroy) +end +ImFontAtlas.IsBuilt = lib.ImFontAtlas_IsBuilt +ImFontAtlas.SetTexID = lib.ImFontAtlas_SetTexID +M.ImFontAtlas = ffi.metatype("ImFontAtlas",ImFontAtlas) +------------------------------------------------------ +function M.AcceptDragDropPayload(type,flags) + flags = flags or 0 + return lib.igAcceptDragDropPayload(type,flags) +end +M.AlignTextToFramePadding = lib.igAlignTextToFramePadding +M.ArrowButton = lib.igArrowButton +function M.Begin(name,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBegin(name,p_open,flags) +end +function M.BeginChild(str_id,size,border,flags) + border = border or false + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igBeginChild(str_id,size,border,flags) +end +function M.BeginChildID(id,size,border,flags) + border = border or false + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igBeginChildID(id,size,border,flags) +end +function M.BeginChildFrame(id,size,flags) + flags = flags or 0 + return lib.igBeginChildFrame(id,size,flags) +end +function M.BeginCombo(label,preview_value,flags) + flags = flags or 0 + return lib.igBeginCombo(label,preview_value,flags) +end +function M.BeginDragDropSource(flags) + flags = flags or 0 + return lib.igBeginDragDropSource(flags) +end +M.BeginDragDropTarget = lib.igBeginDragDropTarget +M.BeginGroup = lib.igBeginGroup +M.BeginMainMenuBar = lib.igBeginMainMenuBar +function M.BeginMenu(label,enabled) + if enabled == nil then enabled = true end + return lib.igBeginMenu(label,enabled) +end +M.BeginMenuBar = lib.igBeginMenuBar +function M.BeginPopup(str_id,flags) + flags = flags or 0 + return lib.igBeginPopup(str_id,flags) +end +function M.BeginPopupContextItem(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextItem(str_id,mouse_button) +end +function M.BeginPopupContextVoid(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextVoid(str_id,mouse_button) +end +function M.BeginPopupContextWindow(str_id,mouse_button,also_over_items) + if also_over_items == nil then also_over_items = true end + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextWindow(str_id,mouse_button,also_over_items) +end +function M.BeginPopupModal(name,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBeginPopupModal(name,p_open,flags) +end +function M.BeginTabBar(str_id,flags) + flags = flags or 0 + return lib.igBeginTabBar(str_id,flags) +end +function M.BeginTabItem(label,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBeginTabItem(label,p_open,flags) +end +M.BeginTooltip = lib.igBeginTooltip +M.Bullet = lib.igBullet +M.BulletText = lib.igBulletText +M.BulletTextV = lib.igBulletTextV +function M.Button(label,size) + size = size or ImVec2(0,0) + return lib.igButton(label,size) +end +M.CalcItemWidth = lib.igCalcItemWidth +M.CalcListClipping = lib.igCalcListClipping +function M.CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width) + text_end = text_end or nil + wrap_width = wrap_width or -1.0 + hide_text_after_double_hash = hide_text_after_double_hash or false + local nonUDT_out = ffi.new("ImVec2") + lib.igCalcTextSize_nonUDT(nonUDT_out,text,text_end,hide_text_after_double_hash,wrap_width) + return nonUDT_out +end +function M.CalcTextSize_nonUDT2(text,text_end,hide_text_after_double_hash,wrap_width) + text_end = text_end or nil + wrap_width = wrap_width or -1.0 + hide_text_after_double_hash = hide_text_after_double_hash or false + return lib.igCalcTextSize_nonUDT2(text,text_end,hide_text_after_double_hash,wrap_width) +end +function M.CaptureKeyboardFromApp(want_capture_keyboard_value) + if want_capture_keyboard_value == nil then want_capture_keyboard_value = true end + return lib.igCaptureKeyboardFromApp(want_capture_keyboard_value) +end +function M.CaptureMouseFromApp(want_capture_mouse_value) + if want_capture_mouse_value == nil then want_capture_mouse_value = true end + return lib.igCaptureMouseFromApp(want_capture_mouse_value) +end +M.Checkbox = lib.igCheckbox +M.CheckboxFlags = lib.igCheckboxFlags +M.CloseCurrentPopup = lib.igCloseCurrentPopup +function M.CollapsingHeader(label,flags) + flags = flags or 0 + return lib.igCollapsingHeader(label,flags) +end +function M.CollapsingHeaderBoolPtr(label,p_open,flags) + flags = flags or 0 + return lib.igCollapsingHeaderBoolPtr(label,p_open,flags) +end +function M.ColorButton(desc_id,col,flags,size) + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igColorButton(desc_id,col,flags,size) +end +M.ColorConvertFloat4ToU32 = lib.igColorConvertFloat4ToU32 +M.ColorConvertHSVtoRGB = lib.igColorConvertHSVtoRGB +M.ColorConvertRGBtoHSV = lib.igColorConvertRGBtoHSV +function M.ColorConvertU32ToFloat4(_in) + local nonUDT_out = ffi.new("ImVec4") + lib.igColorConvertU32ToFloat4_nonUDT(nonUDT_out,_in) + return nonUDT_out +end +M.ColorConvertU32ToFloat4_nonUDT2 = lib.igColorConvertU32ToFloat4_nonUDT2 +function M.ColorEdit3(label,col,flags) + flags = flags or 0 + return lib.igColorEdit3(label,col,flags) +end +function M.ColorEdit4(label,col,flags) + flags = flags or 0 + return lib.igColorEdit4(label,col,flags) +end +function M.ColorPicker3(label,col,flags) + flags = flags or 0 + return lib.igColorPicker3(label,col,flags) +end +function M.ColorPicker4(label,col,flags,ref_col) + ref_col = ref_col or nil + flags = flags or 0 + return lib.igColorPicker4(label,col,flags,ref_col) +end +function M.Columns(count,id,border) + if border == nil then border = true end + count = count or 1 + id = id or nil + return lib.igColumns(count,id,border) +end +function M.Combo(label,current_item,items,items_count,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igCombo(label,current_item,items,items_count,popup_max_height_in_items) +end +function M.ComboStr(label,current_item,items_separated_by_zeros,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igComboStr(label,current_item,items_separated_by_zeros,popup_max_height_in_items) +end +function M.ComboFnPtr(label,current_item,items_getter,data,items_count,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igComboFnPtr(label,current_item,items_getter,data,items_count,popup_max_height_in_items) +end +function M.CreateContext(shared_font_atlas) + shared_font_atlas = shared_font_atlas or nil + return lib.igCreateContext(shared_font_atlas) +end +M.DebugCheckVersionAndDataLayout = lib.igDebugCheckVersionAndDataLayout +function M.DestroyContext(ctx) + ctx = ctx or nil + return lib.igDestroyContext(ctx) +end +function M.DragFloat(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat2(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat2(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat3(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat3(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat4(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat4(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power) + format_max = format_max or nil + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + v_max = v_max or 0.0 + return lib.igDragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power) +end +function M.DragInt(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt2(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt2(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt3(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt3(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt4(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt4(label,v,v_speed,v_min,v_max,format) +end +function M.DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max) + format_max = format_max or nil + format = format or "%d" + v_speed = v_speed or 1.0 + v_max = v_max or 0 + v_min = v_min or 0 + return lib.igDragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max) +end +function M.DragScalar(label,data_type,v,v_speed,v_min,v_max,format,power) + v_max = v_max or nil + format = format or nil + v_min = v_min or nil + power = power or 1.0 + return lib.igDragScalar(label,data_type,v,v_speed,v_min,v_max,format,power) +end +function M.DragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power) + v_max = v_max or nil + format = format or nil + v_min = v_min or nil + power = power or 1.0 + return lib.igDragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power) +end +M.Dummy = lib.igDummy +M.End = lib.igEnd +M.EndChild = lib.igEndChild +M.EndChildFrame = lib.igEndChildFrame +M.EndCombo = lib.igEndCombo +M.EndDragDropSource = lib.igEndDragDropSource +M.EndDragDropTarget = lib.igEndDragDropTarget +M.EndFrame = lib.igEndFrame +M.EndGroup = lib.igEndGroup +M.EndMainMenuBar = lib.igEndMainMenuBar +M.EndMenu = lib.igEndMenu +M.EndMenuBar = lib.igEndMenuBar +M.EndPopup = lib.igEndPopup +M.EndTabBar = lib.igEndTabBar +M.EndTabItem = lib.igEndTabItem +M.EndTooltip = lib.igEndTooltip +M.GetBackgroundDrawList = lib.igGetBackgroundDrawList +M.GetClipboardText = lib.igGetClipboardText +function M.GetColorU32(idx,alpha_mul) + alpha_mul = alpha_mul or 1.0 + return lib.igGetColorU32(idx,alpha_mul) +end +M.GetColorU32Vec4 = lib.igGetColorU32Vec4 +M.GetColorU32U32 = lib.igGetColorU32U32 +M.GetColumnIndex = lib.igGetColumnIndex +function M.GetColumnOffset(column_index) + column_index = column_index or -1 + return lib.igGetColumnOffset(column_index) +end +function M.GetColumnWidth(column_index) + column_index = column_index or -1 + return lib.igGetColumnWidth(column_index) +end +M.GetColumnsCount = lib.igGetColumnsCount +function M.GetContentRegionAvail() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetContentRegionAvail_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetContentRegionAvail_nonUDT2 = lib.igGetContentRegionAvail_nonUDT2 +function M.GetContentRegionMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetContentRegionMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetContentRegionMax_nonUDT2 = lib.igGetContentRegionMax_nonUDT2 +M.GetCurrentContext = lib.igGetCurrentContext +function M.GetCursorPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorPos_nonUDT2 = lib.igGetCursorPos_nonUDT2 +M.GetCursorPosX = lib.igGetCursorPosX +M.GetCursorPosY = lib.igGetCursorPosY +function M.GetCursorScreenPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorScreenPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorScreenPos_nonUDT2 = lib.igGetCursorScreenPos_nonUDT2 +function M.GetCursorStartPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorStartPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorStartPos_nonUDT2 = lib.igGetCursorStartPos_nonUDT2 +M.GetDragDropPayload = lib.igGetDragDropPayload +M.GetDrawData = lib.igGetDrawData +M.GetDrawListSharedData = lib.igGetDrawListSharedData +M.GetFont = lib.igGetFont +M.GetFontSize = lib.igGetFontSize +function M.GetFontTexUvWhitePixel() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetFontTexUvWhitePixel_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetFontTexUvWhitePixel_nonUDT2 = lib.igGetFontTexUvWhitePixel_nonUDT2 +M.GetForegroundDrawList = lib.igGetForegroundDrawList +M.GetFrameCount = lib.igGetFrameCount +M.GetFrameHeight = lib.igGetFrameHeight +M.GetFrameHeightWithSpacing = lib.igGetFrameHeightWithSpacing +M.GetIDStr = lib.igGetIDStr +M.GetIDRange = lib.igGetIDRange +M.GetIDPtr = lib.igGetIDPtr +M.GetIO = lib.igGetIO +function M.GetItemRectMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectMax_nonUDT2 = lib.igGetItemRectMax_nonUDT2 +function M.GetItemRectMin() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectMin_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectMin_nonUDT2 = lib.igGetItemRectMin_nonUDT2 +function M.GetItemRectSize() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectSize_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectSize_nonUDT2 = lib.igGetItemRectSize_nonUDT2 +M.GetKeyIndex = lib.igGetKeyIndex +M.GetKeyPressedAmount = lib.igGetKeyPressedAmount +M.GetMouseCursor = lib.igGetMouseCursor +function M.GetMouseDragDelta(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMouseDragDelta_nonUDT(nonUDT_out,button,lock_threshold) + return nonUDT_out +end +function M.GetMouseDragDelta_nonUDT2(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + return lib.igGetMouseDragDelta_nonUDT2(button,lock_threshold) +end +function M.GetMousePos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMousePos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetMousePos_nonUDT2 = lib.igGetMousePos_nonUDT2 +function M.GetMousePosOnOpeningCurrentPopup() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMousePosOnOpeningCurrentPopup_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetMousePosOnOpeningCurrentPopup_nonUDT2 = lib.igGetMousePosOnOpeningCurrentPopup_nonUDT2 +M.GetScrollMaxX = lib.igGetScrollMaxX +M.GetScrollMaxY = lib.igGetScrollMaxY +M.GetScrollX = lib.igGetScrollX +M.GetScrollY = lib.igGetScrollY +M.GetStateStorage = lib.igGetStateStorage +M.GetStyle = lib.igGetStyle +M.GetStyleColorName = lib.igGetStyleColorName +M.GetStyleColorVec4 = lib.igGetStyleColorVec4 +M.GetTextLineHeight = lib.igGetTextLineHeight +M.GetTextLineHeightWithSpacing = lib.igGetTextLineHeightWithSpacing +M.GetTime = lib.igGetTime +M.GetTreeNodeToLabelSpacing = lib.igGetTreeNodeToLabelSpacing +M.GetVersion = lib.igGetVersion +function M.GetWindowContentRegionMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowContentRegionMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowContentRegionMax_nonUDT2 = lib.igGetWindowContentRegionMax_nonUDT2 +function M.GetWindowContentRegionMin() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowContentRegionMin_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowContentRegionMin_nonUDT2 = lib.igGetWindowContentRegionMin_nonUDT2 +M.GetWindowContentRegionWidth = lib.igGetWindowContentRegionWidth +M.GetWindowDrawList = lib.igGetWindowDrawList +M.GetWindowHeight = lib.igGetWindowHeight +function M.GetWindowPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowPos_nonUDT2 = lib.igGetWindowPos_nonUDT2 +function M.GetWindowSize() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowSize_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowSize_nonUDT2 = lib.igGetWindowSize_nonUDT2 +M.GetWindowWidth = lib.igGetWindowWidth +function M.Image(user_texture_id,size,uv0,uv1,tint_col,border_col) + border_col = border_col or ImVec4(0,0,0,0) + tint_col = tint_col or ImVec4(1,1,1,1) + uv0 = uv0 or ImVec2(0,0) + uv1 = uv1 or ImVec2(1,1) + return lib.igImage(user_texture_id,size,uv0,uv1,tint_col,border_col) +end +function M.ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col) + uv1 = uv1 or ImVec2(1,1) + bg_col = bg_col or ImVec4(0,0,0,0) + uv0 = uv0 or ImVec2(0,0) + tint_col = tint_col or ImVec4(1,1,1,1) + frame_padding = frame_padding or -1 + return lib.igImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col) +end +function M.Indent(indent_w) + indent_w = indent_w or 0.0 + return lib.igIndent(indent_w) +end +function M.InputDouble(label,v,step,step_fast,format,flags) + step = step or 0.0 + format = format or "%.6f" + step_fast = step_fast or 0.0 + flags = flags or 0 + return lib.igInputDouble(label,v,step,step_fast,format,flags) +end +function M.InputFloat(label,v,step,step_fast,format,flags) + step = step or 0.0 + format = format or "%.3f" + step_fast = step_fast or 0.0 + flags = flags or 0 + return lib.igInputFloat(label,v,step,step_fast,format,flags) +end +function M.InputFloat2(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat2(label,v,format,flags) +end +function M.InputFloat3(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat3(label,v,format,flags) +end +function M.InputFloat4(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat4(label,v,format,flags) +end +function M.InputInt(label,v,step,step_fast,flags) + step = step or 1 + step_fast = step_fast or 100 + flags = flags or 0 + return lib.igInputInt(label,v,step,step_fast,flags) +end +function M.InputInt2(label,v,flags) + flags = flags or 0 + return lib.igInputInt2(label,v,flags) +end +function M.InputInt3(label,v,flags) + flags = flags or 0 + return lib.igInputInt3(label,v,flags) +end +function M.InputInt4(label,v,flags) + flags = flags or 0 + return lib.igInputInt4(label,v,flags) +end +function M.InputScalar(label,data_type,v,step,step_fast,format,flags) + step = step or nil + format = format or nil + step_fast = step_fast or nil + flags = flags or 0 + return lib.igInputScalar(label,data_type,v,step,step_fast,format,flags) +end +function M.InputScalarN(label,data_type,v,components,step,step_fast,format,flags) + step = step or nil + format = format or nil + step_fast = step_fast or nil + flags = flags or 0 + return lib.igInputScalarN(label,data_type,v,components,step,step_fast,format,flags) +end +function M.InputText(label,buf,buf_size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + flags = flags or 0 + return lib.igInputText(label,buf,buf_size,flags,callback,user_data) +end +function M.InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igInputTextMultiline(label,buf,buf_size,size,flags,callback,user_data) +end +function M.InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + flags = flags or 0 + return lib.igInputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data) +end +M.InvisibleButton = lib.igInvisibleButton +M.IsAnyItemActive = lib.igIsAnyItemActive +M.IsAnyItemFocused = lib.igIsAnyItemFocused +M.IsAnyItemHovered = lib.igIsAnyItemHovered +M.IsAnyMouseDown = lib.igIsAnyMouseDown +M.IsItemActivated = lib.igIsItemActivated +M.IsItemActive = lib.igIsItemActive +function M.IsItemClicked(mouse_button) + mouse_button = mouse_button or 0 + return lib.igIsItemClicked(mouse_button) +end +M.IsItemDeactivated = lib.igIsItemDeactivated +M.IsItemDeactivatedAfterEdit = lib.igIsItemDeactivatedAfterEdit +M.IsItemEdited = lib.igIsItemEdited +M.IsItemFocused = lib.igIsItemFocused +function M.IsItemHovered(flags) + flags = flags or 0 + return lib.igIsItemHovered(flags) +end +M.IsItemVisible = lib.igIsItemVisible +M.IsKeyDown = lib.igIsKeyDown +function M.IsKeyPressed(user_key_index,_repeat) + if _repeat == nil then _repeat = true end + return lib.igIsKeyPressed(user_key_index,_repeat) +end +M.IsKeyReleased = lib.igIsKeyReleased +function M.IsMouseClicked(button,_repeat) + _repeat = _repeat or false + return lib.igIsMouseClicked(button,_repeat) +end +M.IsMouseDoubleClicked = lib.igIsMouseDoubleClicked +M.IsMouseDown = lib.igIsMouseDown +function M.IsMouseDragging(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + return lib.igIsMouseDragging(button,lock_threshold) +end +function M.IsMouseHoveringRect(r_min,r_max,clip) + if clip == nil then clip = true end + return lib.igIsMouseHoveringRect(r_min,r_max,clip) +end +function M.IsMousePosValid(mouse_pos) + mouse_pos = mouse_pos or nil + return lib.igIsMousePosValid(mouse_pos) +end +M.IsMouseReleased = lib.igIsMouseReleased +M.IsPopupOpen = lib.igIsPopupOpen +M.IsRectVisible = lib.igIsRectVisible +M.IsRectVisibleVec2 = lib.igIsRectVisibleVec2 +M.IsWindowAppearing = lib.igIsWindowAppearing +M.IsWindowCollapsed = lib.igIsWindowCollapsed +function M.IsWindowFocused(flags) + flags = flags or 0 + return lib.igIsWindowFocused(flags) +end +function M.IsWindowHovered(flags) + flags = flags or 0 + return lib.igIsWindowHovered(flags) +end +M.LabelText = lib.igLabelText +M.LabelTextV = lib.igLabelTextV +function M.ListBoxStr_arr(label,current_item,items,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxStr_arr(label,current_item,items,items_count,height_in_items) +end +function M.ListBoxFnPtr(label,current_item,items_getter,data,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxFnPtr(label,current_item,items_getter,data,items_count,height_in_items) +end +M.ListBoxFooter = lib.igListBoxFooter +function M.ListBoxHeaderVec2(label,size) + size = size or ImVec2(0,0) + return lib.igListBoxHeaderVec2(label,size) +end +function M.ListBoxHeaderInt(label,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxHeaderInt(label,items_count,height_in_items) +end +M.LoadIniSettingsFromDisk = lib.igLoadIniSettingsFromDisk +function M.LoadIniSettingsFromMemory(ini_data,ini_size) + ini_size = ini_size or 0 + return lib.igLoadIniSettingsFromMemory(ini_data,ini_size) +end +M.LogButtons = lib.igLogButtons +M.LogFinish = lib.igLogFinish +M.LogText = lib.igLogText +function M.LogToClipboard(auto_open_depth) + auto_open_depth = auto_open_depth or -1 + return lib.igLogToClipboard(auto_open_depth) +end +function M.LogToFile(auto_open_depth,filename) + auto_open_depth = auto_open_depth or -1 + filename = filename or nil + return lib.igLogToFile(auto_open_depth,filename) +end +function M.LogToTTY(auto_open_depth) + auto_open_depth = auto_open_depth or -1 + return lib.igLogToTTY(auto_open_depth) +end +M.MemAlloc = lib.igMemAlloc +M.MemFree = lib.igMemFree +function M.MenuItemBool(label,shortcut,selected,enabled) + if enabled == nil then enabled = true end + shortcut = shortcut or nil + selected = selected or false + return lib.igMenuItemBool(label,shortcut,selected,enabled) +end +function M.MenuItemBoolPtr(label,shortcut,p_selected,enabled) + if enabled == nil then enabled = true end + return lib.igMenuItemBoolPtr(label,shortcut,p_selected,enabled) +end +M.NewFrame = lib.igNewFrame +M.NewLine = lib.igNewLine +M.NextColumn = lib.igNextColumn +M.OpenPopup = lib.igOpenPopup +function M.OpenPopupOnItemClick(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igOpenPopupOnItemClick(str_id,mouse_button) +end +function M.PlotHistogramFloatPtr(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + stride = stride or ffi.sizeof("float") + overlay_text = overlay_text or nil + return lib.igPlotHistogramFloatPtr(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) +end +function M.PlotHistogramFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + overlay_text = overlay_text or nil + return lib.igPlotHistogramFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) +end +function M.PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + stride = stride or ffi.sizeof("float") + overlay_text = overlay_text or nil + return lib.igPlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) +end +function M.PlotLinesFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + overlay_text = overlay_text or nil + return lib.igPlotLinesFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) +end +M.PopAllowKeyboardFocus = lib.igPopAllowKeyboardFocus +M.PopButtonRepeat = lib.igPopButtonRepeat +M.PopClipRect = lib.igPopClipRect +M.PopFont = lib.igPopFont +M.PopID = lib.igPopID +M.PopItemWidth = lib.igPopItemWidth +function M.PopStyleColor(count) + count = count or 1 + return lib.igPopStyleColor(count) +end +function M.PopStyleVar(count) + count = count or 1 + return lib.igPopStyleVar(count) +end +M.PopTextWrapPos = lib.igPopTextWrapPos +function M.ProgressBar(fraction,size_arg,overlay) + overlay = overlay or nil + size_arg = size_arg or ImVec2(-1,0) + return lib.igProgressBar(fraction,size_arg,overlay) +end +M.PushAllowKeyboardFocus = lib.igPushAllowKeyboardFocus +M.PushButtonRepeat = lib.igPushButtonRepeat +M.PushClipRect = lib.igPushClipRect +M.PushFont = lib.igPushFont +M.PushIDStr = lib.igPushIDStr +M.PushIDRange = lib.igPushIDRange +M.PushIDPtr = lib.igPushIDPtr +M.PushIDInt = lib.igPushIDInt +M.PushItemWidth = lib.igPushItemWidth +M.PushStyleColorU32 = lib.igPushStyleColorU32 +M.PushStyleColor = lib.igPushStyleColor +M.PushStyleVarFloat = lib.igPushStyleVarFloat +M.PushStyleVarVec2 = lib.igPushStyleVarVec2 +function M.PushTextWrapPos(wrap_local_pos_x) + wrap_local_pos_x = wrap_local_pos_x or 0.0 + return lib.igPushTextWrapPos(wrap_local_pos_x) +end +M.RadioButtonBool = lib.igRadioButtonBool +M.RadioButtonIntPtr = lib.igRadioButtonIntPtr +M.Render = lib.igRender +function M.ResetMouseDragDelta(button) + button = button or 0 + return lib.igResetMouseDragDelta(button) +end +function M.SameLine(offset_from_start_x,spacing) + spacing = spacing or -1.0 + offset_from_start_x = offset_from_start_x or 0.0 + return lib.igSameLine(offset_from_start_x,spacing) +end +M.SaveIniSettingsToDisk = lib.igSaveIniSettingsToDisk +function M.SaveIniSettingsToMemory(out_ini_size) + out_ini_size = out_ini_size or nil + return lib.igSaveIniSettingsToMemory(out_ini_size) +end +function M.Selectable(label,selected,flags,size) + flags = flags or 0 + size = size or ImVec2(0,0) + selected = selected or false + return lib.igSelectable(label,selected,flags,size) +end +function M.SelectableBoolPtr(label,p_selected,flags,size) + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igSelectableBoolPtr(label,p_selected,flags,size) +end +M.Separator = lib.igSeparator +function M.SetAllocatorFunctions(alloc_func,free_func,user_data) + user_data = user_data or nil + return lib.igSetAllocatorFunctions(alloc_func,free_func,user_data) +end +M.SetClipboardText = lib.igSetClipboardText +M.SetColorEditOptions = lib.igSetColorEditOptions +M.SetColumnOffset = lib.igSetColumnOffset +M.SetColumnWidth = lib.igSetColumnWidth +M.SetCurrentContext = lib.igSetCurrentContext +M.SetCursorPos = lib.igSetCursorPos +M.SetCursorPosX = lib.igSetCursorPosX +M.SetCursorPosY = lib.igSetCursorPosY +M.SetCursorScreenPos = lib.igSetCursorScreenPos +function M.SetDragDropPayload(type,data,sz,cond) + cond = cond or 0 + return lib.igSetDragDropPayload(type,data,sz,cond) +end +M.SetItemAllowOverlap = lib.igSetItemAllowOverlap +M.SetItemDefaultFocus = lib.igSetItemDefaultFocus +function M.SetKeyboardFocusHere(offset) + offset = offset or 0 + return lib.igSetKeyboardFocusHere(offset) +end +M.SetMouseCursor = lib.igSetMouseCursor +function M.SetNextItemOpen(is_open,cond) + cond = cond or 0 + return lib.igSetNextItemOpen(is_open,cond) +end +M.SetNextItemWidth = lib.igSetNextItemWidth +M.SetNextWindowBgAlpha = lib.igSetNextWindowBgAlpha +function M.SetNextWindowCollapsed(collapsed,cond) + cond = cond or 0 + return lib.igSetNextWindowCollapsed(collapsed,cond) +end +M.SetNextWindowContentSize = lib.igSetNextWindowContentSize +M.SetNextWindowFocus = lib.igSetNextWindowFocus +function M.SetNextWindowPos(pos,cond,pivot) + cond = cond or 0 + pivot = pivot or ImVec2(0,0) + return lib.igSetNextWindowPos(pos,cond,pivot) +end +function M.SetNextWindowSize(size,cond) + cond = cond or 0 + return lib.igSetNextWindowSize(size,cond) +end +function M.SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data) + custom_callback = custom_callback or nil + custom_callback_data = custom_callback_data or nil + return lib.igSetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data) +end +function M.SetScrollFromPosX(local_x,center_x_ratio) + center_x_ratio = center_x_ratio or 0.5 + return lib.igSetScrollFromPosX(local_x,center_x_ratio) +end +function M.SetScrollFromPosY(local_y,center_y_ratio) + center_y_ratio = center_y_ratio or 0.5 + return lib.igSetScrollFromPosY(local_y,center_y_ratio) +end +function M.SetScrollHereX(center_x_ratio) + center_x_ratio = center_x_ratio or 0.5 + return lib.igSetScrollHereX(center_x_ratio) +end +function M.SetScrollHereY(center_y_ratio) + center_y_ratio = center_y_ratio or 0.5 + return lib.igSetScrollHereY(center_y_ratio) +end +M.SetScrollX = lib.igSetScrollX +M.SetScrollY = lib.igSetScrollY +M.SetStateStorage = lib.igSetStateStorage +M.SetTabItemClosed = lib.igSetTabItemClosed +M.SetTooltip = lib.igSetTooltip +M.SetTooltipV = lib.igSetTooltipV +function M.SetWindowCollapsedBool(collapsed,cond) + cond = cond or 0 + return lib.igSetWindowCollapsedBool(collapsed,cond) +end +function M.SetWindowCollapsedStr(name,collapsed,cond) + cond = cond or 0 + return lib.igSetWindowCollapsedStr(name,collapsed,cond) +end +M.SetWindowFocus = lib.igSetWindowFocus +M.SetWindowFocusStr = lib.igSetWindowFocusStr +M.SetWindowFontScale = lib.igSetWindowFontScale +function M.SetWindowPosVec2(pos,cond) + cond = cond or 0 + return lib.igSetWindowPosVec2(pos,cond) +end +function M.SetWindowPosStr(name,pos,cond) + cond = cond or 0 + return lib.igSetWindowPosStr(name,pos,cond) +end +function M.SetWindowSizeVec2(size,cond) + cond = cond or 0 + return lib.igSetWindowSizeVec2(size,cond) +end +function M.SetWindowSizeStr(name,size,cond) + cond = cond or 0 + return lib.igSetWindowSizeStr(name,size,cond) +end +function M.ShowAboutWindow(p_open) + p_open = p_open or nil + return lib.igShowAboutWindow(p_open) +end +function M.ShowDemoWindow(p_open) + p_open = p_open or nil + return lib.igShowDemoWindow(p_open) +end +M.ShowFontSelector = lib.igShowFontSelector +function M.ShowMetricsWindow(p_open) + p_open = p_open or nil + return lib.igShowMetricsWindow(p_open) +end +function M.ShowStyleEditor(ref) + ref = ref or nil + return lib.igShowStyleEditor(ref) +end +M.ShowStyleSelector = lib.igShowStyleSelector +M.ShowUserGuide = lib.igShowUserGuide +function M.SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format) + v_degrees_min = v_degrees_min or -360.0 + v_degrees_max = v_degrees_max or 360.0 + format = format or "%.0f deg" + return lib.igSliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format) +end +function M.SliderFloat(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat(label,v,v_min,v_max,format,power) +end +function M.SliderFloat2(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat2(label,v,v_min,v_max,format,power) +end +function M.SliderFloat3(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat3(label,v,v_min,v_max,format,power) +end +function M.SliderFloat4(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat4(label,v,v_min,v_max,format,power) +end +function M.SliderInt(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt(label,v,v_min,v_max,format) +end +function M.SliderInt2(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt2(label,v,v_min,v_max,format) +end +function M.SliderInt3(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt3(label,v,v_min,v_max,format) +end +function M.SliderInt4(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt4(label,v,v_min,v_max,format) +end +function M.SliderScalar(label,data_type,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igSliderScalar(label,data_type,v,v_min,v_max,format,power) +end +function M.SliderScalarN(label,data_type,v,components,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igSliderScalarN(label,data_type,v,components,v_min,v_max,format,power) +end +M.SmallButton = lib.igSmallButton +M.Spacing = lib.igSpacing +function M.StyleColorsClassic(dst) + dst = dst or nil + return lib.igStyleColorsClassic(dst) +end +function M.StyleColorsDark(dst) + dst = dst or nil + return lib.igStyleColorsDark(dst) +end +function M.StyleColorsLight(dst) + dst = dst or nil + return lib.igStyleColorsLight(dst) +end +M.Text = lib.igText +M.TextColored = lib.igTextColored +M.TextColoredV = lib.igTextColoredV +M.TextDisabled = lib.igTextDisabled +M.TextDisabledV = lib.igTextDisabledV +function M.TextUnformatted(text,text_end) + text_end = text_end or nil + return lib.igTextUnformatted(text,text_end) +end +M.TextV = lib.igTextV +M.TextWrapped = lib.igTextWrapped +M.TextWrappedV = lib.igTextWrappedV +M.TreeNodeStr = lib.igTreeNodeStr +M.TreeNodeStrStr = lib.igTreeNodeStrStr +M.TreeNodePtr = lib.igTreeNodePtr +function M.TreeNodeExStr(label,flags) + flags = flags or 0 + return lib.igTreeNodeExStr(label,flags) +end +M.TreeNodeExStrStr = lib.igTreeNodeExStrStr +M.TreeNodeExPtr = lib.igTreeNodeExPtr +M.TreeNodeExVStr = lib.igTreeNodeExVStr +M.TreeNodeExVPtr = lib.igTreeNodeExVPtr +M.TreeNodeVStr = lib.igTreeNodeVStr +M.TreeNodeVPtr = lib.igTreeNodeVPtr +M.TreePop = lib.igTreePop +M.TreePushStr = lib.igTreePushStr +function M.TreePushPtr(ptr_id) + ptr_id = ptr_id or nil + return lib.igTreePushPtr(ptr_id) +end +function M.Unindent(indent_w) + indent_w = indent_w or 0.0 + return lib.igUnindent(indent_w) +end +function M.VSliderFloat(label,size,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igVSliderFloat(label,size,v,v_min,v_max,format,power) +end +function M.VSliderInt(label,size,v,v_min,v_max,format) + format = format or "%d" + return lib.igVSliderInt(label,size,v,v_min,v_max,format) +end +function M.VSliderScalar(label,size,data_type,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igVSliderScalar(label,size,data_type,v,v_min,v_max,format,power) +end +M.ValueBool = lib.igValueBool +M.ValueInt = lib.igValueInt +M.ValueUint = lib.igValueUint +function M.ValueFloat(prefix,v,float_format) + float_format = float_format or nil + return lib.igValueFloat(prefix,v,float_format) +end +return M +----------END_AUTOGENERATED_LUA----------------------------- \ No newline at end of file diff --git a/mimgui/init.lua b/mimgui/init.lua new file mode 100644 index 0000000..4bf36fc --- /dev/null +++ b/mimgui/init.lua @@ -0,0 +1,368 @@ +-- This file is part of mimgui project +-- Licensed under the MIT License +-- Copyright (c) 2018, FYP + +assert(getMoonloaderVersion() >= 025) + +local imgui = require 'mimgui.imgui' +local DX9 = require 'mimgui.dx9' +local ffi = require 'ffi' +local winmsg = require 'windows.message' +local memory = require 'memory' +local mimgui = {} + +local renderer = nil +local subscriptionsInitialize = {} +local subscriptionsNewFrame = {} +local eventsRegistered = false +local active = false +local cursorActive = false +local playerLocked = false +local iniFilePath = nil +local defaultGlyphRanges = nil + +setmetatable(mimgui, {__index = imgui, __newindex = function(t, k, v) + if imgui[k] then + print('[mimgui] Warning! Overwriting existing key "'..k..'"!') + end + rawset(t, k, v) +end}) + +-- background "Shift" triggering fix +memory.fill(0x00531155, 0x90, 5, true) + +local function ShowCursor(show) + if show then + showCursor(true) + elseif cursorActive then + showCursor(false) + end + cursorActive = show +end + +local function LockPlayer(lock) + if lock then + lockPlayerControl(true) + elseif playerLocked then + lockPlayerControl(false) + end + playerLocked = lock +end + +-- MoonLoader v.027 +if not isCursorActive then + isCursorActive = function() return cursorActive end +end + +local function InitializeRenderer() + -- init renderer + local hwnd = ffi.cast('HWND', readMemory(0x00C8CF88, 4, false)) + local d3ddevice = ffi.cast('LPDIRECT3DDEVICE9', getD3DDevicePtr()) + renderer = assert(DX9.new(d3ddevice, hwnd)) + renderer:SwitchContext() + + -- configure imgui + imgui.GetIO().ImeWindowHandle = nil -- default causes crash. TODO: why? + imgui.GetIO().LogFilename = nil + local confdir = getWorkingDirectory() .. [[\config\mimgui\]] + if not doesDirectoryExist(confdir) then + createDirectory(confdir) + end + iniFilePath = ffi.new('char[260]', confdir .. script.this.filename .. '.ini') + imgui.GetIO().IniFilename = iniFilePath + + -- change font + local fontFile = getFolderPath(0x14) .. '\\trebucbd.ttf' + assert(doesFileExist(fontFile), '[mimgui] Font "' .. fontFile .. '" doesn\'t exist!') + local builder = imgui.ImFontGlyphRangesBuilder() + builder:AddRanges(imgui.GetIO().Fonts:GetGlyphRangesCyrillic()) + builder:AddText([[‚„…†‡€‰‹‘’“”•–—™›№]]) + defaultGlyphRanges = imgui.ImVector_ImWchar() + builder:BuildRanges(defaultGlyphRanges) + imgui.GetIO().Fonts:AddFontFromFileTTF(fontFile, 14, nil, defaultGlyphRanges[0].Data) + + -- invoke initializers + for _, cb in ipairs(subscriptionsInitialize) do + cb() + end +end + +local function RegisterEvents() + addEventHandler('onD3DPresent', function() + if active then + if not renderer then + InitializeRenderer() + end + if renderer and not renderer.lost then + renderer:SwitchContext() + for _, sub in ipairs(subscriptionsNewFrame) do + if sub._render and sub._before then + sub:_before() + end + end + renderer:NewFrame() + local hideCursor = true + for _, sub in ipairs(subscriptionsNewFrame) do + if sub._render then + sub:_draw() + hideCursor = hideCursor and sub.HideCursor + end + end + if hideCursor and not isCursorActive() then + imgui.SetMouseCursor(imgui.lib.ImGuiMouseCursor_None) + end + renderer:EndFrame() + end + end + end) + + local keyState = {} + local WM_MOUSEHWHEEL = 0x020E + local mouseMsgs = { + [WM_MOUSEHWHEEL]=true, + [winmsg.WM_LBUTTONDOWN]=true, + [winmsg.WM_LBUTTONDBLCLK]=true, + [winmsg.WM_RBUTTONDOWN]=true, + [winmsg.WM_RBUTTONDBLCLK]=true, + [winmsg.WM_MBUTTONDOWN]=true, + [winmsg.WM_MBUTTONDBLCLK]=true, + [winmsg.WM_LBUTTONUP]=true, + [winmsg.WM_RBUTTONUP]=true, + [winmsg.WM_MBUTTONUP]=true, + [winmsg.WM_MOUSEWHEEL]=true, + [winmsg.WM_SETCURSOR]=true + } + local keyboardMsgs = { + [winmsg.WM_KEYDOWN]=true, + [winmsg.WM_SYSKEYDOWN]=true, + [winmsg.WM_KEYUP]=true, + [winmsg.WM_SYSKEYUP]=true, + [winmsg.WM_CHAR]=true + } + addEventHandler('onWindowMessage', function(msg, wparam, lparam) + if not renderer then + return + end + + if not mimgui.DisableInput then + local keyboard = keyboardMsgs[msg] + local mouse = mouseMsgs[msg] + if active and (keyboard or mouse) then + renderer:SwitchContext() + local io = imgui.GetIO() + renderer:WindowMessage(msg, wparam, lparam) + if (keyboard and io.WantCaptureKeyboard) or (mouse and io.WantCaptureMouse) then + if msg == winmsg.WM_KEYDOWN or msg == winmsg.WM_SYSKEYDOWN then + keyState[wparam] = false + consumeWindowMessage(true, true, true) + elseif msg == winmsg.WM_KEYUP or msg == winmsg.WM_SYSKEYUP then + if not keyState[wparam] then + consumeWindowMessage(true, true, true) + end + else + consumeWindowMessage(true, true, true) + end + end + end + end + + -- save key states to prevent key sticking + if msg == winmsg.WM_KILLFOCUS then + keyState = {} + elseif wparam < 256 then + if msg == winmsg.WM_KEYDOWN or msg == winmsg.WM_SYSKEYDOWN then + keyState[wparam] = true + elseif msg == winmsg.WM_KEYUP or msg == winmsg.WM_SYSKEYUP then + keyState[wparam] = false + end + end + end) + + addEventHandler('onD3DDeviceLost', function() + if renderer and not renderer.lost then + renderer:InvalidateDeviceObjects() + renderer.lost = true + end + end) + + addEventHandler('onD3DDeviceReset', function() + if renderer then + renderer.lost = false + end + end) + + addEventHandler('onScriptTerminate', function(scr) + if scr == script.this then + ShowCursor(false) + LockPlayer(false) + end + end) + + local updaterThread = lua_thread.create(function() + while true do + wait(0) + local activate, hideCursor, lockPlayer = false, true, false + if #subscriptionsNewFrame > 0 then + for i, sub in ipairs(subscriptionsNewFrame) do + if type(sub.Condition) == 'function' then + sub._render = sub.Condition() + else + sub._render = sub.Condition and true + end + if sub._render then + hideCursor = hideCursor and sub.HideCursor + lockPlayer = lockPlayer or sub.LockPlayer + end + activate = activate or sub._render + end + end + active = activate + ShowCursor(active and not hideCursor) + LockPlayer(active and lockPlayer) + end + end) + updaterThread.work_in_pause = true +end + +local function Unsubscribe(t, sub) + for i, v in ipairs(t) do + if v == sub then + table.remove(t, i) + return + end + end +end + +local function ImGuiEnum(name) + return setmetatable({__name = name}, {__index = function(t, k) + return imgui.lib[t.__name .. k] + end}) +end + +--- API --- +mimgui._VERSION = '1.7.0' +mimgui.DisableInput = false + +mimgui.ComboFlags = ImGuiEnum('ImGuiComboFlags_') +mimgui.Dir = ImGuiEnum('ImGuiDir_') +mimgui.ColorEditFlags = ImGuiEnum('ImGuiColorEditFlags_') +mimgui.Col = ImGuiEnum('ImGuiCol_') +mimgui.WindowFlags = ImGuiEnum('ImGuiWindowFlags_') +mimgui.NavInput = ImGuiEnum('ImGuiNavInput_') +mimgui.FocusedFlags = ImGuiEnum('ImGuiFocusedFlags_') +mimgui.Cond = ImGuiEnum('ImGuiCond_') +mimgui.BackendFlags = ImGuiEnum('ImGuiBackendFlags_') +mimgui.TreeNodeFlags = ImGuiEnum('ImGuiTreeNodeFlags_') +mimgui.StyleVar = ImGuiEnum('ImGuiStyleVar_') +mimgui.DrawCornerFlags = ImGuiEnum('ImDrawCornerFlags_') +mimgui.DragDropFlags = ImGuiEnum('ImGuiDragDropFlags_') +mimgui.SelectableFlags = ImGuiEnum('ImGuiSelectableFlags_') +mimgui.InputTextFlags = ImGuiEnum('ImGuiInputTextFlags_') +mimgui.MouseCursor = ImGuiEnum('ImGuiMouseCursor_') +mimgui.FontAtlasFlags = ImGuiEnum('ImFontAtlasFlags_') +mimgui.HoveredFlags = ImGuiEnum('ImGuiHoveredFlags_') +mimgui.ConfigFlags = ImGuiEnum('ImGuiConfigFlags_') +mimgui.DrawListFlags = ImGuiEnum('ImDrawListFlags_') +mimgui.DataType = ImGuiEnum('ImGuiDataType_') +mimgui.Key = ImGuiEnum('ImGuiKey_') + +function mimgui.OnInitialize(cb) + assert(type(cb) == 'function') + table.insert(subscriptionsInitialize, cb) + return {Unsubscribe = function() Unsubscribe(subscriptionsInitialize, cb) end} +end + +function mimgui.OnFrame(cond, cbBeforeFrame, cbDraw) + assert(type(cond) == 'function') + assert(type(cbBeforeFrame) == 'function') + if cbDraw then assert(type(cbDraw) == 'function') end + if not eventsRegistered then + RegisterEvents() + eventsRegistered = true + end + local sub = { + Condition = cond, + LockPlayer = false, + HideCursor = false, + _before = cbDraw and cbBeforeFrame or nil, + _draw = cbDraw or cbBeforeFrame, + _render = false, + } + function sub:Unsubscribe() + Unsubscribe(subscriptionsNewFrame, self) + end + function sub:IsActive() + return self._render + end + table.insert(subscriptionsNewFrame, sub) + return sub +end + +function mimgui.SwitchContext() + return renderer:SwitchContext() +end + +function mimgui.CreateTextureFromFile(path) + return renderer:CreateTextureFromFile(path) +end + +function mimgui.CreateTextureFromFileInMemory(src, size) + return renderer:CreateTextureFromFileInMemory(src, size) +end + +function mimgui.ReleaseTexture(tex) + return renderer:ReleaseTexture(tex) +end + +function mimgui.CreateFontsTexture() + return renderer:CreateFontsTexture() +end + +function mimgui.InvalidateFontsTexture() + return renderer:InvalidateFontsTexture() +end + +function mimgui.GetRenderer() + return renderer +end + +function mimgui.IsInitialized() + return renderer ~= nil +end + +function mimgui.StrCopy(dst, src, len) + if len or tostring(ffi.typeof(dst)):find('*', 1, true) then + ffi.copy(dst, src, len) + else + len = math.min(ffi.sizeof(dst) - 1, #src) + ffi.copy(dst, src, len) + dst[len] = 0 + end +end + +local new = {} +setmetatable(new, { + __index = function(self, key) + local basetype = ffi.typeof(key) + local mt = { + __index = function(self, sz) + return setmetatable({type = ffi.typeof('$[$]', self.type, sz)}, getmetatable(self)) + end, + __call = function(self, ...) + return self.type(...) + end + } + return setmetatable({type = ffi.typeof('$[1]', basetype), basetype = basetype}, { + __index = function(self, sz) + return setmetatable({type = ffi.typeof('$[$]', self.basetype, sz)}, mt) + end, + __call = mt.__call + }) + end, + __call = function(self, t, ...) + return ffi.new(t, ...) + end +}) +mimgui.new = new + +return mimgui