From 94c24865725c17a9105dd6b31a733eb203d2760e Mon Sep 17 00:00:00 2001 From: daniel-j Date: Sat, 20 Aug 2022 20:07:10 +0200 Subject: [PATCH 01/25] some fixes for newer imgui version --- src/imgui.nim | 6 +++--- tests/test.nim | 2 +- tests/tnull.nim | 4 ++-- tools/generator.nim | 14 +++++++++++--- tools/utils.nim | 6 +++--- 5 files changed, 20 insertions(+), 12 deletions(-) diff --git a/src/imgui.nim b/src/imgui.nim index 980bda4..29dae7e 100644 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -26,8 +26,6 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} -when defined(linux): - {.passL: "-Xlinker -rpath .".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): @@ -36,6 +34,8 @@ when not defined(cpp) or defined(cimguiDLL): const imgui_dll* = "cimgui.dylib" else: const imgui_dll* = "cimgui.so" + when defined(linux): + {.passL: "-Xlinker -rpath .".} {.passC: "-DCIMGUI_DEFINE_ENUMS_AND_STRUCTS".} {.pragma: imgui_header, header: "cimgui.h".} else: @@ -746,7 +746,7 @@ type ImVector*[T] = object # Should I importc a generic? size* {.importc: "Size".}: int32 capacity* {.importc: "Capacity".}: int32 - data* {.importc: "Data".}: UncheckedArray[T] + data* {.importc: "Data".}: ptr UncheckedArray[T] ImGuiStyleModBackup* {.union.} = object backup_int* {.importc: "BackupInt".}: int32 # Breaking naming convetion to denote "low level" backup_float* {.importc: "BackupFloat".}: float32 diff --git a/tests/test.nim b/tests/test.nim index 958f2f1..b6ae6db 100644 --- a/tests/test.nim +++ b/tests/test.nim @@ -10,7 +10,7 @@ proc main() = glfwWindowHint(GLFWContextVersionMinor, 1) glfwWindowHint(GLFWOpenglForwardCompat, GLFW_TRUE) glfwWindowHint(GLFWOpenglProfile, GLFW_OPENGL_CORE_PROFILE) - glfwWindowHint(GLFWResizable, GLFW_FALSE) + glfwWindowHint(GLFWResizable, GLFW_TRUE) var w: GLFWWindow = glfwCreateWindow(1280, 720) if w == nil: diff --git a/tests/tnull.nim b/tests/tnull.nim index f66e1de..b63ca26 100644 --- a/tests/tnull.nim +++ b/tests/tnull.nim @@ -8,7 +8,7 @@ igDebugCheckVersionAndDataLayout(version, ImGuiIO.sizeof().uint32, ImDrawIdx.sizeof().uint32).assert() echo "CreateContext() - {version}".fmt -igCreateContext(nil) +let context = igCreateContext() let io = igGetIO() var text_pixels: ptr uint8 = nil @@ -35,4 +35,4 @@ for i in 0 ..< 20: igRender() echo "DestroyContext()" -igDestroyContext(nil) +context.igDestroyContext() diff --git a/tools/generator.nim b/tools/generator.nim index 6257ec5..3ff8eb9 100644 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -1,7 +1,7 @@ # Written by Leonardo Mariscal , 2019 import strutils, json, strformat, tables, - algorithm, sets, ./utils + algorithm, sets, re, ./utils var enums: HashSet[string] var enumsCount: Table[string, int] @@ -24,16 +24,22 @@ proc translateProc(name: string): string = var nameSplit = name.replace(";", "").split("(*)", 1) let procType = nameSplit[0].translateType() + nameSplit[1] = nameSplit[1][1 ..< nameSplit[1].len - 1] var isVarArgs = false var argsSplit = nameSplit[1].split(',') var argSeq: seq[tuple[name: string, kind: string]] + var unnamedArgCounter = 0 for arg in argsSplit: - let argPieces = arg.rsplit(' ', 1) + let argPieces = arg.replace(" const", "").rsplit(' ', 1) if argPieces[0] == "...": isVarArgs = true continue - var argName = argPieces[1] + var argName = if argPieces.len == 1: + inc(unnamedArgCounter) + "unamed_arg_{unnamedArgCounter}".fmt + else: + argPieces[1] var argType = argPieces[0] if argName.contains('*'): argType.add('*') @@ -143,6 +149,8 @@ proc genEnums(output: var string) = dataName = dataName.split("_")[1] if dataName.endsWith("_"): dataName = dataName[0 ..< dataName.len - 1] + if dataName.match(re"^[0-9]"): + dataName = "`\"" & dataName & "\"`" if dataName == "COUNT": enumsCount[data["name"].getStr()] = data["calc_value"].getInt() continue diff --git a/tools/utils.nim b/tools/utils.nim index 8ebd6be..e99430e 100644 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -29,8 +29,6 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} -when defined(linux): - {.passL: "-Xlinker -rpath .".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): @@ -39,6 +37,8 @@ when not defined(cpp) or defined(cimguiDLL): const imgui_dll* = "cimgui.dylib" else: const imgui_dll* = "cimgui.so" + when defined(linux): + {.passL: "-Xlinker -rpath .".} {.passC: "-DCIMGUI_DEFINE_ENUMS_AND_STRUCTS".} {.pragma: imgui_header, header: "cimgui.h".} else: @@ -55,7 +55,7 @@ const notDefinedStructs* = """ ImVector*[T] = object # Should I importc a generic? size* {.importc: "Size".}: int32 capacity* {.importc: "Capacity".}: int32 - data* {.importc: "Data".}: UncheckedArray[T] + data* {.importc: "Data".}: ptr UncheckedArray[T] ImGuiStyleModBackup* {.union.} = object backup_int* {.importc: "BackupInt".}: int32 # Breaking naming convetion to denote "low level" backup_float* {.importc: "BackupFloat".}: float32 From 3cf3fbd69d76e6fa3b9f80db5220401cf673b6b1 Mon Sep 17 00:00:00 2001 From: daniel-j Date: Sat, 20 Aug 2022 20:19:39 +0200 Subject: [PATCH 02/25] Update ImGui to v1.86 --- .gitmodules | 2 +- src/imgui.nim | 83 +++++++++++++++++++++++++++------------- src/imgui/private/cimgui | 2 +- 3 files changed, 58 insertions(+), 29 deletions(-) diff --git a/.gitmodules b/.gitmodules index 0f89537..e35f404 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "src/imgui/private/cimgui"] path = src/imgui/private/cimgui - url = https://github.com/nimgl/cimgui.git + url = https://github.com/cimgui/cimgui.git diff --git a/src/imgui.nim b/src/imgui.nim index 29dae7e..eb25673 100644 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -402,9 +402,10 @@ type NotAllowed = 8 ImGuiNavDirSourceFlags* {.pure, size: int32.sizeof.} = enum None = 0 - Keyboard = 1 - PadDPad = 2 - PadLStick = 4 + RawKeyboard = 1 + Keyboard = 2 + PadDPad = 4 + PadLStick = 8 ImGuiNavHighlightFlags* {.pure, size: int32.sizeof.} = enum None = 0 TypeDefault = 1 @@ -446,9 +447,10 @@ type ScrollToEdgeY = 64 Forwarded = 128 DebugNoResult = 256 - Tabbing = 512 - Activate = 1024 - DontSetNavHighlight = 2048 + FocusApi = 512 + Tabbing = 1024 + Activate = 2048 + DontSetNavHighlight = 4096 ImGuiNextItemDataFlags* {.pure, size: int32.sizeof.} = enum None = 0 HasWidth = 1 @@ -1016,6 +1018,7 @@ type groupStack* {.importc: "GroupStack".}: ImVector[ImGuiGroupData] openPopupStack* {.importc: "OpenPopupStack".}: ImVector[ImGuiPopupData] beginPopupStack* {.importc: "BeginPopupStack".}: ImVector[ImGuiPopupData] + beginMenuCount* {.importc: "BeginMenuCount".}: int32 viewports* {.importc: "Viewports".}: ImVector[ptr ImGuiViewportP] navWindow* {.importc: "NavWindow".}: ptr ImGuiWindow navId* {.importc: "NavId".}: ImGuiID @@ -1025,7 +1028,6 @@ type navActivatePressedId* {.importc: "NavActivatePressedId".}: ImGuiID navActivateInputId* {.importc: "NavActivateInputId".}: ImGuiID navActivateFlags* {.importc: "NavActivateFlags".}: ImGuiActivateFlags - navJustTabbedId* {.importc: "NavJustTabbedId".}: ImGuiID navJustMovedToId* {.importc: "NavJustMovedToId".}: ImGuiID navJustMovedToFocusScopeId* {.importc: "NavJustMovedToFocusScopeId".}: ImGuiID navJustMovedToKeyMods* {.importc: "NavJustMovedToKeyMods".}: ImGuiKeyModFlags @@ -1033,7 +1035,6 @@ type navNextActivateFlags* {.importc: "NavNextActivateFlags".}: ImGuiActivateFlags navInputSource* {.importc: "NavInputSource".}: ImGuiInputSource navLayer* {.importc: "NavLayer".}: ImGuiNavLayer - navIdTabCounter* {.importc: "NavIdTabCounter".}: int32 navIdIsAlive* {.importc: "NavIdIsAlive".}: bool navMousePosDirty* {.importc: "NavMousePosDirty".}: bool navDisableHighlight* {.importc: "NavDisableHighlight".}: bool @@ -1053,22 +1054,20 @@ type navMoveDirForDebug* {.importc: "NavMoveDirForDebug".}: ImGuiDir navMoveClipDir* {.importc: "NavMoveClipDir".}: ImGuiDir navScoringRect* {.importc: "NavScoringRect".}: ImRect + navScoringNoClipRect* {.importc: "NavScoringNoClipRect".}: ImRect navScoringDebugCount* {.importc: "NavScoringDebugCount".}: int32 - navTabbingInputableRemaining* {.importc: "NavTabbingInputableRemaining".}: int32 + navTabbingDir* {.importc: "NavTabbingDir".}: int32 + navTabbingCounter* {.importc: "NavTabbingCounter".}: int32 navMoveResultLocal* {.importc: "NavMoveResultLocal".}: ImGuiNavItemData navMoveResultLocalVisible* {.importc: "NavMoveResultLocalVisible".}: ImGuiNavItemData navMoveResultOther* {.importc: "NavMoveResultOther".}: ImGuiNavItemData + navTabbingResultFirst* {.importc: "NavTabbingResultFirst".}: ImGuiNavItemData navWindowingTarget* {.importc: "NavWindowingTarget".}: ptr ImGuiWindow navWindowingTargetAnim* {.importc: "NavWindowingTargetAnim".}: ptr ImGuiWindow navWindowingListWindow* {.importc: "NavWindowingListWindow".}: ptr ImGuiWindow navWindowingTimer* {.importc: "NavWindowingTimer".}: float32 navWindowingHighlightAlpha* {.importc: "NavWindowingHighlightAlpha".}: float32 navWindowingToggleLayer* {.importc: "NavWindowingToggleLayer".}: bool - tabFocusRequestCurrWindow* {.importc: "TabFocusRequestCurrWindow".}: ptr ImGuiWindow - tabFocusRequestNextWindow* {.importc: "TabFocusRequestNextWindow".}: ptr ImGuiWindow - tabFocusRequestCurrCounterTabStop* {.importc: "TabFocusRequestCurrCounterTabStop".}: int32 - tabFocusRequestNextCounterTabStop* {.importc: "TabFocusRequestNextCounterTabStop".}: int32 - tabFocusPressed* {.importc: "TabFocusPressed".}: bool dimBgRatio* {.importc: "DimBgRatio".}: float32 mouseCursor* {.importc: "MouseCursor".}: ImGuiMouseCursor dragDropActive* {.importc: "DragDropActive".}: bool @@ -1088,10 +1087,12 @@ type dragDropHoldJustPressedId* {.importc: "DragDropHoldJustPressedId".}: ImGuiID dragDropPayloadBufHeap* {.importc: "DragDropPayloadBufHeap".}: ImVector[uint8] dragDropPayloadBufLocal* {.importc: "DragDropPayloadBufLocal".}: array[16, uint8] + clipperTempDataStacked* {.importc: "ClipperTempDataStacked".}: int32 + clipperTempData* {.importc: "ClipperTempData".}: ImVector[ImGuiListClipperData] currentTable* {.importc: "CurrentTable".}: ptr ImGuiTable - currentTableStackIdx* {.importc: "CurrentTableStackIdx".}: int32 + tablesTempDataStacked* {.importc: "TablesTempDataStacked".}: int32 + tablesTempData* {.importc: "TablesTempData".}: ImVector[ImGuiTableTempData] tables* {.importc: "Tables".}: ImVector[ImGuiTable] - tablesTempDataStack* {.importc: "TablesTempDataStack".}: ImVector[ImGuiTableTempData] tablesLastTimeActive* {.importc: "TablesLastTimeActive".}: ImVector[float32] drawChannelsTempMergeBuffer* {.importc: "DrawChannelsTempMergeBuffer".}: ImVector[ImDrawChannel] currentTabBar* {.importc: "CurrentTabBar".}: ptr ImGuiTabBar @@ -1248,10 +1249,11 @@ type mouseClickedTime* {.importc: "MouseClickedTime".}: array[5, float64] mouseClicked* {.importc: "MouseClicked".}: array[5, bool] mouseDoubleClicked* {.importc: "MouseDoubleClicked".}: array[5, bool] + mouseClickedCount* {.importc: "MouseClickedCount".}: array[5, uint16] + mouseClickedLastCount* {.importc: "MouseClickedLastCount".}: array[5, uint16] mouseReleased* {.importc: "MouseReleased".}: array[5, bool] mouseDownOwned* {.importc: "MouseDownOwned".}: array[5, bool] mouseDownOwnedUnlessPopupClose* {.importc: "MouseDownOwnedUnlessPopupClose".}: array[5, bool] - mouseDownWasDoubleClick* {.importc: "MouseDownWasDoubleClick".}: array[5, bool] mouseDownDuration* {.importc: "MouseDownDuration".}: array[5, float32] mouseDownDurationPrev* {.importc: "MouseDownDurationPrev".}: array[5, float32] mouseDragMaxDistanceAbs* {.importc: "MouseDragMaxDistanceAbs".}: array[5, ImVec2] @@ -1293,8 +1295,6 @@ type selectedAllMouseLock* {.importc: "SelectedAllMouseLock".}: bool edited* {.importc: "Edited".}: bool flags* {.importc: "Flags".}: ImGuiInputTextFlags - userCallback* {.importc: "UserCallback".}: ImGuiInputTextCallback - userCallbackData* {.importc: "UserCallbackData".}: pointer ImGuiLastItemData* {.importc: "ImGuiLastItemData", imgui_header.} = object id* {.importc: "ID".}: ImGuiID inFlags* {.importc: "InFlags".}: ImGuiItemFlags @@ -1306,10 +1306,21 @@ type displayStart* {.importc: "DisplayStart".}: int32 displayEnd* {.importc: "DisplayEnd".}: int32 itemsCount* {.importc: "ItemsCount".}: int32 - stepNo* {.importc: "StepNo".}: int32 - itemsFrozen* {.importc: "ItemsFrozen".}: int32 itemsHeight* {.importc: "ItemsHeight".}: float32 startPosY* {.importc: "StartPosY".}: float32 + tempData* {.importc: "TempData".}: pointer + ImGuiListClipperData* {.importc: "ImGuiListClipperData", imgui_header.} = object + listClipper* {.importc: "ListClipper".}: ptr ImGuiListClipper + lossynessOffset* {.importc: "LossynessOffset".}: float32 + stepNo* {.importc: "StepNo".}: int32 + itemsFrozen* {.importc: "ItemsFrozen".}: int32 + ranges* {.importc: "Ranges".}: ImVector[ImGuiListClipperRange] + ImGuiListClipperRange* {.importc: "ImGuiListClipperRange", imgui_header.} = object + min* {.importc: "Min".}: int32 + max* {.importc: "Max".}: int32 + posToIndexConvert* {.importc: "PosToIndexConvert".}: bool + posToIndexOffsetMin* {.importc: "PosToIndexOffsetMin".}: int8 + posToIndexOffsetMax* {.importc: "PosToIndexOffsetMax".}: int8 ImGuiMenuColumns* {.importc: "ImGuiMenuColumns", imgui_header.} = object totalWidth* {.importc: "TotalWidth".}: uint32 nextTotalWidth* {.importc: "NextTotalWidth".}: uint32 @@ -1775,6 +1786,7 @@ type appearing* {.importc: "Appearing".}: bool hidden* {.importc: "Hidden".}: bool isFallbackWindow* {.importc: "IsFallbackWindow".}: bool + isExplicitChild* {.importc: "IsExplicitChild".}: bool hasCloseButton* {.importc: "HasCloseButton".}: bool resizeBorderHeld* {.importc: "ResizeBorderHeld".}: int8 beginCount* {.importc: "BeginCount".}: int16 @@ -1817,6 +1829,7 @@ type drawList* {.importc: "DrawList".}: ptr ImDrawList drawListInst* {.importc: "DrawListInst".}: ImDrawList parentWindow* {.importc: "ParentWindow".}: ptr ImGuiWindow + parentWindowInBeginStack* {.importc: "ParentWindowInBeginStack".}: ptr ImGuiWindow rootWindow* {.importc: "RootWindow".}: ptr ImGuiWindow rootWindowPopupTree* {.importc: "RootWindowPopupTree".}: ptr ImGuiWindow rootWindowForTitleBarHighlight* {.importc: "RootWindowForTitleBarHighlight".}: ptr ImGuiWindow @@ -1850,6 +1863,7 @@ type indent* {.importc: "Indent".}: ImVec1 columnsOffset* {.importc: "ColumnsOffset".}: ImVec1 groupOffset* {.importc: "GroupOffset".}: ImVec1 + cursorStartPosLossyness* {.importc: "CursorStartPosLossyness".}: ImVec2 navLayerCurrent* {.importc: "NavLayerCurrent".}: ImGuiNavLayer navLayersActiveMask* {.importc: "NavLayersActiveMask".}: int16 navLayersActiveMaskNext* {.importc: "NavLayersActiveMaskNext".}: int16 @@ -1867,7 +1881,6 @@ type currentTableIdx* {.importc: "CurrentTableIdx".}: int32 layoutType* {.importc: "LayoutType".}: ImGuiLayoutType parentLayoutType* {.importc: "ParentLayoutType".}: ImGuiLayoutType - focusCounterTabStop* {.importc: "FocusCounterTabStop".}: int32 itemWidth* {.importc: "ItemWidth".}: float32 textWrapPos* {.importc: "TextWrapPos".}: float32 itemWidthStack* {.importc: "ItemWidthStack".}: ImVector[float32] @@ -2148,8 +2161,14 @@ proc selectAll*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextS proc destroy*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_destroy".} proc newImGuiLastItemData*(): void {.importc: "ImGuiLastItemData_ImGuiLastItemData".} proc destroy*(self: ptr ImGuiLastItemData): void {.importc: "ImGuiLastItemData_destroy".} +proc newImGuiListClipperData*(): void {.importc: "ImGuiListClipperData_ImGuiListClipperData".} +proc reset*(self: ptr ImGuiListClipperData, clipper: ptr ImGuiListClipper): void {.importc: "ImGuiListClipperData_Reset".} +proc destroy*(self: ptr ImGuiListClipperData): void {.importc: "ImGuiListClipperData_destroy".} +proc fromIndices*(min: int32, max: int32): ImGuiListClipperRange {.importc: "ImGuiListClipperRange_FromIndices".} +proc fromPositions*(y1: float32, y2: float32, off_min: int32, off_max: int32): ImGuiListClipperRange {.importc: "ImGuiListClipperRange_FromPositions".} proc begin*(self: ptr ImGuiListClipper, items_count: int32, items_height: float32 = -1.0f): void {.importc: "ImGuiListClipper_Begin".} proc `end`*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_End".} +proc forceDisplayRangeByIndices*(self: ptr ImGuiListClipper, item_min: int32, item_max: int32): void {.importc: "ImGuiListClipper_ForceDisplayRangeByIndices".} proc newImGuiListClipper*(): void {.importc: "ImGuiListClipper_ImGuiListClipper".} proc step*(self: ptr ImGuiListClipper): bool {.importc: "ImGuiListClipper_Step".} proc destroy*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_destroy".} @@ -2441,9 +2460,10 @@ proc igBeginTabItem*(label: cstring, p_open: ptr bool = nil, flags: ImGuiTabItem proc igBeginTable*(str_id: cstring, column: int32, flags: ImGuiTableFlags = 0.ImGuiTableFlags, outer_size: ImVec2 = ImVec2(x: 0.0f, y: 0.0f), inner_width: float32 = 0.0f): bool {.importc: "igBeginTable".} proc igBeginTableEx*(name: cstring, id: ImGuiID, columns_count: int32, flags: ImGuiTableFlags = 0.ImGuiTableFlags, outer_size: ImVec2 = ImVec2(x: 0, y: 0), inner_width: float32 = 0.0f): bool {.importc: "igBeginTableEx".} proc igBeginTooltip*(): void {.importc: "igBeginTooltip".} -proc igBeginTooltipEx*(extra_flags: ImGuiWindowFlags, tooltip_flags: ImGuiTooltipFlags): void {.importc: "igBeginTooltipEx".} +proc igBeginTooltipEx*(tooltip_flags: ImGuiTooltipFlags, extra_window_flags: ImGuiWindowFlags): void {.importc: "igBeginTooltipEx".} proc igBeginViewportSideBar*(name: cstring, viewport: ptr ImGuiViewport, dir: ImGuiDir, size: float32, window_flags: ImGuiWindowFlags): bool {.importc: "igBeginViewportSideBar".} proc igBringWindowToDisplayBack*(window: ptr ImGuiWindow): void {.importc: "igBringWindowToDisplayBack".} +proc igBringWindowToDisplayBehind*(window: ptr ImGuiWindow, above_window: ptr ImGuiWindow): void {.importc: "igBringWindowToDisplayBehind".} proc igBringWindowToDisplayFront*(window: ptr ImGuiWindow): void {.importc: "igBringWindowToDisplayFront".} proc igBringWindowToFocusFront*(window: ptr ImGuiWindow): void {.importc: "igBringWindowToFocusFront".} proc igBullet*(): void {.importc: "igBullet".} @@ -2454,7 +2474,6 @@ proc igButtonBehavior*(bb: ImRect, id: ImGuiID, out_hovered: ptr bool, out_held: proc igButtonEx*(label: cstring, size_arg: ImVec2 = ImVec2(x: 0, y: 0), flags: ImGuiButtonFlags = 0.ImGuiButtonFlags): bool {.importc: "igButtonEx".} proc igCalcItemSizeNonUDT*(pOut: ptr ImVec2, size: ImVec2, default_w: float32, default_h: float32): void {.importc: "igCalcItemSize".} proc igCalcItemWidth*(): float32 {.importc: "igCalcItemWidth".} -proc igCalcListClipping*(items_count: int32, items_height: float32, out_items_display_start: ptr int32, out_items_display_end: ptr int32): void {.importc: "igCalcListClipping".} proc igCalcTextSizeNonUDT*(pOut: ptr ImVec2, text: cstring, text_end: cstring = nil, hide_text_after_double_hash: bool = false, wrap_width: float32 = -1.0f): void {.importc: "igCalcTextSize".} proc igCalcTypematicRepeatAmount*(t0: float32, t1: float32, repeat_delay: float32, repeat_rate: float32): int32 {.importc: "igCalcTypematicRepeatAmount".} proc igCalcWindowNextAutoFitSizeNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igCalcWindowNextAutoFitSize".} @@ -2517,6 +2536,7 @@ proc igDebugNodeViewport*(viewport: ptr ImGuiViewportP): void {.importc: "igDebu proc igDebugNodeWindow*(window: ptr ImGuiWindow, label: cstring): void {.importc: "igDebugNodeWindow".} proc igDebugNodeWindowSettings*(settings: ptr ImGuiWindowSettings): void {.importc: "igDebugNodeWindowSettings".} proc igDebugNodeWindowsList*(windows: ptr ImVector[ptr ImGuiWindow], label: cstring): void {.importc: "igDebugNodeWindowsList".} +proc igDebugNodeWindowsListByBeginStackParent*(windows: ptr ptr ImGuiWindow, windows_size: int32, parent_in_begin_stack: ptr ImGuiWindow): void {.importc: "igDebugNodeWindowsListByBeginStackParent".} proc igDebugRenderViewportThumbnail*(draw_list: ptr ImDrawList, viewport: ptr ImGuiViewportP, bb: ImRect): void {.importc: "igDebugRenderViewportThumbnail".} proc igDebugStartItemPicker*(): void {.importc: "igDebugStartItemPicker".} proc igDestroyContext*(ctx: ptr ImGuiContext = nil): void {.importc: "igDestroyContext".} @@ -2558,12 +2578,14 @@ proc igErrorCheckEndFrameRecover*(log_callback: ImGuiErrorLogCallback, user_data proc igErrorCheckEndWindowRecover*(log_callback: ImGuiErrorLogCallback, user_data: pointer = nil): void {.importc: "igErrorCheckEndWindowRecover".} proc igFindBestWindowPosForPopupNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igFindBestWindowPosForPopup".} proc igFindBestWindowPosForPopupExNonUDT*(pOut: ptr ImVec2, ref_pos: ImVec2, size: ImVec2, last_dir: ptr ImGuiDir, r_outer: ImRect, r_avoid: ImRect, policy: ImGuiPopupPositionPolicy): void {.importc: "igFindBestWindowPosForPopupEx".} +proc igFindBottomMostVisibleWindowWithinBeginStack*(window: ptr ImGuiWindow): ptr ImGuiWindow {.importc: "igFindBottomMostVisibleWindowWithinBeginStack".} proc igFindOrCreateColumns*(window: ptr ImGuiWindow, id: ImGuiID): ptr ImGuiOldColumns {.importc: "igFindOrCreateColumns".} proc igFindOrCreateWindowSettings*(name: cstring): ptr ImGuiWindowSettings {.importc: "igFindOrCreateWindowSettings".} proc igFindRenderedTextEnd*(text: cstring, text_end: cstring = nil): cstring {.importc: "igFindRenderedTextEnd".} proc igFindSettingsHandler*(type_name: cstring): ptr ImGuiSettingsHandler {.importc: "igFindSettingsHandler".} proc igFindWindowByID*(id: ImGuiID): ptr ImGuiWindow {.importc: "igFindWindowByID".} proc igFindWindowByName*(name: cstring): ptr ImGuiWindow {.importc: "igFindWindowByName".} +proc igFindWindowDisplayIndex*(window: ptr ImGuiWindow): int32 {.importc: "igFindWindowDisplayIndex".} proc igFindWindowSettings*(id: ImGuiID): ptr ImGuiWindowSettings {.importc: "igFindWindowSettings".} proc igFocusTopMostWindowUnderOne*(under_this_window: ptr ImGuiWindow, ignore_window: ptr ImGuiWindow): void {.importc: "igFocusTopMostWindowUnderOne".} proc igFocusWindow*(window: ptr ImGuiWindow): void {.importc: "igFocusWindow".} @@ -2630,6 +2652,7 @@ proc igGetKeyIndex*(imgui_key: ImGuiKey): int32 {.importc: "igGetKeyIndex".} proc igGetKeyPressedAmount*(key_index: int32, repeat_delay: float32, rate: float32): int32 {.importc: "igGetKeyPressedAmount".} proc igGetMainViewport*(): ptr ImGuiViewport {.importc: "igGetMainViewport".} proc igGetMergedKeyModFlags*(): ImGuiKeyModFlags {.importc: "igGetMergedKeyModFlags".} +proc igGetMouseClickedCount*(button: ImGuiMouseButton): int32 {.importc: "igGetMouseClickedCount".} proc igGetMouseCursor*(): ImGuiMouseCursor {.importc: "igGetMouseCursor".} proc igGetMouseDragDeltaNonUDT*(pOut: ptr ImVec2, button: ImGuiMouseButton = 0.ImGuiMouseButton, lock_threshold: float32 = -1.0f): void {.importc: "igGetMouseDragDelta".} proc igGetMousePosNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePos".} @@ -2648,6 +2671,7 @@ proc igGetStyleColorVec4*(idx: ImGuiCol): ptr ImVec4 {.importc: "igGetStyleColor proc igGetTextLineHeight*(): float32 {.importc: "igGetTextLineHeight".} proc igGetTextLineHeightWithSpacing*(): float32 {.importc: "igGetTextLineHeightWithSpacing".} proc igGetTime*(): float64 {.importc: "igGetTime".} +proc igGetTopMostAndVisiblePopupModal*(): ptr ImGuiWindow {.importc: "igGetTopMostAndVisiblePopupModal".} proc igGetTopMostPopupModal*(): ptr ImGuiWindow {.importc: "igGetTopMostPopupModal".} proc igGetTreeNodeToLabelSpacing*(): float32 {.importc: "igGetTreeNodeToLabelSpacing".} proc igGetVersion*(): cstring {.importc: "igGetVersion".} @@ -2702,6 +2726,7 @@ proc igImGetDirQuadrantFromDelta*(dx: float32, dy: float32): ImGuiDir {.importc: proc igImHashData*(data: pointer, data_size: uint, seed: uint32 = 0): ImGuiID {.importc: "igImHashData".} proc igImHashStr*(data: cstring, data_size: uint = 0, seed: uint32 = 0): ImGuiID {.importc: "igImHashStr".} proc igImInvLength*(lhs: ImVec2, fail_value: float32): float32 {.importc: "igImInvLength".} +proc igImIsFloatAboveGuaranteedIntegerPrecision*(f: float32): bool {.importc: "igImIsFloatAboveGuaranteedIntegerPrecision".} proc igImIsPowerOfTwo*(v: int32): bool {.importc: "igImIsPowerOfTwo_Int".} proc igImIsPowerOfTwo*(v: uint64): bool {.importc: "igImIsPowerOfTwo_U64".} proc igImLengthSqr*(lhs: ImVec2): float32 {.importc: "igImLengthSqr_Vec2".} @@ -2723,6 +2748,7 @@ proc igImParseFormatPrecision*(format: cstring, default_value: int32): int32 {.i proc igImParseFormatTrimDecorations*(format: cstring, buf: cstring, buf_size: uint): cstring {.importc: "igImParseFormatTrimDecorations".} proc igImPow*(x: float32, y: float32): float32 {.importc: "igImPow_Float".} proc igImPow*(x: float64, y: float64): float64 {.importc: "igImPow_double".} +proc igImQsort*(base: pointer, count: uint, size_of_element: uint, compare_func: proc(unamed_arg_1: pointer, unamed_arg_2: pointer): int32 {.cdecl, varargs.}): void {.importc: "igImQsort".} proc igImRotateNonUDT*(pOut: ptr ImVec2, v: ImVec2, cos_a: float32, sin_a: float32): void {.importc: "igImRotate".} proc igImRsqrt*(x: float32): float32 {.importc: "igImRsqrt_Float".} proc igImRsqrt*(x: float64): float64 {.importc: "igImRsqrt_double".} @@ -2819,9 +2845,9 @@ proc igIsWindowCollapsed*(): bool {.importc: "igIsWindowCollapsed".} proc igIsWindowFocused*(flags: ImGuiFocusedFlags = 0.ImGuiFocusedFlags): bool {.importc: "igIsWindowFocused".} proc igIsWindowHovered*(flags: ImGuiHoveredFlags = 0.ImGuiHoveredFlags): bool {.importc: "igIsWindowHovered".} proc igIsWindowNavFocusable*(window: ptr ImGuiWindow): bool {.importc: "igIsWindowNavFocusable".} +proc igIsWindowWithinBeginStackOf*(window: ptr ImGuiWindow, potential_parent: ptr ImGuiWindow): bool {.importc: "igIsWindowWithinBeginStackOf".} proc igItemAdd*(bb: ImRect, id: ImGuiID, nav_bb: ptr ImRect = nil, extra_flags: ImGuiItemFlags = 0.ImGuiItemFlags): bool {.importc: "igItemAdd".} proc igItemHoverable*(bb: ImRect, id: ImGuiID): bool {.importc: "igItemHoverable".} -proc igItemInputable*(window: ptr ImGuiWindow, id: ImGuiID): void {.importc: "igItemInputable".} proc igItemSize*(size: ImVec2, text_baseline_y: float32 = -1.0f): void {.importc: "igItemSize_Vec2".} proc igItemSize*(bb: ImRect, text_baseline_y: float32 = -1.0f): void {.importc: "igItemSize_Rect".} proc igKeepAliveID*(id: ImGuiID): void {.importc: "igKeepAliveID".} @@ -2856,7 +2882,7 @@ proc igNavMoveRequestApplyResult*(): void {.importc: "igNavMoveRequestApplyResul proc igNavMoveRequestButNoResultYet*(): bool {.importc: "igNavMoveRequestButNoResultYet".} proc igNavMoveRequestCancel*(): void {.importc: "igNavMoveRequestCancel".} proc igNavMoveRequestForward*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags: ImGuiNavMoveFlags, scroll_flags: ImGuiScrollFlags): void {.importc: "igNavMoveRequestForward".} -proc igNavMoveRequestResolveWithLastItem*(): void {.importc: "igNavMoveRequestResolveWithLastItem".} +proc igNavMoveRequestResolveWithLastItem*(result: ptr ImGuiNavItemData): void {.importc: "igNavMoveRequestResolveWithLastItem".} proc igNavMoveRequestSubmit*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags: ImGuiNavMoveFlags, scroll_flags: ImGuiScrollFlags): void {.importc: "igNavMoveRequestSubmit".} proc igNavMoveRequestTryWrapping*(window: ptr ImGuiWindow, move_flags: ImGuiNavMoveFlags): void {.importc: "igNavMoveRequestTryWrapping".} proc igNewFrame*(): void {.importc: "igNewFrame".} @@ -2933,7 +2959,7 @@ proc igScrollToItem*(flags: ImGuiScrollFlags = 0.ImGuiScrollFlags): void {.impor proc igScrollToRect*(window: ptr ImGuiWindow, rect: ImRect, flags: ImGuiScrollFlags = 0.ImGuiScrollFlags): void {.importc: "igScrollToRect".} proc igScrollToRectExNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow, rect: ImRect, flags: ImGuiScrollFlags = 0.ImGuiScrollFlags): void {.importc: "igScrollToRectEx".} proc igScrollbar*(axis: ImGuiAxis): void {.importc: "igScrollbar".} -proc igScrollbarEx*(bb: ImRect, id: ImGuiID, axis: ImGuiAxis, p_scroll_v: ptr float32, avail_v: float32, contents_v: float32, flags: ImDrawFlags): bool {.importc: "igScrollbarEx".} +proc igScrollbarEx*(bb: ImRect, id: ImGuiID, axis: ImGuiAxis, p_scroll_v: ptr int64, avail_v: int64, contents_v: int64, flags: ImDrawFlags): bool {.importc: "igScrollbarEx".} proc igSelectable*(label: cstring, selected: bool = false, flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igSelectable_Bool".} proc igSelectable*(label: cstring, p_selected: ptr bool, flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igSelectable_BoolPtr".} proc igSeparator*(): void {.importc: "igSeparator".} @@ -2958,6 +2984,7 @@ proc igSetItemAllowOverlap*(): void {.importc: "igSetItemAllowOverlap".} proc igSetItemDefaultFocus*(): void {.importc: "igSetItemDefaultFocus".} proc igSetItemUsingMouseWheel*(): void {.importc: "igSetItemUsingMouseWheel".} proc igSetKeyboardFocusHere*(offset: int32 = 0): void {.importc: "igSetKeyboardFocusHere".} +proc igSetLastItemData*(item_id: ImGuiID, in_flags: ImGuiItemFlags, status_flags: ImGuiItemStatusFlags, item_rect: ImRect): void {.importc: "igSetLastItemData".} proc igSetMouseCursor*(cursor_type: ImGuiMouseCursor): void {.importc: "igSetMouseCursor".} proc igSetNavID*(id: ImGuiID, nav_layer: ImGuiNavLayer, focus_scope_id: ImGuiID, rect_rel: ImRect): void {.importc: "igSetNavID".} proc igSetNextItemOpen*(is_open: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextItemOpen".} @@ -3140,6 +3167,8 @@ proc igValue*(prefix: cstring, b: bool): void {.importc: "igValue_Bool".} proc igValue*(prefix: cstring, v: int32): void {.importc: "igValue_Int".} proc igValue*(prefix: cstring, v: uint32): void {.importc: "igValue_Uint".} proc igValue*(prefix: cstring, v: float32, float_format: cstring = nil): void {.importc: "igValue_Float".} +proc igWindowRectAbsToRelNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: ImRect): void {.importc: "igWindowRectAbsToRel".} +proc igWindowRectRelToAbsNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: ImRect): void {.importc: "igWindowRectRelToAbs".} {.pop.} # push dynlib / nodecl, etc... {.pop.} # push warning[HoleEnumConv]: off diff --git a/src/imgui/private/cimgui b/src/imgui/private/cimgui index 06c14be..afce852 160000 --- a/src/imgui/private/cimgui +++ b/src/imgui/private/cimgui @@ -1 +1 @@ -Subproject commit 06c14be534a90dfb0bfcc2fef15598e0c68a55c6 +Subproject commit afce852875e36e948951d6253963cea46101c17c From e61e3e14d675dd08a05f0e4716b176e3180611d5 Mon Sep 17 00:00:00 2001 From: daniel-j Date: Sat, 20 Aug 2022 22:10:02 +0200 Subject: [PATCH 03/25] Update ImGui to v1.87 --- src/imgui.nim | 295 ++++++++++++++++++++++++++++++++------- src/imgui/private/cimgui | 2 +- tools/generator.nim | 21 ++- tools/utils.nim | 12 ++ 4 files changed, 273 insertions(+), 57 deletions(-) mode change 100644 => 100755 src/imgui.nim mode change 100644 => 100755 tools/generator.nim mode change 100644 => 100755 tools/utils.nim diff --git a/src/imgui.nim b/src/imgui.nim old mode 100644 new mode 100755 index eb25673..c930a42 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -285,6 +285,14 @@ type AllowWhenOverlapped = 256 RectOnly = 416 AllowWhenDisabled = 512 + ImGuiInputEventType* {.pure, size: int32.sizeof.} = enum + None = 0 + MousePos = 1 + MouseWheel = 2 + MouseButton = 3 + Key = 4 + Char = 5 + Focus = 6 ImGuiInputReadMode* {.pure, size: int32.sizeof.} = enum Down = 0 Pressed = 1 @@ -297,8 +305,8 @@ type Mouse = 1 Keyboard = 2 Gamepad = 3 - Nav = 4 - Clipboard = 5 + Clipboard = 4 + Nav = 5 ImGuiInputTextFlagsPrivate* {.pure, size: int32.sizeof.} = enum Multiline = 67108864 NoMarkEdited = 134217728 @@ -353,29 +361,146 @@ type Shift = 2 Alt = 4 Super = 8 + ImGuiKeyPrivate* {.pure, size: int32.sizeof.} = enum + LegacyNativeKey_BEGIN = 0 + LegacyNativeKey_END = 512 + Gamepad_BEGIN = 617 + Gamepad_END = 641 ImGuiKey* {.pure, size: int32.sizeof.} = enum - Tab = 0 - LeftArrow = 1 - RightArrow = 2 - UpArrow = 3 - DownArrow = 4 - PageUp = 5 - PageDown = 6 - Home = 7 - End = 8 - Insert = 9 - Delete = 10 - Backspace = 11 - Space = 12 - Enter = 13 - Escape = 14 - KeyPadEnter = 15 - A = 16 - C = 17 - V = 18 - X = 19 - Y = 20 - Z = 21 + None = 0 + Tab = 512 + LeftArrow = 513 + RightArrow = 514 + UpArrow = 515 + DownArrow = 516 + PageUp = 517 + PageDown = 518 + Home = 519 + End = 520 + Insert = 521 + Delete = 522 + Backspace = 523 + Space = 524 + Enter = 525 + Escape = 526 + LeftCtrl = 527 + LeftShift = 528 + LeftAlt = 529 + LeftSuper = 530 + RightCtrl = 531 + RightShift = 532 + RightAlt = 533 + RightSuper = 534 + Menu = 535 + `"0"` = 536 + `"1"` = 537 + `"2"` = 538 + `"3"` = 539 + `"4"` = 540 + `"5"` = 541 + `"6"` = 542 + `"7"` = 543 + `"8"` = 544 + `"9"` = 545 + A = 546 + B = 547 + C = 548 + D = 549 + E = 550 + F = 551 + G = 552 + H = 553 + I = 554 + J = 555 + K = 556 + L = 557 + M = 558 + N = 559 + O = 560 + P = 561 + Q = 562 + R = 563 + S = 564 + T = 565 + U = 566 + V = 567 + W = 568 + X = 569 + Y = 570 + Z = 571 + F1 = 572 + F2 = 573 + F3 = 574 + F4 = 575 + F5 = 576 + F6 = 577 + F7 = 578 + F8 = 579 + F9 = 580 + F10 = 581 + F11 = 582 + F12 = 583 + Apostrophe = 584 + Comma = 585 + Minus = 586 + Period = 587 + Slash = 588 + Semicolon = 589 + Equal = 590 + LeftBracket = 591 + Backslash = 592 + RightBracket = 593 + GraveAccent = 594 + CapsLock = 595 + ScrollLock = 596 + NumLock = 597 + PrintScreen = 598 + Pause = 599 + Keypad0 = 600 + Keypad1 = 601 + Keypad2 = 602 + Keypad3 = 603 + Keypad4 = 604 + Keypad5 = 605 + Keypad6 = 606 + Keypad7 = 607 + Keypad8 = 608 + Keypad9 = 609 + KeypadDecimal = 610 + KeypadDivide = 611 + KeypadMultiply = 612 + KeypadSubtract = 613 + KeypadAdd = 614 + KeypadEnter = 615 + KeypadEqual = 616 + GamepadStart = 617 + GamepadBack = 618 + GamepadFaceUp = 619 + GamepadFaceDown = 620 + GamepadFaceLeft = 621 + GamepadFaceRight = 622 + GamepadDpadUp = 623 + GamepadDpadDown = 624 + GamepadDpadLeft = 625 + GamepadDpadRight = 626 + GamepadL1 = 627 + GamepadR1 = 628 + GamepadL2 = 629 + GamepadR2 = 630 + GamepadL3 = 631 + GamepadR3 = 632 + GamepadLStickUp = 633 + GamepadLStickDown = 634 + GamepadLStickLeft = 635 + GamepadLStickRight = 636 + GamepadRStickUp = 637 + GamepadRStickDown = 638 + GamepadRStickLeft = 639 + GamepadRStickRight = 640 + ModCtrl = 641 + ModShift = 642 + ModAlt = 643 + ModSuper = 644 ImGuiLayoutType* {.pure, size: int32.sizeof.} = enum Horizontal = 0 Vertical = 1 @@ -725,6 +850,11 @@ type Modal = 134217728 ChildMenu = 268435456 +const ImGuiKey_NamedKey_END* = 645 +const ImGuiKey_KeysData_SIZE* = 645 +const ImGuiKey_NamedKey_COUNT* = 133 +const ImGuiKey_NamedKey_BEGIN* = 512 + # TypeDefs type ImDrawCallback* = proc(parent_list: ptr ImDrawList, cmd: ptr ImDrawCmd): void {.cdecl, varargs.} @@ -769,6 +899,18 @@ type ImPair* {.importc: "Pair", imgui_header.} = object key* {.importc: "key".}: ImGuiID data*: ImPairData + ImGuiInputEventData* {.union.} = object + mousePos*: ImGuiInputEventMousePos + mouseWheel*: ImGuiInputEventMouseWheel + mouseButton*: ImGuiInputEventMouseButton + key*: ImGuiInputEventKey + text*: ImGuiInputEventText + appFocused*: ImGuiInputEventAppFocused + ImGuiInputEvent* {.importc: "ImGuiInputEvent", imgui_header.} = object + `type`* {.importc: "`type`".}: ImGuiInputEventType + source* {.importc: "Source".}: ImGuiInputSource + data*: ImGuiInputEventData + addedByTestEngine* {.importc: "AddedByTestEngine".}: bool # Undefined data types in cimgui @@ -945,6 +1087,8 @@ type initialized* {.importc: "Initialized".}: bool fontAtlasOwnedByContext* {.importc: "FontAtlasOwnedByContext".}: bool io* {.importc: "IO".}: ImGuiIO + inputEventsQueue* {.importc: "InputEventsQueue".}: ImVector[ImGuiInputEvent] + inputEventsTrail* {.importc: "InputEventsTrail".}: ImVector[ImGuiInputEvent] style* {.importc: "Style".}: ImGuiStyle font* {.importc: "Font".}: ptr ImFont fontSize* {.importc: "FontSize".}: float32 @@ -995,7 +1139,7 @@ type activeIdUsingMouseWheel* {.importc: "ActiveIdUsingMouseWheel".}: bool activeIdUsingNavDirMask* {.importc: "ActiveIdUsingNavDirMask".}: uint32 activeIdUsingNavInputMask* {.importc: "ActiveIdUsingNavInputMask".}: uint32 - activeIdUsingKeyInputMask* {.importc: "ActiveIdUsingKeyInputMask".}: uint64 + activeIdUsingKeyInputMask* {.importc: "ActiveIdUsingKeyInputMask".}: uint32 activeIdClickOffset* {.importc: "ActiveIdClickOffset".}: ImVec2 activeIdWindow* {.importc: "ActiveIdWindow".}: ptr ImGuiWindow activeIdSource* {.importc: "ActiveIdSource".}: ImGuiInputSource @@ -1121,8 +1265,8 @@ type tooltipSlowDelay* {.importc: "TooltipSlowDelay".}: float32 clipboardHandlerData* {.importc: "ClipboardHandlerData".}: ImVector[int8] menusIdSubmittedThisFrame* {.importc: "MenusIdSubmittedThisFrame".}: ImVector[ImGuiID] - platformImePos* {.importc: "PlatformImePos".}: ImVec2 - platformImeLastPos* {.importc: "PlatformImeLastPos".}: ImVec2 + platformImeData* {.importc: "PlatformImeData".}: ImGuiPlatformImeData + platformImeDataPrev* {.importc: "PlatformImeDataPrev".}: ImGuiPlatformImeData platformLocaleDecimalPoint* {.importc: "PlatformLocaleDecimalPoint".}: int8 settingsLoaded* {.importc: "SettingsLoaded".}: bool settingsDirtyTimer* {.importc: "SettingsDirtyTimer".}: float32 @@ -1191,7 +1335,6 @@ type mouseDoubleClickTime* {.importc: "MouseDoubleClickTime".}: float32 mouseDoubleClickMaxDist* {.importc: "MouseDoubleClickMaxDist".}: float32 mouseDragThreshold* {.importc: "MouseDragThreshold".}: float32 - keyMap* {.importc: "KeyMap".}: array[22, int32] keyRepeatDelay* {.importc: "KeyRepeatDelay".}: float32 keyRepeatRate* {.importc: "KeyRepeatRate".}: float32 userData* {.importc: "UserData".}: pointer @@ -1202,6 +1345,7 @@ type displayFramebufferScale* {.importc: "DisplayFramebufferScale".}: ImVec2 mouseDrawCursor* {.importc: "MouseDrawCursor".}: bool configMacOSXBehaviors* {.importc: "ConfigMacOSXBehaviors".}: bool + configInputTrickleEventQueue* {.importc: "ConfigInputTrickleEventQueue".}: bool configInputTextCursorBlink* {.importc: "ConfigInputTextCursorBlink".}: bool configDragClickToInputText* {.importc: "ConfigDragClickToInputText".}: bool configWindowsResizeFromEdges* {.importc: "ConfigWindowsResizeFromEdges".}: bool @@ -1215,18 +1359,8 @@ type getClipboardTextFn* {.importc: "GetClipboardTextFn".}: proc(user_data: pointer): cstring {.cdecl, varargs.} setClipboardTextFn* {.importc: "SetClipboardTextFn".}: proc(user_data: pointer, text: cstring): void {.cdecl, varargs.} clipboardUserData* {.importc: "ClipboardUserData".}: pointer - imeSetInputScreenPosFn* {.importc: "ImeSetInputScreenPosFn".}: proc(x: int32, y: int32): void {.cdecl, varargs.} - imeWindowHandle* {.importc: "ImeWindowHandle".}: pointer - mousePos* {.importc: "MousePos".}: ImVec2 - mouseDown* {.importc: "MouseDown".}: array[5, bool] - mouseWheel* {.importc: "MouseWheel".}: float32 - mouseWheelH* {.importc: "MouseWheelH".}: float32 - keyCtrl* {.importc: "KeyCtrl".}: bool - keyShift* {.importc: "KeyShift".}: bool - keyAlt* {.importc: "KeyAlt".}: bool - keySuper* {.importc: "KeySuper".}: bool - keysDown* {.importc: "KeysDown".}: array[512, bool] - navInputs* {.importc: "NavInputs".}: array[20, float32] + setPlatformImeDataFn* {.importc: "SetPlatformImeDataFn".}: proc(viewport: ptr ImGuiViewport, data: ptr ImGuiPlatformImeData): void {.cdecl, varargs.} + unusedPadding* {.importc: "_UnusedPadding".}: pointer wantCaptureMouse* {.importc: "WantCaptureMouse".}: bool wantCaptureKeyboard* {.importc: "WantCaptureKeyboard".}: bool wantTextInput* {.importc: "WantTextInput".}: bool @@ -1241,9 +1375,21 @@ type metricsActiveWindows* {.importc: "MetricsActiveWindows".}: int32 metricsActiveAllocations* {.importc: "MetricsActiveAllocations".}: int32 mouseDelta* {.importc: "MouseDelta".}: ImVec2 - wantCaptureMouseUnlessPopupClose* {.importc: "WantCaptureMouseUnlessPopupClose".}: bool + keyMap* {.importc: "KeyMap".}: array[645, int32] + keysDown* {.importc: "KeysDown".}: array[512, bool] + mousePos* {.importc: "MousePos".}: ImVec2 + mouseDown* {.importc: "MouseDown".}: array[5, bool] + mouseWheel* {.importc: "MouseWheel".}: float32 + mouseWheelH* {.importc: "MouseWheelH".}: float32 + keyCtrl* {.importc: "KeyCtrl".}: bool + keyShift* {.importc: "KeyShift".}: bool + keyAlt* {.importc: "KeyAlt".}: bool + keySuper* {.importc: "KeySuper".}: bool + navInputs* {.importc: "NavInputs".}: array[20, float32] keyMods* {.importc: "KeyMods".}: ImGuiKeyModFlags keyModsPrev* {.importc: "KeyModsPrev".}: ImGuiKeyModFlags + keysData* {.importc: "KeysData".}: array[ImGuiKey_KeysData_SIZE, ImGuiKeyData] + wantCaptureMouseUnlessPopupClose* {.importc: "WantCaptureMouseUnlessPopupClose".}: bool mousePosPrev* {.importc: "MousePosPrev".}: ImVec2 mouseClickedPos* {.importc: "MouseClickedPos".}: array[5, ImVec2] mouseClickedTime* {.importc: "MouseClickedTime".}: array[5, float64] @@ -1256,16 +1402,32 @@ type mouseDownOwnedUnlessPopupClose* {.importc: "MouseDownOwnedUnlessPopupClose".}: array[5, bool] mouseDownDuration* {.importc: "MouseDownDuration".}: array[5, float32] mouseDownDurationPrev* {.importc: "MouseDownDurationPrev".}: array[5, float32] - mouseDragMaxDistanceAbs* {.importc: "MouseDragMaxDistanceAbs".}: array[5, ImVec2] mouseDragMaxDistanceSqr* {.importc: "MouseDragMaxDistanceSqr".}: array[5, float32] - keysDownDuration* {.importc: "KeysDownDuration".}: array[512, float32] - keysDownDurationPrev* {.importc: "KeysDownDurationPrev".}: array[512, float32] navInputsDownDuration* {.importc: "NavInputsDownDuration".}: array[20, float32] navInputsDownDurationPrev* {.importc: "NavInputsDownDurationPrev".}: array[20, float32] penPressure* {.importc: "PenPressure".}: float32 appFocusLost* {.importc: "AppFocusLost".}: bool + backendUsingLegacyKeyArrays* {.importc: "BackendUsingLegacyKeyArrays".}: int8 + backendUsingLegacyNavInputArray* {.importc: "BackendUsingLegacyNavInputArray".}: bool inputQueueSurrogate* {.importc: "InputQueueSurrogate".}: ImWchar16 inputQueueCharacters* {.importc: "InputQueueCharacters".}: ImVector[ImWchar] + ImGuiInputEventAppFocused* {.importc: "ImGuiInputEventAppFocused", imgui_header.} = object + focused* {.importc: "Focused".}: bool + ImGuiInputEventKey* {.importc: "ImGuiInputEventKey", imgui_header.} = object + key* {.importc: "Key".}: ImGuiKey + down* {.importc: "Down".}: bool + analogValue* {.importc: "AnalogValue".}: float32 + ImGuiInputEventMouseButton* {.importc: "ImGuiInputEventMouseButton", imgui_header.} = object + button* {.importc: "Button".}: int32 + down* {.importc: "Down".}: bool + ImGuiInputEventMousePos* {.importc: "ImGuiInputEventMousePos", imgui_header.} = object + posX* {.importc: "PosX".}: float32 + posY* {.importc: "PosY".}: float32 + ImGuiInputEventMouseWheel* {.importc: "ImGuiInputEventMouseWheel", imgui_header.} = object + wheelX* {.importc: "WheelX".}: float32 + wheelY* {.importc: "WheelY".}: float32 + ImGuiInputEventText* {.importc: "ImGuiInputEventText", imgui_header.} = object + char* {.importc: "Char".}: uint32 ImGuiInputTextCallbackData* {.importc: "ImGuiInputTextCallbackData", imgui_header.} = object eventFlag* {.importc: "EventFlag".}: ImGuiInputTextFlags flags* {.importc: "Flags".}: ImGuiInputTextFlags @@ -1295,6 +1457,11 @@ type selectedAllMouseLock* {.importc: "SelectedAllMouseLock".}: bool edited* {.importc: "Edited".}: bool flags* {.importc: "Flags".}: ImGuiInputTextFlags + ImGuiKeyData* {.importc: "ImGuiKeyData", imgui_header.} = object + down* {.importc: "Down".}: bool + downDuration* {.importc: "DownDuration".}: float32 + downDurationPrev* {.importc: "DownDurationPrev".}: float32 + analogValue* {.importc: "AnalogValue".}: float32 ImGuiLastItemData* {.importc: "ImGuiLastItemData", imgui_header.} = object id* {.importc: "ID".}: ImGuiID inFlags* {.importc: "InFlags".}: ImGuiItemFlags @@ -1404,6 +1571,10 @@ type dataType* {.importc: "DataType".}: array[32+1, int8] preview* {.importc: "Preview".}: bool delivery* {.importc: "Delivery".}: bool + ImGuiPlatformImeData* {.importc: "ImGuiPlatformImeData", imgui_header.} = object + wantVisible* {.importc: "WantVisible".}: bool + inputPos* {.importc: "InputPos".}: ImVec2 + inputLineHeight* {.importc: "InputLineHeight".}: float32 ImGuiPopupData* {.importc: "ImGuiPopupData", imgui_header.} = object popupId* {.importc: "PopupId".}: ImGuiID window* {.importc: "Window".}: ptr ImGuiWindow @@ -1743,6 +1914,7 @@ type size* {.importc: "Size".}: ImVec2 workPos* {.importc: "WorkPos".}: ImVec2 workSize* {.importc: "WorkSize".}: ImVec2 + platformHandleRaw* {.importc: "PlatformHandleRaw".}: pointer ImGuiViewportP* {.importc: "ImGuiViewportP", imgui_header.} = object imGuiViewport* {.importc: "_ImGuiViewport".}: ImGuiViewport drawListsLastFrame* {.importc: "DrawListsLastFrame".}: array[2, int32] @@ -2133,10 +2305,18 @@ proc addFocusEvent*(self: ptr ImGuiIO, focused: bool): void {.importc: "ImGuiIO_ proc addInputCharacter*(self: ptr ImGuiIO, c: uint32): void {.importc: "ImGuiIO_AddInputCharacter".} proc addInputCharacterUTF16*(self: ptr ImGuiIO, c: ImWchar16): void {.importc: "ImGuiIO_AddInputCharacterUTF16".} proc addInputCharactersUTF8*(self: ptr ImGuiIO, str: cstring): void {.importc: "ImGuiIO_AddInputCharactersUTF8".} +proc addKeyAnalogEvent*(self: ptr ImGuiIO, key: ImGuiKey, down: bool, v: float32): void {.importc: "ImGuiIO_AddKeyAnalogEvent".} +proc addKeyEvent*(self: ptr ImGuiIO, key: ImGuiKey, down: bool): void {.importc: "ImGuiIO_AddKeyEvent".} +proc addMouseButtonEvent*(self: ptr ImGuiIO, button: int32, down: bool): void {.importc: "ImGuiIO_AddMouseButtonEvent".} +proc addMousePosEvent*(self: ptr ImGuiIO, x: float32, y: float32): void {.importc: "ImGuiIO_AddMousePosEvent".} +proc addMouseWheelEvent*(self: ptr ImGuiIO, wh_x: float32, wh_y: float32): void {.importc: "ImGuiIO_AddMouseWheelEvent".} proc clearInputCharacters*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputCharacters".} proc clearInputKeys*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputKeys".} proc newImGuiIO*(): void {.importc: "ImGuiIO_ImGuiIO".} +proc setKeyEventNativeData*(self: ptr ImGuiIO, key: ImGuiKey, native_keycode: int32, native_scancode: int32, native_legacy_index: int32 = -1): void {.importc: "ImGuiIO_SetKeyEventNativeData".} proc destroy*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_destroy".} +proc newImGuiInputEvent*(): void {.importc: "ImGuiInputEvent_ImGuiInputEvent".} +proc destroy*(self: ptr ImGuiInputEvent): void {.importc: "ImGuiInputEvent_destroy".} proc clearSelection*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_ClearSelection".} proc deleteChars*(self: ptr ImGuiInputTextCallbackData, pos: int32, bytes_count: int32): void {.importc: "ImGuiInputTextCallbackData_DeleteChars".} proc hasSelection*(self: ptr ImGuiInputTextCallbackData): bool {.importc: "ImGuiInputTextCallbackData_HasSelection".} @@ -2200,6 +2380,8 @@ proc isDataType*(self: ptr ImGuiPayload, `type`: cstring): bool {.importc: "ImGu proc isDelivery*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsDelivery".} proc isPreview*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsPreview".} proc destroy*(self: ptr ImGuiPayload): void {.importc: "ImGuiPayload_destroy".} +proc newImGuiPlatformImeData*(): void {.importc: "ImGuiPlatformImeData_ImGuiPlatformImeData".} +proc destroy*(self: ptr ImGuiPlatformImeData): void {.importc: "ImGuiPlatformImeData_destroy".} proc newImGuiPopupData*(): void {.importc: "ImGuiPopupData_ImGuiPopupData".} proc destroy*(self: ptr ImGuiPopupData): void {.importc: "ImGuiPopupData_destroy".} proc newImGuiPtrOrIndex*(`ptr`: pointer): void {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr".} @@ -2422,7 +2604,7 @@ proc resize*[T](self: ptr ImVector, new_size: int32, v: T): void {.importc: "ImV proc shrink*(self: ptr ImVector, new_size: int32): void {.importc: "ImVector_shrink".} proc size*(self: ptr ImVector): int32 {.importc: "ImVector_size".} proc size_in_bytes*(self: ptr ImVector): int32 {.importc: "ImVector_size_in_bytes".} -proc swap*(self: ptr ImVector, rhs: ptr ImVector): void {.importc: "ImVector_swap".} +proc swap*(self: ptr ImVector, rhs: ptr ImVector[T]): void {.importc: "ImVector_swap".} proc igAcceptDragDropPayload*(`type`: cstring, flags: ImGuiDragDropFlags = 0.ImGuiDragDropFlags): ptr ImGuiPayload {.importc: "igAcceptDragDropPayload".} proc igActivateItem*(id: ImGuiID): void {.importc: "igActivateItem".} proc igAddContextHook*(context: ptr ImGuiContext, hook: ptr ImGuiContextHook): ImGuiID {.importc: "igAddContextHook".} @@ -2515,8 +2697,8 @@ proc igCombo*(label: cstring, current_item: ptr int32, items_separated_by_zeros: proc igCombo*(label: cstring, current_item: ptr int32, items_getter: proc(data: pointer, idx: int32, out_text: ptr cstring): bool {.cdecl, varargs.}, data: pointer, items_count: int32, popup_max_height_in_items: int32 = -1): bool {.importc: "igCombo_FnBoolPtr".} proc igCreateContext*(shared_font_atlas: ptr ImFontAtlas = nil): ptr ImGuiContext {.importc: "igCreateContext".} proc igCreateNewWindowSettings*(name: cstring): ptr ImGuiWindowSettings {.importc: "igCreateNewWindowSettings".} +proc igDataTypeApplyFromText*(buf: cstring, data_type: ImGuiDataType, p_data: pointer, format: cstring): bool {.importc: "igDataTypeApplyFromText".} proc igDataTypeApplyOp*(data_type: ImGuiDataType, op: int32, output: pointer, arg_1: pointer, arg_2: pointer): void {.importc: "igDataTypeApplyOp".} -proc igDataTypeApplyOpFromText*(buf: cstring, initial_value_buf: cstring, data_type: ImGuiDataType, p_data: pointer, format: cstring): bool {.importc: "igDataTypeApplyOpFromText".} proc igDataTypeClamp*(data_type: ImGuiDataType, p_data: pointer, p_min: pointer, p_max: pointer): bool {.importc: "igDataTypeClamp".} proc igDataTypeCompare*(data_type: ImGuiDataType, arg_1: pointer, arg_2: pointer): int32 {.importc: "igDataTypeCompare".} proc igDataTypeFormatString*(buf: cstring, buf_size: int32, data_type: ImGuiDataType, p_data: pointer, format: cstring): int32 {.importc: "igDataTypeFormatString".} @@ -2648,8 +2830,10 @@ proc igGetItemRectMaxNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectMa proc igGetItemRectMinNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectMin".} proc igGetItemRectSizeNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectSize".} proc igGetItemStatusFlags*(): ImGuiItemStatusFlags {.importc: "igGetItemStatusFlags".} -proc igGetKeyIndex*(imgui_key: ImGuiKey): int32 {.importc: "igGetKeyIndex".} -proc igGetKeyPressedAmount*(key_index: int32, repeat_delay: float32, rate: float32): int32 {.importc: "igGetKeyPressedAmount".} +proc igGetKeyData*(key: ImGuiKey): ptr ImGuiKeyData {.importc: "igGetKeyData".} +proc igGetKeyIndex*(key: ImGuiKey): int32 {.importc: "igGetKeyIndex".} +proc igGetKeyName*(key: ImGuiKey): cstring {.importc: "igGetKeyName".} +proc igGetKeyPressedAmount*(key: ImGuiKey, repeat_delay: float32, rate: float32): int32 {.importc: "igGetKeyPressedAmount".} proc igGetMainViewport*(): ptr ImGuiViewport {.importc: "igGetMainViewport".} proc igGetMergedKeyModFlags*(): ImGuiKeyModFlags {.importc: "igGetMergedKeyModFlags".} proc igGetMouseClickedCount*(button: ImGuiMouseButton): int32 {.importc: "igGetMouseClickedCount".} @@ -2659,6 +2843,7 @@ proc igGetMousePosNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePos".} proc igGetMousePosOnOpeningCurrentPopupNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePosOnOpeningCurrentPopup".} proc igGetNavInputAmount*(n: ImGuiNavInput, mode: ImGuiInputReadMode): float32 {.importc: "igGetNavInputAmount".} proc igGetNavInputAmount2dNonUDT*(pOut: ptr ImVec2, dir_sources: ImGuiNavDirSourceFlags, mode: ImGuiInputReadMode, slow_factor: float32 = 0.0f, fast_factor: float32 = 0.0f): void {.importc: "igGetNavInputAmount2d".} +proc igGetNavInputName*(n: ImGuiNavInput): cstring {.importc: "igGetNavInputName".} proc igGetPopupAllowedExtentRectNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow): void {.importc: "igGetPopupAllowedExtentRect".} proc igGetScrollMaxX*(): float32 {.importc: "igGetScrollMaxX".} proc igGetScrollMaxY*(): float32 {.importc: "igGetScrollMaxY".} @@ -2710,7 +2895,8 @@ proc igImFileRead*(data: pointer, size: uint64, count: uint64, file: ImFileHandl proc igImFileWrite*(data: pointer, size: uint64, count: uint64, file: ImFileHandle): uint64 {.importc: "igImFileWrite".} proc igImFloor*(f: float32): float32 {.importc: "igImFloor_Float".} proc igImFloorNonUDT*(pOut: ptr ImVec2, v: ImVec2): void {.importc: "igImFloor_Vec2".} -proc igImFloorSigned*(f: float32): float32 {.importc: "igImFloorSigned".} +proc igImFloorSigned*(f: float32): float32 {.importc: "igImFloorSigned_Float".} +proc igImFloorSignedNonUDT*(pOut: ptr ImVec2, v: ImVec2): void {.importc: "igImFloorSigned_Vec2".} proc igImFontAtlasBuildFinish*(atlas: ptr ImFontAtlas): void {.importc: "igImFontAtlasBuildFinish".} proc igImFontAtlasBuildInit*(atlas: ptr ImFontAtlas): void {.importc: "igImFontAtlasBuildInit".} proc igImFontAtlasBuildMultiplyCalcLookupTable*(out_table: uint8, in_multiply_factor: float32): void {.importc: "igImFontAtlasBuildMultiplyCalcLookupTable".} @@ -2809,6 +2995,7 @@ proc igIsAnyItemHovered*(): bool {.importc: "igIsAnyItemHovered".} proc igIsAnyMouseDown*(): bool {.importc: "igIsAnyMouseDown".} proc igIsClippedEx*(bb: ImRect, id: ImGuiID): bool {.importc: "igIsClippedEx".} proc igIsDragDropPayloadBeingAccepted*(): bool {.importc: "igIsDragDropPayloadBeingAccepted".} +proc igIsGamepadKey*(key: ImGuiKey): bool {.importc: "igIsGamepadKey".} proc igIsItemActivated*(): bool {.importc: "igIsItemActivated".} proc igIsItemActive*(): bool {.importc: "igIsItemActive".} proc igIsItemClicked*(mouse_button: ImGuiMouseButton = 0.ImGuiMouseButton): bool {.importc: "igIsItemClicked".} @@ -2820,10 +3007,11 @@ proc igIsItemHovered*(flags: ImGuiHoveredFlags = 0.ImGuiHoveredFlags): bool {.im proc igIsItemToggledOpen*(): bool {.importc: "igIsItemToggledOpen".} proc igIsItemToggledSelection*(): bool {.importc: "igIsItemToggledSelection".} proc igIsItemVisible*(): bool {.importc: "igIsItemVisible".} -proc igIsKeyDown*(user_key_index: int32): bool {.importc: "igIsKeyDown".} -proc igIsKeyPressed*(user_key_index: int32, repeat: bool = true): bool {.importc: "igIsKeyPressed".} +proc igIsKeyDown*(key: ImGuiKey): bool {.importc: "igIsKeyDown".} +proc igIsKeyPressed*(key: ImGuiKey, repeat: bool = true): bool {.importc: "igIsKeyPressed".} proc igIsKeyPressedMap*(key: ImGuiKey, repeat: bool = true): bool {.importc: "igIsKeyPressedMap".} -proc igIsKeyReleased*(user_key_index: int32): bool {.importc: "igIsKeyReleased".} +proc igIsKeyReleased*(key: ImGuiKey): bool {.importc: "igIsKeyReleased".} +proc igIsLegacyKey*(key: ImGuiKey): bool {.importc: "igIsLegacyKey".} proc igIsMouseClicked*(button: ImGuiMouseButton, repeat: bool = false): bool {.importc: "igIsMouseClicked".} proc igIsMouseDoubleClicked*(button: ImGuiMouseButton): bool {.importc: "igIsMouseDoubleClicked".} proc igIsMouseDown*(button: ImGuiMouseButton): bool {.importc: "igIsMouseDown".} @@ -2832,6 +3020,7 @@ proc igIsMouseDragging*(button: ImGuiMouseButton, lock_threshold: float32 = -1.0 proc igIsMouseHoveringRect*(r_min: ImVec2, r_max: ImVec2, clip: bool = true): bool {.importc: "igIsMouseHoveringRect".} proc igIsMousePosValid*(mouse_pos: ptr ImVec2 = nil): bool {.importc: "igIsMousePosValid".} proc igIsMouseReleased*(button: ImGuiMouseButton): bool {.importc: "igIsMouseReleased".} +proc igIsNamedKey*(key: ImGuiKey): bool {.importc: "igIsNamedKey".} proc igIsNavInputDown*(n: ImGuiNavInput): bool {.importc: "igIsNavInputDown".} proc igIsNavInputTest*(n: ImGuiNavInput, rm: ImGuiInputReadMode): bool {.importc: "igIsNavInputTest".} proc igIsPopupOpen*(str_id: cstring, flags: ImGuiPopupFlags = 0.ImGuiPopupFlags): bool {.importc: "igIsPopupOpen_Str".} @@ -2965,6 +3154,7 @@ proc igSelectable*(label: cstring, p_selected: ptr bool, flags: ImGuiSelectableF proc igSeparator*(): void {.importc: "igSeparator".} proc igSeparatorEx*(flags: ImGuiSeparatorFlags): void {.importc: "igSeparatorEx".} proc igSetActiveID*(id: ImGuiID, window: ptr ImGuiWindow): void {.importc: "igSetActiveID".} +proc igSetActiveIdUsingKey*(key: ImGuiKey): void {.importc: "igSetActiveIdUsingKey".} proc igSetActiveIdUsingNavAndKeys*(): void {.importc: "igSetActiveIdUsingNavAndKeys".} proc igSetAllocatorFunctions*(alloc_func: ImGuiMemAllocFunc, free_func: ImGuiMemFreeFunc, user_data: pointer = nil): void {.importc: "igSetAllocatorFunctions".} proc igSetClipboardText*(text: cstring): void {.importc: "igSetClipboardText".} @@ -3157,6 +3347,7 @@ proc igTreePush*(ptr_id: pointer = nil): void {.importc: "igTreePush_Ptr".} proc igTreePushOverrideID*(id: ImGuiID): void {.importc: "igTreePushOverrideID".} proc igUnindent*(indent_w: float32 = 0.0f): void {.importc: "igUnindent".} proc igUpdateHoveredWindowAndCaptureFlags*(): void {.importc: "igUpdateHoveredWindowAndCaptureFlags".} +proc igUpdateInputEvents*(trickle_fast_inputs: bool): void {.importc: "igUpdateInputEvents".} proc igUpdateMouseMovingWindowEndFrame*(): void {.importc: "igUpdateMouseMovingWindowEndFrame".} proc igUpdateMouseMovingWindowNewFrame*(): void {.importc: "igUpdateMouseMovingWindowNewFrame".} proc igUpdateWindowParentAndRootLinks*(window: ptr ImGuiWindow, flags: ImGuiWindowFlags, parent_window: ptr ImGuiWindow): void {.importc: "igUpdateWindowParentAndRootLinks".} diff --git a/src/imgui/private/cimgui b/src/imgui/private/cimgui index afce852..bd5a043 160000 --- a/src/imgui/private/cimgui +++ b/src/imgui/private/cimgui @@ -1 +1 @@ -Subproject commit afce852875e36e948951d6253963cea46101c17c +Subproject commit bd5a043957f606ba84745e4bb41940e87410c55c diff --git a/tools/generator.nim b/tools/generator.nim old mode 100644 new mode 100755 index 3ff8eb9..72faa17 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -106,6 +106,7 @@ proc translateType(name: string): string = result = result.replace("void", "pointer") depth.dec + result = result.replace("ImBitArrayForNamedKeys", "ImU32") result = result.replace("ImBitArray", "ImU32") result = result.replace("ImGuiWindowPtr", "ptr ImGuiWindow") result = result.replace("ImS8", "int8") # Doing it a little verbose to avoid issues in the future. @@ -123,6 +124,8 @@ proc translateType(name: string): string = result = result["ImVector_".len ..< result.len] result = "ImVector[{result}]".fmt + result = result.replace("ImChunkStream_T", "ImChunkStream") + result = result.replace("ImGuiStorageImPair", "ImGuiStoragePair") for d in 0 ..< depth: @@ -136,6 +139,8 @@ proc genEnums(output: var string) = output.add("\n# Enums\ntype\n") + var tableNamedKeys: Table[string, int] + for name, obj in data["enums"].pairs: var enumName = name if enumName.endsWith("_"): @@ -145,8 +150,12 @@ proc genEnums(output: var string) = var table: Table[int, string] for data in obj: var dataName = data["name"].getStr() + let dataValue = data["calc_value"].getInt() dataName = dataName.replace("__", "_") - dataName = dataName.split("_")[1] + if dataName.contains("NamedKey") or dataName == "ImGuiKey_KeysData_SIZE": + tableNamedKeys[dataName] = dataValue + continue + dataName = dataName.split("_", 1)[1] if dataName.endsWith("_"): dataName = dataName[0 ..< dataName.len - 1] if dataName.match(re"^[0-9]"): @@ -154,7 +163,6 @@ proc genEnums(output: var string) = if dataName == "COUNT": enumsCount[data["name"].getStr()] = data["calc_value"].getInt() continue - let dataValue = data["calc_value"].getInt() if table.hasKey(dataValue): echo "Enum {enumName}.{dataName} already exists as {enumName}.{table[dataValue]} with value {dataValue} skipping...".fmt continue @@ -168,6 +176,11 @@ proc genEnums(output: var string) = for k, v in tableOrder.pairs: output.add(" {v} = {k}\n".fmt) + if tableNamedKeys.len > 0: + output.add("\n") + for k, v in tableNamedKeys.pairs: + output.add("const {k}* = {v}\n".fmt) + proc genTypeDefs(output: var string) = # Must be run after genEnums let file = readFile("src/imgui/private/cimgui/generator/output/typedefs_dict.json") @@ -178,7 +191,7 @@ proc genTypeDefs(output: var string) = for name, obj in data.pairs: let ignorable = ["const_iterator", "iterator", "value_type", "ImS8", "ImS16", "ImS32", "ImS64", "ImU8", "ImU16", "ImU32", - "ImU64"] + "ImU64", "ImBitArrayForNamedKeys"] if obj.getStr().startsWith("struct") or enums.contains(name) or ignorable.contains(name): continue output.add(" {name}* = {obj.getStr().translateType()}\n".fmt) @@ -193,7 +206,7 @@ proc genTypes(output: var string) = output.add(notDefinedStructs) for name, obj in data["structs"].pairs: - if name == "Pair" or name == "ImGuiStoragePair" or name == "ImGuiStyleMod": + if name == "Pair" or name == "ImGuiStoragePair" or name == "ImGuiStyleMod" or name == "ImGuiInputEvent": continue if name == "ImDrawChannel": diff --git a/tools/utils.nim b/tools/utils.nim old mode 100644 new mode 100755 index e99430e..7ee1480 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -76,6 +76,18 @@ const notDefinedStructs* = """ ImPair* {.importc: "Pair", imgui_header.} = object key* {.importc: "key".}: ImGuiID data*: ImPairData + ImGuiInputEventData* {.union.} = object + mousePos*: ImGuiInputEventMousePos + mouseWheel*: ImGuiInputEventMouseWheel + mouseButton*: ImGuiInputEventMouseButton + key*: ImGuiInputEventKey + text*: ImGuiInputEventText + appFocused*: ImGuiInputEventAppFocused + ImGuiInputEvent* {.importc: "ImGuiInputEvent", imgui_header.} = object + `type`* {.importc: "`type`".}: ImGuiInputEventType + source* {.importc: "Source".}: ImGuiInputSource + data*: ImGuiInputEventData + addedByTestEngine* {.importc: "AddedByTestEngine".}: bool # Undefined data types in cimgui From b8011a77c8ceb642bf3b371237e4b5f2521ba4bc Mon Sep 17 00:00:00 2001 From: daniel-j Date: Sat, 20 Aug 2022 22:21:48 +0200 Subject: [PATCH 04/25] Update ImGui to v1.88 --- imgui.nimble | 2 +- src/imgui.nim | 139 ++++++++++++++++++++++++++------------- src/imgui/private/cimgui | 2 +- tools/generator.nim | 11 ++-- 4 files changed, 103 insertions(+), 51 deletions(-) mode change 100644 => 100755 imgui.nimble diff --git a/imgui.nimble b/imgui.nimble old mode 100644 new mode 100755 index 5d642e9..689e73e --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.84.2" +version = "1.88" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index c930a42..d4443b1 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -248,6 +248,15 @@ type U64 = 7 Float = 8 Double = 9 + ImGuiDebugLogFlags* {.pure, size: int32.sizeof.} = enum + None = 0 + EventActiveId = 1 + EventFocus = 2 + EventPopup = 4 + EventNav = 8 + EventIO = 16 + EventMask = 31 + OutputToTTY = 1024 ImGuiDir* {.pure, size: int32.sizeof.} = enum None = -1 Left = 0 @@ -285,21 +294,15 @@ type AllowWhenOverlapped = 256 RectOnly = 416 AllowWhenDisabled = 512 + NoNavOverride = 1024 ImGuiInputEventType* {.pure, size: int32.sizeof.} = enum None = 0 MousePos = 1 MouseWheel = 2 MouseButton = 3 Key = 4 - Char = 5 + Text = 5 Focus = 6 - ImGuiInputReadMode* {.pure, size: int32.sizeof.} = enum - Down = 0 - Pressed = 1 - Released = 2 - Repeat = 3 - RepeatSlow = 4 - RepeatFast = 5 ImGuiInputSource* {.pure, size: int32.sizeof.} = enum None = 0 Mouse = 1 @@ -355,12 +358,6 @@ type Deactivated = 64 HoveredWindow = 128 FocusedByTabbing = 256 - ImGuiKeyModFlags* {.pure, size: int32.sizeof.} = enum - None = 0 - Ctrl = 1 - Shift = 2 - Alt = 4 - Super = 8 ImGuiKeyPrivate* {.pure, size: int32.sizeof.} = enum LegacyNativeKey_BEGIN = 0 LegacyNativeKey_END = 512 @@ -368,6 +365,7 @@ type Gamepad_END = 641 ImGuiKey* {.pure, size: int32.sizeof.} = enum None = 0 + NamedKey_COUNT = 133 Tab = 512 LeftArrow = 513 RightArrow = 514 @@ -501,6 +499,7 @@ type ModShift = 642 ModAlt = 643 ModSuper = 644 + NamedKey_END = 645 ImGuiLayoutType* {.pure, size: int32.sizeof.} = enum Horizontal = 0 Vertical = 1 @@ -510,6 +509,12 @@ type File = 2 Buffer = 3 Clipboard = 4 + ImGuiModFlags* {.pure, size: int32.sizeof.} = enum + None = 0 + Ctrl = 1 + Shift = 2 + Alt = 4 + Super = 8 ImGuiMouseButton* {.pure, size: int32.sizeof.} = enum Left = 0 Right = 1 @@ -576,6 +581,13 @@ type Tabbing = 1024 Activate = 2048 DontSetNavHighlight = 4096 + ImGuiNavReadMode* {.pure, size: int32.sizeof.} = enum + Down = 0 + Pressed = 1 + Released = 2 + Repeat = 3 + RepeatSlow = 4 + RepeatFast = 5 ImGuiNextItemDataFlags* {.pure, size: int32.sizeof.} = enum None = 0 HasWidth = 1 @@ -850,9 +862,15 @@ type Modal = 134217728 ChildMenu = 268435456 -const ImGuiKey_NamedKey_END* = 645 +# Duplicate enums +const ImGuiTabBarFlags_FittingPolicyDefault* = 64 +const ImGuiKey_KeysData_OFFSET* = 0 +const ImDrawFlags_RoundCornersDefault* = 240 +const ImGuiButtonFlags_MouseButtonDefault* = 1 const ImGuiKey_KeysData_SIZE* = 645 -const ImGuiKey_NamedKey_COUNT* = 133 +const ImGuiPopupFlags_MouseButtonLeft* = 0 +const ImGuiPopupFlags_MouseButtonDefault* = 1 +const ImGuiButtonFlagsPrivate_PressedOnDefault* = 32 const ImGuiKey_NamedKey_BEGIN* = 512 # TypeDefs @@ -1136,10 +1154,6 @@ type activeIdHasBeenPressedBefore* {.importc: "ActiveIdHasBeenPressedBefore".}: bool activeIdHasBeenEditedBefore* {.importc: "ActiveIdHasBeenEditedBefore".}: bool activeIdHasBeenEditedThisFrame* {.importc: "ActiveIdHasBeenEditedThisFrame".}: bool - activeIdUsingMouseWheel* {.importc: "ActiveIdUsingMouseWheel".}: bool - activeIdUsingNavDirMask* {.importc: "ActiveIdUsingNavDirMask".}: uint32 - activeIdUsingNavInputMask* {.importc: "ActiveIdUsingNavInputMask".}: uint32 - activeIdUsingKeyInputMask* {.importc: "ActiveIdUsingKeyInputMask".}: uint32 activeIdClickOffset* {.importc: "ActiveIdClickOffset".}: ImVec2 activeIdWindow* {.importc: "ActiveIdWindow".}: ptr ImGuiWindow activeIdSource* {.importc: "ActiveIdSource".}: ImGuiInputSource @@ -1150,6 +1164,10 @@ type activeIdPreviousFrameWindow* {.importc: "ActiveIdPreviousFrameWindow".}: ptr ImGuiWindow lastActiveId* {.importc: "LastActiveId".}: ImGuiID lastActiveIdTimer* {.importc: "LastActiveIdTimer".}: float32 + activeIdUsingMouseWheel* {.importc: "ActiveIdUsingMouseWheel".}: bool + activeIdUsingNavDirMask* {.importc: "ActiveIdUsingNavDirMask".}: uint32 + activeIdUsingNavInputMask* {.importc: "ActiveIdUsingNavInputMask".}: uint32 + activeIdUsingKeyInputMask* {.importc: "ActiveIdUsingKeyInputMask".}: uint32 currentItemFlags* {.importc: "CurrentItemFlags".}: ImGuiItemFlags nextItemData* {.importc: "NextItemData".}: ImGuiNextItemData lastItemData* {.importc: "LastItemData".}: ImGuiLastItemData @@ -1174,7 +1192,7 @@ type navActivateFlags* {.importc: "NavActivateFlags".}: ImGuiActivateFlags navJustMovedToId* {.importc: "NavJustMovedToId".}: ImGuiID navJustMovedToFocusScopeId* {.importc: "NavJustMovedToFocusScopeId".}: ImGuiID - navJustMovedToKeyMods* {.importc: "NavJustMovedToKeyMods".}: ImGuiKeyModFlags + navJustMovedToKeyMods* {.importc: "NavJustMovedToKeyMods".}: ImGuiModFlags navNextActivateId* {.importc: "NavNextActivateId".}: ImGuiID navNextActivateFlags* {.importc: "NavNextActivateFlags".}: ImGuiActivateFlags navInputSource* {.importc: "NavInputSource".}: ImGuiInputSource @@ -1193,7 +1211,7 @@ type navMoveForwardToNextFrame* {.importc: "NavMoveForwardToNextFrame".}: bool navMoveFlags* {.importc: "NavMoveFlags".}: ImGuiNavMoveFlags navMoveScrollFlags* {.importc: "NavMoveScrollFlags".}: ImGuiScrollFlags - navMoveKeyMods* {.importc: "NavMoveKeyMods".}: ImGuiKeyModFlags + navMoveKeyMods* {.importc: "NavMoveKeyMods".}: ImGuiModFlags navMoveDir* {.importc: "NavMoveDir".}: ImGuiDir navMoveDirForDebug* {.importc: "NavMoveDirForDebug".}: ImGuiDir navMoveClipDir* {.importc: "NavMoveClipDir".}: ImGuiDir @@ -1253,6 +1271,7 @@ type colorEditLastColor* {.importc: "ColorEditLastColor".}: uint32 colorPickerRef* {.importc: "ColorPickerRef".}: ImVec4 comboPreviewData* {.importc: "ComboPreviewData".}: ImGuiComboPreviewData + sliderGrabClickOffset* {.importc: "SliderGrabClickOffset".}: float32 sliderCurrentAccum* {.importc: "SliderCurrentAccum".}: float32 sliderCurrentAccumDirty* {.importc: "SliderCurrentAccumDirty".}: bool dragCurrentAccumDirty* {.importc: "DragCurrentAccumDirty".}: bool @@ -1287,6 +1306,8 @@ type logDepthRef* {.importc: "LogDepthRef".}: int32 logDepthToExpand* {.importc: "LogDepthToExpand".}: int32 logDepthToExpandDefault* {.importc: "LogDepthToExpandDefault".}: int32 + debugLogFlags* {.importc: "DebugLogFlags".}: ImGuiDebugLogFlags + debugLogBuf* {.importc: "DebugLogBuf".}: ImGuiTextBuffer debugItemPickerActive* {.importc: "DebugItemPickerActive".}: bool debugItemPickerBreakId* {.importc: "DebugItemPickerBreakId".}: ImGuiID debugMetricsConfig* {.importc: "DebugMetricsConfig".}: ImGuiMetricsConfig @@ -1298,7 +1319,7 @@ type wantCaptureMouseNextFrame* {.importc: "WantCaptureMouseNextFrame".}: int32 wantCaptureKeyboardNextFrame* {.importc: "WantCaptureKeyboardNextFrame".}: int32 wantTextInputNextFrame* {.importc: "WantTextInputNextFrame".}: int32 - tempBuffer* {.importc: "TempBuffer".}: array[1024*3+1, int8] + tempBuffer* {.importc: "TempBuffer".}: ImVector[int8] ImGuiContextHook* {.importc: "ImGuiContextHook", imgui_header.} = object hookId* {.importc: "HookId".}: ImGuiID `type`* {.importc: "`type`".}: ImGuiContextHookType @@ -1376,7 +1397,7 @@ type metricsActiveAllocations* {.importc: "MetricsActiveAllocations".}: int32 mouseDelta* {.importc: "MouseDelta".}: ImVec2 keyMap* {.importc: "KeyMap".}: array[645, int32] - keysDown* {.importc: "KeysDown".}: array[512, bool] + keysDown* {.importc: "KeysDown".}: array[645, bool] mousePos* {.importc: "MousePos".}: ImVec2 mouseDown* {.importc: "MouseDown".}: array[5, bool] mouseWheel* {.importc: "MouseWheel".}: float32 @@ -1386,8 +1407,7 @@ type keyAlt* {.importc: "KeyAlt".}: bool keySuper* {.importc: "KeySuper".}: bool navInputs* {.importc: "NavInputs".}: array[20, float32] - keyMods* {.importc: "KeyMods".}: ImGuiKeyModFlags - keyModsPrev* {.importc: "KeyModsPrev".}: ImGuiKeyModFlags + keyMods* {.importc: "KeyMods".}: ImGuiModFlags keysData* {.importc: "KeysData".}: array[ImGuiKey_KeysData_SIZE, ImGuiKeyData] wantCaptureMouseUnlessPopupClose* {.importc: "WantCaptureMouseUnlessPopupClose".}: bool mousePosPrev* {.importc: "MousePosPrev".}: ImVec2 @@ -1407,6 +1427,7 @@ type navInputsDownDurationPrev* {.importc: "NavInputsDownDurationPrev".}: array[20, float32] penPressure* {.importc: "PenPressure".}: float32 appFocusLost* {.importc: "AppFocusLost".}: bool + appAcceptingEvents* {.importc: "AppAcceptingEvents".}: bool backendUsingLegacyKeyArrays* {.importc: "BackendUsingLegacyKeyArrays".}: int8 backendUsingLegacyNavInputArray* {.importc: "BackendUsingLegacyNavInputArray".}: bool inputQueueSurrogate* {.importc: "InputQueueSurrogate".}: ImWchar16 @@ -1498,6 +1519,7 @@ type offsetMark* {.importc: "OffsetMark".}: uint16 widths* {.importc: "Widths".}: array[4, uint16] ImGuiMetricsConfig* {.importc: "ImGuiMetricsConfig", imgui_header.} = object + showDebugLog* {.importc: "ShowDebugLog".}: bool showStackTool* {.importc: "ShowStackTool".}: bool showWindowsRects* {.importc: "ShowWindowsRects".}: bool showWindowsBeginOrder* {.importc: "ShowWindowsBeginOrder".}: bool @@ -1579,6 +1601,7 @@ type popupId* {.importc: "PopupId".}: ImGuiID window* {.importc: "Window".}: ptr ImGuiWindow sourceWindow* {.importc: "SourceWindow".}: ptr ImGuiWindow + parentNavLayer* {.importc: "ParentNavLayer".}: int32 openFrameCount* {.importc: "OpenFrameCount".}: int32 openParentId* {.importc: "OpenParentId".}: ImGuiID openPopupPos* {.importc: "OpenPopupPos".}: ImVec2 @@ -1599,6 +1622,7 @@ type ImGuiShrinkWidthItem* {.importc: "ImGuiShrinkWidthItem", imgui_header.} = object index* {.importc: "Index".}: int32 width* {.importc: "Width".}: float32 + initialWidth* {.importc: "InitialWidth".}: float32 ImGuiSizeCallbackData* {.importc: "ImGuiSizeCallbackData", imgui_header.} = object userData* {.importc: "UserData".}: pointer pos* {.importc: "Pos".}: ImVec2 @@ -1608,7 +1632,8 @@ type id* {.importc: "ID".}: ImGuiID queryFrameCount* {.importc: "QueryFrameCount".}: int8 querySuccess* {.importc: "QuerySuccess".}: bool - desc* {.importc: "Desc".}: array[58, int8] + dataType* {.importc: "DataType".}: ImGuiDataType + desc* {.importc: "Desc".}: array[57, int8] ImGuiStackSizes* {.importc: "ImGuiStackSizes", imgui_header.} = object sizeOfIDStack* {.importc: "SizeOfIDStack".}: int16 sizeOfColorStack* {.importc: "SizeOfColorStack".}: int16 @@ -1624,6 +1649,8 @@ type stackLevel* {.importc: "StackLevel".}: int32 queryId* {.importc: "QueryId".}: ImGuiID results* {.importc: "Results".}: ImVector[ImGuiStackLevelInfo] + copyToClipboardOnCtrlC* {.importc: "CopyToClipboardOnCtrlC".}: bool + copyToClipboardLastTime* {.importc: "CopyToClipboardLastTime".}: float32 ImGuiStorage* {.importc: "ImGuiStorage", imgui_header.} = object data* {.importc: "Data".}: ImVector[ImGuiStoragePair] ImGuiStyle* {.importc: "ImGuiStyle", imgui_header.} = object @@ -1708,6 +1735,7 @@ type offset* {.importc: "Offset".}: float32 width* {.importc: "Width".}: float32 contentWidth* {.importc: "ContentWidth".}: float32 + requestedWidth* {.importc: "RequestedWidth".}: float32 nameOffset* {.importc: "NameOffset".}: int32 beginOrder* {.importc: "BeginOrder".}: int16 indexDuringLayout* {.importc: "IndexDuringLayout".}: int16 @@ -1752,11 +1780,10 @@ type cellPaddingY* {.importc: "CellPaddingY".}: float32 cellSpacingX1* {.importc: "CellSpacingX1".}: float32 cellSpacingX2* {.importc: "CellSpacingX2".}: float32 - lastOuterHeight* {.importc: "LastOuterHeight".}: float32 - lastFirstRowHeight* {.importc: "LastFirstRowHeight".}: float32 innerWidth* {.importc: "InnerWidth".}: float32 columnsGivenWidth* {.importc: "ColumnsGivenWidth".}: float32 columnsAutoFitWidth* {.importc: "ColumnsAutoFitWidth".}: float32 + columnsStretchSumWeights* {.importc: "ColumnsStretchSumWeights".}: float32 resizedColumnNextWidth* {.importc: "ResizedColumnNextWidth".}: float32 resizeLockMinContentsX2* {.importc: "ResizeLockMinContentsX2".}: float32 refScale* {.importc: "RefScale".}: float32 @@ -1773,6 +1800,8 @@ type innerWindow* {.importc: "InnerWindow".}: ptr ImGuiWindow columnsNames* {.importc: "ColumnsNames".}: ImGuiTextBuffer drawSplitter* {.importc: "DrawSplitter".}: ptr ImDrawListSplitter + instanceDataFirst* {.importc: "InstanceDataFirst".}: ImGuiTableInstanceData + instanceDataExtra* {.importc: "InstanceDataExtra".}: ImVector[ImGuiTableInstanceData] sortSpecsSingle* {.importc: "SortSpecsSingle".}: ImGuiTableColumnSortSpecs sortSpecsMulti* {.importc: "SortSpecsMulti".}: ImVector[ImGuiTableColumnSortSpecs] sortSpecs* {.importc: "SortSpecs".}: ImGuiTableSortSpecs @@ -1875,6 +1904,9 @@ type columnIndex* {.importc: "ColumnIndex".}: int16 sortOrder* {.importc: "SortOrder".}: int16 sortDirection* {.importc: "SortDirection".}: ImGuiSortDirection + ImGuiTableInstanceData* {.importc: "ImGuiTableInstanceData", imgui_header.} = object + lastOuterHeight* {.importc: "LastOuterHeight".}: float32 + lastFirstRowHeight* {.importc: "LastFirstRowHeight".}: float32 ImGuiTableSettings* {.importc: "ImGuiTableSettings", imgui_header.} = object id* {.importc: "ID".}: ImGuiID saveFlags* {.importc: "SaveFlags".}: ImGuiTableFlags @@ -1929,6 +1961,7 @@ type name* {.importc: "Name".}: cstring id* {.importc: "ID".}: ImGuiID flags* {.importc: "Flags".}: ImGuiWindowFlags + viewport* {.importc: "Viewport".}: ptr ImGuiViewportP pos* {.importc: "Pos".}: ImVec2 size* {.importc: "Size".}: ImVec2 sizeFull* {.importc: "SizeFull".}: ImVec2 @@ -2032,6 +2065,7 @@ type prevLineSize* {.importc: "PrevLineSize".}: ImVec2 currLineTextBaseOffset* {.importc: "CurrLineTextBaseOffset".}: float32 prevLineTextBaseOffset* {.importc: "PrevLineTextBaseOffset".}: float32 + isSameLine* {.importc: "IsSameLine".}: bool indent* {.importc: "Indent".}: ImVec1 columnsOffset* {.importc: "ColumnsOffset".}: ImVec1 groupOffset* {.importc: "GroupOffset".}: ImVec1 @@ -2141,10 +2175,10 @@ proc size*(self: ptr ImChunkStream): int32 {.importc: "ImChunkStream_size".} proc swap*(self: ptr ImChunkStream, rhs: ptr ImChunkStream): void {.importc: "ImChunkStream_swap".} proc hSVNonUDT*(pOut: ptr ImColor, h: float32, s: float32, v: float32, a: float32 = 1.0f): void {.importc: "ImColor_HSV".} proc newImColor*(): void {.importc: "ImColor_ImColor_Nil".} -proc newImColor*(r: int32, g: int32, b: int32, a: int32 = 255): void {.importc: "ImColor_ImColor_Int".} -proc newImColor*(rgba: uint32): void {.importc: "ImColor_ImColor_U32".} proc newImColor*(r: float32, g: float32, b: float32, a: float32 = 1.0f): void {.importc: "ImColor_ImColor_Float".} proc newImColor*(col: ImVec4): void {.importc: "ImColor_ImColor_Vec4".} +proc newImColor*(r: int32, g: int32, b: int32, a: int32 = 255): void {.importc: "ImColor_ImColor_Int".} +proc newImColor*(rgba: uint32): void {.importc: "ImColor_ImColor_U32".} proc setHSV*(self: ptr ImColor, h: float32, s: float32, v: float32, a: float32 = 1.0f): void {.importc: "ImColor_SetHSV".} proc destroy*(self: ptr ImColor): void {.importc: "ImColor_destroy".} proc getTexID*(self: ptr ImDrawCmd): ImTextureID {.importc: "ImDrawCmd_GetTexID".} @@ -2313,6 +2347,7 @@ proc addMouseWheelEvent*(self: ptr ImGuiIO, wh_x: float32, wh_y: float32): void proc clearInputCharacters*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputCharacters".} proc clearInputKeys*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputKeys".} proc newImGuiIO*(): void {.importc: "ImGuiIO_ImGuiIO".} +proc setAppAcceptingEvents*(self: ptr ImGuiIO, accepting_events: bool): void {.importc: "ImGuiIO_SetAppAcceptingEvents".} proc setKeyEventNativeData*(self: ptr ImGuiIO, key: ImGuiKey, native_keycode: int32, native_scancode: int32, native_legacy_index: int32 = -1): void {.importc: "ImGuiIO_SetKeyEventNativeData".} proc destroy*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_destroy".} proc newImGuiInputEvent*(): void {.importc: "ImGuiInputEvent_ImGuiInputEvent".} @@ -2435,6 +2470,8 @@ proc newImGuiTableColumnSortSpecs*(): void {.importc: "ImGuiTableColumnSortSpecs proc destroy*(self: ptr ImGuiTableColumnSortSpecs): void {.importc: "ImGuiTableColumnSortSpecs_destroy".} proc newImGuiTableColumn*(): void {.importc: "ImGuiTableColumn_ImGuiTableColumn".} proc destroy*(self: ptr ImGuiTableColumn): void {.importc: "ImGuiTableColumn_destroy".} +proc newImGuiTableInstanceData*(): void {.importc: "ImGuiTableInstanceData_ImGuiTableInstanceData".} +proc destroy*(self: ptr ImGuiTableInstanceData): void {.importc: "ImGuiTableInstanceData_destroy".} proc getColumnSettings*(self: ptr ImGuiTableSettings): ptr ImGuiTableColumnSettings {.importc: "ImGuiTableSettings_GetColumnSettings".} proc newImGuiTableSettings*(): void {.importc: "ImGuiTableSettings_ImGuiTableSettings".} proc destroy*(self: ptr ImGuiTableSettings): void {.importc: "ImGuiTableSettings_destroy".} @@ -2488,9 +2525,6 @@ proc getID*(self: ptr ImGuiWindow, str: cstring, str_end: cstring = nil): ImGuiI proc getID*(self: ptr ImGuiWindow, `ptr`: pointer): ImGuiID {.importc: "ImGuiWindow_GetID_Ptr".} proc getID*(self: ptr ImGuiWindow, n: int32): ImGuiID {.importc: "ImGuiWindow_GetID_Int".} proc getIDFromRectangle*(self: ptr ImGuiWindow, r_abs: ImRect): ImGuiID {.importc: "ImGuiWindow_GetIDFromRectangle".} -proc getIDNoKeepAlive*(self: ptr ImGuiWindow, str: cstring, str_end: cstring = nil): ImGuiID {.importc: "ImGuiWindow_GetIDNoKeepAlive_Str".} -proc getIDNoKeepAlive*(self: ptr ImGuiWindow, `ptr`: pointer): ImGuiID {.importc: "ImGuiWindow_GetIDNoKeepAlive_Ptr".} -proc getIDNoKeepAlive*(self: ptr ImGuiWindow, n: int32): ImGuiID {.importc: "ImGuiWindow_GetIDNoKeepAlive_Int".} proc newImGuiWindow*(context: ptr ImGuiContext, name: cstring): void {.importc: "ImGuiWindow_ImGuiWindow".} proc menuBarHeight*(self: ptr ImGuiWindow): float32 {.importc: "ImGuiWindow_MenuBarHeight".} proc menuBarRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiWindow): void {.importc: "ImGuiWindow_MenuBarRect".} @@ -2599,6 +2633,7 @@ proc pop_back*(self: ptr ImVector): void {.importc: "ImVector_pop_back".} proc push_back*[T](self: ptr ImVector, v: T): void {.importc: "ImVector_push_back".} proc push_front*[T](self: ptr ImVector, v: T): void {.importc: "ImVector_push_front".} proc reserve*(self: ptr ImVector, new_capacity: int32): void {.importc: "ImVector_reserve".} +proc reserve_discard*(self: ptr ImVector, new_capacity: int32): void {.importc: "ImVector_reserve_discard".} proc resize*(self: ptr ImVector, new_size: int32): void {.importc: "ImVector_resize_Nil".} proc resize*[T](self: ptr ImVector, new_size: int32, v: T): void {.importc: "ImVector_resize_T".} proc shrink*(self: ptr ImVector, new_size: int32): void {.importc: "ImVector_shrink".} @@ -2608,6 +2643,7 @@ proc swap*(self: ptr ImVector, rhs: ptr ImVector[T]): void {.importc: "ImVector_ proc igAcceptDragDropPayload*(`type`: cstring, flags: ImGuiDragDropFlags = 0.ImGuiDragDropFlags): ptr ImGuiPayload {.importc: "igAcceptDragDropPayload".} proc igActivateItem*(id: ImGuiID): void {.importc: "igActivateItem".} proc igAddContextHook*(context: ptr ImGuiContext, hook: ptr ImGuiContextHook): ImGuiID {.importc: "igAddContextHook".} +proc igAddSettingsHandler*(handler: ptr ImGuiSettingsHandler): void {.importc: "igAddSettingsHandler".} proc igAlignTextToFramePadding*(): void {.importc: "igAlignTextToFramePadding".} proc igArrowButton*(str_id: cstring, dir: ImGuiDir): bool {.importc: "igArrowButton".} proc igArrowButtonEx*(str_id: cstring, dir: ImGuiDir, size_arg: ImVec2, flags: ImGuiButtonFlags = 0.ImGuiButtonFlags): bool {.importc: "igArrowButtonEx".} @@ -2661,8 +2697,6 @@ proc igCalcTypematicRepeatAmount*(t0: float32, t1: float32, repeat_delay: float3 proc igCalcWindowNextAutoFitSizeNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igCalcWindowNextAutoFitSize".} proc igCalcWrapWidthForPos*(pos: ImVec2, wrap_pos_x: float32): float32 {.importc: "igCalcWrapWidthForPos".} proc igCallContextHooks*(context: ptr ImGuiContext, `type`: ImGuiContextHookType): void {.importc: "igCallContextHooks".} -proc igCaptureKeyboardFromApp*(want_capture_keyboard_value: bool = true): void {.importc: "igCaptureKeyboardFromApp".} -proc igCaptureMouseFromApp*(want_capture_mouse_value: bool = true): void {.importc: "igCaptureMouseFromApp".} proc igCheckbox*(label: cstring, v: ptr bool): bool {.importc: "igCheckbox".} proc igCheckboxFlags*(label: cstring, flags: ptr int32, flags_value: int32): bool {.importc: "igCheckboxFlags_IntPtr".} proc igCheckboxFlags*(label: cstring, flags: ptr uint32, flags_value: uint32): bool {.importc: "igCheckboxFlags_UintPtr".} @@ -2706,10 +2740,14 @@ proc igDataTypeGetInfo*(data_type: ImGuiDataType): ptr ImGuiDataTypeInfo {.impor proc igDebugCheckVersionAndDataLayout*(version_str: cstring, sz_io: uint, sz_style: uint, sz_vec2: uint, sz_vec4: uint, sz_drawvert: uint, sz_drawidx: uint): bool {.importc: "igDebugCheckVersionAndDataLayout".} proc igDebugDrawItemRect*(col: uint32 = 4278190335'u32): void {.importc: "igDebugDrawItemRect".} proc igDebugHookIdInfo*(id: ImGuiID, data_type: ImGuiDataType, data_id: pointer, data_id_end: pointer): void {.importc: "igDebugHookIdInfo".} +proc igDebugLog*(fmt: cstring): void {.importc: "igDebugLog", varargs.} +proc igDebugLogV*(fmt: cstring): void {.importc: "igDebugLogV", varargs.} proc igDebugNodeColumns*(columns: ptr ImGuiOldColumns): void {.importc: "igDebugNodeColumns".} proc igDebugNodeDrawCmdShowMeshAndBoundingBox*(out_draw_list: ptr ImDrawList, draw_list: ptr ImDrawList, draw_cmd: ptr ImDrawCmd, show_mesh: bool, show_aabb: bool): void {.importc: "igDebugNodeDrawCmdShowMeshAndBoundingBox".} proc igDebugNodeDrawList*(window: ptr ImGuiWindow, draw_list: ptr ImDrawList, label: cstring): void {.importc: "igDebugNodeDrawList".} proc igDebugNodeFont*(font: ptr ImFont): void {.importc: "igDebugNodeFont".} +proc igDebugNodeFontGlyph*(font: ptr ImFont, glyph: ptr ImFontGlyph): void {.importc: "igDebugNodeFontGlyph".} +proc igDebugNodeInputTextState*(state: ptr ImGuiInputTextState): void {.importc: "igDebugNodeInputTextState".} proc igDebugNodeStorage*(storage: ptr ImGuiStorage, label: cstring): void {.importc: "igDebugNodeStorage".} proc igDebugNodeTabBar*(tab_bar: ptr ImGuiTabBar, label: cstring): void {.importc: "igDebugNodeTabBar".} proc igDebugNodeTable*(table: ptr ImGuiTable): void {.importc: "igDebugNodeTable".} @@ -2721,6 +2759,7 @@ proc igDebugNodeWindowsList*(windows: ptr ImVector[ptr ImGuiWindow], label: cstr proc igDebugNodeWindowsListByBeginStackParent*(windows: ptr ptr ImGuiWindow, windows_size: int32, parent_in_begin_stack: ptr ImGuiWindow): void {.importc: "igDebugNodeWindowsListByBeginStackParent".} proc igDebugRenderViewportThumbnail*(draw_list: ptr ImDrawList, viewport: ptr ImGuiViewportP, bb: ImRect): void {.importc: "igDebugRenderViewportThumbnail".} proc igDebugStartItemPicker*(): void {.importc: "igDebugStartItemPicker".} +proc igDebugTextEncoding*(text: cstring): void {.importc: "igDebugTextEncoding".} proc igDestroyContext*(ctx: ptr ImGuiContext = nil): void {.importc: "igDestroyContext".} proc igDragBehavior*(id: ImGuiID, data_type: ImGuiDataType, p_v: pointer, v_speed: float32, p_min: pointer, p_max: pointer, format: cstring, flags: ImGuiSliderFlags): bool {.importc: "igDragBehavior".} proc igDragFloat*(label: cstring, v: ptr float32, v_speed: float32 = 1.0f, v_min: float32 = 0.0f, v_max: float32 = 0.0f, format: cstring = "%.3f", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igDragFloat".} @@ -2835,14 +2874,14 @@ proc igGetKeyIndex*(key: ImGuiKey): int32 {.importc: "igGetKeyIndex".} proc igGetKeyName*(key: ImGuiKey): cstring {.importc: "igGetKeyName".} proc igGetKeyPressedAmount*(key: ImGuiKey, repeat_delay: float32, rate: float32): int32 {.importc: "igGetKeyPressedAmount".} proc igGetMainViewport*(): ptr ImGuiViewport {.importc: "igGetMainViewport".} -proc igGetMergedKeyModFlags*(): ImGuiKeyModFlags {.importc: "igGetMergedKeyModFlags".} +proc igGetMergedModFlags*(): ImGuiModFlags {.importc: "igGetMergedModFlags".} proc igGetMouseClickedCount*(button: ImGuiMouseButton): int32 {.importc: "igGetMouseClickedCount".} proc igGetMouseCursor*(): ImGuiMouseCursor {.importc: "igGetMouseCursor".} proc igGetMouseDragDeltaNonUDT*(pOut: ptr ImVec2, button: ImGuiMouseButton = 0.ImGuiMouseButton, lock_threshold: float32 = -1.0f): void {.importc: "igGetMouseDragDelta".} proc igGetMousePosNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePos".} proc igGetMousePosOnOpeningCurrentPopupNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePosOnOpeningCurrentPopup".} -proc igGetNavInputAmount*(n: ImGuiNavInput, mode: ImGuiInputReadMode): float32 {.importc: "igGetNavInputAmount".} -proc igGetNavInputAmount2dNonUDT*(pOut: ptr ImVec2, dir_sources: ImGuiNavDirSourceFlags, mode: ImGuiInputReadMode, slow_factor: float32 = 0.0f, fast_factor: float32 = 0.0f): void {.importc: "igGetNavInputAmount2d".} +proc igGetNavInputAmount*(n: ImGuiNavInput, mode: ImGuiNavReadMode): float32 {.importc: "igGetNavInputAmount".} +proc igGetNavInputAmount2dNonUDT*(pOut: ptr ImVec2, dir_sources: ImGuiNavDirSourceFlags, mode: ImGuiNavReadMode, slow_factor: float32 = 0.0f, fast_factor: float32 = 0.0f): void {.importc: "igGetNavInputAmount2d".} proc igGetNavInputName*(n: ImGuiNavInput): cstring {.importc: "igGetNavInputName".} proc igGetPopupAllowedExtentRectNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow): void {.importc: "igGetPopupAllowedExtentRect".} proc igGetScrollMaxX*(): float32 {.importc: "igGetScrollMaxX".} @@ -2907,6 +2946,8 @@ proc igImFontAtlasBuildRender8bppRectFromString*(atlas: ptr ImFontAtlas, x: int3 proc igImFontAtlasBuildSetupFont*(atlas: ptr ImFontAtlas, font: ptr ImFont, font_config: ptr ImFontConfig, ascent: float32, descent: float32): void {.importc: "igImFontAtlasBuildSetupFont".} proc igImFontAtlasGetBuilderForStbTruetype*(): ptr ImFontBuilderIO {.importc: "igImFontAtlasGetBuilderForStbTruetype".} proc igImFormatString*(buf: cstring, buf_size: uint, fmt: cstring): int32 {.importc: "igImFormatString", varargs.} +proc igImFormatStringToTempBuffer*(out_buf: ptr cstring, out_buf_end: ptr cstring, fmt: cstring): void {.importc: "igImFormatStringToTempBuffer", varargs.} +proc igImFormatStringToTempBufferV*(out_buf: ptr cstring, out_buf_end: ptr cstring, fmt: cstring): void {.importc: "igImFormatStringToTempBufferV", varargs.} proc igImFormatStringV*(buf: cstring, buf_size: uint, fmt: cstring): int32 {.importc: "igImFormatStringV", varargs.} proc igImGetDirQuadrantFromDelta*(dx: float32, dy: float32): ImGuiDir {.importc: "igImGetDirQuadrantFromDelta".} proc igImHashData*(data: pointer, data_size: uint, seed: uint32 = 0): ImGuiID {.importc: "igImHashData".} @@ -2931,6 +2972,8 @@ proc igImMulNonUDT*(pOut: ptr ImVec2, lhs: ImVec2, rhs: ImVec2): void {.importc: proc igImParseFormatFindEnd*(format: cstring): cstring {.importc: "igImParseFormatFindEnd".} proc igImParseFormatFindStart*(format: cstring): cstring {.importc: "igImParseFormatFindStart".} proc igImParseFormatPrecision*(format: cstring, default_value: int32): int32 {.importc: "igImParseFormatPrecision".} +proc igImParseFormatSanitizeForPrinting*(fmt_in: cstring, fmt_out: cstring, fmt_out_size: uint): void {.importc: "igImParseFormatSanitizeForPrinting".} +proc igImParseFormatSanitizeForScanning*(fmt_in: cstring, fmt_out: cstring, fmt_out_size: uint): cstring {.importc: "igImParseFormatSanitizeForScanning".} proc igImParseFormatTrimDecorations*(format: cstring, buf: cstring, buf_size: uint): cstring {.importc: "igImParseFormatTrimDecorations".} proc igImPow*(x: float32, y: float32): float32 {.importc: "igImPow_Float".} proc igImPow*(x: float64, y: float64): float64 {.importc: "igImPow_double".} @@ -2969,7 +3012,7 @@ proc igImage*(user_texture_id: ImTextureID, size: ImVec2, uv0: ImVec2 = ImVec2(x proc igImageButton*(user_texture_id: ImTextureID, size: ImVec2, uv0: ImVec2 = ImVec2(x: 0, y: 0), uv1: ImVec2 = ImVec2(x: 1, y: 1), frame_padding: int32 = -1, bg_col: ImVec4 = ImVec4(x: 0, y: 0, z: 0, w: 0), tint_col: ImVec4 = ImVec4(x: 1, y: 1, z: 1, w: 1)): bool {.importc: "igImageButton".} proc igImageButtonEx*(id: ImGuiID, texture_id: ImTextureID, size: ImVec2, uv0: ImVec2, uv1: ImVec2, padding: ImVec2, bg_col: ImVec4, tint_col: ImVec4): bool {.importc: "igImageButtonEx".} proc igIndent*(indent_w: float32 = 0.0f): void {.importc: "igIndent".} -proc igInitialize*(context: ptr ImGuiContext): void {.importc: "igInitialize".} +proc igInitialize*(): void {.importc: "igInitialize".} proc igInputDouble*(label: cstring, v: ptr float64, step: float64 = 0.0, step_fast: float64 = 0.0, format: cstring = "%.6f", flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputDouble".} proc igInputFloat*(label: cstring, v: ptr float32, step: float32 = 0.0f, step_fast: float32 = 0.0f, format: cstring = "%.3f", flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputFloat".} proc igInputFloat2*(label: cstring, v: var array[2, float32], format: cstring = "%.3f", flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputFloat2".} @@ -2994,6 +3037,7 @@ proc igIsAnyItemFocused*(): bool {.importc: "igIsAnyItemFocused".} proc igIsAnyItemHovered*(): bool {.importc: "igIsAnyItemHovered".} proc igIsAnyMouseDown*(): bool {.importc: "igIsAnyMouseDown".} proc igIsClippedEx*(bb: ImRect, id: ImGuiID): bool {.importc: "igIsClippedEx".} +proc igIsDragDropActive*(): bool {.importc: "igIsDragDropActive".} proc igIsDragDropPayloadBeingAccepted*(): bool {.importc: "igIsDragDropPayloadBeingAccepted".} proc igIsGamepadKey*(key: ImGuiKey): bool {.importc: "igIsGamepadKey".} proc igIsItemActivated*(): bool {.importc: "igIsItemActivated".} @@ -3022,7 +3066,7 @@ proc igIsMousePosValid*(mouse_pos: ptr ImVec2 = nil): bool {.importc: "igIsMouse proc igIsMouseReleased*(button: ImGuiMouseButton): bool {.importc: "igIsMouseReleased".} proc igIsNamedKey*(key: ImGuiKey): bool {.importc: "igIsNamedKey".} proc igIsNavInputDown*(n: ImGuiNavInput): bool {.importc: "igIsNavInputDown".} -proc igIsNavInputTest*(n: ImGuiNavInput, rm: ImGuiInputReadMode): bool {.importc: "igIsNavInputTest".} +proc igIsNavInputTest*(n: ImGuiNavInput, rm: ImGuiNavReadMode): bool {.importc: "igIsNavInputTest".} proc igIsPopupOpen*(str_id: cstring, flags: ImGuiPopupFlags = 0.ImGuiPopupFlags): bool {.importc: "igIsPopupOpen_Str".} proc igIsPopupOpen*(id: ImGuiID, popup_flags: ImGuiPopupFlags): bool {.importc: "igIsPopupOpen_ID".} proc igIsRectVisible*(size: ImVec2): bool {.importc: "igIsRectVisible_Nil".} @@ -3122,6 +3166,7 @@ proc igPushTextWrapPos*(wrap_local_pos_x: float32 = 0.0f): void {.importc: "igPu proc igRadioButton*(label: cstring, active: bool): bool {.importc: "igRadioButton_Bool".} proc igRadioButton*(label: cstring, v: ptr int32, v_button: int32): bool {.importc: "igRadioButton_IntPtr".} proc igRemoveContextHook*(context: ptr ImGuiContext, hook_to_remove: ImGuiID): void {.importc: "igRemoveContextHook".} +proc igRemoveSettingsHandler*(type_name: cstring): void {.importc: "igRemoveSettingsHandler".} proc igRender*(): void {.importc: "igRender".} proc igRenderArrow*(draw_list: ptr ImDrawList, pos: ImVec2, col: uint32, dir: ImGuiDir, scale: float32 = 1.0f): void {.importc: "igRenderArrow".} proc igRenderArrowPointingAt*(draw_list: ptr ImDrawList, pos: ImVec2, half_sz: ImVec2, direction: ImGuiDir, col: uint32): void {.importc: "igRenderArrowPointingAt".} @@ -3130,7 +3175,7 @@ proc igRenderCheckMark*(draw_list: ptr ImDrawList, pos: ImVec2, col: uint32, sz: proc igRenderColorRectWithAlphaCheckerboard*(draw_list: ptr ImDrawList, p_min: ImVec2, p_max: ImVec2, fill_col: uint32, grid_step: float32, grid_off: ImVec2, rounding: float32 = 0.0f, flags: ImDrawFlags = 0.ImDrawFlags): void {.importc: "igRenderColorRectWithAlphaCheckerboard".} proc igRenderFrame*(p_min: ImVec2, p_max: ImVec2, fill_col: uint32, border: bool = true, rounding: float32 = 0.0f): void {.importc: "igRenderFrame".} proc igRenderFrameBorder*(p_min: ImVec2, p_max: ImVec2, rounding: float32 = 0.0f): void {.importc: "igRenderFrameBorder".} -proc igRenderMouseCursor*(draw_list: ptr ImDrawList, pos: ImVec2, scale: float32, mouse_cursor: ImGuiMouseCursor, col_fill: uint32, col_border: uint32, col_shadow: uint32): void {.importc: "igRenderMouseCursor".} +proc igRenderMouseCursor*(pos: ImVec2, scale: float32, mouse_cursor: ImGuiMouseCursor, col_fill: uint32, col_border: uint32, col_shadow: uint32): void {.importc: "igRenderMouseCursor".} proc igRenderNavHighlight*(bb: ImRect, id: ImGuiID, flags: ImGuiNavHighlightFlags = ImGuiNavHighlightFlags.TypeDefault.ImGuiNavHighlightFlags): void {.importc: "igRenderNavHighlight".} proc igRenderRectFilledRangeH*(draw_list: ptr ImDrawList, rect: ImRect, col: uint32, x_start_norm: float32, x_end_norm: float32, rounding: float32): void {.importc: "igRenderRectFilledRangeH".} proc igRenderRectFilledWithHole*(draw_list: ptr ImDrawList, outer: ImRect, inner: ImRect, col: uint32, rounding: float32): void {.importc: "igRenderRectFilledWithHole".} @@ -3177,6 +3222,9 @@ proc igSetKeyboardFocusHere*(offset: int32 = 0): void {.importc: "igSetKeyboardF proc igSetLastItemData*(item_id: ImGuiID, in_flags: ImGuiItemFlags, status_flags: ImGuiItemStatusFlags, item_rect: ImRect): void {.importc: "igSetLastItemData".} proc igSetMouseCursor*(cursor_type: ImGuiMouseCursor): void {.importc: "igSetMouseCursor".} proc igSetNavID*(id: ImGuiID, nav_layer: ImGuiNavLayer, focus_scope_id: ImGuiID, rect_rel: ImRect): void {.importc: "igSetNavID".} +proc igSetNavWindow*(window: ptr ImGuiWindow): void {.importc: "igSetNavWindow".} +proc igSetNextFrameWantCaptureKeyboard*(want_capture_keyboard: bool): void {.importc: "igSetNextFrameWantCaptureKeyboard".} +proc igSetNextFrameWantCaptureMouse*(want_capture_mouse: bool): void {.importc: "igSetNextFrameWantCaptureMouse".} proc igSetNextItemOpen*(is_open: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextItemOpen".} proc igSetNextItemWidth*(item_width: float32): void {.importc: "igSetNextItemWidth".} proc igSetNextWindowBgAlpha*(alpha: float32): void {.importc: "igSetNextWindowBgAlpha".} @@ -3215,9 +3263,11 @@ proc igSetWindowPos*(window: ptr ImGuiWindow, pos: ImVec2, cond: ImGuiCond = 0.I proc igSetWindowSize*(size: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowSize_Vec2".} proc igSetWindowSize*(name: cstring, size: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowSize_Str".} proc igSetWindowSize*(window: ptr ImGuiWindow, size: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowSize_WindowPtr".} +proc igSetWindowViewport*(window: ptr ImGuiWindow, viewport: ptr ImGuiViewportP): void {.importc: "igSetWindowViewport".} proc igShadeVertsLinearColorGradientKeepAlpha*(draw_list: ptr ImDrawList, vert_start_idx: int32, vert_end_idx: int32, gradient_p0: ImVec2, gradient_p1: ImVec2, col0: uint32, col1: uint32): void {.importc: "igShadeVertsLinearColorGradientKeepAlpha".} proc igShadeVertsLinearUV*(draw_list: ptr ImDrawList, vert_start_idx: int32, vert_end_idx: int32, a: ImVec2, b: ImVec2, uv_a: ImVec2, uv_b: ImVec2, clamp: bool): void {.importc: "igShadeVertsLinearUV".} proc igShowAboutWindow*(p_open: ptr bool = nil): void {.importc: "igShowAboutWindow".} +proc igShowDebugLogWindow*(p_open: ptr bool = nil): void {.importc: "igShowDebugLogWindow".} proc igShowDemoWindow*(p_open: ptr bool = nil): void {.importc: "igShowDemoWindow".} proc igShowFontAtlas*(atlas: ptr ImFontAtlas): void {.importc: "igShowFontAtlas".} proc igShowFontSelector*(label: cstring): void {.importc: "igShowFontSelector".} @@ -3227,7 +3277,7 @@ proc igShowStyleEditor*(`ref`: ptr ImGuiStyle = nil): void {.importc: "igShowSty proc igShowStyleSelector*(label: cstring): bool {.importc: "igShowStyleSelector".} proc igShowUserGuide*(): void {.importc: "igShowUserGuide".} proc igShrinkWidths*(items: ptr ImGuiShrinkWidthItem, count: int32, width_excess: float32): void {.importc: "igShrinkWidths".} -proc igShutdown*(context: ptr ImGuiContext): void {.importc: "igShutdown".} +proc igShutdown*(): void {.importc: "igShutdown".} proc igSliderAngle*(label: cstring, v_rad: ptr float32, v_degrees_min: float32 = -360.0f, v_degrees_max: float32 = +360.0f, format: cstring = "%.0f deg", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igSliderAngle".} proc igSliderBehavior*(bb: ImRect, id: ImGuiID, data_type: ImGuiDataType, p_v: pointer, p_min: pointer, p_max: pointer, format: cstring, flags: ImGuiSliderFlags, out_grab_bb: ptr ImRect): bool {.importc: "igSliderBehavior".} proc igSliderFloat*(label: cstring, v: ptr float32, v_min: float32, v_max: float32, format: cstring = "%.3f", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igSliderFloat".} @@ -3283,6 +3333,7 @@ proc igTableGetColumnResizeID*(table: ptr ImGuiTable, column_n: int32, instance_ proc igTableGetColumnWidthAuto*(table: ptr ImGuiTable, column: ptr ImGuiTableColumn): float32 {.importc: "igTableGetColumnWidthAuto".} proc igTableGetHeaderRowHeight*(): float32 {.importc: "igTableGetHeaderRowHeight".} proc igTableGetHoveredColumn*(): int32 {.importc: "igTableGetHoveredColumn".} +proc igTableGetInstanceData*(table: ptr ImGuiTable, instance_no: int32): ptr ImGuiTableInstanceData {.importc: "igTableGetInstanceData".} proc igTableGetMaxColumnWidth*(table: ptr ImGuiTable, column_n: int32): float32 {.importc: "igTableGetMaxColumnWidth".} proc igTableGetRowIndex*(): int32 {.importc: "igTableGetRowIndex".} proc igTableGetSortSpecs*(): ptr ImGuiTableSortSpecs {.importc: "igTableGetSortSpecs".} @@ -3305,9 +3356,9 @@ proc igTableSetColumnSortDirection*(column_n: int32, sort_direction: ImGuiSortDi proc igTableSetColumnWidth*(column_n: int32, width: float32): void {.importc: "igTableSetColumnWidth".} proc igTableSetColumnWidthAutoAll*(table: ptr ImGuiTable): void {.importc: "igTableSetColumnWidthAutoAll".} proc igTableSetColumnWidthAutoSingle*(table: ptr ImGuiTable, column_n: int32): void {.importc: "igTableSetColumnWidthAutoSingle".} +proc igTableSettingsAddSettingsHandler*(): void {.importc: "igTableSettingsAddSettingsHandler".} proc igTableSettingsCreate*(id: ImGuiID, columns_count: int32): ptr ImGuiTableSettings {.importc: "igTableSettingsCreate".} proc igTableSettingsFindByID*(id: ImGuiID): ptr ImGuiTableSettings {.importc: "igTableSettingsFindByID".} -proc igTableSettingsInstallHandler*(context: ptr ImGuiContext): void {.importc: "igTableSettingsInstallHandler".} proc igTableSetupColumn*(label: cstring, flags: ImGuiTableColumnFlags = 0.ImGuiTableColumnFlags, init_width_or_weight: float32 = 0.0f, user_id: ImGuiID = 0.ImGuiID): void {.importc: "igTableSetupColumn".} proc igTableSetupDrawChannels*(table: ptr ImGuiTable): void {.importc: "igTableSetupDrawChannels".} proc igTableSetupScrollFreeze*(cols: int32, rows: int32): void {.importc: "igTableSetupScrollFreeze".} diff --git a/src/imgui/private/cimgui b/src/imgui/private/cimgui index bd5a043..08d5ad7 160000 --- a/src/imgui/private/cimgui +++ b/src/imgui/private/cimgui @@ -1 +1 @@ -Subproject commit bd5a043957f606ba84745e4bb41940e87410c55c +Subproject commit 08d5ad7f93eb169377c20bd42748877a41759b63 diff --git a/tools/generator.nim b/tools/generator.nim index 72faa17..ef7253f 100755 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -133,6 +133,9 @@ proc translateType(name: string): string = if result == "ptr ptr ImDrawList": result = "UncheckedArray[ptr ImDrawList]" + if result == "": + result = "void" + proc genEnums(output: var string) = let file = readFile("src/imgui/private/cimgui/generator/output/structs_and_enums.json") let data = file.parseJson() @@ -152,9 +155,6 @@ proc genEnums(output: var string) = var dataName = data["name"].getStr() let dataValue = data["calc_value"].getInt() dataName = dataName.replace("__", "_") - if dataName.contains("NamedKey") or dataName == "ImGuiKey_KeysData_SIZE": - tableNamedKeys[dataName] = dataValue - continue dataName = dataName.split("_", 1)[1] if dataName.endsWith("_"): dataName = dataName[0 ..< dataName.len - 1] @@ -164,7 +164,8 @@ proc genEnums(output: var string) = enumsCount[data["name"].getStr()] = data["calc_value"].getInt() continue if table.hasKey(dataValue): - echo "Enum {enumName}.{dataName} already exists as {enumName}.{table[dataValue]} with value {dataValue} skipping...".fmt + echo "Notice: Enum {enumName}.{dataName} already exists as {enumName}.{table[dataValue]} with value {dataValue}, use constant {enumName}_{dataName} to access it".fmt + tableNamedKeys[enumName & "_" & dataName] = dataValue continue table[dataValue] = dataName @@ -177,7 +178,7 @@ proc genEnums(output: var string) = output.add(" {v} = {k}\n".fmt) if tableNamedKeys.len > 0: - output.add("\n") + output.add("\n# Duplicate enums as consts\n") for k, v in tableNamedKeys.pairs: output.add("const {k}* = {v}\n".fmt) From f30c1b97ffcdd23ceaa036213a964f40837be232 Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 09:17:03 +0900 Subject: [PATCH 05/25] modified: test order --- imgui.nimble | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index 689e73e..73a49c3 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.88" +version = "1.89.8" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" @@ -16,10 +16,10 @@ task gen, "Generate bindings from source": task test, "Create window with imgui demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 - exec("nim c -r tests/test.nim") # requires cimgui.dll exec("nim cpp -r tests/test.nim") + exec("nim c -r tests/test.nim") # requires cimgui.dll task ci, "Create window with imgui null demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 - exec("nim c -r tests/tnull.nim") # requires cimgui.dll exec("nim cpp -r tests/tnull.nim") + exec("nim c -r tests/tnull.nim") # requires cimgui.dll From dda28e24879383d4adbe61aa026b38ff56b2ec0e Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 09:18:38 +0900 Subject: [PATCH 06/25] replaced: "assert" with "doAssert" --- tests/test.nim | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/tests/test.nim b/tests/test.nim index b6ae6db..93e2404 100644 --- a/tests/test.nim +++ b/tests/test.nim @@ -3,11 +3,12 @@ import imgui, imgui/[impl_opengl, impl_glfw] import nimgl/[opengl, glfw] + proc main() = - assert glfwInit() + doAssert glfwInit() - glfwWindowHint(GLFWContextVersionMajor, 4) - glfwWindowHint(GLFWContextVersionMinor, 1) + glfwWindowHint(GLFWContextVersionMajor, 3) + glfwWindowHint(GLFWContextVersionMinor, 3) glfwWindowHint(GLFWOpenglForwardCompat, GLFW_TRUE) glfwWindowHint(GLFWOpenglProfile, GLFW_OPENGL_CORE_PROFILE) glfwWindowHint(GLFWResizable, GLFW_TRUE) @@ -18,13 +19,13 @@ proc main() = w.makeContextCurrent() - assert glInit() + doAssert glInit() let context = igCreateContext() #let io = igGetIO() - assert igGlfwInitForOpenGL(w, true) - assert igOpenGL3Init() + doAssert igGlfwInitForOpenGL(w, true) + doAssert igOpenGL3Init() igStyleColorsCherry() From 247447f7c7d50f05801124e2352bc848c91afe78 Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 09:21:08 +0900 Subject: [PATCH 07/25] modified: for ImGui v1.89.8 --- src/imgui.nim | 966 ++++++++++++++++++++++++++++++-------- src/imgui/impl_glfw.nim | 4 +- src/imgui/impl_opengl.nim | 2 +- src/imgui/private/cimgui | 2 +- tools/generator.nim | 2 +- tools/utils.nim | 8 + 6 files changed, 787 insertions(+), 197 deletions(-) diff --git a/src/imgui.nim b/src/imgui.nim index d4443b1..56a50be 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -21,6 +21,14 @@ import strutils +## Tentative workaround [start] +type + uint32Ptr* = ptr uint32 + const_cstringPtr* = cstring + Imguidockrequest* = distinct object + ImGuiDockNodeSettings* = distinct object +## Tentative workaround [end] + proc currentSourceDir(): string {.compileTime.} = result = currentSourcePath().replace("\\", "/") result = result[0 ..< result.rfind("/")] @@ -89,6 +97,9 @@ type HasMouseCursors = 2 HasSetMousePos = 4 RendererHasVtxOffset = 8 + PlatformHasViewports = 1024 + HasMouseHoveredViewport = 2048 + RendererHasViewports = 4096 ImGuiButtonFlagsPrivate* {.pure, size: int32.sizeof.} = enum PressedOnClick = 16 PressedOnClickRelease = 32 @@ -99,13 +110,15 @@ type PressedOnMask = 1008 Repeat = 1024 FlattenChildren = 2048 - AllowItemOverlap = 4096 + AllowOverlap = 4096 DontClosePopups = 8192 AlignTextBaseLine = 32768 NoKeyModifiers = 65536 NoHoldingActiveId = 131072 NoNavFocus = 262144 NoHoveredOnFocus = 524288 + NoSetKeyOwner = 1048576 + NoTestKeyOwner = 2097152 ImGuiButtonFlags* {.pure, size: int32.sizeof.} = enum None = 0 MouseButtonLeft = 1 @@ -151,21 +164,23 @@ type TabActive = 35 TabUnfocused = 36 TabUnfocusedActive = 37 - PlotLines = 38 - PlotLinesHovered = 39 - PlotHistogram = 40 - PlotHistogramHovered = 41 - TableHeaderBg = 42 - TableBorderStrong = 43 - TableBorderLight = 44 - TableRowBg = 45 - TableRowBgAlt = 46 - TextSelectedBg = 47 - DragDropTarget = 48 - NavHighlight = 49 - NavWindowingHighlight = 50 - NavWindowingDimBg = 51 - ModalWindowDimBg = 52 + DockingPreview = 38 + DockingEmptyBg = 39 + PlotLines = 40 + PlotLinesHovered = 41 + PlotHistogram = 42 + PlotHistogramHovered = 43 + TableHeaderBg = 44 + TableBorderStrong = 45 + TableBorderLight = 46 + TableRowBg = 47 + TableRowBgAlt = 48 + TextSelectedBg = 49 + DragDropTarget = 50 + NavHighlight = 51 + NavWindowingHighlight = 52 + NavWindowingDimBg = 53 + ModalWindowDimBg = 54 ImGuiColorEditFlags* {.pure, size: int32.sizeof.} = enum None = 0 NoAlpha = 2 @@ -222,6 +237,10 @@ type NavNoCaptureKeyboard = 8 NoMouse = 16 NoMouseCursorChange = 32 + DockingEnable = 64 + ViewportsEnable = 1024 + DpiEnableScaleViewports = 16384 + DpiEnableScaleFonts = 32768 IsSRGB = 1048576 IsTouchScreen = 2097152 ImGuiContextHookType* {.pure, size: int32.sizeof.} = enum @@ -233,6 +252,10 @@ type RenderPost = 5 Shutdown = 6 PendingRemoval = 7 + ImGuiDataAuthority* {.pure, size: int32.sizeof.} = enum + Auto = 0 + DockNode = 1 + Window = 2 ImGuiDataTypePrivate* {.pure, size: int32.sizeof.} = enum String = 11 Pointer = 12 @@ -254,8 +277,12 @@ type EventFocus = 2 EventPopup = 4 EventNav = 8 - EventIO = 16 - EventMask = 31 + EventClipper = 16 + EventSelection = 32 + EventIO = 64 + EventDocking = 128 + EventViewport = 256 + EventMask = 511 OutputToTTY = 1024 ImGuiDir* {.pure, size: int32.sizeof.} = enum None = -1 @@ -263,6 +290,39 @@ type Right = 1 Up = 2 Down = 3 + ImGuiDockNodeFlagsPrivate* {.pure, size: int32.sizeof.} = enum + SharedFlagsInheritMask = -1 + DockSpace = 1024 + CentralNode = 2048 + NoTabBar = 4096 + HiddenTabBar = 8192 + NoWindowMenuButton = 16384 + NoCloseButton = 32768 + NoDocking = 65536 + NoDockingSplitMe = 131072 + NoDockingSplitOther = 262144 + NoDockingOverMe = 524288 + NoDockingOverOther = 1048576 + NoDockingOverEmpty = 2097152 + NoResizeX = 4194304 + NoResizeY = 8388608 + NoResizeFlagsMask = 12582944 + LocalFlagsTransferMask = 12712048 + SavedFlagsMask = 12712992 + LocalFlagsMask = 12713072 + ImGuiDockNodeFlags* {.pure, size: int32.sizeof.} = enum + None = 0 + KeepAliveOnly = 1 + NoDockingInCentralNode = 4 + PassthruCentralNode = 8 + NoSplit = 16 + NoResize = 32 + AutoHideTabBar = 64 + ImGuiDockNodeState* {.pure, size: int32.sizeof.} = enum + Unknown = 0 + HostWindowHiddenBecauseSingleWindow = 1 + HostWindowHiddenBecauseWindowsAreResizing = 2 + HostWindowVisible = 3 ImGuiDragDropFlags* {.pure, size: int32.sizeof.} = enum None = 0 SourceNoPreviewTooltip = 1 @@ -275,6 +335,10 @@ type AcceptNoDrawDefaultRect = 2048 AcceptPeekOnly = 3072 AcceptNoPreviewTooltip = 4096 + ImGuiFocusRequestFlags* {.pure, size: int32.sizeof.} = enum + None = 0 + RestoreFocusedChild = 1 + UnlessBelowModal = 2 ImGuiFocusedFlags* {.pure, size: int32.sizeof.} = enum None = 0 ChildWindows = 1 @@ -282,6 +346,11 @@ type RootAndChildWindows = 3 AnyWindow = 4 NoPopupHierarchy = 8 + DockHierarchy = 16 + ImGuiHoveredFlagsPrivate* {.pure, size: int32.sizeof.} = enum + AllowedMaskForIsWindowHovered = 12479 + DelayMask = 245760 + AllowedMaskForIsItemHovered = 262048 ImGuiHoveredFlags* {.pure, size: int32.sizeof.} = enum None = 0 ChildWindows = 1 @@ -289,27 +358,60 @@ type RootAndChildWindows = 3 AnyWindow = 4 NoPopupHierarchy = 8 + DockHierarchy = 16 AllowWhenBlockedByPopup = 32 AllowWhenBlockedByActiveItem = 128 - AllowWhenOverlapped = 256 - RectOnly = 416 - AllowWhenDisabled = 512 - NoNavOverride = 1024 + AllowWhenOverlappedByItem = 256 + AllowWhenOverlappedByWindow = 512 + AllowWhenOverlapped = 768 + RectOnly = 928 + AllowWhenDisabled = 1024 + NoNavOverride = 2048 + ForTooltip = 4096 + Stationary = 8192 + DelayNone = 16384 + DelayShort = 32768 + DelayNormal = 65536 + NoSharedDelay = 131072 ImGuiInputEventType* {.pure, size: int32.sizeof.} = enum None = 0 MousePos = 1 MouseWheel = 2 MouseButton = 3 - Key = 4 - Text = 5 - Focus = 6 + MouseViewport = 4 + Key = 5 + Text = 6 + Focus = 7 + ImGuiInputFlags* {.pure, size: int32.sizeof.} = enum + None = 0 + Repeat = 1 + RepeatRateDefault = 2 + RepeatRateNavMove = 4 + RepeatRateNavTweak = 8 + RepeatRateMask = 14 + SupportedByIsKeyPressed = 15 + CondHovered = 16 + CondActive = 32 + CondDefault = 48 + LockThisFrame = 64 + LockUntilRelease = 128 + SupportedBySetKeyOwner = 192 + SupportedBySetItemKeyOwner = 240 + RouteFocused = 256 + RouteGlobalLow = 512 + RouteGlobal = 1024 + RouteGlobalHigh = 2048 + RouteMask = 3840 + RouteAlways = 4096 + RouteUnlessBgFocused = 8192 + RouteExtraMask = 12288 + SupportedByShortcut = 16143 ImGuiInputSource* {.pure, size: int32.sizeof.} = enum None = 0 Mouse = 1 Keyboard = 2 Gamepad = 3 Clipboard = 4 - Nav = 5 ImGuiInputTextFlagsPrivate* {.pure, size: int32.sizeof.} = enum Multiline = 67108864 NoMarkEdited = 134217728 @@ -336,6 +438,7 @@ type CharsScientific = 131072 CallbackResize = 262144 CallbackEdit = 524288 + EscapeClearsAll = 1048576 ImGuiItemFlags* {.pure, size: int32.sizeof.} = enum None = 0 NoTabStop = 1 @@ -346,7 +449,9 @@ type SelectableDontClosePopup = 32 MixedValue = 64 ReadOnly = 128 - Inputable = 256 + NoWindowHoverableCheck = 256 + AllowOverlap = 512 + Inputable = 1024 ImGuiItemStatusFlags* {.pure, size: int32.sizeof.} = enum None = 0 HoveredRect = 1 @@ -358,14 +463,9 @@ type Deactivated = 64 HoveredWindow = 128 FocusedByTabbing = 256 - ImGuiKeyPrivate* {.pure, size: int32.sizeof.} = enum - LegacyNativeKey_BEGIN = 0 - LegacyNativeKey_END = 512 - Gamepad_BEGIN = 617 - Gamepad_END = 641 + Visible = 512 ImGuiKey* {.pure, size: int32.sizeof.} = enum None = 0 - NamedKey_COUNT = 133 Tab = 512 LeftArrow = 513 RightArrow = 514 @@ -473,48 +573,65 @@ type KeypadEqual = 616 GamepadStart = 617 GamepadBack = 618 - GamepadFaceUp = 619 - GamepadFaceDown = 620 - GamepadFaceLeft = 621 - GamepadFaceRight = 622 - GamepadDpadUp = 623 - GamepadDpadDown = 624 - GamepadDpadLeft = 625 - GamepadDpadRight = 626 + GamepadFaceLeft = 619 + GamepadFaceRight = 620 + GamepadFaceUp = 621 + GamepadFaceDown = 622 + GamepadDpadLeft = 623 + GamepadDpadRight = 624 + GamepadDpadUp = 625 + GamepadDpadDown = 626 GamepadL1 = 627 GamepadR1 = 628 GamepadL2 = 629 GamepadR2 = 630 GamepadL3 = 631 GamepadR3 = 632 - GamepadLStickUp = 633 - GamepadLStickDown = 634 - GamepadLStickLeft = 635 - GamepadLStickRight = 636 - GamepadRStickUp = 637 - GamepadRStickDown = 638 - GamepadRStickLeft = 639 - GamepadRStickRight = 640 - ModCtrl = 641 - ModShift = 642 - ModAlt = 643 - ModSuper = 644 - NamedKey_END = 645 + GamepadLStickLeft = 633 + GamepadLStickRight = 634 + GamepadLStickUp = 635 + GamepadLStickDown = 636 + GamepadRStickLeft = 637 + GamepadRStickRight = 638 + GamepadRStickUp = 639 + GamepadRStickDown = 640 + MouseLeft = 641 + MouseRight = 642 + MouseMiddle = 643 + MouseX1 = 644 + MouseX2 = 645 + MouseWheelX = 646 + MouseWheelY = 647 + ReservedForModCtrl = 648 + ReservedForModShift = 649 + ReservedForModAlt = 650 + ReservedForModSuper = 651 + NamedKey_END = 652 + Shortcut = 2048 + Ctrl = 4096 + Shift = 8192 + Alt = 16384 + Super = 32768 + Mask = 63488 ImGuiLayoutType* {.pure, size: int32.sizeof.} = enum Horizontal = 0 Vertical = 1 + ImGuiLocKey* {.pure, size: int32.sizeof.} = enum + VersionStr = 0 + TableSizeOne = 1 + TableSizeAllFit = 2 + TableSizeAllDefault = 3 + TableResetOrder = 4 + WindowingMainMenuBar = 5 + WindowingPopup = 6 + WindowingUntitled = 7 + DockingHideTabBar = 8 ImGuiLogType* {.pure, size: int32.sizeof.} = enum None = 0 TTY = 1 File = 2 Buffer = 3 Clipboard = 4 - ImGuiModFlags* {.pure, size: int32.sizeof.} = enum - None = 0 - Ctrl = 1 - Shift = 2 - Alt = 4 - Super = 8 ImGuiMouseButton* {.pure, size: int32.sizeof.} = enum Left = 0 Right = 1 @@ -530,12 +647,10 @@ type ResizeNWSE = 6 Hand = 7 NotAllowed = 8 - ImGuiNavDirSourceFlags* {.pure, size: int32.sizeof.} = enum - None = 0 - RawKeyboard = 1 - Keyboard = 2 - PadDPad = 4 - PadLStick = 8 + ImGuiMouseSource* {.pure, size: int32.sizeof.} = enum + Mouse = 0 + TouchScreen = 1 + Pen = 2 ImGuiNavHighlightFlags* {.pure, size: int32.sizeof.} = enum None = 0 TypeDefault = 1 @@ -559,10 +674,6 @@ type FocusNext = 13 TweakSlow = 14 TweakFast = 15 - KeyLeft = 16 - KeyRight = 17 - KeyUp = 18 - KeyDown = 19 ImGuiNavLayer* {.pure, size: int32.sizeof.} = enum Main = 0 Menu = 1 @@ -572,22 +683,18 @@ type LoopY = 2 WrapX = 4 WrapY = 8 + WrapMask = 15 AllowCurrentNavId = 16 AlsoScoreVisibleSet = 32 ScrollToEdgeY = 64 Forwarded = 128 DebugNoResult = 256 FocusApi = 512 - Tabbing = 1024 - Activate = 2048 - DontSetNavHighlight = 4096 - ImGuiNavReadMode* {.pure, size: int32.sizeof.} = enum - Down = 0 - Pressed = 1 - Released = 2 - Repeat = 3 - RepeatSlow = 4 - RepeatFast = 5 + IsTabbing = 1024 + IsPageMove = 2048 + Activate = 4096 + NoSelect = 8192 + NoSetNavHighlight = 16384 ImGuiNextItemDataFlags* {.pure, size: int32.sizeof.} = enum None = 0 HasWidth = 1 @@ -602,6 +709,9 @@ type HasFocus = 32 HasBgAlpha = 64 HasScroll = 128 + HasViewport = 256 + HasDock = 512 + HasWindowClass = 1024 ImGuiOldColumnFlags* {.pure, size: int32.sizeof.} = enum None = 0 NoBorder = 1 @@ -643,16 +753,16 @@ type SelectOnClick = 4194304 SelectOnRelease = 8388608 SpanAvailWidth = 16777216 - DrawHoveredWhenHeld = 33554432 - SetNavIdOnHover = 67108864 - NoPadWithHalfSpacing = 134217728 + SetNavIdOnHover = 33554432 + NoPadWithHalfSpacing = 67108864 + NoSetKeyOwner = 134217728 ImGuiSelectableFlags* {.pure, size: int32.sizeof.} = enum None = 0 DontClosePopups = 1 SpanAllColumns = 2 AllowDoubleClick = 4 Disabled = 8 - AllowItemOverlap = 16 + AllowOverlap = 16 ImGuiSeparatorFlags* {.pure, size: int32.sizeof.} = enum None = 0 Horizontal = 1 @@ -698,6 +808,10 @@ type TabRounding = 22 ButtonTextAlign = 23 SelectableTextAlign = 24 + SeparatorTextBorderSize = 25 + SeparatorTextAlign = 26 + SeparatorTextPadding = 27 + DockingSeparatorSize = 28 ImGuiTabBarFlagsPrivate* {.pure, size: int32.sizeof.} = enum DockNode = 1048576 IsFocused = 2097152 @@ -717,6 +831,8 @@ type SectionMask = 192 NoCloseButton = 1048576 Button = 2097152 + Unsorted = 4194304 + Preview = 8388608 ImGuiTabItemFlags* {.pure, size: int32.sizeof.} = enum None = 0 UnsavedDocument = 1 @@ -805,14 +921,15 @@ type NoWidthForLargeClippedText = 1 ImGuiTooltipFlags* {.pure, size: int32.sizeof.} = enum None = 0 - OverridePreviousTooltip = 1 + OverridePrevious = 2 ImGuiTreeNodeFlagsPrivate* {.pure, size: int32.sizeof.} = enum ClipLabelForTrailingButton = 1048576 + UpsideDownArrow = 2097152 ImGuiTreeNodeFlags* {.pure, size: int32.sizeof.} = enum None = 0 Selected = 1 Framed = 2 - AllowItemOverlap = 4 + AllowOverlap = 4 NoTreePushOnOpen = 8 NoAutoOpenOnLog = 16 CollapsingHeader = 26 @@ -830,6 +947,24 @@ type IsPlatformWindow = 1 IsPlatformMonitor = 2 OwnedByApp = 4 + NoDecoration = 8 + NoTaskBarIcon = 16 + NoFocusOnAppearing = 32 + NoFocusOnClick = 64 + NoInputs = 128 + NoRendererClear = 256 + NoAutoMerge = 512 + TopMost = 1024 + CanHostOtherWindows = 2048 + IsMinimized = 4096 + IsFocused = 8192 + ImGuiWindowDockStyleCol* {.pure, size: int32.sizeof.} = enum + Text = 0 + Tab = 1 + TabHovered = 2 + TabActive = 3 + TabUnfocused = 4 + TabUnfocusedActive = 5 ImGuiWindowFlags* {.pure, size: int32.sizeof.} = enum None = 0 NoTitleBar = 1 @@ -855,26 +990,31 @@ type NoNav = 786432 NoInputs = 786944 UnsavedDocument = 1048576 + NoDocking = 2097152 NavFlattened = 8388608 ChildWindow = 16777216 Tooltip = 33554432 Popup = 67108864 Modal = 134217728 ChildMenu = 268435456 + DockNodeHost = 536870912 -# Duplicate enums +# Duplicate enums as consts +const ImGuiKey_None* = 0 const ImGuiTabBarFlags_FittingPolicyDefault* = 64 const ImGuiKey_KeysData_OFFSET* = 0 const ImDrawFlags_RoundCornersDefault* = 240 const ImGuiButtonFlags_MouseButtonDefault* = 1 -const ImGuiKey_KeysData_SIZE* = 645 +const ImGuiKey_KeysData_SIZE* = 652 const ImGuiPopupFlags_MouseButtonLeft* = 0 const ImGuiPopupFlags_MouseButtonDefault* = 1 const ImGuiButtonFlagsPrivate_PressedOnDefault* = 32 +const ImGuiInputFlags_CondMask* = 48 const ImGuiKey_NamedKey_BEGIN* = 512 # TypeDefs type + ImBitArrayPtr* = ptr uint32 ImDrawCallback* = proc(parent_list: ptr ImDrawList, cmd: ptr ImDrawCmd): void {.cdecl, varargs.} ImDrawIdx* = uint16 ImFileHandle* = ptr FILE @@ -882,11 +1022,13 @@ type ImGuiErrorLogCallback* = proc(user_data: pointer, fmt: cstring): void {.cdecl.} ImGuiID* = uint32 ImGuiInputTextCallback* = proc(data: ptr ImGuiInputTextCallbackData): int32 {.cdecl, varargs.} + ImGuiKeyChord* = int32 + ImGuiKeyRoutingIndex* = int16 ImGuiMemAllocFunc* = proc(sz: uint, user_data: pointer): pointer {.cdecl, varargs.} ImGuiMemFreeFunc* = proc(`ptr`: pointer, user_data: pointer): void {.cdecl, varargs.} ImGuiSizeCallback* = proc(data: ptr ImGuiSizeCallbackData): void {.cdecl, varargs.} - ImGuiTableColumnIdx* = int8 - ImGuiTableDrawChannelIdx* = uint8 + ImGuiTableColumnIdx* = int16 + ImGuiTableDrawChannelIdx* = uint16 ImPoolIdx* = int32 ImTextureID* = pointer ImWchar* = ImWchar16 @@ -962,12 +1104,14 @@ type cmdListsCount* {.importc: "CmdListsCount".}: int32 totalIdxCount* {.importc: "TotalIdxCount".}: int32 totalVtxCount* {.importc: "TotalVtxCount".}: int32 - cmdLists* {.importc: "CmdLists".}: UncheckedArray[ptr ImDrawList] + cmdLists* {.importc: "CmdLists".}: ImVector[ptr ImDrawList] displayPos* {.importc: "DisplayPos".}: ImVec2 displaySize* {.importc: "DisplaySize".}: ImVec2 framebufferScale* {.importc: "FramebufferScale".}: ImVec2 + ownerViewport* {.importc: "OwnerViewport".}: ptr ImGuiViewport ImDrawDataBuilder* {.importc: "ImDrawDataBuilder", imgui_header.} = object - layers* {.importc: "Layers".}: array[2, ImVector[ImDrawListPtr]] + layers* {.importc: "Layers".}: array[2, ptr ImVector[ImDrawListPtr]] + layerData1* {.importc: "LayerData1".}: ImVector[ptr ImDrawList] ImDrawList* {.importc: "ImDrawList", imgui_header.} = object cmdBuffer* {.importc: "CmdBuffer".}: ImVector[ImDrawCmd] idxBuffer* {.importc: "IdxBuffer".}: ImVector[ImDrawIdx] @@ -992,6 +1136,7 @@ type circleSegmentMaxError* {.importc: "CircleSegmentMaxError".}: float32 clipRectFullscreen* {.importc: "ClipRectFullscreen".}: ImVec4 initialFlags* {.importc: "InitialFlags".}: ImDrawListFlags + tempBuffer* {.importc: "TempBuffer".}: ImVector[ImVec2] arcFastVtx* {.importc: "ArcFastVtx".}: array[48, ImVec2] arcFastRadiusCutoff* {.importc: "ArcFastRadiusCutoff".}: float32 circleSegmentCounts* {.importc: "CircleSegmentCounts".}: array[64, uint8] @@ -1016,7 +1161,9 @@ type configDataCount* {.importc: "ConfigDataCount".}: int16 fallbackChar* {.importc: "FallbackChar".}: ImWchar ellipsisChar* {.importc: "EllipsisChar".}: ImWchar - dotChar* {.importc: "DotChar".}: ImWchar + ellipsisCharCount* {.importc: "EllipsisCharCount".}: int16 + ellipsisWidth* {.importc: "EllipsisWidth".}: float32 + ellipsisCharStep* {.importc: "EllipsisCharStep".}: float32 dirtyLookupTables* {.importc: "DirtyLookupTables".}: bool scale* {.importc: "Scale".}: float32 ascent* {.importc: "Ascent".}: float32 @@ -1029,6 +1176,7 @@ type texDesiredWidth* {.importc: "TexDesiredWidth".}: int32 texGlyphPadding* {.importc: "TexGlyphPadding".}: int32 locked* {.importc: "Locked".}: bool + userData* {.importc: "UserData".}: pointer texReady* {.importc: "TexReady".}: bool texPixelsUseColors* {.importc: "TexPixelsUseColors".}: bool texPixelsAlpha8* {.importc: "TexPixelsAlpha8".}: ptr uint8 @@ -1105,9 +1253,10 @@ type initialized* {.importc: "Initialized".}: bool fontAtlasOwnedByContext* {.importc: "FontAtlasOwnedByContext".}: bool io* {.importc: "IO".}: ImGuiIO - inputEventsQueue* {.importc: "InputEventsQueue".}: ImVector[ImGuiInputEvent] - inputEventsTrail* {.importc: "InputEventsTrail".}: ImVector[ImGuiInputEvent] + platformIO* {.importc: "PlatformIO".}: ImGuiPlatformIO style* {.importc: "Style".}: ImGuiStyle + configFlagsCurrFrame* {.importc: "ConfigFlagsCurrFrame".}: ImGuiConfigFlags + configFlagsLastFrame* {.importc: "ConfigFlagsLastFrame".}: ImGuiConfigFlags font* {.importc: "Font".}: ptr ImFont fontSize* {.importc: "FontSize".}: float32 fontBaseSize* {.importc: "FontBaseSize".}: float32 @@ -1115,6 +1264,7 @@ type time* {.importc: "Time".}: float64 frameCount* {.importc: "FrameCount".}: int32 frameCountEnded* {.importc: "FrameCountEnded".}: int32 + frameCountPlatformEnded* {.importc: "FrameCountPlatformEnded".}: int32 frameCountRendered* {.importc: "FrameCountRendered".}: int32 withinFrameScope* {.importc: "WithinFrameScope".}: bool withinFrameScopeWithImplicitWindow* {.importc: "WithinFrameScopeWithImplicitWindow".}: bool @@ -1122,6 +1272,10 @@ type gcCompactAll* {.importc: "GcCompactAll".}: bool testEngineHookItems* {.importc: "TestEngineHookItems".}: bool testEngine* {.importc: "TestEngine".}: pointer + inputEventsQueue* {.importc: "InputEventsQueue".}: ImVector[ImGuiInputEvent] + inputEventsTrail* {.importc: "InputEventsTrail".}: ImVector[ImGuiInputEvent] + inputEventsNextMouseSource* {.importc: "InputEventsNextMouseSource".}: ImGuiMouseSource + inputEventsNextEventId* {.importc: "InputEventsNextEventId".}: uint32 windows* {.importc: "Windows".}: ImVector[ptr ImGuiWindow] windowsFocusOrder* {.importc: "WindowsFocusOrder".}: ImVector[ptr ImGuiWindow] windowsTempSortBuffer* {.importc: "WindowsTempSortBuffer".}: ImVector[ptr ImGuiWindow] @@ -1135,13 +1289,14 @@ type movingWindow* {.importc: "MovingWindow".}: ptr ImGuiWindow wheelingWindow* {.importc: "WheelingWindow".}: ptr ImGuiWindow wheelingWindowRefMousePos* {.importc: "WheelingWindowRefMousePos".}: ImVec2 - wheelingWindowTimer* {.importc: "WheelingWindowTimer".}: float32 + wheelingWindowStartFrame* {.importc: "WheelingWindowStartFrame".}: int32 + wheelingWindowReleaseTimer* {.importc: "WheelingWindowReleaseTimer".}: float32 + wheelingWindowWheelRemainder* {.importc: "WheelingWindowWheelRemainder".}: ImVec2 + wheelingAxisAvg* {.importc: "WheelingAxisAvg".}: ImVec2 debugHookIdInfo* {.importc: "DebugHookIdInfo".}: ImGuiID hoveredId* {.importc: "HoveredId".}: ImGuiID hoveredIdPreviousFrame* {.importc: "HoveredIdPreviousFrame".}: ImGuiID hoveredIdAllowOverlap* {.importc: "HoveredIdAllowOverlap".}: bool - hoveredIdUsingMouseWheel* {.importc: "HoveredIdUsingMouseWheel".}: bool - hoveredIdPreviousFrameUsingMouseWheel* {.importc: "HoveredIdPreviousFrameUsingMouseWheel".}: bool hoveredIdDisabled* {.importc: "HoveredIdDisabled".}: bool hoveredIdTimer* {.importc: "HoveredIdTimer".}: float32 hoveredIdNotActiveTimer* {.importc: "HoveredIdNotActiveTimer".}: float32 @@ -1164,11 +1319,14 @@ type activeIdPreviousFrameWindow* {.importc: "ActiveIdPreviousFrameWindow".}: ptr ImGuiWindow lastActiveId* {.importc: "LastActiveId".}: ImGuiID lastActiveIdTimer* {.importc: "LastActiveIdTimer".}: float32 - activeIdUsingMouseWheel* {.importc: "ActiveIdUsingMouseWheel".}: bool + keysOwnerData* {.importc: "KeysOwnerData".}: array[140, ImGuiKeyOwnerData] + keysRoutingTable* {.importc: "KeysRoutingTable".}: ImGuiKeyRoutingTable activeIdUsingNavDirMask* {.importc: "ActiveIdUsingNavDirMask".}: uint32 + activeIdUsingAllKeyboardKeys* {.importc: "ActiveIdUsingAllKeyboardKeys".}: bool activeIdUsingNavInputMask* {.importc: "ActiveIdUsingNavInputMask".}: uint32 - activeIdUsingKeyInputMask* {.importc: "ActiveIdUsingKeyInputMask".}: uint32 + currentFocusScopeId* {.importc: "CurrentFocusScopeId".}: ImGuiID currentItemFlags* {.importc: "CurrentItemFlags".}: ImGuiItemFlags + debugLocateId* {.importc: "DebugLocateId".}: ImGuiID nextItemData* {.importc: "NextItemData".}: ImGuiNextItemData lastItemData* {.importc: "LastItemData".}: ImGuiLastItemData nextWindowData* {.importc: "NextWindowData".}: ImGuiNextWindowData @@ -1182,17 +1340,25 @@ type beginPopupStack* {.importc: "BeginPopupStack".}: ImVector[ImGuiPopupData] beginMenuCount* {.importc: "BeginMenuCount".}: int32 viewports* {.importc: "Viewports".}: ImVector[ptr ImGuiViewportP] + currentDpiScale* {.importc: "CurrentDpiScale".}: float32 + currentViewport* {.importc: "CurrentViewport".}: ptr ImGuiViewportP + mouseViewport* {.importc: "MouseViewport".}: ptr ImGuiViewportP + mouseLastHoveredViewport* {.importc: "MouseLastHoveredViewport".}: ptr ImGuiViewportP + platformLastFocusedViewportId* {.importc: "PlatformLastFocusedViewportId".}: ImGuiID + fallbackMonitor* {.importc: "FallbackMonitor".}: ImGuiPlatformMonitor + viewportCreatedCount* {.importc: "ViewportCreatedCount".}: int32 + platformWindowsCreatedCount* {.importc: "PlatformWindowsCreatedCount".}: int32 + viewportFocusedStampCount* {.importc: "ViewportFocusedStampCount".}: int32 navWindow* {.importc: "NavWindow".}: ptr ImGuiWindow navId* {.importc: "NavId".}: ImGuiID navFocusScopeId* {.importc: "NavFocusScopeId".}: ImGuiID navActivateId* {.importc: "NavActivateId".}: ImGuiID navActivateDownId* {.importc: "NavActivateDownId".}: ImGuiID navActivatePressedId* {.importc: "NavActivatePressedId".}: ImGuiID - navActivateInputId* {.importc: "NavActivateInputId".}: ImGuiID navActivateFlags* {.importc: "NavActivateFlags".}: ImGuiActivateFlags navJustMovedToId* {.importc: "NavJustMovedToId".}: ImGuiID navJustMovedToFocusScopeId* {.importc: "NavJustMovedToFocusScopeId".}: ImGuiID - navJustMovedToKeyMods* {.importc: "NavJustMovedToKeyMods".}: ImGuiModFlags + navJustMovedToKeyMods* {.importc: "NavJustMovedToKeyMods".}: ImGuiKeyChord navNextActivateId* {.importc: "NavNextActivateId".}: ImGuiID navNextActivateFlags* {.importc: "NavNextActivateFlags".}: ImGuiActivateFlags navInputSource* {.importc: "NavInputSource".}: ImGuiInputSource @@ -1204,14 +1370,13 @@ type navAnyRequest* {.importc: "NavAnyRequest".}: bool navInitRequest* {.importc: "NavInitRequest".}: bool navInitRequestFromMove* {.importc: "NavInitRequestFromMove".}: bool - navInitResultId* {.importc: "NavInitResultId".}: ImGuiID - navInitResultRectRel* {.importc: "NavInitResultRectRel".}: ImRect + navInitResult* {.importc: "NavInitResult".}: ImGuiNavItemData navMoveSubmitted* {.importc: "NavMoveSubmitted".}: bool navMoveScoringItems* {.importc: "NavMoveScoringItems".}: bool navMoveForwardToNextFrame* {.importc: "NavMoveForwardToNextFrame".}: bool navMoveFlags* {.importc: "NavMoveFlags".}: ImGuiNavMoveFlags navMoveScrollFlags* {.importc: "NavMoveScrollFlags".}: ImGuiScrollFlags - navMoveKeyMods* {.importc: "NavMoveKeyMods".}: ImGuiModFlags + navMoveKeyMods* {.importc: "NavMoveKeyMods".}: ImGuiKeyChord navMoveDir* {.importc: "NavMoveDir".}: ImGuiDir navMoveDirForDebug* {.importc: "NavMoveDirForDebug".}: ImGuiDir navMoveClipDir* {.importc: "NavMoveClipDir".}: ImGuiDir @@ -1224,14 +1389,17 @@ type navMoveResultLocalVisible* {.importc: "NavMoveResultLocalVisible".}: ImGuiNavItemData navMoveResultOther* {.importc: "NavMoveResultOther".}: ImGuiNavItemData navTabbingResultFirst* {.importc: "NavTabbingResultFirst".}: ImGuiNavItemData + configNavWindowingKeyNext* {.importc: "ConfigNavWindowingKeyNext".}: ImGuiKeyChord + configNavWindowingKeyPrev* {.importc: "ConfigNavWindowingKeyPrev".}: ImGuiKeyChord navWindowingTarget* {.importc: "NavWindowingTarget".}: ptr ImGuiWindow navWindowingTargetAnim* {.importc: "NavWindowingTargetAnim".}: ptr ImGuiWindow navWindowingListWindow* {.importc: "NavWindowingListWindow".}: ptr ImGuiWindow navWindowingTimer* {.importc: "NavWindowingTimer".}: float32 navWindowingHighlightAlpha* {.importc: "NavWindowingHighlightAlpha".}: float32 navWindowingToggleLayer* {.importc: "NavWindowingToggleLayer".}: bool + navWindowingAccumDeltaPos* {.importc: "NavWindowingAccumDeltaPos".}: ImVec2 + navWindowingAccumDeltaSize* {.importc: "NavWindowingAccumDeltaSize".}: ImVec2 dimBgRatio* {.importc: "DimBgRatio".}: float32 - mouseCursor* {.importc: "MouseCursor".}: ImGuiMouseCursor dragDropActive* {.importc: "DragDropActive".}: bool dragDropWithinSource* {.importc: "DragDropWithinSource".}: bool dragDropWithinTarget* {.importc: "DragDropWithinTarget".}: bool @@ -1261,14 +1429,25 @@ type tabBars* {.importc: "TabBars".}: ptr ImPool currentTabBarStack* {.importc: "CurrentTabBarStack".}: ImVector[ImGuiPtrOrIndex] shrinkWidthBuffer* {.importc: "ShrinkWidthBuffer".}: ImVector[ImGuiShrinkWidthItem] + hoverItemDelayId* {.importc: "HoverItemDelayId".}: ImGuiID + hoverItemDelayIdPreviousFrame* {.importc: "HoverItemDelayIdPreviousFrame".}: ImGuiID + hoverItemDelayTimer* {.importc: "HoverItemDelayTimer".}: float32 + hoverItemDelayClearTimer* {.importc: "HoverItemDelayClearTimer".}: float32 + hoverItemUnlockedStationaryId* {.importc: "HoverItemUnlockedStationaryId".}: ImGuiID + hoverWindowUnlockedStationaryId* {.importc: "HoverWindowUnlockedStationaryId".}: ImGuiID + mouseCursor* {.importc: "MouseCursor".}: ImGuiMouseCursor + mouseStationaryTimer* {.importc: "MouseStationaryTimer".}: float32 mouseLastValidPos* {.importc: "MouseLastValidPos".}: ImVec2 inputTextState* {.importc: "InputTextState".}: ImGuiInputTextState + inputTextDeactivatedState* {.importc: "InputTextDeactivatedState".}: ImGuiInputTextDeactivatedState inputTextPasswordFont* {.importc: "InputTextPasswordFont".}: ImFont tempInputId* {.importc: "TempInputId".}: ImGuiID colorEditOptions* {.importc: "ColorEditOptions".}: ImGuiColorEditFlags - colorEditLastHue* {.importc: "ColorEditLastHue".}: float32 - colorEditLastSat* {.importc: "ColorEditLastSat".}: float32 - colorEditLastColor* {.importc: "ColorEditLastColor".}: uint32 + colorEditCurrentID* {.importc: "ColorEditCurrentID".}: ImGuiID + colorEditSavedID* {.importc: "ColorEditSavedID".}: ImGuiID + colorEditSavedHue* {.importc: "ColorEditSavedHue".}: float32 + colorEditSavedSat* {.importc: "ColorEditSavedSat".}: float32 + colorEditSavedColor* {.importc: "ColorEditSavedColor".}: uint32 colorPickerRef* {.importc: "ColorPickerRef".}: ImVec4 comboPreviewData* {.importc: "ComboPreviewData".}: ImGuiComboPreviewData sliderGrabClickOffset* {.importc: "SliderGrabClickOffset".}: float32 @@ -1281,12 +1460,14 @@ type disabledAlphaBackup* {.importc: "DisabledAlphaBackup".}: float32 disabledStackSize* {.importc: "DisabledStackSize".}: int16 tooltipOverrideCount* {.importc: "TooltipOverrideCount".}: int16 - tooltipSlowDelay* {.importc: "TooltipSlowDelay".}: float32 clipboardHandlerData* {.importc: "ClipboardHandlerData".}: ImVector[int8] menusIdSubmittedThisFrame* {.importc: "MenusIdSubmittedThisFrame".}: ImVector[ImGuiID] platformImeData* {.importc: "PlatformImeData".}: ImGuiPlatformImeData platformImeDataPrev* {.importc: "PlatformImeDataPrev".}: ImGuiPlatformImeData + platformImeViewport* {.importc: "PlatformImeViewport".}: ImGuiID platformLocaleDecimalPoint* {.importc: "PlatformLocaleDecimalPoint".}: int8 + dockContext* {.importc: "DockContext".}: ImGuiDockContext + dockNodeWindowMenuHandler* {.importc: "DockNodeWindowMenuHandler".}: proc(ctx: ptr ImGuiContext, node: ptr ImGuiDockNode, tab_bar: ptr ImGuiTabBar): void {.cdecl, varargs.} settingsLoaded* {.importc: "SettingsLoaded".}: bool settingsDirtyTimer* {.importc: "SettingsDirtyTimer".}: float32 settingsIniData* {.importc: "SettingsIniData".}: ImGuiTextBuffer @@ -1295,6 +1476,7 @@ type settingsTables* {.importc: "SettingsTables".}: ImVector[ImGuiTableSettings] hooks* {.importc: "Hooks".}: ImVector[ImGuiContextHook] hookIdNext* {.importc: "HookIdNext".}: ImGuiID + localizationTable* {.importc: "LocalizationTable".}: array[9, cstring] logEnabled* {.importc: "LogEnabled".}: bool logType* {.importc: "LogType".}: ImGuiLogType logFile* {.importc: "LogFile".}: ImFileHandle @@ -1308,11 +1490,17 @@ type logDepthToExpandDefault* {.importc: "LogDepthToExpandDefault".}: int32 debugLogFlags* {.importc: "DebugLogFlags".}: ImGuiDebugLogFlags debugLogBuf* {.importc: "DebugLogBuf".}: ImGuiTextBuffer + debugLogIndex* {.importc: "DebugLogIndex".}: ImGuiTextIndex + debugLogClipperAutoDisableFrames* {.importc: "DebugLogClipperAutoDisableFrames".}: uint8 + debugLocateFrames* {.importc: "DebugLocateFrames".}: uint8 + debugBeginReturnValueCullDepth* {.importc: "DebugBeginReturnValueCullDepth".}: int8 debugItemPickerActive* {.importc: "DebugItemPickerActive".}: bool + debugItemPickerMouseButton* {.importc: "DebugItemPickerMouseButton".}: uint8 debugItemPickerBreakId* {.importc: "DebugItemPickerBreakId".}: ImGuiID debugMetricsConfig* {.importc: "DebugMetricsConfig".}: ImGuiMetricsConfig debugStackTool* {.importc: "DebugStackTool".}: ImGuiStackTool - framerateSecPerFrame* {.importc: "FramerateSecPerFrame".}: array[120, float32] + debugHoveredDockNode* {.importc: "DebugHoveredDockNode".}: ptr ImGuiDockNode + framerateSecPerFrame* {.importc: "FramerateSecPerFrame".}: array[60, float32] framerateSecPerFrameIdx* {.importc: "FramerateSecPerFrameIdx".}: int32 framerateSecPerFrameCount* {.importc: "FramerateSecPerFrameCount".}: int32 framerateSecPerFrameAccum* {.importc: "FramerateSecPerFrameAccum".}: float32 @@ -1333,6 +1521,58 @@ type scanFmt* {.importc: "ScanFmt".}: cstring ImGuiDataTypeTempStorage* {.importc: "ImGuiDataTypeTempStorage", imgui_header.} = object data* {.importc: "Data".}: array[8, uint8] + ImGuiDataVarInfo* {.importc: "ImGuiDataVarInfo", imgui_header.} = object + `type`* {.importc: "`type`".}: ImGuiDataType + count* {.importc: "Count".}: uint32 + offset* {.importc: "Offset".}: uint32 + ImGuiDockContext* {.importc: "ImGuiDockContext", imgui_header.} = object + nodes* {.importc: "Nodes".}: ImGuiStorage + requests* {.importc: "Requests".}: ImVector[ImGuiDockRequest] + nodesSettings* {.importc: "NodesSettings".}: ImVector[ImGuiDockNodeSettings] + wantFullRebuild* {.importc: "WantFullRebuild".}: bool + ImGuiDockNode* {.importc: "ImGuiDockNode", imgui_header.} = object + id* {.importc: "ID".}: ImGuiID + sharedFlags* {.importc: "SharedFlags".}: ImGuiDockNodeFlags + localFlags* {.importc: "LocalFlags".}: ImGuiDockNodeFlags + localFlagsInWindows* {.importc: "LocalFlagsInWindows".}: ImGuiDockNodeFlags + mergedFlags* {.importc: "MergedFlags".}: ImGuiDockNodeFlags + state* {.importc: "State".}: ImGuiDockNodeState + parentNode* {.importc: "ParentNode".}: ptr ImGuiDockNode + childNodes* {.importc: "ChildNodes".}: array[2, ptr ImGuiDockNode] + windows* {.importc: "Windows".}: ImVector[ptr ImGuiWindow] + tabBar* {.importc: "TabBar".}: ptr ImGuiTabBar + pos* {.importc: "Pos".}: ImVec2 + size* {.importc: "Size".}: ImVec2 + sizeRef* {.importc: "SizeRef".}: ImVec2 + splitAxis* {.importc: "SplitAxis".}: ImGuiAxis + windowClass* {.importc: "WindowClass".}: ImGuiWindowClass + lastBgColor* {.importc: "LastBgColor".}: uint32 + hostWindow* {.importc: "HostWindow".}: ptr ImGuiWindow + visibleWindow* {.importc: "VisibleWindow".}: ptr ImGuiWindow + centralNode* {.importc: "CentralNode".}: ptr ImGuiDockNode + onlyNodeWithWindows* {.importc: "OnlyNodeWithWindows".}: ptr ImGuiDockNode + countNodeWithWindows* {.importc: "CountNodeWithWindows".}: int32 + lastFrameAlive* {.importc: "LastFrameAlive".}: int32 + lastFrameActive* {.importc: "LastFrameActive".}: int32 + lastFrameFocused* {.importc: "LastFrameFocused".}: int32 + lastFocusedNodeId* {.importc: "LastFocusedNodeId".}: ImGuiID + selectedTabId* {.importc: "SelectedTabId".}: ImGuiID + wantCloseTabId* {.importc: "WantCloseTabId".}: ImGuiID + refViewportId* {.importc: "RefViewportId".}: ImGuiID + authorityForPos* {.importc: "AuthorityForPos".}: ImGuiDataAuthority + authorityForSize* {.importc: "AuthorityForSize".}: ImGuiDataAuthority + authorityForViewport* {.importc: "AuthorityForViewport".}: ImGuiDataAuthority + isVisible* {.importc: "IsVisible".}: bool + isFocused* {.importc: "IsFocused".}: bool + isBgDrawnThisFrame* {.importc: "IsBgDrawnThisFrame".}: bool + hasCloseButton* {.importc: "HasCloseButton".}: bool + hasWindowMenuButton* {.importc: "HasWindowMenuButton".}: bool + hasCentralNodeChild* {.importc: "HasCentralNodeChild".}: bool + wantCloseAll* {.importc: "WantCloseAll".}: bool + wantLockSizeOnce* {.importc: "WantLockSizeOnce".}: bool + wantMouseMove* {.importc: "WantMouseMove".}: bool + wantHiddenTabBarUpdate* {.importc: "WantHiddenTabBarUpdate".}: bool + wantHiddenTabBarToggle* {.importc: "WantHiddenTabBarToggle".}: bool ImGuiGroupData* {.importc: "ImGuiGroupData", imgui_header.} = object windowID* {.importc: "WindowID".}: ImGuiID backupCursorPos* {.importc: "BackupCursorPos".}: ImVec2 @@ -1353,25 +1593,38 @@ type iniSavingRate* {.importc: "IniSavingRate".}: float32 iniFilename* {.importc: "IniFilename".}: cstring logFilename* {.importc: "LogFilename".}: cstring - mouseDoubleClickTime* {.importc: "MouseDoubleClickTime".}: float32 - mouseDoubleClickMaxDist* {.importc: "MouseDoubleClickMaxDist".}: float32 - mouseDragThreshold* {.importc: "MouseDragThreshold".}: float32 - keyRepeatDelay* {.importc: "KeyRepeatDelay".}: float32 - keyRepeatRate* {.importc: "KeyRepeatRate".}: float32 userData* {.importc: "UserData".}: pointer fonts* {.importc: "Fonts".}: ptr ImFontAtlas fontGlobalScale* {.importc: "FontGlobalScale".}: float32 fontAllowUserScaling* {.importc: "FontAllowUserScaling".}: bool fontDefault* {.importc: "FontDefault".}: ptr ImFont displayFramebufferScale* {.importc: "DisplayFramebufferScale".}: ImVec2 + configDockingNoSplit* {.importc: "ConfigDockingNoSplit".}: bool + configDockingWithShift* {.importc: "ConfigDockingWithShift".}: bool + configDockingAlwaysTabBar* {.importc: "ConfigDockingAlwaysTabBar".}: bool + configDockingTransparentPayload* {.importc: "ConfigDockingTransparentPayload".}: bool + configViewportsNoAutoMerge* {.importc: "ConfigViewportsNoAutoMerge".}: bool + configViewportsNoTaskBarIcon* {.importc: "ConfigViewportsNoTaskBarIcon".}: bool + configViewportsNoDecoration* {.importc: "ConfigViewportsNoDecoration".}: bool + configViewportsNoDefaultParent* {.importc: "ConfigViewportsNoDefaultParent".}: bool mouseDrawCursor* {.importc: "MouseDrawCursor".}: bool configMacOSXBehaviors* {.importc: "ConfigMacOSXBehaviors".}: bool configInputTrickleEventQueue* {.importc: "ConfigInputTrickleEventQueue".}: bool configInputTextCursorBlink* {.importc: "ConfigInputTextCursorBlink".}: bool + configInputTextEnterKeepActive* {.importc: "ConfigInputTextEnterKeepActive".}: bool configDragClickToInputText* {.importc: "ConfigDragClickToInputText".}: bool configWindowsResizeFromEdges* {.importc: "ConfigWindowsResizeFromEdges".}: bool configWindowsMoveFromTitleBarOnly* {.importc: "ConfigWindowsMoveFromTitleBarOnly".}: bool configMemoryCompactTimer* {.importc: "ConfigMemoryCompactTimer".}: float32 + mouseDoubleClickTime* {.importc: "MouseDoubleClickTime".}: float32 + mouseDoubleClickMaxDist* {.importc: "MouseDoubleClickMaxDist".}: float32 + mouseDragThreshold* {.importc: "MouseDragThreshold".}: float32 + keyRepeatDelay* {.importc: "KeyRepeatDelay".}: float32 + keyRepeatRate* {.importc: "KeyRepeatRate".}: float32 + configDebugBeginReturnValueOnce* {.importc: "ConfigDebugBeginReturnValueOnce".}: bool + configDebugBeginReturnValueLoop* {.importc: "ConfigDebugBeginReturnValueLoop".}: bool + configDebugIgnoreFocusLoss* {.importc: "ConfigDebugIgnoreFocusLoss".}: bool + configDebugIniSettings* {.importc: "ConfigDebugIniSettings".}: bool backendPlatformName* {.importc: "BackendPlatformName".}: cstring backendRendererName* {.importc: "BackendRendererName".}: cstring backendPlatformUserData* {.importc: "BackendPlatformUserData".}: pointer @@ -1396,18 +1649,21 @@ type metricsActiveWindows* {.importc: "MetricsActiveWindows".}: int32 metricsActiveAllocations* {.importc: "MetricsActiveAllocations".}: int32 mouseDelta* {.importc: "MouseDelta".}: ImVec2 - keyMap* {.importc: "KeyMap".}: array[645, int32] - keysDown* {.importc: "KeysDown".}: array[645, bool] + keyMap* {.importc: "KeyMap".}: array[652, int32] + keysDown* {.importc: "KeysDown".}: array[652, bool] + navInputs* {.importc: "NavInputs".}: array[16, float32] + ctx* {.importc: "Ctx".}: ptr ImGuiContext mousePos* {.importc: "MousePos".}: ImVec2 mouseDown* {.importc: "MouseDown".}: array[5, bool] mouseWheel* {.importc: "MouseWheel".}: float32 mouseWheelH* {.importc: "MouseWheelH".}: float32 + mouseSource* {.importc: "MouseSource".}: ImGuiMouseSource + mouseHoveredViewport* {.importc: "MouseHoveredViewport".}: ImGuiID keyCtrl* {.importc: "KeyCtrl".}: bool keyShift* {.importc: "KeyShift".}: bool keyAlt* {.importc: "KeyAlt".}: bool keySuper* {.importc: "KeySuper".}: bool - navInputs* {.importc: "NavInputs".}: array[20, float32] - keyMods* {.importc: "KeyMods".}: ImGuiModFlags + keyMods* {.importc: "KeyMods".}: ImGuiKeyChord keysData* {.importc: "KeysData".}: array[ImGuiKey_KeysData_SIZE, ImGuiKeyData] wantCaptureMouseUnlessPopupClose* {.importc: "WantCaptureMouseUnlessPopupClose".}: bool mousePosPrev* {.importc: "MousePosPrev".}: ImVec2 @@ -1420,11 +1676,11 @@ type mouseReleased* {.importc: "MouseReleased".}: array[5, bool] mouseDownOwned* {.importc: "MouseDownOwned".}: array[5, bool] mouseDownOwnedUnlessPopupClose* {.importc: "MouseDownOwnedUnlessPopupClose".}: array[5, bool] + mouseWheelRequestAxisSwap* {.importc: "MouseWheelRequestAxisSwap".}: bool mouseDownDuration* {.importc: "MouseDownDuration".}: array[5, float32] mouseDownDurationPrev* {.importc: "MouseDownDurationPrev".}: array[5, float32] + mouseDragMaxDistanceAbs* {.importc: "MouseDragMaxDistanceAbs".}: array[5, ImVec2] mouseDragMaxDistanceSqr* {.importc: "MouseDragMaxDistanceSqr".}: array[5, float32] - navInputsDownDuration* {.importc: "NavInputsDownDuration".}: array[20, float32] - navInputsDownDurationPrev* {.importc: "NavInputsDownDurationPrev".}: array[20, float32] penPressure* {.importc: "PenPressure".}: float32 appFocusLost* {.importc: "AppFocusLost".}: bool appAcceptingEvents* {.importc: "AppAcceptingEvents".}: bool @@ -1441,15 +1697,21 @@ type ImGuiInputEventMouseButton* {.importc: "ImGuiInputEventMouseButton", imgui_header.} = object button* {.importc: "Button".}: int32 down* {.importc: "Down".}: bool + mouseSource* {.importc: "MouseSource".}: ImGuiMouseSource ImGuiInputEventMousePos* {.importc: "ImGuiInputEventMousePos", imgui_header.} = object posX* {.importc: "PosX".}: float32 posY* {.importc: "PosY".}: float32 + mouseSource* {.importc: "MouseSource".}: ImGuiMouseSource + ImGuiInputEventMouseViewport* {.importc: "ImGuiInputEventMouseViewport", imgui_header.} = object + hoveredViewportID* {.importc: "HoveredViewportID".}: ImGuiID ImGuiInputEventMouseWheel* {.importc: "ImGuiInputEventMouseWheel", imgui_header.} = object wheelX* {.importc: "WheelX".}: float32 wheelY* {.importc: "WheelY".}: float32 + mouseSource* {.importc: "MouseSource".}: ImGuiMouseSource ImGuiInputEventText* {.importc: "ImGuiInputEventText", imgui_header.} = object char* {.importc: "Char".}: uint32 ImGuiInputTextCallbackData* {.importc: "ImGuiInputTextCallbackData", imgui_header.} = object + ctx* {.importc: "Ctx".}: ptr ImGuiContext eventFlag* {.importc: "EventFlag".}: ImGuiInputTextFlags flags* {.importc: "Flags".}: ImGuiInputTextFlags userData* {.importc: "UserData".}: pointer @@ -1462,7 +1724,11 @@ type cursorPos* {.importc: "CursorPos".}: int32 selectionStart* {.importc: "SelectionStart".}: int32 selectionEnd* {.importc: "SelectionEnd".}: int32 + ImGuiInputTextDeactivatedState* {.importc: "ImGuiInputTextDeactivatedState", imgui_header.} = object + id* {.importc: "ID".}: ImGuiID + textA* {.importc: "TextA".}: ImVector[int8] ImGuiInputTextState* {.importc: "ImGuiInputTextState", imgui_header.} = object + ctx* {.importc: "Ctx".}: ptr ImGuiContext id* {.importc: "ID".}: ImGuiID curLenW* {.importc: "CurLenW".}: int32 curLenA* {.importc: "CurLenA".}: int32 @@ -1483,6 +1749,21 @@ type downDuration* {.importc: "DownDuration".}: float32 downDurationPrev* {.importc: "DownDurationPrev".}: float32 analogValue* {.importc: "AnalogValue".}: float32 + ImGuiKeyOwnerData* {.importc: "ImGuiKeyOwnerData", imgui_header.} = object + ownerCurr* {.importc: "OwnerCurr".}: ImGuiID + ownerNext* {.importc: "OwnerNext".}: ImGuiID + lockThisFrame* {.importc: "LockThisFrame".}: bool + lockUntilRelease* {.importc: "LockUntilRelease".}: bool + ImGuiKeyRoutingData* {.importc: "ImGuiKeyRoutingData", imgui_header.} = object + nextEntryIndex* {.importc: "NextEntryIndex".}: ImGuiKeyRoutingIndex + mods* {.importc: "Mods".}: uint16 + routingNextScore* {.importc: "RoutingNextScore".}: uint8 + routingCurr* {.importc: "RoutingCurr".}: ImGuiID + routingNext* {.importc: "RoutingNext".}: ImGuiID + ImGuiKeyRoutingTable* {.importc: "ImGuiKeyRoutingTable", imgui_header.} = object + index* {.importc: "Index".}: array[140, ImGuiKeyRoutingIndex] + entries* {.importc: "Entries".}: ImVector[ImGuiKeyRoutingData] + entriesNext* {.importc: "EntriesNext".}: ImVector[ImGuiKeyRoutingData] ImGuiLastItemData* {.importc: "ImGuiLastItemData", imgui_header.} = object id* {.importc: "ID".}: ImGuiID inFlags* {.importc: "InFlags".}: ImGuiItemFlags @@ -1491,6 +1772,7 @@ type navRect* {.importc: "NavRect".}: ImRect displayRect* {.importc: "DisplayRect".}: ImRect ImGuiListClipper* {.importc: "ImGuiListClipper", imgui_header.} = object + ctx* {.importc: "Ctx".}: ptr ImGuiContext displayStart* {.importc: "DisplayStart".}: int32 displayEnd* {.importc: "DisplayEnd".}: int32 itemsCount* {.importc: "ItemsCount".}: int32 @@ -1509,6 +1791,9 @@ type posToIndexConvert* {.importc: "PosToIndexConvert".}: bool posToIndexOffsetMin* {.importc: "PosToIndexOffsetMin".}: int8 posToIndexOffsetMax* {.importc: "PosToIndexOffsetMax".}: int8 + ImGuiLocEntry* {.importc: "ImGuiLocEntry", imgui_header.} = object + key* {.importc: "Key".}: ImGuiLocKey + text* {.importc: "Text".}: cstring ImGuiMenuColumns* {.importc: "ImGuiMenuColumns", imgui_header.} = object totalWidth* {.importc: "TotalWidth".}: uint32 nextTotalWidth* {.importc: "NextTotalWidth".}: uint32 @@ -1526,6 +1811,8 @@ type showTablesRects* {.importc: "ShowTablesRects".}: bool showDrawCmdMesh* {.importc: "ShowDrawCmdMesh".}: bool showDrawCmdBoundingBoxes* {.importc: "ShowDrawCmdBoundingBoxes".}: bool + showAtlasTintedWithTextColor* {.importc: "ShowAtlasTintedWithTextColor".}: bool + showDockingNodes* {.importc: "ShowDockingNodes".}: bool showWindowsRectsType* {.importc: "ShowWindowsRectsType".}: int32 showTablesRectsType* {.importc: "ShowTablesRectsType".}: int32 ImGuiNavItemData* {.importc: "ImGuiNavItemData", imgui_header.} = object @@ -1539,6 +1826,7 @@ type distAxial* {.importc: "DistAxial".}: float32 ImGuiNextItemData* {.importc: "ImGuiNextItemData", imgui_header.} = object flags* {.importc: "Flags".}: ImGuiNextItemDataFlags + itemFlags* {.importc: "ItemFlags".}: ImGuiItemFlags width* {.importc: "Width".}: float32 focusScopeId* {.importc: "FocusScopeId".}: ImGuiID openCond* {.importc: "OpenCond".}: ImGuiCond @@ -1548,16 +1836,21 @@ type posCond* {.importc: "PosCond".}: ImGuiCond sizeCond* {.importc: "SizeCond".}: ImGuiCond collapsedCond* {.importc: "CollapsedCond".}: ImGuiCond + dockCond* {.importc: "DockCond".}: ImGuiCond posVal* {.importc: "PosVal".}: ImVec2 posPivotVal* {.importc: "PosPivotVal".}: ImVec2 sizeVal* {.importc: "SizeVal".}: ImVec2 contentSizeVal* {.importc: "ContentSizeVal".}: ImVec2 scrollVal* {.importc: "ScrollVal".}: ImVec2 + posUndock* {.importc: "PosUndock".}: bool collapsedVal* {.importc: "CollapsedVal".}: bool sizeConstraintRect* {.importc: "SizeConstraintRect".}: ImRect sizeCallback* {.importc: "SizeCallback".}: ImGuiSizeCallback sizeCallbackUserData* {.importc: "SizeCallbackUserData".}: pointer bgAlphaVal* {.importc: "BgAlphaVal".}: float32 + viewportId* {.importc: "ViewportId".}: ImGuiID + dockId* {.importc: "DockId".}: ImGuiID + windowClass* {.importc: "WindowClass".}: ImGuiWindowClass menuBarOffsetMinVal* {.importc: "MenuBarOffsetMinVal".}: ImVec2 ImGuiOldColumnData* {.importc: "ImGuiOldColumnData", imgui_header.} = object offsetNorm* {.importc: "OffsetNorm".}: float32 @@ -1593,14 +1886,47 @@ type dataType* {.importc: "DataType".}: array[32+1, int8] preview* {.importc: "Preview".}: bool delivery* {.importc: "Delivery".}: bool + ImGuiPlatformIO* {.importc: "ImGuiPlatformIO", imgui_header.} = object + platform_CreateWindow* {.importc: "Platform_CreateWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_DestroyWindow* {.importc: "Platform_DestroyWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_ShowWindow* {.importc: "Platform_ShowWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_SetWindowPos* {.importc: "Platform_SetWindowPos".}: proc(vp: ptr ImGuiViewport, pos: ImVec2): void {.cdecl, varargs.} + platform_GetWindowPos* {.importc: "Platform_GetWindowPos".}: proc(vp: ptr ImGuiViewport): ImVec2 {.cdecl, varargs.} + platform_SetWindowSize* {.importc: "Platform_SetWindowSize".}: proc(vp: ptr ImGuiViewport, size: ImVec2): void {.cdecl, varargs.} + platform_GetWindowSize* {.importc: "Platform_GetWindowSize".}: proc(vp: ptr ImGuiViewport): ImVec2 {.cdecl, varargs.} + platform_SetWindowFocus* {.importc: "Platform_SetWindowFocus".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_GetWindowFocus* {.importc: "Platform_GetWindowFocus".}: proc(vp: ptr ImGuiViewport): bool {.cdecl, varargs.} + platform_GetWindowMinimized* {.importc: "Platform_GetWindowMinimized".}: proc(vp: ptr ImGuiViewport): bool {.cdecl, varargs.} + platform_SetWindowTitle* {.importc: "Platform_SetWindowTitle".}: proc(vp: ptr ImGuiViewport, str: cstring): void {.cdecl, varargs.} + platform_SetWindowAlpha* {.importc: "Platform_SetWindowAlpha".}: proc(vp: ptr ImGuiViewport, alpha: float32): void {.cdecl, varargs.} + platform_UpdateWindow* {.importc: "Platform_UpdateWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_RenderWindow* {.importc: "Platform_RenderWindow".}: proc(vp: ptr ImGuiViewport, render_arg: pointer): void {.cdecl, varargs.} + platform_SwapBuffers* {.importc: "Platform_SwapBuffers".}: proc(vp: ptr ImGuiViewport, render_arg: pointer): void {.cdecl, varargs.} + platform_GetWindowDpiScale* {.importc: "Platform_GetWindowDpiScale".}: proc(vp: ptr ImGuiViewport): float32 {.cdecl, varargs.} + platform_OnChangedViewport* {.importc: "Platform_OnChangedViewport".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + platform_CreateVkSurface* {.importc: "Platform_CreateVkSurface".}: proc(vp: ptr ImGuiViewport, vk_inst: uint64, vk_allocators: pointer, out_vk_surface: ptr uint64): int32 {.cdecl, varargs.} + renderer_CreateWindow* {.importc: "Renderer_CreateWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + renderer_DestroyWindow* {.importc: "Renderer_DestroyWindow".}: proc(vp: ptr ImGuiViewport): void {.cdecl, varargs.} + renderer_SetWindowSize* {.importc: "Renderer_SetWindowSize".}: proc(vp: ptr ImGuiViewport, size: ImVec2): void {.cdecl, varargs.} + renderer_RenderWindow* {.importc: "Renderer_RenderWindow".}: proc(vp: ptr ImGuiViewport, render_arg: pointer): void {.cdecl, varargs.} + renderer_SwapBuffers* {.importc: "Renderer_SwapBuffers".}: proc(vp: ptr ImGuiViewport, render_arg: pointer): void {.cdecl, varargs.} + monitors* {.importc: "Monitors".}: ImVector[ImGuiPlatformMonitor] + viewports* {.importc: "Viewports".}: ImVector[ptr ImGuiViewport] ImGuiPlatformImeData* {.importc: "ImGuiPlatformImeData", imgui_header.} = object wantVisible* {.importc: "WantVisible".}: bool inputPos* {.importc: "InputPos".}: ImVec2 inputLineHeight* {.importc: "InputLineHeight".}: float32 + ImGuiPlatformMonitor* {.importc: "ImGuiPlatformMonitor", imgui_header.} = object + mainPos* {.importc: "MainPos".}: ImVec2 + mainSize* {.importc: "MainSize".}: ImVec2 + workPos* {.importc: "WorkPos".}: ImVec2 + workSize* {.importc: "WorkSize".}: ImVec2 + dpiScale* {.importc: "DpiScale".}: float32 + platformHandle* {.importc: "PlatformHandle".}: pointer ImGuiPopupData* {.importc: "ImGuiPopupData", imgui_header.} = object popupId* {.importc: "PopupId".}: ImGuiID window* {.importc: "Window".}: ptr ImGuiWindow - sourceWindow* {.importc: "SourceWindow".}: ptr ImGuiWindow + backupNavWindow* {.importc: "BackupNavWindow".}: ptr ImGuiWindow parentNavLayer* {.importc: "ParentNavLayer".}: int32 openFrameCount* {.importc: "OpenFrameCount".}: int32 openParentId* {.importc: "OpenParentId".}: ImGuiID @@ -1686,15 +2012,24 @@ type colorButtonPosition* {.importc: "ColorButtonPosition".}: ImGuiDir buttonTextAlign* {.importc: "ButtonTextAlign".}: ImVec2 selectableTextAlign* {.importc: "SelectableTextAlign".}: ImVec2 + separatorTextBorderSize* {.importc: "SeparatorTextBorderSize".}: float32 + separatorTextAlign* {.importc: "SeparatorTextAlign".}: ImVec2 + separatorTextPadding* {.importc: "SeparatorTextPadding".}: ImVec2 displayWindowPadding* {.importc: "DisplayWindowPadding".}: ImVec2 displaySafeAreaPadding* {.importc: "DisplaySafeAreaPadding".}: ImVec2 + dockingSeparatorSize* {.importc: "DockingSeparatorSize".}: float32 mouseCursorScale* {.importc: "MouseCursorScale".}: float32 antiAliasedLines* {.importc: "AntiAliasedLines".}: bool antiAliasedLinesUseTex* {.importc: "AntiAliasedLinesUseTex".}: bool antiAliasedFill* {.importc: "AntiAliasedFill".}: bool curveTessellationTol* {.importc: "CurveTessellationTol".}: float32 circleTessellationMaxError* {.importc: "CircleTessellationMaxError".}: float32 - colors* {.importc: "Colors".}: array[53, ImVec4] + colors* {.importc: "Colors".}: array[55, ImVec4] + hoverStationaryDelay* {.importc: "HoverStationaryDelay".}: float32 + hoverDelayShort* {.importc: "HoverDelayShort".}: float32 + hoverDelayNormal* {.importc: "HoverDelayNormal".}: float32 + hoverFlagsForTooltipMouse* {.importc: "HoverFlagsForTooltipMouse".}: ImGuiHoveredFlags + hoverFlagsForTooltipNav* {.importc: "HoverFlagsForTooltipNav".}: ImGuiHoveredFlags ImGuiTabBar* {.importc: "ImGuiTabBar", imgui_header.} = object tabs* {.importc: "Tabs".}: ImVector[ImGuiTabItem] flags* {.importc: "Flags".}: ImGuiTabBarFlags @@ -1730,6 +2065,7 @@ type ImGuiTabItem* {.importc: "ImGuiTabItem", imgui_header.} = object id* {.importc: "ID".}: ImGuiID flags* {.importc: "Flags".}: ImGuiTabItemFlags + window* {.importc: "Window".}: ptr ImGuiWindow lastFrameVisible* {.importc: "LastFrameVisible".}: int32 lastFrameSelected* {.importc: "LastFrameSelected".}: int32 offset* {.importc: "Offset".}: float32 @@ -1748,10 +2084,9 @@ type columns* {.importc: "Columns".}: ImVector[ImGuiTableColumn] displayOrderToIndex* {.importc: "DisplayOrderToIndex".}: ImVector[ImGuiTableColumnIdx] rowCellData* {.importc: "RowCellData".}: ImVector[ImGuiTableCellData] - enabledMaskByDisplayOrder* {.importc: "EnabledMaskByDisplayOrder".}: uint64 - enabledMaskByIndex* {.importc: "EnabledMaskByIndex".}: uint64 - visibleMaskByIndex* {.importc: "VisibleMaskByIndex".}: uint64 - requestOutputMaskByIndex* {.importc: "RequestOutputMaskByIndex".}: uint64 + enabledMaskByDisplayOrder* {.importc: "EnabledMaskByDisplayOrder".}: uint32Ptr + enabledMaskByIndex* {.importc: "EnabledMaskByIndex".}: uint32Ptr + visibleMaskByIndex* {.importc: "VisibleMaskByIndex".}: uint32Ptr settingsLoadedFlags* {.importc: "SettingsLoadedFlags".}: ImGuiTableFlags settingsOffset* {.importc: "SettingsOffset".}: int32 lastFrameActive* {.importc: "LastFrameActive".}: int32 @@ -1843,6 +2178,8 @@ type isResetDisplayOrderRequest* {.importc: "IsResetDisplayOrderRequest".}: bool isUnfrozenRows* {.importc: "IsUnfrozenRows".}: bool isDefaultSizingPolicy* {.importc: "IsDefaultSizingPolicy".}: bool + hasScrollbarYCurr* {.importc: "HasScrollbarYCurr".}: bool + hasScrollbarYPrev* {.importc: "HasScrollbarYPrev".}: bool memoryCompacted* {.importc: "MemoryCompacted".}: bool hostSkipItems* {.importc: "HostSkipItems".}: bool ImGuiTableCellData* {.importc: "ImGuiTableCellData", imgui_header.} = object @@ -1905,8 +2242,12 @@ type sortOrder* {.importc: "SortOrder".}: int16 sortDirection* {.importc: "SortDirection".}: ImGuiSortDirection ImGuiTableInstanceData* {.importc: "ImGuiTableInstanceData", imgui_header.} = object + tableInstanceID* {.importc: "TableInstanceID".}: ImGuiID lastOuterHeight* {.importc: "LastOuterHeight".}: float32 lastFirstRowHeight* {.importc: "LastFirstRowHeight".}: float32 + lastFrozenHeight* {.importc: "LastFrozenHeight".}: float32 + hoveredRowLast* {.importc: "HoveredRowLast".}: int32 + hoveredRowNext* {.importc: "HoveredRowNext".}: int32 ImGuiTableSettings* {.importc: "ImGuiTableSettings", imgui_header.} = object id* {.importc: "ID".}: ImGuiID saveFlags* {.importc: "SaveFlags".}: ImGuiTableFlags @@ -1937,31 +2278,64 @@ type inputBuf* {.importc: "InputBuf".}: array[256, int8] filters* {.importc: "Filters".}: ImVector[ImGuiTextRange] countGrep* {.importc: "CountGrep".}: int32 + ImGuiTextIndex* {.importc: "ImGuiTextIndex", imgui_header.} = object + lineOffsets* {.importc: "LineOffsets".}: ImVector[int32] + endOffset* {.importc: "EndOffset".}: int32 ImGuiTextRange* {.importc: "ImGuiTextRange", imgui_header.} = object b* {.importc: "b".}: cstring e* {.importc: "e".}: cstring ImGuiViewport* {.importc: "ImGuiViewport", imgui_header.} = object + id* {.importc: "ID".}: ImGuiID flags* {.importc: "Flags".}: ImGuiViewportFlags pos* {.importc: "Pos".}: ImVec2 size* {.importc: "Size".}: ImVec2 workPos* {.importc: "WorkPos".}: ImVec2 workSize* {.importc: "WorkSize".}: ImVec2 + dpiScale* {.importc: "DpiScale".}: float32 + parentViewportId* {.importc: "ParentViewportId".}: ImGuiID + drawData* {.importc: "DrawData".}: ptr ImDrawData + rendererUserData* {.importc: "RendererUserData".}: pointer + platformUserData* {.importc: "PlatformUserData".}: pointer + platformHandle* {.importc: "PlatformHandle".}: pointer platformHandleRaw* {.importc: "PlatformHandleRaw".}: pointer + platformWindowCreated* {.importc: "PlatformWindowCreated".}: bool + platformRequestMove* {.importc: "PlatformRequestMove".}: bool + platformRequestResize* {.importc: "PlatformRequestResize".}: bool + platformRequestClose* {.importc: "PlatformRequestClose".}: bool ImGuiViewportP* {.importc: "ImGuiViewportP", imgui_header.} = object imGuiViewport* {.importc: "_ImGuiViewport".}: ImGuiViewport + window* {.importc: "Window".}: ptr ImGuiWindow + idx* {.importc: "Idx".}: int32 + lastFrameActive* {.importc: "LastFrameActive".}: int32 + lastFocusedStampCount* {.importc: "LastFocusedStampCount".}: int32 + lastNameHash* {.importc: "LastNameHash".}: ImGuiID + lastPos* {.importc: "LastPos".}: ImVec2 + alpha* {.importc: "Alpha".}: float32 + lastAlpha* {.importc: "LastAlpha".}: float32 + lastFocusedHadNavWindow* {.importc: "LastFocusedHadNavWindow".}: bool + platformMonitor* {.importc: "PlatformMonitor".}: int16 drawListsLastFrame* {.importc: "DrawListsLastFrame".}: array[2, int32] drawLists* {.importc: "DrawLists".}: array[2, ptr ImDrawList] drawDataP* {.importc: "DrawDataP".}: ImDrawData drawDataBuilder* {.importc: "DrawDataBuilder".}: ImDrawDataBuilder + lastPlatformPos* {.importc: "LastPlatformPos".}: ImVec2 + lastPlatformSize* {.importc: "LastPlatformSize".}: ImVec2 + lastRendererSize* {.importc: "LastRendererSize".}: ImVec2 workOffsetMin* {.importc: "WorkOffsetMin".}: ImVec2 workOffsetMax* {.importc: "WorkOffsetMax".}: ImVec2 buildWorkOffsetMin* {.importc: "BuildWorkOffsetMin".}: ImVec2 buildWorkOffsetMax* {.importc: "BuildWorkOffsetMax".}: ImVec2 ImGuiWindow* {.importc: "ImGuiWindow", imgui_header.} = object + ctx* {.importc: "Ctx".}: ptr ImGuiContext name* {.importc: "Name".}: cstring id* {.importc: "ID".}: ImGuiID flags* {.importc: "Flags".}: ImGuiWindowFlags + flagsPreviousFrame* {.importc: "FlagsPreviousFrame".}: ImGuiWindowFlags + windowClass* {.importc: "WindowClass".}: ImGuiWindowClass viewport* {.importc: "Viewport".}: ptr ImGuiViewportP + viewportId* {.importc: "ViewportId".}: ImGuiID + viewportPos* {.importc: "ViewportPos".}: ImVec2 + viewportAllowPlatformMonitorExtend* {.importc: "ViewportAllowPlatformMonitorExtend".}: int32 pos* {.importc: "Pos".}: ImVec2 size* {.importc: "Size".}: ImVec2 sizeFull* {.importc: "SizeFull".}: ImVec2 @@ -1971,8 +2345,15 @@ type windowPadding* {.importc: "WindowPadding".}: ImVec2 windowRounding* {.importc: "WindowRounding".}: float32 windowBorderSize* {.importc: "WindowBorderSize".}: float32 + decoOuterSizeX1* {.importc: "DecoOuterSizeX1".}: float32 + decoOuterSizeY1* {.importc: "DecoOuterSizeY1".}: float32 + decoOuterSizeX2* {.importc: "DecoOuterSizeX2".}: float32 + decoOuterSizeY2* {.importc: "DecoOuterSizeY2".}: float32 + decoInnerSizeX1* {.importc: "DecoInnerSizeX1".}: float32 + decoInnerSizeY1* {.importc: "DecoInnerSizeY1".}: float32 nameBufLen* {.importc: "NameBufLen".}: int32 moveId* {.importc: "MoveId".}: ImGuiID + tabId* {.importc: "TabId".}: ImGuiID childId* {.importc: "ChildId".}: ImGuiID scroll* {.importc: "Scroll".}: ImVec2 scrollMax* {.importc: "ScrollMax".}: ImVec2 @@ -1982,6 +2363,7 @@ type scrollbarSizes* {.importc: "ScrollbarSizes".}: ImVec2 scrollbarX* {.importc: "ScrollbarX".}: bool scrollbarY* {.importc: "ScrollbarY".}: bool + viewportOwned* {.importc: "ViewportOwned".}: bool active* {.importc: "Active".}: bool wasActive* {.importc: "WasActive".}: bool writeAccessed* {.importc: "WriteAccessed".}: bool @@ -1995,6 +2377,7 @@ type hasCloseButton* {.importc: "HasCloseButton".}: bool resizeBorderHeld* {.importc: "ResizeBorderHeld".}: int8 beginCount* {.importc: "BeginCount".}: int16 + beginCountPreviousFrame* {.importc: "BeginCountPreviousFrame".}: int16 beginOrderWithinParent* {.importc: "BeginOrderWithinParent".}: int16 beginOrderWithinContext* {.importc: "BeginOrderWithinContext".}: int16 focusOrder* {.importc: "FocusOrder".}: int16 @@ -2011,6 +2394,7 @@ type setWindowPosAllowFlags* {.importc: "SetWindowPosAllowFlags".}: ImGuiCond setWindowSizeAllowFlags* {.importc: "SetWindowSizeAllowFlags".}: ImGuiCond setWindowCollapsedAllowFlags* {.importc: "SetWindowCollapsedAllowFlags".}: ImGuiCond + setWindowDockAllowFlags* {.importc: "SetWindowDockAllowFlags".}: ImGuiCond setWindowPosVal* {.importc: "SetWindowPosVal".}: ImVec2 setWindowPosPivot* {.importc: "SetWindowPosPivot".}: ImVec2 iDStack* {.importc: "IDStack".}: ImVector[ImGuiID] @@ -2025,11 +2409,13 @@ type hitTestHoleSize* {.importc: "HitTestHoleSize".}: ImVec2ih hitTestHoleOffset* {.importc: "HitTestHoleOffset".}: ImVec2ih lastFrameActive* {.importc: "LastFrameActive".}: int32 + lastFrameJustFocused* {.importc: "LastFrameJustFocused".}: int32 lastTimeActive* {.importc: "LastTimeActive".}: float32 itemWidthDefault* {.importc: "ItemWidthDefault".}: float32 stateStorage* {.importc: "StateStorage".}: ImGuiStorage columnsStorage* {.importc: "ColumnsStorage".}: ImVector[ImGuiOldColumns] fontWindowScale* {.importc: "FontWindowScale".}: float32 + fontDpiScale* {.importc: "FontDpiScale".}: float32 settingsOffset* {.importc: "SettingsOffset".}: int32 drawList* {.importc: "DrawList".}: ptr ImDrawList drawListInst* {.importc: "DrawListInst".}: ImDrawList @@ -2037,20 +2423,51 @@ type parentWindowInBeginStack* {.importc: "ParentWindowInBeginStack".}: ptr ImGuiWindow rootWindow* {.importc: "RootWindow".}: ptr ImGuiWindow rootWindowPopupTree* {.importc: "RootWindowPopupTree".}: ptr ImGuiWindow + rootWindowDockTree* {.importc: "RootWindowDockTree".}: ptr ImGuiWindow rootWindowForTitleBarHighlight* {.importc: "RootWindowForTitleBarHighlight".}: ptr ImGuiWindow rootWindowForNav* {.importc: "RootWindowForNav".}: ptr ImGuiWindow navLastChildNavWindow* {.importc: "NavLastChildNavWindow".}: ptr ImGuiWindow navLastIds* {.importc: "NavLastIds".}: array[2, ImGuiID] navRectRel* {.importc: "NavRectRel".}: array[2, ImRect] + navPreferredScoringPosRel* {.importc: "NavPreferredScoringPosRel".}: array[2, ImVec2] + navRootFocusScopeId* {.importc: "NavRootFocusScopeId".}: ImGuiID memoryDrawListIdxCapacity* {.importc: "MemoryDrawListIdxCapacity".}: int32 memoryDrawListVtxCapacity* {.importc: "MemoryDrawListVtxCapacity".}: int32 memoryCompacted* {.importc: "MemoryCompacted".}: bool + dockIsActive* {.importc: "DockIsActive".}: bool + dockNodeIsVisible* {.importc: "DockNodeIsVisible".}: bool + dockTabIsVisible* {.importc: "DockTabIsVisible".}: bool + dockTabWantClose* {.importc: "DockTabWantClose".}: bool + dockOrder* {.importc: "DockOrder".}: int16 + dockStyle* {.importc: "DockStyle".}: ImGuiWindowDockStyle + dockNode* {.importc: "DockNode".}: ptr ImGuiDockNode + dockNodeAsHost* {.importc: "DockNodeAsHost".}: ptr ImGuiDockNode + dockId* {.importc: "DockId".}: ImGuiID + dockTabItemStatusFlags* {.importc: "DockTabItemStatusFlags".}: ImGuiItemStatusFlags + dockTabItemRect* {.importc: "DockTabItemRect".}: ImRect + ImGuiWindowClass* {.importc: "ImGuiWindowClass", imgui_header.} = object + classId* {.importc: "ClassId".}: ImGuiID + parentViewportId* {.importc: "ParentViewportId".}: ImGuiID + viewportFlagsOverrideSet* {.importc: "ViewportFlagsOverrideSet".}: ImGuiViewportFlags + viewportFlagsOverrideClear* {.importc: "ViewportFlagsOverrideClear".}: ImGuiViewportFlags + tabItemFlagsOverrideSet* {.importc: "TabItemFlagsOverrideSet".}: ImGuiTabItemFlags + dockNodeFlagsOverrideSet* {.importc: "DockNodeFlagsOverrideSet".}: ImGuiDockNodeFlags + dockingAlwaysTabBar* {.importc: "DockingAlwaysTabBar".}: bool + dockingAllowUnclassed* {.importc: "DockingAllowUnclassed".}: bool + ImGuiWindowDockStyle* {.importc: "ImGuiWindowDockStyle", imgui_header.} = object + colors* {.importc: "Colors".}: array[6, uint32] ImGuiWindowSettings* {.importc: "ImGuiWindowSettings", imgui_header.} = object id* {.importc: "ID".}: ImGuiID pos* {.importc: "Pos".}: ImVec2ih size* {.importc: "Size".}: ImVec2ih + viewportPos* {.importc: "ViewportPos".}: ImVec2ih + viewportId* {.importc: "ViewportId".}: ImGuiID + dockId* {.importc: "DockId".}: ImGuiID + classId* {.importc: "ClassId".}: ImGuiID + dockOrder* {.importc: "DockOrder".}: int16 collapsed* {.importc: "Collapsed".}: bool wantApply* {.importc: "WantApply".}: bool + wantDelete* {.importc: "WantDelete".}: bool ImGuiWindowStackData* {.importc: "ImGuiWindowStackData", imgui_header.} = object window* {.importc: "Window".}: ptr ImGuiWindow parentLastItemDataBackup* {.importc: "ParentLastItemDataBackup".}: ImGuiLastItemData @@ -2066,6 +2483,7 @@ type currLineTextBaseOffset* {.importc: "CurrLineTextBaseOffset".}: float32 prevLineTextBaseOffset* {.importc: "PrevLineTextBaseOffset".}: float32 isSameLine* {.importc: "IsSameLine".}: bool + isSetPos* {.importc: "IsSetPos".}: bool indent* {.importc: "Indent".}: ImVec1 columnsOffset* {.importc: "ColumnsOffset".}: ImVec1 groupOffset* {.importc: "GroupOffset".}: ImVec1 @@ -2073,9 +2491,9 @@ type navLayerCurrent* {.importc: "NavLayerCurrent".}: ImGuiNavLayer navLayersActiveMask* {.importc: "NavLayersActiveMask".}: int16 navLayersActiveMaskNext* {.importc: "NavLayersActiveMaskNext".}: int16 - navFocusScopeIdCurrent* {.importc: "NavFocusScopeIdCurrent".}: ImGuiID + navIsScrollPushableX* {.importc: "NavIsScrollPushableX".}: bool navHideHighlightOneFrame* {.importc: "NavHideHighlightOneFrame".}: bool - navHasScroll* {.importc: "NavHasScroll".}: bool + navWindowHasScrollY* {.importc: "NavWindowHasScrollY".}: bool menuBarAppending* {.importc: "MenuBarAppending".}: bool menuBarOffset* {.importc: "MenuBarOffset".}: ImVec2 menuColumns* {.importc: "MenuColumns".}: ImGuiMenuColumns @@ -2184,10 +2602,9 @@ proc destroy*(self: ptr ImColor): void {.importc: "ImColor_destroy".} proc getTexID*(self: ptr ImDrawCmd): ImTextureID {.importc: "ImDrawCmd_GetTexID".} proc newImDrawCmd*(): void {.importc: "ImDrawCmd_ImDrawCmd".} proc destroy*(self: ptr ImDrawCmd): void {.importc: "ImDrawCmd_destroy".} -proc clear*(self: ptr ImDrawDataBuilder): void {.importc: "ImDrawDataBuilder_Clear".} -proc clearFreeMemory*(self: ptr ImDrawDataBuilder): void {.importc: "ImDrawDataBuilder_ClearFreeMemory".} -proc flattenIntoSingleLayer*(self: ptr ImDrawDataBuilder): void {.importc: "ImDrawDataBuilder_FlattenIntoSingleLayer".} -proc getDrawListCount*(self: ptr ImDrawDataBuilder): int32 {.importc: "ImDrawDataBuilder_GetDrawListCount".} +proc newImDrawDataBuilder*(): void {.importc: "ImDrawDataBuilder_ImDrawDataBuilder".} +proc destroy*(self: ptr ImDrawDataBuilder): void {.importc: "ImDrawDataBuilder_destroy".} +proc addDrawList*(self: ptr ImDrawData, draw_list: ptr ImDrawList): void {.importc: "ImDrawData_AddDrawList".} proc clear*(self: ptr ImDrawData): void {.importc: "ImDrawData_Clear".} proc deIndexAllBuffers*(self: ptr ImDrawData): void {.importc: "ImDrawData_DeIndexAllBuffers".} proc newImDrawData*(): void {.importc: "ImDrawData_ImDrawData".} @@ -2289,6 +2706,7 @@ proc getGlyphRangesChineseFull*(self: ptr ImFontAtlas): ptr ImWchar {.importc: " proc getGlyphRangesChineseSimplifiedCommon*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon".} proc getGlyphRangesCyrillic*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesCyrillic".} proc getGlyphRangesDefault*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesDefault".} +proc getGlyphRangesGreek*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesGreek".} proc getGlyphRangesJapanese*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesJapanese".} proc getGlyphRangesKorean*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesKorean".} proc getGlyphRangesThai*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "ImFontAtlas_GetGlyphRangesThai".} @@ -2335,6 +2753,23 @@ proc newImGuiContextHook*(): void {.importc: "ImGuiContextHook_ImGuiContextHook" proc destroy*(self: ptr ImGuiContextHook): void {.importc: "ImGuiContextHook_destroy".} proc newImGuiContext*(shared_font_atlas: ptr ImFontAtlas): void {.importc: "ImGuiContext_ImGuiContext".} proc destroy*(self: ptr ImGuiContext): void {.importc: "ImGuiContext_destroy".} +proc getVarPtr*(self: ptr ImGuiDataVarInfo, parent: pointer): pointer {.importc: "ImGuiDataVarInfo_GetVarPtr".} +proc newImGuiDockContext*(): void {.importc: "ImGuiDockContext_ImGuiDockContext".} +proc destroy*(self: ptr ImGuiDockContext): void {.importc: "ImGuiDockContext_destroy".} +proc newImGuiDockNode*(id: ImGuiID): void {.importc: "ImGuiDockNode_ImGuiDockNode".} +proc isCentralNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsCentralNode".} +proc isDockSpace*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsDockSpace".} +proc isEmpty*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsEmpty".} +proc isFloatingNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsFloatingNode".} +proc isHiddenTabBar*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsHiddenTabBar".} +proc isLeafNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsLeafNode".} +proc isNoTabBar*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsNoTabBar".} +proc isRootNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsRootNode".} +proc isSplitNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsSplitNode".} +proc rectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiDockNode): void {.importc: "ImGuiDockNode_Rect".} +proc setLocalFlags*(self: ptr ImGuiDockNode, flags: ImGuiDockNodeFlags): void {.importc: "ImGuiDockNode_SetLocalFlags".} +proc updateMergedFlags*(self: ptr ImGuiDockNode): void {.importc: "ImGuiDockNode_UpdateMergedFlags".} +proc destroy*(self: ptr ImGuiDockNode): void {.importc: "ImGuiDockNode_destroy".} proc addFocusEvent*(self: ptr ImGuiIO, focused: bool): void {.importc: "ImGuiIO_AddFocusEvent".} proc addInputCharacter*(self: ptr ImGuiIO, c: uint32): void {.importc: "ImGuiIO_AddInputCharacter".} proc addInputCharacterUTF16*(self: ptr ImGuiIO, c: ImWchar16): void {.importc: "ImGuiIO_AddInputCharacterUTF16".} @@ -2343,8 +2778,10 @@ proc addKeyAnalogEvent*(self: ptr ImGuiIO, key: ImGuiKey, down: bool, v: float32 proc addKeyEvent*(self: ptr ImGuiIO, key: ImGuiKey, down: bool): void {.importc: "ImGuiIO_AddKeyEvent".} proc addMouseButtonEvent*(self: ptr ImGuiIO, button: int32, down: bool): void {.importc: "ImGuiIO_AddMouseButtonEvent".} proc addMousePosEvent*(self: ptr ImGuiIO, x: float32, y: float32): void {.importc: "ImGuiIO_AddMousePosEvent".} -proc addMouseWheelEvent*(self: ptr ImGuiIO, wh_x: float32, wh_y: float32): void {.importc: "ImGuiIO_AddMouseWheelEvent".} -proc clearInputCharacters*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputCharacters".} +proc addMouseSourceEvent*(self: ptr ImGuiIO, source: ImGuiMouseSource): void {.importc: "ImGuiIO_AddMouseSourceEvent".} +proc addMouseViewportEvent*(self: ptr ImGuiIO, id: ImGuiID): void {.importc: "ImGuiIO_AddMouseViewportEvent".} +proc addMouseWheelEvent*(self: ptr ImGuiIO, wheel_x: float32, wheel_y: float32): void {.importc: "ImGuiIO_AddMouseWheelEvent".} +proc clearEventsQueue*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearEventsQueue".} proc clearInputKeys*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputKeys".} proc newImGuiIO*(): void {.importc: "ImGuiIO_ImGuiIO".} proc setAppAcceptingEvents*(self: ptr ImGuiIO, accepting_events: bool): void {.importc: "ImGuiIO_SetAppAcceptingEvents".} @@ -2359,6 +2796,9 @@ proc newImGuiInputTextCallbackData*(): void {.importc: "ImGuiInputTextCallbackDa proc insertChars*(self: ptr ImGuiInputTextCallbackData, pos: int32, text: cstring, text_end: cstring = nil): void {.importc: "ImGuiInputTextCallbackData_InsertChars".} proc selectAll*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_SelectAll".} proc destroy*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_destroy".} +proc clearFreeMemory*(self: ptr ImGuiInputTextDeactivatedState): void {.importc: "ImGuiInputTextDeactivatedState_ClearFreeMemory".} +proc newImGuiInputTextDeactivatedState*(): void {.importc: "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState".} +proc destroy*(self: ptr ImGuiInputTextDeactivatedState): void {.importc: "ImGuiInputTextDeactivatedState_destroy".} proc clearFreeMemory*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_ClearFreeMemory".} proc clearSelection*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_ClearSelection".} proc clearText*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_ClearText".} @@ -2374,6 +2814,13 @@ proc newImGuiInputTextState*(): void {.importc: "ImGuiInputTextState_ImGuiInputT proc onKeyPressed*(self: ptr ImGuiInputTextState, key: int32): void {.importc: "ImGuiInputTextState_OnKeyPressed".} proc selectAll*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_SelectAll".} proc destroy*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_destroy".} +proc newImGuiKeyOwnerData*(): void {.importc: "ImGuiKeyOwnerData_ImGuiKeyOwnerData".} +proc destroy*(self: ptr ImGuiKeyOwnerData): void {.importc: "ImGuiKeyOwnerData_destroy".} +proc newImGuiKeyRoutingData*(): void {.importc: "ImGuiKeyRoutingData_ImGuiKeyRoutingData".} +proc destroy*(self: ptr ImGuiKeyRoutingData): void {.importc: "ImGuiKeyRoutingData_destroy".} +proc clear*(self: ptr ImGuiKeyRoutingTable): void {.importc: "ImGuiKeyRoutingTable_Clear".} +proc newImGuiKeyRoutingTable*(): void {.importc: "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable".} +proc destroy*(self: ptr ImGuiKeyRoutingTable): void {.importc: "ImGuiKeyRoutingTable_destroy".} proc newImGuiLastItemData*(): void {.importc: "ImGuiLastItemData_ImGuiLastItemData".} proc destroy*(self: ptr ImGuiLastItemData): void {.importc: "ImGuiLastItemData_destroy".} proc newImGuiListClipperData*(): void {.importc: "ImGuiListClipperData_ImGuiListClipperData".} @@ -2383,8 +2830,8 @@ proc fromIndices*(min: int32, max: int32): ImGuiListClipperRange {.importc: "ImG proc fromPositions*(y1: float32, y2: float32, off_min: int32, off_max: int32): ImGuiListClipperRange {.importc: "ImGuiListClipperRange_FromPositions".} proc begin*(self: ptr ImGuiListClipper, items_count: int32, items_height: float32 = -1.0f): void {.importc: "ImGuiListClipper_Begin".} proc `end`*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_End".} -proc forceDisplayRangeByIndices*(self: ptr ImGuiListClipper, item_min: int32, item_max: int32): void {.importc: "ImGuiListClipper_ForceDisplayRangeByIndices".} proc newImGuiListClipper*(): void {.importc: "ImGuiListClipper_ImGuiListClipper".} +proc includeRangeByIndices*(self: ptr ImGuiListClipper, item_begin: int32, item_end: int32): void {.importc: "ImGuiListClipper_IncludeRangeByIndices".} proc step*(self: ptr ImGuiListClipper): bool {.importc: "ImGuiListClipper_Step".} proc destroy*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_destroy".} proc calcNextTotalWidth*(self: ptr ImGuiMenuColumns, update_offsets: bool): void {.importc: "ImGuiMenuColumns_CalcNextTotalWidth".} @@ -2392,8 +2839,6 @@ proc declColumns*(self: ptr ImGuiMenuColumns, w_icon: float32, w_label: float32, proc newImGuiMenuColumns*(): void {.importc: "ImGuiMenuColumns_ImGuiMenuColumns".} proc update*(self: ptr ImGuiMenuColumns, spacing: float32, window_reappearing: bool): void {.importc: "ImGuiMenuColumns_Update".} proc destroy*(self: ptr ImGuiMenuColumns): void {.importc: "ImGuiMenuColumns_destroy".} -proc newImGuiMetricsConfig*(): void {.importc: "ImGuiMetricsConfig_ImGuiMetricsConfig".} -proc destroy*(self: ptr ImGuiMetricsConfig): void {.importc: "ImGuiMetricsConfig_destroy".} proc clear*(self: ptr ImGuiNavItemData): void {.importc: "ImGuiNavItemData_Clear".} proc newImGuiNavItemData*(): void {.importc: "ImGuiNavItemData_ImGuiNavItemData".} proc destroy*(self: ptr ImGuiNavItemData): void {.importc: "ImGuiNavItemData_destroy".} @@ -2415,8 +2860,12 @@ proc isDataType*(self: ptr ImGuiPayload, `type`: cstring): bool {.importc: "ImGu proc isDelivery*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsDelivery".} proc isPreview*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsPreview".} proc destroy*(self: ptr ImGuiPayload): void {.importc: "ImGuiPayload_destroy".} +proc newImGuiPlatformIO*(): void {.importc: "ImGuiPlatformIO_ImGuiPlatformIO".} +proc destroy*(self: ptr ImGuiPlatformIO): void {.importc: "ImGuiPlatformIO_destroy".} proc newImGuiPlatformImeData*(): void {.importc: "ImGuiPlatformImeData_ImGuiPlatformImeData".} proc destroy*(self: ptr ImGuiPlatformImeData): void {.importc: "ImGuiPlatformImeData_destroy".} +proc newImGuiPlatformMonitor*(): void {.importc: "ImGuiPlatformMonitor_ImGuiPlatformMonitor".} +proc destroy*(self: ptr ImGuiPlatformMonitor): void {.importc: "ImGuiPlatformMonitor_destroy".} proc newImGuiPopupData*(): void {.importc: "ImGuiPopupData_ImGuiPopupData".} proc destroy*(self: ptr ImGuiPopupData): void {.importc: "ImGuiPopupData_destroy".} proc newImGuiPtrOrIndex*(`ptr`: pointer): void {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr".} @@ -2426,9 +2875,9 @@ proc newImGuiSettingsHandler*(): void {.importc: "ImGuiSettingsHandler_ImGuiSett proc destroy*(self: ptr ImGuiSettingsHandler): void {.importc: "ImGuiSettingsHandler_destroy".} proc newImGuiStackLevelInfo*(): void {.importc: "ImGuiStackLevelInfo_ImGuiStackLevelInfo".} proc destroy*(self: ptr ImGuiStackLevelInfo): void {.importc: "ImGuiStackLevelInfo_destroy".} -proc compareWithCurrentState*(self: ptr ImGuiStackSizes): void {.importc: "ImGuiStackSizes_CompareWithCurrentState".} +proc compareWithContextState*(self: ptr ImGuiStackSizes, ctx: ptr ImGuiContext): void {.importc: "ImGuiStackSizes_CompareWithContextState".} proc newImGuiStackSizes*(): void {.importc: "ImGuiStackSizes_ImGuiStackSizes".} -proc setToCurrentState*(self: ptr ImGuiStackSizes): void {.importc: "ImGuiStackSizes_SetToCurrentState".} +proc setToContextState*(self: ptr ImGuiStackSizes, ctx: ptr ImGuiContext): void {.importc: "ImGuiStackSizes_SetToContextState".} proc destroy*(self: ptr ImGuiStackSizes): void {.importc: "ImGuiStackSizes_destroy".} proc newImGuiStackTool*(): void {.importc: "ImGuiStackTool_ImGuiStackTool".} proc destroy*(self: ptr ImGuiStackTool): void {.importc: "ImGuiStackTool_destroy".} @@ -2458,8 +2907,6 @@ proc destroy*(self: ptr ImGuiStyleMod): void {.importc: "ImGuiStyleMod_destroy". proc newImGuiStyle*(): void {.importc: "ImGuiStyle_ImGuiStyle".} proc scaleAllSizes*(self: ptr ImGuiStyle, scale_factor: float32): void {.importc: "ImGuiStyle_ScaleAllSizes".} proc destroy*(self: ptr ImGuiStyle): void {.importc: "ImGuiStyle_destroy".} -proc getTabName*(self: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): cstring {.importc: "ImGuiTabBar_GetTabName".} -proc getTabOrder*(self: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): int32 {.importc: "ImGuiTabBar_GetTabOrder".} proc newImGuiTabBar*(): void {.importc: "ImGuiTabBar_ImGuiTabBar".} proc destroy*(self: ptr ImGuiTabBar): void {.importc: "ImGuiTabBar_destroy".} proc newImGuiTabItem*(): void {.importc: "ImGuiTabItem_ImGuiTabItem".} @@ -2500,6 +2947,11 @@ proc newImGuiTextFilter*(default_filter: cstring = ""): void {.importc: "ImGuiTe proc isActive*(self: ptr ImGuiTextFilter): bool {.importc: "ImGuiTextFilter_IsActive".} proc passFilter*(self: ptr ImGuiTextFilter, text: cstring, text_end: cstring = nil): bool {.importc: "ImGuiTextFilter_PassFilter".} proc destroy*(self: ptr ImGuiTextFilter): void {.importc: "ImGuiTextFilter_destroy".} +proc append*(self: ptr ImGuiTextIndex, base: cstring, old_size: int32, new_size: int32): void {.importc: "ImGuiTextIndex_append".} +proc clear*(self: ptr ImGuiTextIndex): void {.importc: "ImGuiTextIndex_clear".} +proc get_line_begin*(self: ptr ImGuiTextIndex, base: cstring, n: int32): cstring {.importc: "ImGuiTextIndex_get_line_begin".} +proc get_line_end*(self: ptr ImGuiTextIndex, base: cstring, n: int32): cstring {.importc: "ImGuiTextIndex_get_line_end".} +proc size*(self: ptr ImGuiTextIndex): int32 {.importc: "ImGuiTextIndex_size".} proc newImGuiTextRange*(): void {.importc: "ImGuiTextRange_ImGuiTextRange_Nil".} proc newImGuiTextRange*(b: cstring, e: cstring): void {.importc: "ImGuiTextRange_ImGuiTextRange_Str".} proc destroy*(self: ptr ImGuiTextRange): void {.importc: "ImGuiTextRange_destroy".} @@ -2507,6 +2959,7 @@ proc empty*(self: ptr ImGuiTextRange): bool {.importc: "ImGuiTextRange_empty".} proc split*(self: ptr ImGuiTextRange, separator: int8, `out`: ptr ImVector[ImGuiTextRange]): void {.importc: "ImGuiTextRange_split".} proc calcWorkRectPosNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewportP, off_min: ImVec2): void {.importc: "ImGuiViewportP_CalcWorkRectPos".} proc calcWorkRectSizeNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewportP, off_min: ImVec2, off_max: ImVec2): void {.importc: "ImGuiViewportP_CalcWorkRectSize".} +proc clearRequestFlags*(self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_ClearRequestFlags".} proc getBuildWorkRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetBuildWorkRect".} proc getMainRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetMainRect".} proc getWorkRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetWorkRect".} @@ -2517,6 +2970,8 @@ proc getCenterNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewport): void {.importc proc getWorkCenterNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewport): void {.importc: "ImGuiViewport_GetWorkCenter".} proc newImGuiViewport*(): void {.importc: "ImGuiViewport_ImGuiViewport".} proc destroy*(self: ptr ImGuiViewport): void {.importc: "ImGuiViewport_destroy".} +proc newImGuiWindowClass*(): void {.importc: "ImGuiWindowClass_ImGuiWindowClass".} +proc destroy*(self: ptr ImGuiWindowClass): void {.importc: "ImGuiWindowClass_destroy".} proc getName*(self: ptr ImGuiWindowSettings): cstring {.importc: "ImGuiWindowSettings_GetName".} proc newImGuiWindowSettings*(): void {.importc: "ImGuiWindowSettings_ImGuiWindowSettings".} proc destroy*(self: ptr ImGuiWindowSettings): void {.importc: "ImGuiWindowSettings_destroy".} @@ -2641,8 +3096,9 @@ proc size*(self: ptr ImVector): int32 {.importc: "ImVector_size".} proc size_in_bytes*(self: ptr ImVector): int32 {.importc: "ImVector_size_in_bytes".} proc swap*(self: ptr ImVector, rhs: ptr ImVector[T]): void {.importc: "ImVector_swap".} proc igAcceptDragDropPayload*(`type`: cstring, flags: ImGuiDragDropFlags = 0.ImGuiDragDropFlags): ptr ImGuiPayload {.importc: "igAcceptDragDropPayload".} -proc igActivateItem*(id: ImGuiID): void {.importc: "igActivateItem".} +proc igActivateItemByID*(id: ImGuiID): void {.importc: "igActivateItemByID".} proc igAddContextHook*(context: ptr ImGuiContext, hook: ptr ImGuiContextHook): ImGuiID {.importc: "igAddContextHook".} +proc igAddDrawListToDrawDataEx*(draw_data: ptr ImDrawData, out_list: ptr ImVector[ImDrawListPtr], draw_list: ptr ImDrawList): void {.importc: "igAddDrawListToDrawDataEx".} proc igAddSettingsHandler*(handler: ptr ImGuiSettingsHandler): void {.importc: "igAddSettingsHandler".} proc igAlignTextToFramePadding*(): void {.importc: "igAlignTextToFramePadding".} proc igArrowButton*(str_id: cstring, dir: ImGuiDir): bool {.importc: "igArrowButton".} @@ -2657,10 +3113,14 @@ proc igBeginCombo*(label: cstring, preview_value: cstring, flags: ImGuiComboFlag proc igBeginComboPopup*(popup_id: ImGuiID, bb: ImRect, flags: ImGuiComboFlags): bool {.importc: "igBeginComboPopup".} proc igBeginComboPreview*(): bool {.importc: "igBeginComboPreview".} proc igBeginDisabled*(disabled: bool = true): void {.importc: "igBeginDisabled".} +proc igBeginDockableDragDropSource*(window: ptr ImGuiWindow): void {.importc: "igBeginDockableDragDropSource".} +proc igBeginDockableDragDropTarget*(window: ptr ImGuiWindow): void {.importc: "igBeginDockableDragDropTarget".} +proc igBeginDocked*(window: ptr ImGuiWindow, p_open: ptr bool): void {.importc: "igBeginDocked".} proc igBeginDragDropSource*(flags: ImGuiDragDropFlags = 0.ImGuiDragDropFlags): bool {.importc: "igBeginDragDropSource".} proc igBeginDragDropTarget*(): bool {.importc: "igBeginDragDropTarget".} proc igBeginDragDropTargetCustom*(bb: ImRect, id: ImGuiID): bool {.importc: "igBeginDragDropTargetCustom".} proc igBeginGroup*(): void {.importc: "igBeginGroup".} +proc igBeginItemTooltip*(): bool {.importc: "igBeginItemTooltip".} proc igBeginListBox*(label: cstring, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igBeginListBox".} proc igBeginMainMenuBar*(): bool {.importc: "igBeginMainMenuBar".} proc igBeginMenu*(label: cstring, enabled: bool = true): bool {.importc: "igBeginMenu".} @@ -2673,12 +3133,12 @@ proc igBeginPopupContextWindow*(str_id: cstring = nil, popup_flags: ImGuiPopupFl proc igBeginPopupEx*(id: ImGuiID, extra_flags: ImGuiWindowFlags): bool {.importc: "igBeginPopupEx".} proc igBeginPopupModal*(name: cstring, p_open: ptr bool = nil, flags: ImGuiWindowFlags = 0.ImGuiWindowFlags): bool {.importc: "igBeginPopupModal".} proc igBeginTabBar*(str_id: cstring, flags: ImGuiTabBarFlags = 0.ImGuiTabBarFlags): bool {.importc: "igBeginTabBar".} -proc igBeginTabBarEx*(tab_bar: ptr ImGuiTabBar, bb: ImRect, flags: ImGuiTabBarFlags): bool {.importc: "igBeginTabBarEx".} +proc igBeginTabBarEx*(tab_bar: ptr ImGuiTabBar, bb: ImRect, flags: ImGuiTabBarFlags, dock_node: ptr ImGuiDockNode): bool {.importc: "igBeginTabBarEx".} proc igBeginTabItem*(label: cstring, p_open: ptr bool = nil, flags: ImGuiTabItemFlags = 0.ImGuiTabItemFlags): bool {.importc: "igBeginTabItem".} proc igBeginTable*(str_id: cstring, column: int32, flags: ImGuiTableFlags = 0.ImGuiTableFlags, outer_size: ImVec2 = ImVec2(x: 0.0f, y: 0.0f), inner_width: float32 = 0.0f): bool {.importc: "igBeginTable".} proc igBeginTableEx*(name: cstring, id: ImGuiID, columns_count: int32, flags: ImGuiTableFlags = 0.ImGuiTableFlags, outer_size: ImVec2 = ImVec2(x: 0, y: 0), inner_width: float32 = 0.0f): bool {.importc: "igBeginTableEx".} -proc igBeginTooltip*(): void {.importc: "igBeginTooltip".} -proc igBeginTooltipEx*(tooltip_flags: ImGuiTooltipFlags, extra_window_flags: ImGuiWindowFlags): void {.importc: "igBeginTooltipEx".} +proc igBeginTooltip*(): bool {.importc: "igBeginTooltip".} +proc igBeginTooltipEx*(tooltip_flags: ImGuiTooltipFlags, extra_window_flags: ImGuiWindowFlags): bool {.importc: "igBeginTooltipEx".} proc igBeginViewportSideBar*(name: cstring, viewport: ptr ImGuiViewport, dir: ImGuiDir, size: float32, window_flags: ImGuiWindowFlags): bool {.importc: "igBeginViewportSideBar".} proc igBringWindowToDisplayBack*(window: ptr ImGuiWindow): void {.importc: "igBringWindowToDisplayBack".} proc igBringWindowToDisplayBehind*(window: ptr ImGuiWindow, above_window: ptr ImGuiWindow): void {.importc: "igBringWindowToDisplayBehind".} @@ -2692,6 +3152,7 @@ proc igButtonBehavior*(bb: ImRect, id: ImGuiID, out_hovered: ptr bool, out_held: proc igButtonEx*(label: cstring, size_arg: ImVec2 = ImVec2(x: 0, y: 0), flags: ImGuiButtonFlags = 0.ImGuiButtonFlags): bool {.importc: "igButtonEx".} proc igCalcItemSizeNonUDT*(pOut: ptr ImVec2, size: ImVec2, default_w: float32, default_h: float32): void {.importc: "igCalcItemSize".} proc igCalcItemWidth*(): float32 {.importc: "igCalcItemWidth".} +proc igCalcRoundingFlagsForRectInRect*(r_in: ImRect, r_outer: ImRect, threshold: float32): ImDrawFlags {.importc: "igCalcRoundingFlagsForRectInRect".} proc igCalcTextSizeNonUDT*(pOut: ptr ImVec2, text: cstring, text_end: cstring = nil, hide_text_after_double_hash: bool = false, wrap_width: float32 = -1.0f): void {.importc: "igCalcTextSize".} proc igCalcTypematicRepeatAmount*(t0: float32, t1: float32, repeat_delay: float32, repeat_rate: float32): int32 {.importc: "igCalcTypematicRepeatAmount".} proc igCalcWindowNextAutoFitSizeNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igCalcWindowNextAutoFitSize".} @@ -2705,12 +3166,13 @@ proc igCheckboxFlags*(label: cstring, flags: ptr uint64, flags_value: uint64): b proc igClearActiveID*(): void {.importc: "igClearActiveID".} proc igClearDragDrop*(): void {.importc: "igClearDragDrop".} proc igClearIniSettings*(): void {.importc: "igClearIniSettings".} +proc igClearWindowSettings*(name: cstring): void {.importc: "igClearWindowSettings".} proc igCloseButton*(id: ImGuiID, pos: ImVec2): bool {.importc: "igCloseButton".} proc igCloseCurrentPopup*(): void {.importc: "igCloseCurrentPopup".} proc igClosePopupToLevel*(remaining: int32, restore_focus_to_window_under_popup: bool): void {.importc: "igClosePopupToLevel".} proc igClosePopupsExceptModals*(): void {.importc: "igClosePopupsExceptModals".} proc igClosePopupsOverWindow*(ref_window: ptr ImGuiWindow, restore_focus_to_window_under_popup: bool): void {.importc: "igClosePopupsOverWindow".} -proc igCollapseButton*(id: ImGuiID, pos: ImVec2): bool {.importc: "igCollapseButton".} +proc igCollapseButton*(id: ImGuiID, pos: ImVec2, dock_node: ptr ImGuiDockNode): bool {.importc: "igCollapseButton".} proc igCollapsingHeader*(label: cstring, flags: ImGuiTreeNodeFlags = 0.ImGuiTreeNodeFlags): bool {.importc: "igCollapsingHeader_TreeNodeFlags".} proc igCollapsingHeader*(label: cstring, p_visible: ptr bool, flags: ImGuiTreeNodeFlags = 0.ImGuiTreeNodeFlags): bool {.importc: "igCollapsingHeader_BoolPtr".} proc igColorButton*(desc_id: cstring, col: ImVec4, flags: ImGuiColorEditFlags = 0.ImGuiColorEditFlags, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igColorButton".} @@ -2729,6 +3191,8 @@ proc igColumns*(count: int32 = 1, id: cstring = nil, border: bool = true): void proc igCombo*(label: cstring, current_item: ptr int32, items: ptr cstring, items_count: int32, popup_max_height_in_items: int32 = -1): bool {.importc: "igCombo_Str_arr".} proc igCombo*(label: cstring, current_item: ptr int32, items_separated_by_zeros: cstring, popup_max_height_in_items: int32 = -1): bool {.importc: "igCombo_Str".} proc igCombo*(label: cstring, current_item: ptr int32, items_getter: proc(data: pointer, idx: int32, out_text: ptr cstring): bool {.cdecl, varargs.}, data: pointer, items_count: int32, popup_max_height_in_items: int32 = -1): bool {.importc: "igCombo_FnBoolPtr".} +proc igConvertShortcutMod*(key_chord: ImGuiKeyChord): ImGuiKeyChord {.importc: "igConvertShortcutMod".} +proc igConvertSingleModFlagToKey*(ctx: ptr ImGuiContext, key: ImGuiKey): ImGuiKey {.importc: "igConvertSingleModFlagToKey".} proc igCreateContext*(shared_font_atlas: ptr ImFontAtlas = nil): ptr ImGuiContext {.importc: "igCreateContext".} proc igCreateNewWindowSettings*(name: cstring): ptr ImGuiWindowSettings {.importc: "igCreateNewWindowSettings".} proc igDataTypeApplyFromText*(buf: cstring, data_type: ImGuiDataType, p_data: pointer, format: cstring): bool {.importc: "igDataTypeApplyFromText".} @@ -2740,11 +3204,15 @@ proc igDataTypeGetInfo*(data_type: ImGuiDataType): ptr ImGuiDataTypeInfo {.impor proc igDebugCheckVersionAndDataLayout*(version_str: cstring, sz_io: uint, sz_style: uint, sz_vec2: uint, sz_vec4: uint, sz_drawvert: uint, sz_drawidx: uint): bool {.importc: "igDebugCheckVersionAndDataLayout".} proc igDebugDrawItemRect*(col: uint32 = 4278190335'u32): void {.importc: "igDebugDrawItemRect".} proc igDebugHookIdInfo*(id: ImGuiID, data_type: ImGuiDataType, data_id: pointer, data_id_end: pointer): void {.importc: "igDebugHookIdInfo".} +proc igDebugLocateItem*(target_id: ImGuiID): void {.importc: "igDebugLocateItem".} +proc igDebugLocateItemOnHover*(target_id: ImGuiID): void {.importc: "igDebugLocateItemOnHover".} +proc igDebugLocateItemResolveWithLastItem*(): void {.importc: "igDebugLocateItemResolveWithLastItem".} proc igDebugLog*(fmt: cstring): void {.importc: "igDebugLog", varargs.} proc igDebugLogV*(fmt: cstring): void {.importc: "igDebugLogV", varargs.} proc igDebugNodeColumns*(columns: ptr ImGuiOldColumns): void {.importc: "igDebugNodeColumns".} +proc igDebugNodeDockNode*(node: ptr ImGuiDockNode, label: cstring): void {.importc: "igDebugNodeDockNode".} proc igDebugNodeDrawCmdShowMeshAndBoundingBox*(out_draw_list: ptr ImDrawList, draw_list: ptr ImDrawList, draw_cmd: ptr ImDrawCmd, show_mesh: bool, show_aabb: bool): void {.importc: "igDebugNodeDrawCmdShowMeshAndBoundingBox".} -proc igDebugNodeDrawList*(window: ptr ImGuiWindow, draw_list: ptr ImDrawList, label: cstring): void {.importc: "igDebugNodeDrawList".} +proc igDebugNodeDrawList*(window: ptr ImGuiWindow, viewport: ptr ImGuiViewportP, draw_list: ptr ImDrawList, label: cstring): void {.importc: "igDebugNodeDrawList".} proc igDebugNodeFont*(font: ptr ImFont): void {.importc: "igDebugNodeFont".} proc igDebugNodeFontGlyph*(font: ptr ImFont, glyph: ptr ImFontGlyph): void {.importc: "igDebugNodeFontGlyph".} proc igDebugNodeInputTextState*(state: ptr ImGuiInputTextState): void {.importc: "igDebugNodeInputTextState".} @@ -2757,10 +3225,51 @@ proc igDebugNodeWindow*(window: ptr ImGuiWindow, label: cstring): void {.importc proc igDebugNodeWindowSettings*(settings: ptr ImGuiWindowSettings): void {.importc: "igDebugNodeWindowSettings".} proc igDebugNodeWindowsList*(windows: ptr ImVector[ptr ImGuiWindow], label: cstring): void {.importc: "igDebugNodeWindowsList".} proc igDebugNodeWindowsListByBeginStackParent*(windows: ptr ptr ImGuiWindow, windows_size: int32, parent_in_begin_stack: ptr ImGuiWindow): void {.importc: "igDebugNodeWindowsListByBeginStackParent".} +proc igDebugRenderKeyboardPreview*(draw_list: ptr ImDrawList): void {.importc: "igDebugRenderKeyboardPreview".} proc igDebugRenderViewportThumbnail*(draw_list: ptr ImDrawList, viewport: ptr ImGuiViewportP, bb: ImRect): void {.importc: "igDebugRenderViewportThumbnail".} proc igDebugStartItemPicker*(): void {.importc: "igDebugStartItemPicker".} proc igDebugTextEncoding*(text: cstring): void {.importc: "igDebugTextEncoding".} proc igDestroyContext*(ctx: ptr ImGuiContext = nil): void {.importc: "igDestroyContext".} +proc igDestroyPlatformWindow*(viewport: ptr ImGuiViewportP): void {.importc: "igDestroyPlatformWindow".} +proc igDestroyPlatformWindows*(): void {.importc: "igDestroyPlatformWindows".} +proc igDockBuilderAddNode*(node_id: ImGuiID = 0.ImGuiID, flags: ImGuiDockNodeFlags = 0.ImGuiDockNodeFlags): ImGuiID {.importc: "igDockBuilderAddNode".} +proc igDockBuilderCopyDockSpace*(src_dockspace_id: ImGuiID, dst_dockspace_id: ImGuiID, in_window_remap_pairs: ImVector[const_cstringPtr]): void {.importc: "igDockBuilderCopyDockSpace".} +proc igDockBuilderCopyNode*(src_node_id: ImGuiID, dst_node_id: ImGuiID, out_node_remap_pairs: ptr ImVector[ImGuiID]): void {.importc: "igDockBuilderCopyNode".} +proc igDockBuilderCopyWindowSettings*(src_name: cstring, dst_name: cstring): void {.importc: "igDockBuilderCopyWindowSettings".} +proc igDockBuilderDockWindow*(window_name: cstring, node_id: ImGuiID): void {.importc: "igDockBuilderDockWindow".} +proc igDockBuilderFinish*(node_id: ImGuiID): void {.importc: "igDockBuilderFinish".} +proc igDockBuilderGetCentralNode*(node_id: ImGuiID): ptr ImGuiDockNode {.importc: "igDockBuilderGetCentralNode".} +proc igDockBuilderGetNode*(node_id: ImGuiID): ptr ImGuiDockNode {.importc: "igDockBuilderGetNode".} +proc igDockBuilderRemoveNode*(node_id: ImGuiID): void {.importc: "igDockBuilderRemoveNode".} +proc igDockBuilderRemoveNodeChildNodes*(node_id: ImGuiID): void {.importc: "igDockBuilderRemoveNodeChildNodes".} +proc igDockBuilderRemoveNodeDockedWindows*(node_id: ImGuiID, clear_settings_refs: bool = true): void {.importc: "igDockBuilderRemoveNodeDockedWindows".} +proc igDockBuilderSetNodePos*(node_id: ImGuiID, pos: ImVec2): void {.importc: "igDockBuilderSetNodePos".} +proc igDockBuilderSetNodeSize*(node_id: ImGuiID, size: ImVec2): void {.importc: "igDockBuilderSetNodeSize".} +proc igDockBuilderSplitNode*(node_id: ImGuiID, split_dir: ImGuiDir, size_ratio_for_node_at_dir: float32, out_id_at_dir: ptr ImGuiID, out_id_at_opposite_dir: ptr ImGuiID): ImGuiID {.importc: "igDockBuilderSplitNode".} +proc igDockContextCalcDropPosForDocking*(target: ptr ImGuiWindow, target_node: ptr ImGuiDockNode, payload_window: ptr ImGuiWindow, payload_node: ptr ImGuiDockNode, split_dir: ImGuiDir, split_outer: bool, out_pos: ptr ImVec2): bool {.importc: "igDockContextCalcDropPosForDocking".} +proc igDockContextClearNodes*(ctx: ptr ImGuiContext, root_id: ImGuiID, clear_settings_refs: bool): void {.importc: "igDockContextClearNodes".} +proc igDockContextEndFrame*(ctx: ptr ImGuiContext): void {.importc: "igDockContextEndFrame".} +proc igDockContextFindNodeByID*(ctx: ptr ImGuiContext, id: ImGuiID): ptr ImGuiDockNode {.importc: "igDockContextFindNodeByID".} +proc igDockContextGenNodeID*(ctx: ptr ImGuiContext): ImGuiID {.importc: "igDockContextGenNodeID".} +proc igDockContextInitialize*(ctx: ptr ImGuiContext): void {.importc: "igDockContextInitialize".} +proc igDockContextNewFrameUpdateDocking*(ctx: ptr ImGuiContext): void {.importc: "igDockContextNewFrameUpdateDocking".} +proc igDockContextNewFrameUpdateUndocking*(ctx: ptr ImGuiContext): void {.importc: "igDockContextNewFrameUpdateUndocking".} +proc igDockContextProcessUndockNode*(ctx: ptr ImGuiContext, node: ptr ImGuiDockNode): void {.importc: "igDockContextProcessUndockNode".} +proc igDockContextProcessUndockWindow*(ctx: ptr ImGuiContext, window: ptr ImGuiWindow, clear_persistent_docking_ref: bool = true): void {.importc: "igDockContextProcessUndockWindow".} +proc igDockContextQueueDock*(ctx: ptr ImGuiContext, target: ptr ImGuiWindow, target_node: ptr ImGuiDockNode, payload: ptr ImGuiWindow, split_dir: ImGuiDir, split_ratio: float32, split_outer: bool): void {.importc: "igDockContextQueueDock".} +proc igDockContextQueueUndockNode*(ctx: ptr ImGuiContext, node: ptr ImGuiDockNode): void {.importc: "igDockContextQueueUndockNode".} +proc igDockContextQueueUndockWindow*(ctx: ptr ImGuiContext, window: ptr ImGuiWindow): void {.importc: "igDockContextQueueUndockWindow".} +proc igDockContextRebuildNodes*(ctx: ptr ImGuiContext): void {.importc: "igDockContextRebuildNodes".} +proc igDockContextShutdown*(ctx: ptr ImGuiContext): void {.importc: "igDockContextShutdown".} +proc igDockNodeBeginAmendTabBar*(node: ptr ImGuiDockNode): bool {.importc: "igDockNodeBeginAmendTabBar".} +proc igDockNodeEndAmendTabBar*(): void {.importc: "igDockNodeEndAmendTabBar".} +proc igDockNodeGetDepth*(node: ptr ImGuiDockNode): int32 {.importc: "igDockNodeGetDepth".} +proc igDockNodeGetRootNode*(node: ptr ImGuiDockNode): ptr ImGuiDockNode {.importc: "igDockNodeGetRootNode".} +proc igDockNodeGetWindowMenuButtonId*(node: ptr ImGuiDockNode): ImGuiID {.importc: "igDockNodeGetWindowMenuButtonId".} +proc igDockNodeIsInHierarchyOf*(node: ptr ImGuiDockNode, parent: ptr ImGuiDockNode): bool {.importc: "igDockNodeIsInHierarchyOf".} +proc igDockNodeWindowMenuHandler_Default*(ctx: ptr ImGuiContext, node: ptr ImGuiDockNode, tab_bar: ptr ImGuiTabBar): void {.importc: "igDockNodeWindowMenuHandler_Default".} +proc igDockSpace*(id: ImGuiID, size: ImVec2 = ImVec2(x: 0, y: 0), flags: ImGuiDockNodeFlags = 0.ImGuiDockNodeFlags, window_class: ptr ImGuiWindowClass = nil): ImGuiID {.importc: "igDockSpace".} +proc igDockSpaceOverViewport*(viewport: ptr ImGuiViewport = nil, flags: ImGuiDockNodeFlags = 0.ImGuiDockNodeFlags, window_class: ptr ImGuiWindowClass = nil): ImGuiID {.importc: "igDockSpaceOverViewport".} proc igDragBehavior*(id: ImGuiID, data_type: ImGuiDataType, p_v: pointer, v_speed: float32, p_min: pointer, p_max: pointer, format: cstring, flags: ImGuiSliderFlags): bool {.importc: "igDragBehavior".} proc igDragFloat*(label: cstring, v: ptr float32, v_speed: float32 = 1.0f, v_min: float32 = 0.0f, v_max: float32 = 0.0f, format: cstring = "%.3f", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igDragFloat".} proc igDragFloat2*(label: cstring, v: var array[2, float32], v_speed: float32 = 1.0f, v_min: float32 = 0.0f, v_max: float32 = 0.0f, format: cstring = "%.3f", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igDragFloat2".} @@ -2797,19 +3306,25 @@ proc igEndTable*(): void {.importc: "igEndTable".} proc igEndTooltip*(): void {.importc: "igEndTooltip".} proc igErrorCheckEndFrameRecover*(log_callback: ImGuiErrorLogCallback, user_data: pointer = nil): void {.importc: "igErrorCheckEndFrameRecover".} proc igErrorCheckEndWindowRecover*(log_callback: ImGuiErrorLogCallback, user_data: pointer = nil): void {.importc: "igErrorCheckEndWindowRecover".} +proc igErrorCheckUsingSetCursorPosToExtendParentBoundaries*(): void {.importc: "igErrorCheckUsingSetCursorPosToExtendParentBoundaries".} proc igFindBestWindowPosForPopupNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igFindBestWindowPosForPopup".} proc igFindBestWindowPosForPopupExNonUDT*(pOut: ptr ImVec2, ref_pos: ImVec2, size: ImVec2, last_dir: ptr ImGuiDir, r_outer: ImRect, r_avoid: ImRect, policy: ImGuiPopupPositionPolicy): void {.importc: "igFindBestWindowPosForPopupEx".} +proc igFindBlockingModal*(window: ptr ImGuiWindow): ptr ImGuiWindow {.importc: "igFindBlockingModal".} proc igFindBottomMostVisibleWindowWithinBeginStack*(window: ptr ImGuiWindow): ptr ImGuiWindow {.importc: "igFindBottomMostVisibleWindowWithinBeginStack".} +proc igFindHoveredViewportFromPlatformWindowStack*(mouse_platform_pos: ImVec2): ptr ImGuiViewportP {.importc: "igFindHoveredViewportFromPlatformWindowStack".} proc igFindOrCreateColumns*(window: ptr ImGuiWindow, id: ImGuiID): ptr ImGuiOldColumns {.importc: "igFindOrCreateColumns".} -proc igFindOrCreateWindowSettings*(name: cstring): ptr ImGuiWindowSettings {.importc: "igFindOrCreateWindowSettings".} proc igFindRenderedTextEnd*(text: cstring, text_end: cstring = nil): cstring {.importc: "igFindRenderedTextEnd".} proc igFindSettingsHandler*(type_name: cstring): ptr ImGuiSettingsHandler {.importc: "igFindSettingsHandler".} +proc igFindViewportByID*(id: ImGuiID): ptr ImGuiViewport {.importc: "igFindViewportByID".} +proc igFindViewportByPlatformHandle*(platform_handle: pointer): ptr ImGuiViewport {.importc: "igFindViewportByPlatformHandle".} proc igFindWindowByID*(id: ImGuiID): ptr ImGuiWindow {.importc: "igFindWindowByID".} proc igFindWindowByName*(name: cstring): ptr ImGuiWindow {.importc: "igFindWindowByName".} proc igFindWindowDisplayIndex*(window: ptr ImGuiWindow): int32 {.importc: "igFindWindowDisplayIndex".} -proc igFindWindowSettings*(id: ImGuiID): ptr ImGuiWindowSettings {.importc: "igFindWindowSettings".} -proc igFocusTopMostWindowUnderOne*(under_this_window: ptr ImGuiWindow, ignore_window: ptr ImGuiWindow): void {.importc: "igFocusTopMostWindowUnderOne".} -proc igFocusWindow*(window: ptr ImGuiWindow): void {.importc: "igFocusWindow".} +proc igFindWindowSettingsByID*(id: ImGuiID): ptr ImGuiWindowSettings {.importc: "igFindWindowSettingsByID".} +proc igFindWindowSettingsByWindow*(window: ptr ImGuiWindow): ptr ImGuiWindowSettings {.importc: "igFindWindowSettingsByWindow".} +proc igFocusItem*(): void {.importc: "igFocusItem".} +proc igFocusTopMostWindowUnderOne*(under_this_window: ptr ImGuiWindow, ignore_window: ptr ImGuiWindow, filter_viewport: ptr ImGuiViewport, flags: ImGuiFocusRequestFlags): void {.importc: "igFocusTopMostWindowUnderOne".} +proc igFocusWindow*(window: ptr ImGuiWindow, flags: ImGuiFocusRequestFlags = 0.ImGuiFocusRequestFlags): void {.importc: "igFocusWindow".} proc igGcAwakeTransientWindowBuffers*(window: ptr ImGuiWindow): void {.importc: "igGcAwakeTransientWindowBuffers".} proc igGcCompactTransientMiscBuffers*(): void {.importc: "igGcCompactTransientMiscBuffers".} proc igGcCompactTransientWindowBuffers*(window: ptr ImGuiWindow): void {.importc: "igGcCompactTransientWindowBuffers".} @@ -2832,6 +3347,8 @@ proc igGetContentRegionAvailNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetCon proc igGetContentRegionMaxNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetContentRegionMax".} proc igGetContentRegionMaxAbsNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetContentRegionMaxAbs".} proc igGetCurrentContext*(): ptr ImGuiContext {.importc: "igGetCurrentContext".} +proc igGetCurrentFocusScope*(): ImGuiID {.importc: "igGetCurrentFocusScope".} +proc igGetCurrentTabBar*(): ptr ImGuiTabBar {.importc: "igGetCurrentTabBar".} proc igGetCurrentTable*(): ptr ImGuiTable {.importc: "igGetCurrentTable".} proc igGetCurrentWindow*(): ptr ImGuiWindow {.importc: "igGetCurrentWindow".} proc igGetCurrentWindowRead*(): ptr ImGuiWindow {.importc: "igGetCurrentWindowRead".} @@ -2845,14 +3362,12 @@ proc igGetDragDropPayload*(): ptr ImGuiPayload {.importc: "igGetDragDropPayload" proc igGetDrawData*(): ptr ImDrawData {.importc: "igGetDrawData".} proc igGetDrawListSharedData*(): ptr ImDrawListSharedData {.importc: "igGetDrawListSharedData".} proc igGetFocusID*(): ImGuiID {.importc: "igGetFocusID".} -proc igGetFocusScope*(): ImGuiID {.importc: "igGetFocusScope".} -proc igGetFocusedFocusScope*(): ImGuiID {.importc: "igGetFocusedFocusScope".} proc igGetFont*(): ptr ImFont {.importc: "igGetFont".} proc igGetFontSize*(): float32 {.importc: "igGetFontSize".} proc igGetFontTexUvWhitePixelNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetFontTexUvWhitePixel".} proc igGetForegroundDrawList*(): ptr ImDrawList {.importc: "igGetForegroundDrawList_Nil".} -proc igGetForegroundDrawList*(window: ptr ImGuiWindow): ptr ImDrawList {.importc: "igGetForegroundDrawList_WindowPtr".} proc igGetForegroundDrawList*(viewport: ptr ImGuiViewport): ptr ImDrawList {.importc: "igGetForegroundDrawList_ViewportPtr".} +proc igGetForegroundDrawList*(window: ptr ImGuiWindow): ptr ImDrawList {.importc: "igGetForegroundDrawList_WindowPtr".} proc igGetFrameCount*(): int32 {.importc: "igGetFrameCount".} proc igGetFrameHeight*(): float32 {.importc: "igGetFrameHeight".} proc igGetFrameHeightWithSpacing*(): float32 {.importc: "igGetFrameHeightWithSpacing".} @@ -2860,7 +3375,8 @@ proc igGetHoveredID*(): ImGuiID {.importc: "igGetHoveredID".} proc igGetID*(str_id: cstring): ImGuiID {.importc: "igGetID_Str".} proc igGetID*(str_id_begin: cstring, str_id_end: cstring): ImGuiID {.importc: "igGetID_StrStr".} proc igGetID*(ptr_id: pointer): ImGuiID {.importc: "igGetID_Ptr".} -proc igGetIDWithSeed*(str_id_begin: cstring, str_id_end: cstring, seed: ImGuiID): ImGuiID {.importc: "igGetIDWithSeed".} +proc igGetIDWithSeed*(str_id_begin: cstring, str_id_end: cstring, seed: ImGuiID): ImGuiID {.importc: "igGetIDWithSeed_Str".} +proc igGetIDWithSeed*(n: int32, seed: ImGuiID): ImGuiID {.importc: "igGetIDWithSeed_Int".} proc igGetIO*(): ptr ImGuiIO {.importc: "igGetIO".} proc igGetInputTextState*(id: ImGuiID): ptr ImGuiInputTextState {.importc: "igGetInputTextState".} proc igGetItemFlags*(): ImGuiItemFlags {.importc: "igGetItemFlags".} @@ -2869,38 +3385,49 @@ proc igGetItemRectMaxNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectMa proc igGetItemRectMinNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectMin".} proc igGetItemRectSizeNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetItemRectSize".} proc igGetItemStatusFlags*(): ImGuiItemStatusFlags {.importc: "igGetItemStatusFlags".} -proc igGetKeyData*(key: ImGuiKey): ptr ImGuiKeyData {.importc: "igGetKeyData".} -proc igGetKeyIndex*(key: ImGuiKey): int32 {.importc: "igGetKeyIndex".} +proc igGetKeyChordName*(key_chord: ImGuiKeyChord, out_buf: cstring, out_buf_size: int32): void {.importc: "igGetKeyChordName".} +proc igGetKeyData*(ctx: ptr ImGuiContext, key: ImGuiKey): ptr ImGuiKeyData {.importc: "igGetKeyData_ContextPtr".} +proc igGetKeyData*(key: ImGuiKey): ptr ImGuiKeyData {.importc: "igGetKeyData_Key".} +proc igGetKeyIndex*(key: ImGuiKey): ImGuiKey {.importc: "igGetKeyIndex".} +proc igGetKeyMagnitude2dNonUDT*(pOut: ptr ImVec2, key_left: ImGuiKey, key_right: ImGuiKey, key_up: ImGuiKey, key_down: ImGuiKey): void {.importc: "igGetKeyMagnitude2d".} proc igGetKeyName*(key: ImGuiKey): cstring {.importc: "igGetKeyName".} +proc igGetKeyOwner*(key: ImGuiKey): ImGuiID {.importc: "igGetKeyOwner".} +proc igGetKeyOwnerData*(ctx: ptr ImGuiContext, key: ImGuiKey): ptr ImGuiKeyOwnerData {.importc: "igGetKeyOwnerData".} proc igGetKeyPressedAmount*(key: ImGuiKey, repeat_delay: float32, rate: float32): int32 {.importc: "igGetKeyPressedAmount".} proc igGetMainViewport*(): ptr ImGuiViewport {.importc: "igGetMainViewport".} -proc igGetMergedModFlags*(): ImGuiModFlags {.importc: "igGetMergedModFlags".} proc igGetMouseClickedCount*(button: ImGuiMouseButton): int32 {.importc: "igGetMouseClickedCount".} proc igGetMouseCursor*(): ImGuiMouseCursor {.importc: "igGetMouseCursor".} proc igGetMouseDragDeltaNonUDT*(pOut: ptr ImVec2, button: ImGuiMouseButton = 0.ImGuiMouseButton, lock_threshold: float32 = -1.0f): void {.importc: "igGetMouseDragDelta".} proc igGetMousePosNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePos".} proc igGetMousePosOnOpeningCurrentPopupNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetMousePosOnOpeningCurrentPopup".} -proc igGetNavInputAmount*(n: ImGuiNavInput, mode: ImGuiNavReadMode): float32 {.importc: "igGetNavInputAmount".} -proc igGetNavInputAmount2dNonUDT*(pOut: ptr ImVec2, dir_sources: ImGuiNavDirSourceFlags, mode: ImGuiNavReadMode, slow_factor: float32 = 0.0f, fast_factor: float32 = 0.0f): void {.importc: "igGetNavInputAmount2d".} -proc igGetNavInputName*(n: ImGuiNavInput): cstring {.importc: "igGetNavInputName".} +proc igGetNavTweakPressedAmount*(axis: ImGuiAxis): float32 {.importc: "igGetNavTweakPressedAmount".} +proc igGetPlatformIO*(): ptr ImGuiPlatformIO {.importc: "igGetPlatformIO".} proc igGetPopupAllowedExtentRectNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow): void {.importc: "igGetPopupAllowedExtentRect".} proc igGetScrollMaxX*(): float32 {.importc: "igGetScrollMaxX".} proc igGetScrollMaxY*(): float32 {.importc: "igGetScrollMaxY".} proc igGetScrollX*(): float32 {.importc: "igGetScrollX".} proc igGetScrollY*(): float32 {.importc: "igGetScrollY".} +proc igGetShortcutRoutingData*(key_chord: ImGuiKeyChord): ptr ImGuiKeyRoutingData {.importc: "igGetShortcutRoutingData".} proc igGetStateStorage*(): ptr ImGuiStorage {.importc: "igGetStateStorage".} proc igGetStyle*(): ptr ImGuiStyle {.importc: "igGetStyle".} proc igGetStyleColorName*(idx: ImGuiCol): cstring {.importc: "igGetStyleColorName".} proc igGetStyleColorVec4*(idx: ImGuiCol): ptr ImVec4 {.importc: "igGetStyleColorVec4".} +proc igGetStyleVarInfo*(idx: ImGuiStyleVar): ptr ImGuiDataVarInfo {.importc: "igGetStyleVarInfo".} proc igGetTextLineHeight*(): float32 {.importc: "igGetTextLineHeight".} proc igGetTextLineHeightWithSpacing*(): float32 {.importc: "igGetTextLineHeightWithSpacing".} proc igGetTime*(): float64 {.importc: "igGetTime".} proc igGetTopMostAndVisiblePopupModal*(): ptr ImGuiWindow {.importc: "igGetTopMostAndVisiblePopupModal".} proc igGetTopMostPopupModal*(): ptr ImGuiWindow {.importc: "igGetTopMostPopupModal".} proc igGetTreeNodeToLabelSpacing*(): float32 {.importc: "igGetTreeNodeToLabelSpacing".} +proc igGetTypematicRepeatRate*(flags: ImGuiInputFlags, repeat_delay: ptr float32, repeat_rate: ptr float32): void {.importc: "igGetTypematicRepeatRate".} proc igGetVersion*(): cstring {.importc: "igGetVersion".} +proc igGetViewportPlatformMonitor*(viewport: ptr ImGuiViewport): ptr ImGuiPlatformMonitor {.importc: "igGetViewportPlatformMonitor".} +proc igGetWindowAlwaysWantOwnTabBar*(window: ptr ImGuiWindow): bool {.importc: "igGetWindowAlwaysWantOwnTabBar".} proc igGetWindowContentRegionMaxNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetWindowContentRegionMax".} proc igGetWindowContentRegionMinNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetWindowContentRegionMin".} +proc igGetWindowDockID*(): ImGuiID {.importc: "igGetWindowDockID".} +proc igGetWindowDockNode*(): ptr ImGuiDockNode {.importc: "igGetWindowDockNode".} +proc igGetWindowDpiScale*(): float32 {.importc: "igGetWindowDpiScale".} proc igGetWindowDrawList*(): ptr ImDrawList {.importc: "igGetWindowDrawList".} proc igGetWindowHeight*(): float32 {.importc: "igGetWindowHeight".} proc igGetWindowPosNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetWindowPos".} @@ -2909,6 +3436,7 @@ proc igGetWindowResizeCornerID*(window: ptr ImGuiWindow, n: int32): ImGuiID {.im proc igGetWindowScrollbarID*(window: ptr ImGuiWindow, axis: ImGuiAxis): ImGuiID {.importc: "igGetWindowScrollbarID".} proc igGetWindowScrollbarRectNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, axis: ImGuiAxis): void {.importc: "igGetWindowScrollbarRect".} proc igGetWindowSizeNonUDT*(pOut: ptr ImVec2): void {.importc: "igGetWindowSize".} +proc igGetWindowViewport*(): ptr ImGuiViewport {.importc: "igGetWindowViewport".} proc igGetWindowWidth*(): float32 {.importc: "igGetWindowWidth".} proc igImAbs*(x: int32): int32 {.importc: "igImAbs_Int".} proc igImAbs*(x: float32): float32 {.importc: "igImAbs_Float".} @@ -2918,7 +3446,9 @@ proc igImBezierCubicCalcNonUDT*(pOut: ptr ImVec2, p1: ImVec2, p2: ImVec2, p3: Im proc igImBezierCubicClosestPointNonUDT*(pOut: ptr ImVec2, p1: ImVec2, p2: ImVec2, p3: ImVec2, p4: ImVec2, p: ImVec2, num_segments: int32): void {.importc: "igImBezierCubicClosestPoint".} proc igImBezierCubicClosestPointCasteljauNonUDT*(pOut: ptr ImVec2, p1: ImVec2, p2: ImVec2, p3: ImVec2, p4: ImVec2, p: ImVec2, tess_tol: float32): void {.importc: "igImBezierCubicClosestPointCasteljau".} proc igImBezierQuadraticCalcNonUDT*(pOut: ptr ImVec2, p1: ImVec2, p2: ImVec2, p3: ImVec2, t: float32): void {.importc: "igImBezierQuadraticCalc".} +proc igImBitArrayClearAllBits*(arr: ptr uint32, bitcount: int32): void {.importc: "igImBitArrayClearAllBits".} proc igImBitArrayClearBit*(arr: ptr uint32, n: int32): void {.importc: "igImBitArrayClearBit".} +proc igImBitArrayGetStorageSizeInBytes*(bitcount: int32): uint {.importc: "igImBitArrayGetStorageSizeInBytes".} proc igImBitArraySetBit*(arr: ptr uint32, n: int32): void {.importc: "igImBitArraySetBit".} proc igImBitArraySetBitRange*(arr: ptr uint32, n: int32, n2: int32): void {.importc: "igImBitArraySetBitRange".} proc igImBitArrayTestBit*(arr: ptr uint32, n: int32): bool {.importc: "igImBitArrayTestBit".} @@ -2926,6 +3456,7 @@ proc igImCharIsBlankA*(c: int8): bool {.importc: "igImCharIsBlankA".} proc igImCharIsBlankW*(c: uint32): bool {.importc: "igImCharIsBlankW".} proc igImClampNonUDT*(pOut: ptr ImVec2, v: ImVec2, mn: ImVec2, mx: ImVec2): void {.importc: "igImClamp".} proc igImDot*(a: ImVec2, b: ImVec2): float32 {.importc: "igImDot".} +proc igImExponentialMovingAverage*(avg: float32, sample: float32, n: int32): float32 {.importc: "igImExponentialMovingAverage".} proc igImFileClose*(file: ImFileHandle): bool {.importc: "igImFileClose".} proc igImFileGetSize*(file: ImFileHandle): uint64 {.importc: "igImFileGetSize".} proc igImFileLoadToMemory*(filename: cstring, mode: cstring, out_file_size: ptr uint = nil, padding_bytes: int32 = 0): pointer {.importc: "igImFileLoadToMemory".} @@ -2949,9 +3480,8 @@ proc igImFormatString*(buf: cstring, buf_size: uint, fmt: cstring): int32 {.impo proc igImFormatStringToTempBuffer*(out_buf: ptr cstring, out_buf_end: ptr cstring, fmt: cstring): void {.importc: "igImFormatStringToTempBuffer", varargs.} proc igImFormatStringToTempBufferV*(out_buf: ptr cstring, out_buf_end: ptr cstring, fmt: cstring): void {.importc: "igImFormatStringToTempBufferV", varargs.} proc igImFormatStringV*(buf: cstring, buf_size: uint, fmt: cstring): int32 {.importc: "igImFormatStringV", varargs.} -proc igImGetDirQuadrantFromDelta*(dx: float32, dy: float32): ImGuiDir {.importc: "igImGetDirQuadrantFromDelta".} -proc igImHashData*(data: pointer, data_size: uint, seed: uint32 = 0): ImGuiID {.importc: "igImHashData".} -proc igImHashStr*(data: cstring, data_size: uint = 0, seed: uint32 = 0): ImGuiID {.importc: "igImHashStr".} +proc igImHashData*(data: pointer, data_size: uint, seed: ImGuiID = 0.ImGuiID): ImGuiID {.importc: "igImHashData".} +proc igImHashStr*(data: cstring, data_size: uint = 0, seed: ImGuiID = 0.ImGuiID): ImGuiID {.importc: "igImHashStr".} proc igImInvLength*(lhs: ImVec2, fail_value: float32): float32 {.importc: "igImInvLength".} proc igImIsFloatAboveGuaranteedIntegerPrecision*(f: float32): bool {.importc: "igImIsFloatAboveGuaranteedIntegerPrecision".} proc igImIsPowerOfTwo*(v: int32): bool {.importc: "igImIsPowerOfTwo_Int".} @@ -3003,14 +3533,15 @@ proc igImTextCountUtf8BytesFromChar*(in_text: cstring, in_text_end: cstring): in proc igImTextCountUtf8BytesFromStr*(in_text: ptr ImWchar, in_text_end: ptr ImWchar): int32 {.importc: "igImTextCountUtf8BytesFromStr".} proc igImTextStrFromUtf8*(out_buf: ptr ImWchar, out_buf_size: int32, in_text: cstring, in_text_end: cstring, in_remaining: ptr cstring = nil): int32 {.importc: "igImTextStrFromUtf8".} proc igImTextStrToUtf8*(out_buf: cstring, out_buf_size: int32, in_text: ptr ImWchar, in_text_end: ptr ImWchar): int32 {.importc: "igImTextStrToUtf8".} +proc igImToUpper*(c: int8): int8 {.importc: "igImToUpper".} proc igImTriangleArea*(a: ImVec2, b: ImVec2, c: ImVec2): float32 {.importc: "igImTriangleArea".} proc igImTriangleBarycentricCoords*(a: ImVec2, b: ImVec2, c: ImVec2, p: ImVec2, out_u: ptr float32, out_v: ptr float32, out_w: ptr float32): void {.importc: "igImTriangleBarycentricCoords".} proc igImTriangleClosestPointNonUDT*(pOut: ptr ImVec2, a: ImVec2, b: ImVec2, c: ImVec2, p: ImVec2): void {.importc: "igImTriangleClosestPoint".} proc igImTriangleContainsPoint*(a: ImVec2, b: ImVec2, c: ImVec2, p: ImVec2): bool {.importc: "igImTriangleContainsPoint".} proc igImUpperPowerOfTwo*(v: int32): int32 {.importc: "igImUpperPowerOfTwo".} proc igImage*(user_texture_id: ImTextureID, size: ImVec2, uv0: ImVec2 = ImVec2(x: 0, y: 0), uv1: ImVec2 = ImVec2(x: 1, y: 1), tint_col: ImVec4 = ImVec4(x: 1, y: 1, z: 1, w: 1), border_col: ImVec4 = ImVec4(x: 0, y: 0, z: 0, w: 0)): void {.importc: "igImage".} -proc igImageButton*(user_texture_id: ImTextureID, size: ImVec2, uv0: ImVec2 = ImVec2(x: 0, y: 0), uv1: ImVec2 = ImVec2(x: 1, y: 1), frame_padding: int32 = -1, bg_col: ImVec4 = ImVec4(x: 0, y: 0, z: 0, w: 0), tint_col: ImVec4 = ImVec4(x: 1, y: 1, z: 1, w: 1)): bool {.importc: "igImageButton".} -proc igImageButtonEx*(id: ImGuiID, texture_id: ImTextureID, size: ImVec2, uv0: ImVec2, uv1: ImVec2, padding: ImVec2, bg_col: ImVec4, tint_col: ImVec4): bool {.importc: "igImageButtonEx".} +proc igImageButton*(str_id: cstring, user_texture_id: ImTextureID, size: ImVec2, uv0: ImVec2 = ImVec2(x: 0, y: 0), uv1: ImVec2 = ImVec2(x: 1, y: 1), bg_col: ImVec4 = ImVec4(x: 0, y: 0, z: 0, w: 0), tint_col: ImVec4 = ImVec4(x: 1, y: 1, z: 1, w: 1)): bool {.importc: "igImageButton".} +proc igImageButtonEx*(id: ImGuiID, texture_id: ImTextureID, size: ImVec2, uv0: ImVec2, uv1: ImVec2, bg_col: ImVec4, tint_col: ImVec4, flags: ImGuiButtonFlags = 0.ImGuiButtonFlags): bool {.importc: "igImageButtonEx".} proc igIndent*(indent_w: float32 = 0.0f): void {.importc: "igIndent".} proc igInitialize*(): void {.importc: "igInitialize".} proc igInputDouble*(label: cstring, v: ptr float64, step: float64 = 0.0, step_fast: float64 = 0.0, format: cstring = "%.6f", flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputDouble".} @@ -3025,13 +3556,13 @@ proc igInputInt4*(label: cstring, v: var array[4, int32], flags: ImGuiInputTextF proc igInputScalar*(label: cstring, data_type: ImGuiDataType, p_data: pointer, p_step: pointer = nil, p_step_fast: pointer = nil, format: cstring = nil, flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputScalar".} proc igInputScalarN*(label: cstring, data_type: ImGuiDataType, p_data: pointer, components: int32, p_step: pointer = nil, p_step_fast: pointer = nil, format: cstring = nil, flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags): bool {.importc: "igInputScalarN".} proc igInputText*(label: cstring, buf: cstring, buf_size: uint, flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags, callback: ImGuiInputTextCallback = nil, user_data: pointer = nil): bool {.importc: "igInputText".} +proc igInputTextDeactivateHook*(id: ImGuiID): void {.importc: "igInputTextDeactivateHook".} proc igInputTextEx*(label: cstring, hint: cstring, buf: cstring, buf_size: int32, size_arg: ImVec2, flags: ImGuiInputTextFlags, callback: ImGuiInputTextCallback = nil, user_data: pointer = nil): bool {.importc: "igInputTextEx".} proc igInputTextMultiline*(label: cstring, buf: cstring, buf_size: uint, size: ImVec2 = ImVec2(x: 0, y: 0), flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags, callback: ImGuiInputTextCallback = nil, user_data: pointer = nil): bool {.importc: "igInputTextMultiline".} proc igInputTextWithHint*(label: cstring, hint: cstring, buf: cstring, buf_size: uint, flags: ImGuiInputTextFlags = 0.ImGuiInputTextFlags, callback: ImGuiInputTextCallback = nil, user_data: pointer = nil): bool {.importc: "igInputTextWithHint".} proc igInvisibleButton*(str_id: cstring, size: ImVec2, flags: ImGuiButtonFlags = 0.ImGuiButtonFlags): bool {.importc: "igInvisibleButton".} -proc igIsActiveIdUsingKey*(key: ImGuiKey): bool {.importc: "igIsActiveIdUsingKey".} proc igIsActiveIdUsingNavDir*(dir: ImGuiDir): bool {.importc: "igIsActiveIdUsingNavDir".} -proc igIsActiveIdUsingNavInput*(input: ImGuiNavInput): bool {.importc: "igIsActiveIdUsingNavInput".} +proc igIsAliasKey*(key: ImGuiKey): bool {.importc: "igIsAliasKey".} proc igIsAnyItemActive*(): bool {.importc: "igIsAnyItemActive".} proc igIsAnyItemFocused*(): bool {.importc: "igIsAnyItemFocused".} proc igIsAnyItemHovered*(): bool {.importc: "igIsAnyItemHovered".} @@ -3051,36 +3582,45 @@ proc igIsItemHovered*(flags: ImGuiHoveredFlags = 0.ImGuiHoveredFlags): bool {.im proc igIsItemToggledOpen*(): bool {.importc: "igIsItemToggledOpen".} proc igIsItemToggledSelection*(): bool {.importc: "igIsItemToggledSelection".} proc igIsItemVisible*(): bool {.importc: "igIsItemVisible".} -proc igIsKeyDown*(key: ImGuiKey): bool {.importc: "igIsKeyDown".} -proc igIsKeyPressed*(key: ImGuiKey, repeat: bool = true): bool {.importc: "igIsKeyPressed".} +proc igIsKeyDown*(key: ImGuiKey): bool {.importc: "igIsKeyDown_Nil".} +proc igIsKeyDown*(key: ImGuiKey, owner_id: ImGuiID): bool {.importc: "igIsKeyDown_ID".} +proc igIsKeyPressed*(key: ImGuiKey, repeat: bool = true): bool {.importc: "igIsKeyPressed_Bool".} +proc igIsKeyPressed*(key: ImGuiKey, owner_id: ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): bool {.importc: "igIsKeyPressed_ID".} proc igIsKeyPressedMap*(key: ImGuiKey, repeat: bool = true): bool {.importc: "igIsKeyPressedMap".} -proc igIsKeyReleased*(key: ImGuiKey): bool {.importc: "igIsKeyReleased".} +proc igIsKeyReleased*(key: ImGuiKey): bool {.importc: "igIsKeyReleased_Nil".} +proc igIsKeyReleased*(key: ImGuiKey, owner_id: ImGuiID): bool {.importc: "igIsKeyReleased_ID".} +proc igIsKeyboardKey*(key: ImGuiKey): bool {.importc: "igIsKeyboardKey".} proc igIsLegacyKey*(key: ImGuiKey): bool {.importc: "igIsLegacyKey".} -proc igIsMouseClicked*(button: ImGuiMouseButton, repeat: bool = false): bool {.importc: "igIsMouseClicked".} +proc igIsMouseClicked*(button: ImGuiMouseButton, repeat: bool = false): bool {.importc: "igIsMouseClicked_Bool".} +proc igIsMouseClicked*(button: ImGuiMouseButton, owner_id: ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): bool {.importc: "igIsMouseClicked_ID".} proc igIsMouseDoubleClicked*(button: ImGuiMouseButton): bool {.importc: "igIsMouseDoubleClicked".} -proc igIsMouseDown*(button: ImGuiMouseButton): bool {.importc: "igIsMouseDown".} +proc igIsMouseDown*(button: ImGuiMouseButton): bool {.importc: "igIsMouseDown_Nil".} +proc igIsMouseDown*(button: ImGuiMouseButton, owner_id: ImGuiID): bool {.importc: "igIsMouseDown_ID".} proc igIsMouseDragPastThreshold*(button: ImGuiMouseButton, lock_threshold: float32 = -1.0f): bool {.importc: "igIsMouseDragPastThreshold".} proc igIsMouseDragging*(button: ImGuiMouseButton, lock_threshold: float32 = -1.0f): bool {.importc: "igIsMouseDragging".} proc igIsMouseHoveringRect*(r_min: ImVec2, r_max: ImVec2, clip: bool = true): bool {.importc: "igIsMouseHoveringRect".} +proc igIsMouseKey*(key: ImGuiKey): bool {.importc: "igIsMouseKey".} proc igIsMousePosValid*(mouse_pos: ptr ImVec2 = nil): bool {.importc: "igIsMousePosValid".} -proc igIsMouseReleased*(button: ImGuiMouseButton): bool {.importc: "igIsMouseReleased".} +proc igIsMouseReleased*(button: ImGuiMouseButton): bool {.importc: "igIsMouseReleased_Nil".} +proc igIsMouseReleased*(button: ImGuiMouseButton, owner_id: ImGuiID): bool {.importc: "igIsMouseReleased_ID".} proc igIsNamedKey*(key: ImGuiKey): bool {.importc: "igIsNamedKey".} -proc igIsNavInputDown*(n: ImGuiNavInput): bool {.importc: "igIsNavInputDown".} -proc igIsNavInputTest*(n: ImGuiNavInput, rm: ImGuiNavReadMode): bool {.importc: "igIsNavInputTest".} +proc igIsNamedKeyOrModKey*(key: ImGuiKey): bool {.importc: "igIsNamedKeyOrModKey".} proc igIsPopupOpen*(str_id: cstring, flags: ImGuiPopupFlags = 0.ImGuiPopupFlags): bool {.importc: "igIsPopupOpen_Str".} proc igIsPopupOpen*(id: ImGuiID, popup_flags: ImGuiPopupFlags): bool {.importc: "igIsPopupOpen_ID".} proc igIsRectVisible*(size: ImVec2): bool {.importc: "igIsRectVisible_Nil".} proc igIsRectVisible*(rect_min: ImVec2, rect_max: ImVec2): bool {.importc: "igIsRectVisible_Vec2".} proc igIsWindowAbove*(potential_above: ptr ImGuiWindow, potential_below: ptr ImGuiWindow): bool {.importc: "igIsWindowAbove".} proc igIsWindowAppearing*(): bool {.importc: "igIsWindowAppearing".} -proc igIsWindowChildOf*(window: ptr ImGuiWindow, potential_parent: ptr ImGuiWindow, popup_hierarchy: bool): bool {.importc: "igIsWindowChildOf".} +proc igIsWindowChildOf*(window: ptr ImGuiWindow, potential_parent: ptr ImGuiWindow, popup_hierarchy: bool, dock_hierarchy: bool): bool {.importc: "igIsWindowChildOf".} proc igIsWindowCollapsed*(): bool {.importc: "igIsWindowCollapsed".} +proc igIsWindowContentHoverable*(window: ptr ImGuiWindow, flags: ImGuiHoveredFlags = 0.ImGuiHoveredFlags): bool {.importc: "igIsWindowContentHoverable".} +proc igIsWindowDocked*(): bool {.importc: "igIsWindowDocked".} proc igIsWindowFocused*(flags: ImGuiFocusedFlags = 0.ImGuiFocusedFlags): bool {.importc: "igIsWindowFocused".} proc igIsWindowHovered*(flags: ImGuiHoveredFlags = 0.ImGuiHoveredFlags): bool {.importc: "igIsWindowHovered".} proc igIsWindowNavFocusable*(window: ptr ImGuiWindow): bool {.importc: "igIsWindowNavFocusable".} proc igIsWindowWithinBeginStackOf*(window: ptr ImGuiWindow, potential_parent: ptr ImGuiWindow): bool {.importc: "igIsWindowWithinBeginStackOf".} proc igItemAdd*(bb: ImRect, id: ImGuiID, nav_bb: ptr ImRect = nil, extra_flags: ImGuiItemFlags = 0.ImGuiItemFlags): bool {.importc: "igItemAdd".} -proc igItemHoverable*(bb: ImRect, id: ImGuiID): bool {.importc: "igItemHoverable".} +proc igItemHoverable*(bb: ImRect, id: ImGuiID, item_flags: ImGuiItemFlags): bool {.importc: "igItemHoverable".} proc igItemSize*(size: ImVec2, text_baseline_y: float32 = -1.0f): void {.importc: "igItemSize_Vec2".} proc igItemSize*(bb: ImRect, text_baseline_y: float32 = -1.0f): void {.importc: "igItemSize_Rect".} proc igKeepAliveID*(id: ImGuiID): void {.importc: "igKeepAliveID".} @@ -3090,6 +3630,8 @@ proc igListBox*(label: cstring, current_item: ptr int32, items: ptr cstring, ite proc igListBox*(label: cstring, current_item: ptr int32, items_getter: proc(data: pointer, idx: int32, out_text: ptr cstring): bool {.cdecl, varargs.}, data: pointer, items_count: int32, height_in_items: int32 = -1): bool {.importc: "igListBox_FnBoolPtr".} proc igLoadIniSettingsFromDisk*(ini_filename: cstring): void {.importc: "igLoadIniSettingsFromDisk".} proc igLoadIniSettingsFromMemory*(ini_data: cstring, ini_size: uint = 0): void {.importc: "igLoadIniSettingsFromMemory".} +proc igLocalizeGetMsg*(key: ImGuiLocKey): cstring {.importc: "igLocalizeGetMsg".} +proc igLocalizeRegisterEntries*(entries: ptr ImGuiLocEntry, count: int32): void {.importc: "igLocalizeRegisterEntries".} proc igLogBegin*(`type`: ImGuiLogType, auto_open_depth: int32): void {.importc: "igLogBegin".} proc igLogButtons*(): void {.importc: "igLogButtons".} proc igLogFinish*(): void {.importc: "igLogFinish".} @@ -3109,6 +3651,8 @@ proc igMemFree*(`ptr`: pointer): void {.importc: "igMemFree".} proc igMenuItem*(label: cstring, shortcut: cstring = nil, selected: bool = false, enabled: bool = true): bool {.importc: "igMenuItem_Bool".} proc igMenuItem*(label: cstring, shortcut: cstring, p_selected: ptr bool, enabled: bool = true): bool {.importc: "igMenuItem_BoolPtr".} proc igMenuItemEx*(label: cstring, icon: cstring, shortcut: cstring = nil, selected: bool = false, enabled: bool = true): bool {.importc: "igMenuItemEx".} +proc igMouseButtonToKey*(button: ImGuiMouseButton): ImGuiKey {.importc: "igMouseButtonToKey".} +proc igNavClearPreferredPosForAxis*(axis: ImGuiAxis): void {.importc: "igNavClearPreferredPosForAxis".} proc igNavInitRequestApplyResult*(): void {.importc: "igNavInitRequestApplyResult".} proc igNavInitWindow*(window: ptr ImGuiWindow, force_reinit: bool): void {.importc: "igNavInitWindow".} proc igNavMoveRequestApplyResult*(): void {.importc: "igNavMoveRequestApplyResult".} @@ -3118,6 +3662,7 @@ proc igNavMoveRequestForward*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags proc igNavMoveRequestResolveWithLastItem*(result: ptr ImGuiNavItemData): void {.importc: "igNavMoveRequestResolveWithLastItem".} proc igNavMoveRequestSubmit*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags: ImGuiNavMoveFlags, scroll_flags: ImGuiScrollFlags): void {.importc: "igNavMoveRequestSubmit".} proc igNavMoveRequestTryWrapping*(window: ptr ImGuiWindow, move_flags: ImGuiNavMoveFlags): void {.importc: "igNavMoveRequestTryWrapping".} +proc igNavUpdateCurrentWindowIsScrollPushableX*(): void {.importc: "igNavUpdateCurrentWindowIsScrollPushableX".} proc igNewFrame*(): void {.importc: "igNewFrame".} proc igNewLine*(): void {.importc: "igNewLine".} proc igNextColumn*(): void {.importc: "igNextColumn".} @@ -3125,12 +3670,11 @@ proc igOpenPopup*(str_id: cstring, popup_flags: ImGuiPopupFlags = 0.ImGuiPopupFl proc igOpenPopup*(id: ImGuiID, popup_flags: ImGuiPopupFlags = 0.ImGuiPopupFlags): void {.importc: "igOpenPopup_ID".} proc igOpenPopupEx*(id: ImGuiID, popup_flags: ImGuiPopupFlags = ImGuiPopupFlags.None.ImGuiPopupFlags): void {.importc: "igOpenPopupEx".} proc igOpenPopupOnItemClick*(str_id: cstring = nil, popup_flags: ImGuiPopupFlags = 1.ImGuiPopupFlags): void {.importc: "igOpenPopupOnItemClick".} -proc igPlotEx*(plot_type: ImGuiPlotType, label: cstring, values_getter: proc(data: pointer, idx: int32): float32 {.cdecl, varargs.}, data: pointer, values_count: int32, values_offset: int32, overlay_text: cstring, scale_min: float32, scale_max: float32, frame_size: ImVec2): int32 {.importc: "igPlotEx".} +proc igPlotEx*(plot_type: ImGuiPlotType, label: cstring, values_getter: proc(data: pointer, idx: int32): float32 {.cdecl, varargs.}, data: pointer, values_count: int32, values_offset: int32, overlay_text: cstring, scale_min: float32, scale_max: float32, size_arg: ImVec2): int32 {.importc: "igPlotEx".} proc igPlotHistogram*(label: cstring, values: ptr float32, values_count: int32, values_offset: int32 = 0, overlay_text: cstring = nil, scale_min: float32 = high(float32), scale_max: float32 = high(float32), graph_size: ImVec2 = ImVec2(x: 0, y: 0), stride: int32 = sizeof(float32).int32): void {.importc: "igPlotHistogram_FloatPtr".} proc igPlotHistogram*(label: cstring, values_getter: proc(data: pointer, idx: int32): float32 {.cdecl, varargs.}, data: pointer, values_count: int32, values_offset: int32 = 0, overlay_text: cstring = nil, scale_min: float32 = high(float32), scale_max: float32 = high(float32), graph_size: ImVec2 = ImVec2(x: 0, y: 0)): void {.importc: "igPlotHistogram_FnFloatPtr".} proc igPlotLines*(label: cstring, values: ptr float32, values_count: int32, values_offset: int32 = 0, overlay_text: cstring = nil, scale_min: float32 = high(float32), scale_max: float32 = high(float32), graph_size: ImVec2 = ImVec2(x: 0, y: 0), stride: int32 = sizeof(float32).int32): void {.importc: "igPlotLines_FloatPtr".} proc igPlotLines*(label: cstring, values_getter: proc(data: pointer, idx: int32): float32 {.cdecl, varargs.}, data: pointer, values_count: int32, values_offset: int32 = 0, overlay_text: cstring = nil, scale_min: float32 = high(float32), scale_max: float32 = high(float32), graph_size: ImVec2 = ImVec2(x: 0, y: 0)): void {.importc: "igPlotLines_FnFloatPtr".} -proc igPopAllowKeyboardFocus*(): void {.importc: "igPopAllowKeyboardFocus".} proc igPopButtonRepeat*(): void {.importc: "igPopButtonRepeat".} proc igPopClipRect*(): void {.importc: "igPopClipRect".} proc igPopColumnsBackground*(): void {.importc: "igPopColumnsBackground".} @@ -3141,9 +3685,9 @@ proc igPopItemFlag*(): void {.importc: "igPopItemFlag".} proc igPopItemWidth*(): void {.importc: "igPopItemWidth".} proc igPopStyleColor*(count: int32 = 1): void {.importc: "igPopStyleColor".} proc igPopStyleVar*(count: int32 = 1): void {.importc: "igPopStyleVar".} +proc igPopTabStop*(): void {.importc: "igPopTabStop".} proc igPopTextWrapPos*(): void {.importc: "igPopTextWrapPos".} proc igProgressBar*(fraction: float32, size_arg: ImVec2 = ImVec2(x: 0, y: 0), overlay: cstring = nil): void {.importc: "igProgressBar".} -proc igPushAllowKeyboardFocus*(allow_keyboard_focus: bool): void {.importc: "igPushAllowKeyboardFocus".} proc igPushButtonRepeat*(repeat: bool): void {.importc: "igPushButtonRepeat".} proc igPushClipRect*(clip_rect_min: ImVec2, clip_rect_max: ImVec2, intersect_with_current_clip_rect: bool): void {.importc: "igPushClipRect".} proc igPushColumnClipRect*(column_index: int32): void {.importc: "igPushColumnClipRect".} @@ -3162,6 +3706,7 @@ proc igPushStyleColor*(idx: ImGuiCol, col: uint32): void {.importc: "igPushStyle proc igPushStyleColor*(idx: ImGuiCol, col: ImVec4): void {.importc: "igPushStyleColor_Vec4".} proc igPushStyleVar*(idx: ImGuiStyleVar, val: float32): void {.importc: "igPushStyleVar_Float".} proc igPushStyleVar*(idx: ImGuiStyleVar, val: ImVec2): void {.importc: "igPushStyleVar_Vec2".} +proc igPushTabStop*(tab_stop: bool): void {.importc: "igPushTabStop".} proc igPushTextWrapPos*(wrap_local_pos_x: float32 = 0.0f): void {.importc: "igPushTextWrapPos".} proc igRadioButton*(label: cstring, active: bool): bool {.importc: "igRadioButton_Bool".} proc igRadioButton*(label: cstring, v: ptr int32, v_button: int32): bool {.importc: "igRadioButton_IntPtr".} @@ -3169,14 +3714,17 @@ proc igRemoveContextHook*(context: ptr ImGuiContext, hook_to_remove: ImGuiID): v proc igRemoveSettingsHandler*(type_name: cstring): void {.importc: "igRemoveSettingsHandler".} proc igRender*(): void {.importc: "igRender".} proc igRenderArrow*(draw_list: ptr ImDrawList, pos: ImVec2, col: uint32, dir: ImGuiDir, scale: float32 = 1.0f): void {.importc: "igRenderArrow".} +proc igRenderArrowDockMenu*(draw_list: ptr ImDrawList, p_min: ImVec2, sz: float32, col: uint32): void {.importc: "igRenderArrowDockMenu".} proc igRenderArrowPointingAt*(draw_list: ptr ImDrawList, pos: ImVec2, half_sz: ImVec2, direction: ImGuiDir, col: uint32): void {.importc: "igRenderArrowPointingAt".} proc igRenderBullet*(draw_list: ptr ImDrawList, pos: ImVec2, col: uint32): void {.importc: "igRenderBullet".} proc igRenderCheckMark*(draw_list: ptr ImDrawList, pos: ImVec2, col: uint32, sz: float32): void {.importc: "igRenderCheckMark".} proc igRenderColorRectWithAlphaCheckerboard*(draw_list: ptr ImDrawList, p_min: ImVec2, p_max: ImVec2, fill_col: uint32, grid_step: float32, grid_off: ImVec2, rounding: float32 = 0.0f, flags: ImDrawFlags = 0.ImDrawFlags): void {.importc: "igRenderColorRectWithAlphaCheckerboard".} +proc igRenderDragDropTargetRect*(bb: ImRect): void {.importc: "igRenderDragDropTargetRect".} proc igRenderFrame*(p_min: ImVec2, p_max: ImVec2, fill_col: uint32, border: bool = true, rounding: float32 = 0.0f): void {.importc: "igRenderFrame".} proc igRenderFrameBorder*(p_min: ImVec2, p_max: ImVec2, rounding: float32 = 0.0f): void {.importc: "igRenderFrameBorder".} proc igRenderMouseCursor*(pos: ImVec2, scale: float32, mouse_cursor: ImGuiMouseCursor, col_fill: uint32, col_border: uint32, col_shadow: uint32): void {.importc: "igRenderMouseCursor".} proc igRenderNavHighlight*(bb: ImRect, id: ImGuiID, flags: ImGuiNavHighlightFlags = ImGuiNavHighlightFlags.TypeDefault.ImGuiNavHighlightFlags): void {.importc: "igRenderNavHighlight".} +proc igRenderPlatformWindowsDefault*(platform_render_arg: pointer = nil, renderer_render_arg: pointer = nil): void {.importc: "igRenderPlatformWindowsDefault".} proc igRenderRectFilledRangeH*(draw_list: ptr ImDrawList, rect: ImRect, col: uint32, x_start_norm: float32, x_end_norm: float32, rounding: float32): void {.importc: "igRenderRectFilledRangeH".} proc igRenderRectFilledWithHole*(draw_list: ptr ImDrawList, outer: ImRect, inner: ImRect, col: uint32, rounding: float32): void {.importc: "igRenderRectFilledWithHole".} proc igRenderText*(pos: ImVec2, text: cstring, text_end: cstring = nil, hide_text_after_hash: bool = true): void {.importc: "igRenderText".} @@ -3188,6 +3736,7 @@ proc igResetMouseDragDelta*(button: ImGuiMouseButton = 0.ImGuiMouseButton): void proc igSameLine*(offset_from_start_x: float32 = 0.0f, spacing: float32 = -1.0f): void {.importc: "igSameLine".} proc igSaveIniSettingsToDisk*(ini_filename: cstring): void {.importc: "igSaveIniSettingsToDisk".} proc igSaveIniSettingsToMemory*(out_ini_size: ptr uint = nil): cstring {.importc: "igSaveIniSettingsToMemory".} +proc igScaleWindowsInViewport*(viewport: ptr ImGuiViewportP, scale: float32): void {.importc: "igScaleWindowsInViewport".} proc igScrollToBringRectIntoView*(window: ptr ImGuiWindow, rect: ImRect): void {.importc: "igScrollToBringRectIntoView".} proc igScrollToItem*(flags: ImGuiScrollFlags = 0.ImGuiScrollFlags): void {.importc: "igScrollToItem".} proc igScrollToRect*(window: ptr ImGuiWindow, rect: ImRect, flags: ImGuiScrollFlags = 0.ImGuiScrollFlags): void {.importc: "igScrollToRect".} @@ -3197,10 +3746,11 @@ proc igScrollbarEx*(bb: ImRect, id: ImGuiID, axis: ImGuiAxis, p_scroll_v: ptr in proc igSelectable*(label: cstring, selected: bool = false, flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igSelectable_Bool".} proc igSelectable*(label: cstring, p_selected: ptr bool, flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, size: ImVec2 = ImVec2(x: 0, y: 0)): bool {.importc: "igSelectable_BoolPtr".} proc igSeparator*(): void {.importc: "igSeparator".} -proc igSeparatorEx*(flags: ImGuiSeparatorFlags): void {.importc: "igSeparatorEx".} +proc igSeparatorEx*(flags: ImGuiSeparatorFlags, thickness: float32 = 1.0f): void {.importc: "igSeparatorEx".} +proc igSeparatorText*(label: cstring): void {.importc: "igSeparatorText".} +proc igSeparatorTextEx*(id: ImGuiID, label: cstring, label_end: cstring, extra_width: float32): void {.importc: "igSeparatorTextEx".} proc igSetActiveID*(id: ImGuiID, window: ptr ImGuiWindow): void {.importc: "igSetActiveID".} -proc igSetActiveIdUsingKey*(key: ImGuiKey): void {.importc: "igSetActiveIdUsingKey".} -proc igSetActiveIdUsingNavAndKeys*(): void {.importc: "igSetActiveIdUsingNavAndKeys".} +proc igSetActiveIdUsingAllKeyboardKeys*(): void {.importc: "igSetActiveIdUsingAllKeyboardKeys".} proc igSetAllocatorFunctions*(alloc_func: ImGuiMemAllocFunc, free_func: ImGuiMemFreeFunc, user_data: pointer = nil): void {.importc: "igSetAllocatorFunctions".} proc igSetClipboardText*(text: cstring): void {.importc: "igSetClipboardText".} proc igSetColorEditOptions*(flags: ImGuiColorEditFlags): void {.importc: "igSetColorEditOptions".} @@ -3208,6 +3758,7 @@ proc igSetColumnOffset*(column_index: int32, offset_x: float32): void {.importc: proc igSetColumnWidth*(column_index: int32, width: float32): void {.importc: "igSetColumnWidth".} proc igSetCurrentContext*(ctx: ptr ImGuiContext): void {.importc: "igSetCurrentContext".} proc igSetCurrentFont*(font: ptr ImFont): void {.importc: "igSetCurrentFont".} +proc igSetCurrentViewport*(window: ptr ImGuiWindow, viewport: ptr ImGuiViewportP): void {.importc: "igSetCurrentViewport".} proc igSetCursorPos*(local_pos: ImVec2): void {.importc: "igSetCursorPos".} proc igSetCursorPosX*(local_x: float32): void {.importc: "igSetCursorPosX".} proc igSetCursorPosY*(local_y: float32): void {.importc: "igSetCursorPosY".} @@ -3215,9 +3766,12 @@ proc igSetCursorScreenPos*(pos: ImVec2): void {.importc: "igSetCursorScreenPos". proc igSetDragDropPayload*(`type`: cstring, data: pointer, sz: uint, cond: ImGuiCond = 0.ImGuiCond): bool {.importc: "igSetDragDropPayload".} proc igSetFocusID*(id: ImGuiID, window: ptr ImGuiWindow): void {.importc: "igSetFocusID".} proc igSetHoveredID*(id: ImGuiID): void {.importc: "igSetHoveredID".} -proc igSetItemAllowOverlap*(): void {.importc: "igSetItemAllowOverlap".} proc igSetItemDefaultFocus*(): void {.importc: "igSetItemDefaultFocus".} -proc igSetItemUsingMouseWheel*(): void {.importc: "igSetItemUsingMouseWheel".} +proc igSetItemKeyOwner*(key: ImGuiKey, flags: ImGuiInputFlags = 0.ImGuiInputFlags): void {.importc: "igSetItemKeyOwner".} +proc igSetItemTooltip*(fmt: cstring): void {.importc: "igSetItemTooltip", varargs.} +proc igSetItemTooltipV*(fmt: cstring): void {.importc: "igSetItemTooltipV", varargs.} +proc igSetKeyOwner*(key: ImGuiKey, owner_id: ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): void {.importc: "igSetKeyOwner".} +proc igSetKeyOwnersForKeyChord*(key: ImGuiKeyChord, owner_id: ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): void {.importc: "igSetKeyOwnersForKeyChord".} proc igSetKeyboardFocusHere*(offset: int32 = 0): void {.importc: "igSetKeyboardFocusHere".} proc igSetLastItemData*(item_id: ImGuiID, in_flags: ImGuiItemFlags, status_flags: ImGuiItemStatusFlags, item_rect: ImRect): void {.importc: "igSetLastItemData".} proc igSetMouseCursor*(cursor_type: ImGuiMouseCursor): void {.importc: "igSetMouseCursor".} @@ -3225,16 +3779,20 @@ proc igSetNavID*(id: ImGuiID, nav_layer: ImGuiNavLayer, focus_scope_id: ImGuiID, proc igSetNavWindow*(window: ptr ImGuiWindow): void {.importc: "igSetNavWindow".} proc igSetNextFrameWantCaptureKeyboard*(want_capture_keyboard: bool): void {.importc: "igSetNextFrameWantCaptureKeyboard".} proc igSetNextFrameWantCaptureMouse*(want_capture_mouse: bool): void {.importc: "igSetNextFrameWantCaptureMouse".} +proc igSetNextItemAllowOverlap*(): void {.importc: "igSetNextItemAllowOverlap".} proc igSetNextItemOpen*(is_open: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextItemOpen".} proc igSetNextItemWidth*(item_width: float32): void {.importc: "igSetNextItemWidth".} proc igSetNextWindowBgAlpha*(alpha: float32): void {.importc: "igSetNextWindowBgAlpha".} +proc igSetNextWindowClass*(window_class: ptr ImGuiWindowClass): void {.importc: "igSetNextWindowClass".} proc igSetNextWindowCollapsed*(collapsed: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextWindowCollapsed".} proc igSetNextWindowContentSize*(size: ImVec2): void {.importc: "igSetNextWindowContentSize".} +proc igSetNextWindowDockID*(dock_id: ImGuiID, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextWindowDockID".} proc igSetNextWindowFocus*(): void {.importc: "igSetNextWindowFocus".} proc igSetNextWindowPos*(pos: ImVec2, cond: ImGuiCond = 0.ImGuiCond, pivot: ImVec2 = ImVec2(x: 0, y: 0)): void {.importc: "igSetNextWindowPos".} proc igSetNextWindowScroll*(scroll: ImVec2): void {.importc: "igSetNextWindowScroll".} proc igSetNextWindowSize*(size: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetNextWindowSize".} proc igSetNextWindowSizeConstraints*(size_min: ImVec2, size_max: ImVec2, custom_callback: ImGuiSizeCallback = nil, custom_callback_data: pointer = nil): void {.importc: "igSetNextWindowSizeConstraints".} +proc igSetNextWindowViewport*(viewport_id: ImGuiID): void {.importc: "igSetNextWindowViewport".} proc igSetScrollFromPosX*(local_x: float32, center_x_ratio: float32 = 0.5f): void {.importc: "igSetScrollFromPosX_Float".} proc igSetScrollFromPosX*(window: ptr ImGuiWindow, local_x: float32, center_x_ratio: float32): void {.importc: "igSetScrollFromPosX_WindowPtr".} proc igSetScrollFromPosY*(local_y: float32, center_y_ratio: float32 = 0.5f): void {.importc: "igSetScrollFromPosY_Float".} @@ -3245,6 +3803,7 @@ proc igSetScrollX*(scroll_x: float32): void {.importc: "igSetScrollX_Float".} proc igSetScrollX*(window: ptr ImGuiWindow, scroll_x: float32): void {.importc: "igSetScrollX_WindowPtr".} proc igSetScrollY*(scroll_y: float32): void {.importc: "igSetScrollY_Float".} proc igSetScrollY*(window: ptr ImGuiWindow, scroll_y: float32): void {.importc: "igSetScrollY_WindowPtr".} +proc igSetShortcutRouting*(key_chord: ImGuiKeyChord, owner_id: ImGuiID = 0.ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): bool {.importc: "igSetShortcutRouting".} proc igSetStateStorage*(storage: ptr ImGuiStorage): void {.importc: "igSetStateStorage".} proc igSetTabItemClosed*(tab_or_docked_window_label: cstring): void {.importc: "igSetTabItemClosed".} proc igSetTooltip*(fmt: cstring): void {.importc: "igSetTooltip", varargs.} @@ -3253,9 +3812,11 @@ proc igSetWindowClipRectBeforeSetChannel*(window: ptr ImGuiWindow, clip_rect: Im proc igSetWindowCollapsed*(collapsed: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowCollapsed_Bool".} proc igSetWindowCollapsed*(name: cstring, collapsed: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowCollapsed_Str".} proc igSetWindowCollapsed*(window: ptr ImGuiWindow, collapsed: bool, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowCollapsed_WindowPtr".} +proc igSetWindowDock*(window: ptr ImGuiWindow, dock_id: ImGuiID, cond: ImGuiCond): void {.importc: "igSetWindowDock".} proc igSetWindowFocus*(): void {.importc: "igSetWindowFocus_Nil".} proc igSetWindowFocus*(name: cstring): void {.importc: "igSetWindowFocus_Str".} proc igSetWindowFontScale*(scale: float32): void {.importc: "igSetWindowFontScale".} +proc igSetWindowHiddendAndSkipItemsForCurrentFrame*(window: ptr ImGuiWindow): void {.importc: "igSetWindowHiddendAndSkipItemsForCurrentFrame".} proc igSetWindowHitTestHole*(window: ptr ImGuiWindow, pos: ImVec2, size: ImVec2): void {.importc: "igSetWindowHitTestHole".} proc igSetWindowPos*(pos: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowPos_Vec2".} proc igSetWindowPos*(name: cstring, pos: ImVec2, cond: ImGuiCond = 0.ImGuiCond): void {.importc: "igSetWindowPos_Str".} @@ -3266,6 +3827,7 @@ proc igSetWindowSize*(window: ptr ImGuiWindow, size: ImVec2, cond: ImGuiCond = 0 proc igSetWindowViewport*(window: ptr ImGuiWindow, viewport: ptr ImGuiViewportP): void {.importc: "igSetWindowViewport".} proc igShadeVertsLinearColorGradientKeepAlpha*(draw_list: ptr ImDrawList, vert_start_idx: int32, vert_end_idx: int32, gradient_p0: ImVec2, gradient_p1: ImVec2, col0: uint32, col1: uint32): void {.importc: "igShadeVertsLinearColorGradientKeepAlpha".} proc igShadeVertsLinearUV*(draw_list: ptr ImDrawList, vert_start_idx: int32, vert_end_idx: int32, a: ImVec2, b: ImVec2, uv_a: ImVec2, uv_b: ImVec2, clamp: bool): void {.importc: "igShadeVertsLinearUV".} +proc igShortcut*(key_chord: ImGuiKeyChord, owner_id: ImGuiID = 0.ImGuiID, flags: ImGuiInputFlags = 0.ImGuiInputFlags): bool {.importc: "igShortcut".} proc igShowAboutWindow*(p_open: ptr bool = nil): void {.importc: "igShowAboutWindow".} proc igShowDebugLogWindow*(p_open: ptr bool = nil): void {.importc: "igShowDebugLogWindow".} proc igShowDemoWindow*(p_open: ptr bool = nil): void {.importc: "igShowDemoWindow".} @@ -3292,24 +3854,34 @@ proc igSliderScalar*(label: cstring, data_type: ImGuiDataType, p_data: pointer, proc igSliderScalarN*(label: cstring, data_type: ImGuiDataType, p_data: pointer, components: int32, p_min: pointer, p_max: pointer, format: cstring = nil, flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igSliderScalarN".} proc igSmallButton*(label: cstring): bool {.importc: "igSmallButton".} proc igSpacing*(): void {.importc: "igSpacing".} -proc igSplitterBehavior*(bb: ImRect, id: ImGuiID, axis: ImGuiAxis, size1: ptr float32, size2: ptr float32, min_size1: float32, min_size2: float32, hover_extend: float32 = 0.0f, hover_visibility_delay: float32 = 0.0f): bool {.importc: "igSplitterBehavior".} +proc igSplitterBehavior*(bb: ImRect, id: ImGuiID, axis: ImGuiAxis, size1: ptr float32, size2: ptr float32, min_size1: float32, min_size2: float32, hover_extend: float32 = 0.0f, hover_visibility_delay: float32 = 0.0f, bg_col: uint32 = 0): bool {.importc: "igSplitterBehavior".} proc igStartMouseMovingWindow*(window: ptr ImGuiWindow): void {.importc: "igStartMouseMovingWindow".} +proc igStartMouseMovingWindowOrNode*(window: ptr ImGuiWindow, node: ptr ImGuiDockNode, undock_floating_node: bool): void {.importc: "igStartMouseMovingWindowOrNode".} proc igStyleColorsClassic*(dst: ptr ImGuiStyle = nil): void {.importc: "igStyleColorsClassic".} proc igStyleColorsDark*(dst: ptr ImGuiStyle = nil): void {.importc: "igStyleColorsDark".} proc igStyleColorsLight*(dst: ptr ImGuiStyle = nil): void {.importc: "igStyleColorsLight".} +proc igTabBarAddTab*(tab_bar: ptr ImGuiTabBar, tab_flags: ImGuiTabItemFlags, window: ptr ImGuiWindow): void {.importc: "igTabBarAddTab".} proc igTabBarCloseTab*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): void {.importc: "igTabBarCloseTab".} +proc igTabBarFindMostRecentlySelectedTabForActiveWindow*(tab_bar: ptr ImGuiTabBar): ptr ImGuiTabItem {.importc: "igTabBarFindMostRecentlySelectedTabForActiveWindow".} proc igTabBarFindTabByID*(tab_bar: ptr ImGuiTabBar, tab_id: ImGuiID): ptr ImGuiTabItem {.importc: "igTabBarFindTabByID".} +proc igTabBarFindTabByOrder*(tab_bar: ptr ImGuiTabBar, order: int32): ptr ImGuiTabItem {.importc: "igTabBarFindTabByOrder".} +proc igTabBarGetCurrentTab*(tab_bar: ptr ImGuiTabBar): ptr ImGuiTabItem {.importc: "igTabBarGetCurrentTab".} +proc igTabBarGetTabName*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): cstring {.importc: "igTabBarGetTabName".} +proc igTabBarGetTabOrder*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): int32 {.importc: "igTabBarGetTabOrder".} proc igTabBarProcessReorder*(tab_bar: ptr ImGuiTabBar): bool {.importc: "igTabBarProcessReorder".} +proc igTabBarQueueFocus*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem): void {.importc: "igTabBarQueueFocus".} proc igTabBarQueueReorder*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem, offset: int32): void {.importc: "igTabBarQueueReorder".} proc igTabBarQueueReorderFromMousePos*(tab_bar: ptr ImGuiTabBar, tab: ptr ImGuiTabItem, mouse_pos: ImVec2): void {.importc: "igTabBarQueueReorderFromMousePos".} proc igTabBarRemoveTab*(tab_bar: ptr ImGuiTabBar, tab_id: ImGuiID): void {.importc: "igTabBarRemoveTab".} proc igTabItemBackground*(draw_list: ptr ImDrawList, bb: ImRect, flags: ImGuiTabItemFlags, col: uint32): void {.importc: "igTabItemBackground".} proc igTabItemButton*(label: cstring, flags: ImGuiTabItemFlags = 0.ImGuiTabItemFlags): bool {.importc: "igTabItemButton".} -proc igTabItemCalcSizeNonUDT*(pOut: ptr ImVec2, label: cstring, has_close_button: bool): void {.importc: "igTabItemCalcSize".} -proc igTabItemEx*(tab_bar: ptr ImGuiTabBar, label: cstring, p_open: ptr bool, flags: ImGuiTabItemFlags): bool {.importc: "igTabItemEx".} +proc igTabItemCalcSizeNonUDT*(pOut: ptr ImVec2, label: cstring, has_close_button_or_unsaved_marker: bool): void {.importc: "igTabItemCalcSize_Str".} +proc igTabItemCalcSizeNonUDT2*(pOut: ptr ImVec2, window: ptr ImGuiWindow): void {.importc: "igTabItemCalcSize_WindowPtr".} +proc igTabItemEx*(tab_bar: ptr ImGuiTabBar, label: cstring, p_open: ptr bool, flags: ImGuiTabItemFlags, docked_window: ptr ImGuiWindow): bool {.importc: "igTabItemEx".} proc igTabItemLabelAndCloseButton*(draw_list: ptr ImDrawList, bb: ImRect, flags: ImGuiTabItemFlags, frame_padding: ImVec2, label: cstring, tab_id: ImGuiID, close_button_id: ImGuiID, is_contents_visible: bool, out_just_closed: ptr bool, out_text_clipped: ptr bool): void {.importc: "igTabItemLabelAndCloseButton".} proc igTableBeginApplyRequests*(table: ptr ImGuiTable): void {.importc: "igTableBeginApplyRequests".} proc igTableBeginCell*(table: ptr ImGuiTable, column_n: int32): void {.importc: "igTableBeginCell".} +proc igTableBeginContextMenuPopup*(table: ptr ImGuiTable): bool {.importc: "igTableBeginContextMenuPopup".} proc igTableBeginInitMemory*(table: ptr ImGuiTable, columns_count: int32): void {.importc: "igTableBeginInitMemory".} proc igTableBeginRow*(table: ptr ImGuiTable): void {.importc: "igTableBeginRow".} proc igTableDrawBorders*(table: ptr ImGuiTable): void {.importc: "igTableDrawBorders".} @@ -3333,7 +3905,9 @@ proc igTableGetColumnResizeID*(table: ptr ImGuiTable, column_n: int32, instance_ proc igTableGetColumnWidthAuto*(table: ptr ImGuiTable, column: ptr ImGuiTableColumn): float32 {.importc: "igTableGetColumnWidthAuto".} proc igTableGetHeaderRowHeight*(): float32 {.importc: "igTableGetHeaderRowHeight".} proc igTableGetHoveredColumn*(): int32 {.importc: "igTableGetHoveredColumn".} +proc igTableGetHoveredRow*(): int32 {.importc: "igTableGetHoveredRow".} proc igTableGetInstanceData*(table: ptr ImGuiTable, instance_no: int32): ptr ImGuiTableInstanceData {.importc: "igTableGetInstanceData".} +proc igTableGetInstanceID*(table: ptr ImGuiTable, instance_no: int32): ImGuiID {.importc: "igTableGetInstanceID".} proc igTableGetMaxColumnWidth*(table: ptr ImGuiTable, column_n: int32): float32 {.importc: "igTableGetMaxColumnWidth".} proc igTableGetRowIndex*(): int32 {.importc: "igTableGetRowIndex".} proc igTableGetSortSpecs*(): ptr ImGuiTableSortSpecs {.importc: "igTableGetSortSpecs".} @@ -3370,6 +3944,8 @@ proc igTableUpdateLayout*(table: ptr ImGuiTable): void {.importc: "igTableUpdate proc igTempInputIsActive*(id: ImGuiID): bool {.importc: "igTempInputIsActive".} proc igTempInputScalar*(bb: ImRect, id: ImGuiID, label: cstring, data_type: ImGuiDataType, p_data: pointer, format: cstring, p_clamp_min: pointer = nil, p_clamp_max: pointer = nil): bool {.importc: "igTempInputScalar".} proc igTempInputText*(bb: ImRect, id: ImGuiID, label: cstring, buf: cstring, buf_size: int32, flags: ImGuiInputTextFlags): bool {.importc: "igTempInputText".} +proc igTestKeyOwner*(key: ImGuiKey, owner_id: ImGuiID): bool {.importc: "igTestKeyOwner".} +proc igTestShortcutRouting*(key_chord: ImGuiKeyChord, owner_id: ImGuiID): bool {.importc: "igTestShortcutRouting".} proc igText*(fmt: cstring): void {.importc: "igText", varargs.} proc igTextColored*(col: ImVec4, fmt: cstring): void {.importc: "igTextColored", varargs.} proc igTextColoredV*(col: ImVec4, fmt: cstring): void {.importc: "igTextColoredV", varargs.} @@ -3380,27 +3956,30 @@ proc igTextUnformatted*(text: cstring, text_end: cstring = nil): void {.importc: proc igTextV*(fmt: cstring): void {.importc: "igTextV", varargs.} proc igTextWrapped*(fmt: cstring): void {.importc: "igTextWrapped", varargs.} proc igTextWrappedV*(fmt: cstring): void {.importc: "igTextWrappedV", varargs.} +proc igTranslateWindowsInViewport*(viewport: ptr ImGuiViewportP, old_pos: ImVec2, new_pos: ImVec2): void {.importc: "igTranslateWindowsInViewport".} proc igTreeNode*(label: cstring): bool {.importc: "igTreeNode_Str".} proc igTreeNode*(str_id: cstring, fmt: cstring): bool {.importc: "igTreeNode_StrStr", varargs.} proc igTreeNode*(ptr_id: pointer, fmt: cstring): bool {.importc: "igTreeNode_Ptr", varargs.} proc igTreeNodeBehavior*(id: ImGuiID, flags: ImGuiTreeNodeFlags, label: cstring, label_end: cstring = nil): bool {.importc: "igTreeNodeBehavior".} -proc igTreeNodeBehaviorIsOpen*(id: ImGuiID, flags: ImGuiTreeNodeFlags = 0.ImGuiTreeNodeFlags): bool {.importc: "igTreeNodeBehaviorIsOpen".} proc igTreeNodeEx*(label: cstring, flags: ImGuiTreeNodeFlags = 0.ImGuiTreeNodeFlags): bool {.importc: "igTreeNodeEx_Str".} proc igTreeNodeEx*(str_id: cstring, flags: ImGuiTreeNodeFlags, fmt: cstring): bool {.importc: "igTreeNodeEx_StrStr", varargs.} proc igTreeNodeEx*(ptr_id: pointer, flags: ImGuiTreeNodeFlags, fmt: cstring): bool {.importc: "igTreeNodeEx_Ptr", varargs.} proc igTreeNodeExV*(str_id: cstring, flags: ImGuiTreeNodeFlags, fmt: cstring): bool {.importc: "igTreeNodeExV_Str", varargs.} proc igTreeNodeExV*(ptr_id: pointer, flags: ImGuiTreeNodeFlags, fmt: cstring): bool {.importc: "igTreeNodeExV_Ptr", varargs.} +proc igTreeNodeSetOpen*(id: ImGuiID, open: bool): void {.importc: "igTreeNodeSetOpen".} +proc igTreeNodeUpdateNextOpen*(id: ImGuiID, flags: ImGuiTreeNodeFlags): bool {.importc: "igTreeNodeUpdateNextOpen".} proc igTreeNodeV*(str_id: cstring, fmt: cstring): bool {.importc: "igTreeNodeV_Str", varargs.} proc igTreeNodeV*(ptr_id: pointer, fmt: cstring): bool {.importc: "igTreeNodeV_Ptr", varargs.} proc igTreePop*(): void {.importc: "igTreePop".} proc igTreePush*(str_id: cstring): void {.importc: "igTreePush_Str".} -proc igTreePush*(ptr_id: pointer = nil): void {.importc: "igTreePush_Ptr".} +proc igTreePush*(ptr_id: pointer): void {.importc: "igTreePush_Ptr".} proc igTreePushOverrideID*(id: ImGuiID): void {.importc: "igTreePushOverrideID".} proc igUnindent*(indent_w: float32 = 0.0f): void {.importc: "igUnindent".} proc igUpdateHoveredWindowAndCaptureFlags*(): void {.importc: "igUpdateHoveredWindowAndCaptureFlags".} proc igUpdateInputEvents*(trickle_fast_inputs: bool): void {.importc: "igUpdateInputEvents".} proc igUpdateMouseMovingWindowEndFrame*(): void {.importc: "igUpdateMouseMovingWindowEndFrame".} proc igUpdateMouseMovingWindowNewFrame*(): void {.importc: "igUpdateMouseMovingWindowNewFrame".} +proc igUpdatePlatformWindows*(): void {.importc: "igUpdatePlatformWindows".} proc igUpdateWindowParentAndRootLinks*(window: ptr ImGuiWindow, flags: ImGuiWindowFlags, parent_window: ptr ImGuiWindow): void {.importc: "igUpdateWindowParentAndRootLinks".} proc igVSliderFloat*(label: cstring, size: ImVec2, v: ptr float32, v_min: float32, v_max: float32, format: cstring = "%.3f", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igVSliderFloat".} proc igVSliderInt*(label: cstring, size: ImVec2, v: ptr int32, v_min: int32, v_max: int32, format: cstring = "%d", flags: ImGuiSliderFlags = 0.ImGuiSliderFlags): bool {.importc: "igVSliderInt".} @@ -3409,6 +3988,7 @@ proc igValue*(prefix: cstring, b: bool): void {.importc: "igValue_Bool".} proc igValue*(prefix: cstring, v: int32): void {.importc: "igValue_Int".} proc igValue*(prefix: cstring, v: uint32): void {.importc: "igValue_Uint".} proc igValue*(prefix: cstring, v: float32, float_format: cstring = nil): void {.importc: "igValue_Float".} +proc igWindowPosRelToAbsNonUDT*(pOut: ptr ImVec2, window: ptr ImGuiWindow, p: ImVec2): void {.importc: "igWindowPosRelToAbs".} proc igWindowRectAbsToRelNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: ImRect): void {.importc: "igWindowRectAbsToRel".} proc igWindowRectRelToAbsNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: ImRect): void {.importc: "igWindowRectRelToAbs".} diff --git a/src/imgui/impl_glfw.nim b/src/imgui/impl_glfw.nim index 85560d1..5c4a923 100644 --- a/src/imgui/impl_glfw.nim +++ b/src/imgui/impl_glfw.nim @@ -119,7 +119,9 @@ proc igGlfwInit(window: GLFWwindow, installCallbacks: bool, clientApi: GlfwClien io.getClipboardTextFn = igGlfwGetClipboardText io.clipboardUserData = gWindow when defined windows: - io.imeWindowHandle = gWindow.getWin32Window() + var viewPort = igGetMainViewport() # CIMGUI_API ImGuiViewport* igGetMainViewport() + viewPort.platformhandleRaw = gWindow.getWin32Window() + #io.imeWindowHandle = gWindow.getWin32Window() # Obsoleted ? gMouseCursors[ImGuiMouseCursor.Arrow.int32] = glfwCreateStandardCursor(GLFWArrowCursor) gMouseCursors[ImGuiMouseCursor.TextInput.int32] = glfwCreateStandardCursor(GLFWIbeamCursor) diff --git a/src/imgui/impl_opengl.nim b/src/imgui/impl_opengl.nim index f36b2f6..833b9a3 100644 --- a/src/imgui/impl_opengl.nim +++ b/src/imgui/impl_opengl.nim @@ -227,7 +227,7 @@ proc igOpenGL3RenderDrawData*(data: ptr ImDrawData) = let pos = data.displayPos for n in 0 ..< data.cmdListsCount: - var cmd_list = data.cmdLists[n] + var cmd_list = data.cmdLists.data[n] var idx_buffer_offset: int = 0 glBindBuffer(GL_ARRAY_BUFFER, gVboHandle) diff --git a/src/imgui/private/cimgui b/src/imgui/private/cimgui index 08d5ad7..35fc7d1 160000 --- a/src/imgui/private/cimgui +++ b/src/imgui/private/cimgui @@ -1 +1 @@ -Subproject commit 08d5ad7f93eb169377c20bd42748877a41759b63 +Subproject commit 35fc7d191e4d1eb2b41d20fef2298b7d4a65bfdf diff --git a/tools/generator.nim b/tools/generator.nim index ef7253f..a30a36f 100755 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -160,7 +160,7 @@ proc genEnums(output: var string) = dataName = dataName[0 ..< dataName.len - 1] if dataName.match(re"^[0-9]"): dataName = "`\"" & dataName & "\"`" - if dataName == "COUNT": + if dataName.match(re".*COUNT$"): enumsCount[data["name"].getStr()] = data["calc_value"].getInt() continue if table.hasKey(dataValue): diff --git a/tools/utils.nim b/tools/utils.nim index 7ee1480..3a0d3fb 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -24,6 +24,14 @@ const srcHeader* = """ import strutils +## Tentative workaround [start] +type + uint32Ptr* = ptr uint32 + const_cstringPtr* = cstring + Imguidockrequest* = distinct object + ImGuiDockNodeSettings* = distinct object +## Tentative workaround [end] + proc currentSourceDir(): string {.compileTime.} = result = currentSourcePath().replace("\\", "/") result = result[0 ..< result.rfind("/")] From a30263da9fe46058df4023c8048b1830be2d322b Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 11:51:33 +0900 Subject: [PATCH 08/25] added: Jp locale sample : enable IME(input method) --- .gitignore | 2 + tests/jp/Makefile | 97 ++++++++++++++++++ tests/jp/REAME.md | 24 +++++ tests/jp/config.nims | 26 +++++ tests/jp/imgui_test.nim | 211 ++++++++++++++++++++++++++++++++++++++++ tests/jp/setupFonts.nim | 54 ++++++++++ 6 files changed, 414 insertions(+) create mode 100644 tests/jp/Makefile create mode 100644 tests/jp/REAME.md create mode 100644 tests/jp/config.nims create mode 100644 tests/jp/imgui_test.nim create mode 100644 tests/jp/setupFonts.nim diff --git a/.gitignore b/.gitignore index 6e04da4..8df82d0 100644 --- a/.gitignore +++ b/.gitignore @@ -165,4 +165,6 @@ tests/tnull imgui.ini docs/ +.nimcache/ +setenv.common.bat # End of https://www.gitignore.io/api/c,osx,nim,c++,linux,macos,windows,visualstudiocode diff --git a/tests/jp/Makefile b/tests/jp/Makefile new file mode 100644 index 0000000..40b3b81 --- /dev/null +++ b/tests/jp/Makefile @@ -0,0 +1,97 @@ +# - $ make +# Build "imgui_test.exe" --- test program +# +# - $ make test +# Build test executables and "cimgui.dll" +# +# - $ make dll +# Build "cimgui.dll" that statically linked with libstdc++-6.dll and etc +# +ifeq ($(OS),Windows_NT) + EXE = .exe +endif + +NIMCACHE = .nimcache + +OPT += -d:release +OPT += -d:strip +OPT += --nimcache:$(NIMCACHE) +#OPT += --verbosity:3 + +# All static link +OPT += --passL:-static +# Use cimgui.dll +#OPT += -d:cimguiDLL --passL:-static + +TARGET = imgui_test + +all: + @# All static link + nim cpp $(OPT) $(TARGET) + @# Use cimgui.dll + @#nim c $(OPT) $(TARGET) + +.PHONY: clean test + +clean: + @-rm $(TARGET)$(EXE) + @-rm -fr $(NIMCACHE) + +TEST = test +TNULL = tnull + +test: dll Makefile + nim cpp $(OPT) -o:$(TEST)Cpp$(EXE) ../$(TEST) + nim c $(OPT) -o:$(TEST)$(EXE) ../$(TEST) + @# + nim cpp $(OPT) -o:$(TNULL)Cpp$(EXE) ../$(TNULL) + nim c $(OPT) -o:$(TNULL)$(EXE) ../$(TNULL) + +cleantest: + @- rm test{,Cpp}$(EXE) + @- rm tnull{,Cpp}$(EXE) + +# +CIMGUI_DIR = ../../src/imgui/private/cimgui +#VPATH = $(CIMGUI_DIR),$(CIMGUI_DIR)/imgui + +SRCS += $(CIMGUI_DIR)/cimgui.cpp +SRCS += $(wildcard $(CIMGUI_DIR)/imgui/*.cpp) +OBJS += $(SRCS:.cpp=.o) + +CXXFLAGS += -O2 -fno-exceptions -fno-rtti + +ifeq ($(OS), Windows_NT) + ECHO_MESSAGE = "Windows" + + OUTPUTNAME = cimgui.dll + + CXXFLAGS += -I./imgui/ + CXXFLAGS += -Wall + CXXFLAGS += -shared + LINKFLAGS += -limm32 + # Let include libstdc++-6.dll and etc + CXXFLAGS += -static + # Enable input method (IME) + CXXFLAGS += -DIMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS + # Delele debug info + LINKFLAGS += -s + CFLAGS = $(CXXFLAGS) +endif + +dll:$(OUTPUTNAME) + @echo Build complete for $(ECHO_MESSAGE) + +%.o: %.cpp + $(CXX) $(CXXFLAGS) -c -o $@ $< + +$(OUTPUTNAME):$(OBJS) Makefile + $(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS) + +cleandll: + @-rm $(OUTPUTNAME) + @-rm $(OBJS) + +cleanall: clean cleandll cleantest + +.PHONY: dll cleandll cleanall cleantest diff --git a/tests/jp/REAME.md b/tests/jp/REAME.md new file mode 100644 index 0000000..ce30144 --- /dev/null +++ b/tests/jp/REAME.md @@ -0,0 +1,24 @@ +### Jp locale test program + +#### Build + +--- + +- Build "imgui_test.exe" --- Test GUI program + + ```sh + $ make + ``` + +- Build executables for test and "cimgui.dll" + + ```sh + $ make test + ``` + +- Build "cimgui.dll" that statically linked with libstdc++-6.dll and etc + + ```sh + $ make dll + ``` + diff --git a/tests/jp/config.nims b/tests/jp/config.nims new file mode 100644 index 0000000..12e1d43 --- /dev/null +++ b/tests/jp/config.nims @@ -0,0 +1,26 @@ +switch("path", "$projectDir/../../src") + +# These lines should delete +switch "warning","HoleEnumConv:off" +switch "warning","CStringConv:off" +switch "warning","PtrToCstringConv:off" +switch "hint","XDeclaredButNotUsed:off" +# + +# Enable IME implement for Asia region +import std/[pegs,os,strutils] +when defined(windows): + var fBreak = false + for val in ["LC_ALL","LANG", "LC_CTYPE", "LANGUAGE"]: + const AsiaLocale = [" 'ja' / 'jp' "," 'ko' / 'lr' "," 'zh' / 'cn' "," 'zh' / 'tw' "] + for locale in AsiaLocale: + if getEnv(val).toLowerAscii =~ peg(locale): + {.passC:"-DIMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS".} + {.passL:"-limm32".} + echo "\n=== Enabled: Input Method, current locale is [ ",locale," ] ===\n" + fBreak = true + break + if fBreak: + break + + diff --git a/tests/jp/imgui_test.nim b/tests/jp/imgui_test.nim new file mode 100644 index 0000000..af5fecb --- /dev/null +++ b/tests/jp/imgui_test.nim @@ -0,0 +1,211 @@ +# 2023/07 modified +# 2023/02 first +# written by audin. +# +# For Windows10. +# For Linux Debian 11 Bullseye, +# $ sudo apt install xorg-dev libopengl-dev ibgl1-mesa-glx libgl1-mesa-dev + +import imgui, imgui/[impl_opengl, impl_glfw] +import nimgl/[opengl, glfw] +# +import std/[os, strutils] +when defined(windows): + import osDialog +include "setupFonts.nim" + +# メインウインドウのサイズ +const MainWinWidth = 1080 +const MainWinHeight = 800 + +# Global variables +var + show_demo: bool = true # デモ表示 可否 + glfwWin: GLFWWindow + sActiveFontName,sActiveFontTitle:string + fExistMultbytesFonts = false + +var sBuf{.global.}:string = newString(200) + +# Forward definition +proc winMain(hWin:GLFWWindow) +proc startSimpleWindow() + +#-------------- +# main +#-------------- +proc main() = + # GLFWの初期化 開始 + doAssert glfwInit() + defer: glfwTerminate() + + glfwWindowHint(GLFWContextVersionMajor, 3) + glfwWindowHint(GLFWContextVersionMinor, 3) + glfwWindowHint(GLFWOpenglForwardCompat, GLFW_TRUE) + glfwWindowHint(GLFWOpenglProfile, GLFW_OPENGL_CORE_PROFILE) + glfwWindowHint(GLFWResizable, GLFW_TRUE) + + glfwWin = glfwCreateWindow(MainWinWidth, MainWinHeight) + if glfwWin.isNil: + quit(-1) + glfwWin.makeContextCurrent() + defer: glfwWin.destroyWindow() + + glfwSwapInterval(1) # Enable vsync 画面の更新頻度 CPU負荷を低減 + + doAssert glInit() + # ImGuiの初期化 開始 + let context = igCreateContext() + defer: context.igDestroyContext() + + # バックエンドは GLFW + OpenGL + doAssert igGlfwInitForOpenGL(glfwWin, true) + defer: igGlfwShutdown() + doAssert igOpenGL3Init() + defer: igOpenGL3Shutdown() + # + glfwWin.winMain() + +#-------------- +# winMain +#-------------- +proc winMain(hWin:GLFWWindow) = + ## メイン + + # テーマの起動時配色 選択 theme + #igStyleColorsLight() # Windows風 + igStyleColorsDark() # ダーク系1 + #igStyleColorsClassic() # ダーク系2 + #igStyleColorsCherry() # ダーク系3 + # + # 日本語フォントを追加 + (fExistMultbytesFonts,sActiveFontName,sActiveFontTitle) = setupFonts() + # メインループ + while not hWin.windowShouldClose: + glfwPollEvents() + # start imgui frame + igOpenGL3NewFrame() + igGlfwNewFrame() + # + # 動的にフォント変更するならここ + # + igNewFrame() + + if show_demo: # デモ画面の表示 + igShowDemoWindow(show_demo.addr) + + startSimpleWindow() # Simple window start + + igRender() + glClearColor(0.45f, 0.55f, 0.60f, 1.00f) # 背景の色 + glClear(GL_COLOR_BUFFER_BIT) + + igOpenGL3RenderDrawData(igGetDrawData()) + hWin.swapBuffers() + +#------------------- +# helpMaker +#------------------- +proc helpMarker(desc:string) = + igTextDisabled("(?)") + if (igIsItemHovered()): + igBeginTooltip() + igPushTextWrapPos(igGetFontSize() * 35.0f) + igTextUnformatted(desc) + igPopTextWrapPos() + igEndTooltip() + +#------------------- +# showStyleSelector +#------------------- +proc showStyleSelector(label:string) : bool = + var style_idx {.global.}:int32 = -1 + if igCombo(label, addr style_idx, "Dark\0Light\0Classic\0"): + case style_idx + of 0: igStyleColorsDark() + of 1: igStyleColorsLight() + of 2: igStyleColorsClassic() + else: discard + return true + return false + +#------------------- +# startSimpleWindow +#------------------- +proc startSimpleWindow() = + ## 画面左の小さいWindowを描画 + + var + somefloat {.global.} = 0.0'f32 + counter {.global.} = 0'i32 + sFnameSelected {.global.}: string + var pio = igGetIO() + + ### Window開始 + let sTitle = "[ImGui: v$#] テスト by Nim-lang 2023/07" % [$igGetVersion()] + igBegin(sTitle.cstring) + defer: igEnd() + ### テーマの選択 + discard showStyleSelector("テーマ色の選択") + ### フォント選択 コンボボックス + igSeparator() + var fontCurrent = igGetfont() + if igBeginCombo("フォント選択",fontCurrent.getDebugName()): + defer: igEndCombo() + for n in 0..AddFontFromFileTTF(). +- フォントマップは io.Fonts->GetTexDataAsXXXX() 又は io.Fonts->Build()が実行された時に追加される. +- 詳細はFAQ と docs/FONTS.md を読んで下さいs. +- 実行時にフォントの追加と削除が必要なら(例:DPIの変更等) NewFrame()の呼び出し前に行って下さい.""" + ) + ### + igSeparator() + igText("これは日本語テキスト") + igInputText("ここに日本語入力".cstring,sBuf.cstring,sBuf.len.csize_t,0.ImguiInputTextFlags,nil,nil) + igText("出力: ") + igSameLine() + igText(sBuf.cstring) + igSeparator() + igSliderFloat("浮動小数", somefloat.addr, 0.0f, 1.0f) + # + igSeparator() + when defined(windows): + if igButton("ファイルを開く", ImVec2(x: 0, y: 0)): + sFnameSelected = fileDialog(fdOpenFile, path = ".", filename = "*.*", + # filters = "Source[.nim, .nims, .nimble, .c, .cpp] : nim,nims,nimble,c,cpp,m;Header[.h]:h,hpp").cstring + filters="Source:c,cpp,m;Header:h,hpp") + igSameLine() + igText("選択ファイル名 = %s", sFnameSelected.cstring) + # + igSeparator() + igText("描画フレームレート %.3f ms/frame (%.1f FPS)" + , 1000.0f / pio.framerate, pio.framerate) + igText("経過時間 = %.1f [s]", counter.float32 / pio.framerate) + counter.inc + let delay = 600 * 3 + somefloat = (counter mod delay).float32 / delay.float32 + # + igSeparator() + igCheckbox("デモ・ウインドウ表示", show_demo.addr) + +#-------------- +# main +#-------------- +main() + + + +# proc igBeginCombo*(label: cstring, preview_value: cstring, flags: ImGuiComboFlags = 0.ImGuiComboFlags): bool {.importc: "igBeginCombo".} +# proc igSelectable*(label: cstring, selected: bool = false, +# flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, +# size: ImVec2 = ImVec2(x: 0, y: 0).ImVec2): bool {.importc: "igSelectable_Bool".} +# proc igSelectable*(label: cstring, p_selected: ptr bool, +# flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, +# size: ImVec2 = ImVec2(x: 0, y: 0).ImVec2): bool {.importc: "igSelectable_BoolPtr".} diff --git a/tests/jp/setupFonts.nim b/tests/jp/setupFonts.nim new file mode 100644 index 0000000..39ec0b8 --- /dev/null +++ b/tests/jp/setupFonts.nim @@ -0,0 +1,54 @@ +#import std/[os] + +#-------------- +# point2px +#-------------- +proc point2px(point: float32): cfloat = + ## Convert point to pixel + + ((point * 96) / 72).cfloat + +#-------------- +# setupFonts +#-------------- +type + TFontInfo = object + fontDir,osRootDir:string + fontTable:seq[(string # fontName + ,string # fontTitle + ,float)] # point +when defined(windows): + const fontInfo = TFontInfo( + osRootDir: os.getEnv("windir") # get OS root + ,fontDir: "fonts" + ,fontTable: @[ # 以下全て有効にすると起動が遅くなる + ("meiryob.ttc","メイリオ B",14.0) + ,("meiryo.ttc","メイリオ",14.0) + ,("YuGothM.ttc","遊ゴシック M",11.0) + ,("msgothic.ttc","MS ゴシック",11.0) + # ,("myricam.ttc","MyricaM",11.0) + ]) +else: # For Debian/Ubuntu + const fontInfo = TFontInfo( + osRootDir: "/" + ,fontDir: "usr/share/fonts" + ,fontTable: @[ + ("opentype/ipafont-gothic/ipag.ttf","IPAゴシック",12.0) + ,("opentype/ipafont-gothic/ipam.ttf","IPAゴシック M",12.0)]) + +proc setupFonts*(): (bool,string,string) = + ## return font first file name + + result = (false,"Default","ProggyClean.ttf") # + let io = igGetIO() + var seqFontNames: seq[(string,string)] + for (fontName,fontTitle,point) in fontInfo.fontTable: + let fontFullPath = os.joinPath(fontInfo.osRootDir, fontInfo.fontDir, fontName) + if os.fileExists(fontFullPath): + seqFontNames.add (fontName,fontTitle) + # フォントを追加 + io.fonts.addFontFromFileTTF(fontFullPath.cstring, point.point2px, + nil, io.fonts.getGlyphRangesJapanese()); + if seqFontNames.len > 0: + result = (true,seqFontNames[0][0].extractFilename ,seqFontNames[0][1]) + From 20f6ed78219f01e88a94e1315c06b6943de8a25c Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 12:15:15 +0900 Subject: [PATCH 09/25] modified: Definition of "const_cstringPtr" --- src/imgui.nim | 5 ++++- tools/utils.nim | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/imgui.nim b/src/imgui.nim index 56a50be..6d16a75 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -24,9 +24,12 @@ import strutils ## Tentative workaround [start] type uint32Ptr* = ptr uint32 - const_cstringPtr* = cstring Imguidockrequest* = distinct object ImGuiDockNodeSettings* = distinct object + const_cstringPtr* {.pure, inheritable, bycopy.} = object + Size*: cint + Capacity*: cint + Data*: ptr ptr cschar ## Tentative workaround [end] proc currentSourceDir(): string {.compileTime.} = diff --git a/tools/utils.nim b/tools/utils.nim index 3a0d3fb..dc5e1fa 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -27,9 +27,12 @@ import strutils ## Tentative workaround [start] type uint32Ptr* = ptr uint32 - const_cstringPtr* = cstring Imguidockrequest* = distinct object ImGuiDockNodeSettings* = distinct object + const_cstringPtr* {.pure, inheritable, bycopy.} = object + Size*: cint + Capacity*: cint + Data*: ptr ptr cschar ## Tentative workaround [end] proc currentSourceDir(): string {.compileTime.} = From 25230b32b6eac3b5f008f179d2ee144c9c3ff716 Mon Sep 17 00:00:00 2001 From: dinau Date: Mon, 14 Aug 2023 13:32:40 +0900 Subject: [PATCH 10/25] tests/jp/config.nims: added: version checking --- tests/jp/config.nims | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/tests/jp/config.nims b/tests/jp/config.nims index 12e1d43..82e2507 100644 --- a/tests/jp/config.nims +++ b/tests/jp/config.nims @@ -1,11 +1,17 @@ switch("path", "$projectDir/../../src") -# These lines should delete -switch "warning","HoleEnumConv:off" -switch "warning","CStringConv:off" -switch "warning","PtrToCstringConv:off" -switch "hint","XDeclaredButNotUsed:off" -# +when (NimMajor, NimMinor, NimPatch) >= (1, 6, 10): + # These lines should delete + switch "warning","HoleEnumConv:off" + switch "warning","CStringConv:off" + switch "warning","PtrToCstringConv:off" + switch "hint","XDeclaredButNotUsed:off" + +when (NimMajor, NimMinor, NimPatch) < (1, 6, 10): + echo "=====================================================" + echo "=== Error! Nim version: Use nim-1.6.10 or later ===" + echo "=====================================================" + quit 1 # Enable IME implement for Asia region import std/[pegs,os,strutils] From d8eaca91b44310e26f5a61f57c41c8a8539b02b9 Mon Sep 17 00:00:00 2001 From: dinau Date: Tue, 15 Aug 2023 16:14:22 +0900 Subject: [PATCH 11/25] fixed: compile error : added header file pragma for ncimgui.h --- imgui.nimble | 2 +- src/imgui.nim | 2 +- tools/utils.nim | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index 73a49c3..163f0b0 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.8" +version = "1.89.8.1" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index 6d16a75..0477358 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -2568,7 +2568,7 @@ type when not defined(cpp) or defined(cimguiDLL): {.push dynlib: imgui_dll, cdecl, discardable.} else: - {.push nodecl, discardable.} + {.push nodecl, discardable,header: currentSourceDir() & "/imgui/private/ncimgui.h".} proc clearAllBits*(self: ptr uint32): void {.importc: "ImBitArray_ClearAllBits".} proc clearBit*(self: ptr uint32, n: int32): void {.importc: "ImBitArray_ClearBit".} diff --git a/tools/utils.nim b/tools/utils.nim index dc5e1fa..dd61952 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -118,7 +118,7 @@ const preProcs* = """ when not defined(cpp) or defined(cimguiDLL): {.push dynlib: imgui_dll, cdecl, discardable.} else: - {.push nodecl, discardable.} + {.push nodecl, discardable,header: currentSourceDir() & "/imgui/private/ncimgui.h".} """ const postProcs* = """ From 991cfe937a1b06460673a5ac9a3886e70d1bf625 Mon Sep 17 00:00:00 2001 From: dinau Date: Thu, 17 Aug 2023 22:52:49 +0900 Subject: [PATCH 12/25] - Enabled 32-bit indices by defining ImDrawIdx = unsigned int - Replaced the content of Opengl3 driver ( impl_opengl.nim ) with ImGui backend driver --- imgui.nimble | 2 +- src/imgui.nim | 5 +- src/imgui/imgui_impl_opengl_defs.nim | 59 +++++ src/imgui/impl_opengl.nim | 344 ++++----------------------- tests/test.nim | 3 +- tools/generator.nim | 14 +- tools/utils.nim | 1 + 7 files changed, 125 insertions(+), 303 deletions(-) create mode 100644 src/imgui/imgui_impl_opengl_defs.nim diff --git a/imgui.nimble b/imgui.nimble index 163f0b0..58ecaac 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.8.1" +version = "1.89.8.2" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index 0477358..eb86ac3 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -37,6 +37,7 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} +{.passC:"-DImDrawIdx=\"unsigned int\"".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): @@ -1019,7 +1020,7 @@ const ImGuiKey_NamedKey_BEGIN* = 512 type ImBitArrayPtr* = ptr uint32 ImDrawCallback* = proc(parent_list: ptr ImDrawList, cmd: ptr ImDrawCmd): void {.cdecl, varargs.} - ImDrawIdx* = uint16 + ImDrawIdx* = uint32 ImFileHandle* = ptr FILE ImGuiContextHookCallback* = proc(ctx: ptr ImGuiContext, hook: ptr ImGuiContextHook): void {.cdecl, varargs.} ImGuiErrorLogCallback* = proc(user_data: pointer, fmt: cstring): void {.cdecl.} @@ -4073,4 +4074,4 @@ proc igStyleColorsCherry*(dst: ptr ImGuiStyle = nil): void = style.windowPadding.y = 3 style.scrollbarSize = 13 style.frameBorderSize = 1 - style.tabBorderSize = 1 + style.tabBorderSize = 1 \ No newline at end of file diff --git a/src/imgui/imgui_impl_opengl_defs.nim b/src/imgui/imgui_impl_opengl_defs.nim new file mode 100644 index 0000000..479bd43 --- /dev/null +++ b/src/imgui/imgui_impl_opengl_defs.nim @@ -0,0 +1,59 @@ + +from macros import hint + +when not declared(Imguiimplopengl3init): + proc Imguiimplopengl3init*(glslversion: cstring): cint {.cdecl, + importc: "ImGui_ImplOpenGL3_Init".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3init" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3shutdown): + proc Imguiimplopengl3shutdown*(): void {.cdecl, + importc: "ImGui_ImplOpenGL3_Shutdown".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3shutdown" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3newframe): + proc Imguiimplopengl3newframe*(): void {.cdecl, + importc: "ImGui_ImplOpenGL3_NewFrame".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3newframe" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3renderdrawdata): + proc Imguiimplopengl3renderdrawdata*(drawdata: ptr cint): void {.cdecl, + importc: "ImGui_ImplOpenGL3_RenderDrawData".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3renderdrawdata" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3createfontstexture): + proc Imguiimplopengl3createfontstexture*(): cint {.cdecl, + importc: "ImGui_ImplOpenGL3_CreateFontsTexture".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3createfontstexture" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3destroyfontstexture): + proc Imguiimplopengl3destroyfontstexture*(): void {.cdecl, + importc: "ImGui_ImplOpenGL3_DestroyFontsTexture".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3destroyfontstexture" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3createdeviceobjects): + proc Imguiimplopengl3createdeviceobjects*(): cint {.cdecl, + importc: "ImGui_ImplOpenGL3_CreateDeviceObjects".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3createdeviceobjects" & + " already exists, not redeclaring") +when not declared(Imguiimplopengl3destroydeviceobjects): + proc Imguiimplopengl3destroydeviceobjects*(): void {.cdecl, + importc: "ImGui_ImplOpenGL3_DestroyDeviceObjects".} +else: + static : + hint("Declaration of " & "Imguiimplopengl3destroydeviceobjects" & + " already exists, not redeclaring") \ No newline at end of file diff --git a/src/imgui/impl_opengl.nim b/src/imgui/impl_opengl.nim index 833b9a3..0d67e8e 100644 --- a/src/imgui/impl_opengl.nim +++ b/src/imgui/impl_opengl.nim @@ -1,298 +1,46 @@ -# Copyright 2018, NimGL contributors. - -## ImGUI OpenGL (modern OpenGL with shaders / programmatic pipeline) Implementation -## ==== -## Implementation based on the imgui examples implementations. -## Feel free to use and modify this implementation. -## This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..) -## -## HACK: To be honest, there are a lot of things to optimize in here if you have control of every step. - -import ../imgui, nimgl/opengl - -var - gGlslVersionString: cstring = "#version 330 core" - gFontTexture: uint32 = 0 - gShaderHandle: uint32 = 0 - gVertHandle: uint32 = 0 - gFragHandle: uint32 = 0 - gAttribLocationTex: int32 = 0 - gAttribLocationProjMtx: int32 = 0 - gAttribLocationPosition: int32 = 0 - gAttribLocationUV: int32 = 0 - gAttribLocationColor: int32 = 0 - gVboHandle: uint32 = 0 - gElementsHandle: uint32 = 0 - -proc igOpenGL3Init*(): bool = - ## Initiate Opengl, this proc does nothing here because I assume that you are using modern opengl 3.2>. - ## If you actually need to use lower specs open and issue or PR the fix please. - # @TODO: add opengles support - return true - -proc igOpenGL3CheckProgram(handle: uint32, desc: string) = - var status: int32 - var log_length: int32 - glGetProgramiv(handle, GL_LINK_STATUS, status.addr) - glGetProgramiv(handle, GL_INFO_LOG_LENGTH, log_length.addr) - if status == GL_FALSE.int32: - echo "ERROR: impl_opengl failed to link " & desc - if log_length > 0: - var msg: seq[char] = newSeq[char](log_length) - glGetProgramInfoLog(handle, log_length, nil, msg[0].addr) - for m in msg: - stdout.write(m) - echo "" - -proc igOpenGL3CheckShader(handle: uint32, desc: string) = - var status: int32 - var log_length: int32 - glGetShaderiv(handle, GL_COMPILE_STATUS, status.addr) - glGetShaderiv(handle, GL_INFO_LOG_LENGTH, log_length.addr) - if status == GL_FALSE.int32: - echo "ERROR: impl_opengl failed to compile " & desc - if log_length > 0: - var msg: seq[char] = newSeq[char](log_length) - glGetShaderInfoLog(handle, log_length, nil, msg[0].addr) - for m in msg: - stdout.write(m) - echo "" - -proc igOpenGL3CreateFontsTexture() = - let io = igGetIO() - var text_pixels: ptr uint8 - var text_w: int32 - var text_h: int32 - io.fonts.getTexDataAsRGBA32(text_pixels.addr, text_w.addr, text_h.addr) - - var last_texture: int32 - glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) - glGenTextures(1, gFontTexture.addr) - glBindTexture(GL_TEXTURE_2D, gFontTexture) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR.ord) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR.ord) - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0) - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA.ord, text_w, text_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, text_pixels) - - io.fonts.texID = cast[ImTextureID](gFontTexture) - glBindTexture(GL_TEXTURE_2D, last_texture.uint32) - -proc igOpenGL3CreateDeviceObjects() = - var last_texture: int32 - var last_array_buffer: int32 - var last_vertex_array: int32 - glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) - glGetIntegerv(GL_ARRAY_BUFFER_BINDING, last_array_buffer.addr) - glGetIntegerv(GL_VERTEX_ARRAY_BINDING, last_vertex_array.addr) - - # @NOTE: if you need the other shader versions, PR them please. - var vertex_shader_glsl: cstring = """ -layout (location = 0) in vec2 Position; -layout (location = 1) in vec2 UV; -layout (location = 2) in vec4 Color; -uniform mat4 ProjMtx; -out vec2 Frag_UV; -out vec4 Frag_Color; -void main() { - Frag_UV = UV; - Frag_Color = Color; - gl_Position = ProjMtx * vec4(Position.xy, 0, 1); -} - """ - var fragment_shader_glsl: cstring = """ -in vec2 Frag_UV; -in vec4 Frag_Color; -uniform sampler2D Texture; -layout (location = 0) out vec4 Out_Color; -void main() { - Out_Color = Frag_Color * texture(Texture, Frag_UV.st); -} - """ - vertex_shader_glsl = $gGlslVersionString & "\n" & $vertex_shader_glsl - fragment_shader_glsl = $gGlslVersionString & "\n" & $fragment_shader_glsl - - gVertHandle = glCreateShader(GL_VERTEX_SHADER) - glShaderSource(gVertHandle, 1, vertex_shader_glsl.addr, nil) - glCompileShader(gVertHandle) - igOpenGL3CheckShader(gVertHandle, "vertex shader") - - gFragHandle = glCreateShader(GL_FRAGMENT_SHADER) - glShaderSource(gFragHandle, 1, fragment_shader_glsl.addr, nil) - glCompileShader(gFragHandle) - igOpenGL3CheckShader(gFragHandle, "fragment shader") - - gShaderHandle = glCreateProgram() - glAttachShader(gShaderHandle, gVertHandle) - glAttachShader(gShaderHandle, gFragHandle) - glLinkProgram(gShaderHandle) - igOpenGL3CheckProgram(gShaderHandle, "shader program") - - gAttribLocationTex = glGetUniformLocation(gShaderHandle, "Texture") - gAttribLocationProjMtx = glGetUniformLocation(gShaderHandle, "ProjMtx") - gAttribLocationPosition = glGetAttribLocation(gShaderHandle, "Position") - gAttribLocationUV = glGetAttribLocation(gShaderHandle, "UV") - gAttribLocationColor = glGetAttribLocation(gShaderHandle, "Color") - - glGenBuffers(1, gVboHandle.addr) - glGenBuffers(1, gElementsHandle.addr) - - igOpenGL3CreateFontsTexture() - - glBindTexture(GL_TEXTURE_2D, last_texture.uint32) - glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer.uint32) - glBindVertexArray(last_vertex_array.uint32) - -proc igOpenGL3NewFrame*() = - if gFontTexture == 0: - igOpenGL3CreateDeviceObjects() - -proc igOpenGL3RenderDrawData*(data: ptr ImDrawData) = - let io = igGetIO() - let fb_width = (data.displaySize.x * io.displayFramebufferScale.x).int32 - let fb_height = (data.displaySize.y * io.displayFramebufferScale.y).int32 - if fb_width <= 0 or fb_height <= 0: - return - data.scaleClipRects(io.displayFramebufferScale) - - var - last_active_texture: int32 - last_program: int32 - last_texture: int32 - last_array_buffer: int32 - last_vertex_array: int32 - last_viewport: array[4, int32] - last_scissor_box: array[4, int32] - last_blend_src_rgb: int32 - last_blend_dst_rgb: int32 - last_blend_src_alpha: int32 - last_blend_dst_alpha: int32 - last_blend_equation_rgb: int32 - last_blend_equation_alpha: int32 - last_enable_blend: bool - last_enable_cull_face: bool - last_enable_depth_test: bool - last_enable_scissor_test: bool - - glGetIntegerv(GL_ACTIVE_TEXTURE, last_active_texture.addr) - glActiveTexture(GL_TEXTURE_0) - glGetIntegerv(GL_CURRENT_PROGRAM, last_program.addr) - glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) - glGetIntegerv(GL_ARRAY_BUFFER_BINDING, last_array_buffer.addr) - glGetIntegerv(GL_VERTEX_ARRAY_BINDING, last_vertex_array.addr) - glGetIntegerv(GL_VIEWPORT, last_viewport[0].addr) - glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box[0].addr) - glGetIntegerv(GL_BLEND_SRC_RGB, last_blend_src_rgb.addr) - glGetIntegerv(GL_BLEND_DST_RGB, last_blend_dst_rgb.addr) - glGetIntegerv(GL_BLEND_SRC_ALPHA, last_blend_src_alpha.addr) - glGetIntegerv(GL_BLEND_DST_ALPHA, last_blend_dst_alpha.addr) - glGetIntegerv(GL_BLEND_EQUATION_RGB, last_blend_equation_rgb.addr) - glGetIntegerv(GL_BLEND_EQUATION_ALPHA, last_blend_equation_alpha.addr) - last_enable_blend = glIsEnabled(GL_BLEND) - last_enable_cull_face = glIsEnabled(GL_CULL_FACE) - last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST) - last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST) - - glEnable(GL_BLEND) - glBlendEquation(GL_FUNC_ADD) - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) - glDisable(GL_CULL_FACE) - glDisable(GL_DEPTH_TEST) - glEnable(GL_SCISSOR_TEST) - - glViewport(0, 0, fb_width, fb_height) - let L: float32 = data.displayPos.x - let R: float32 = data.displayPos.x + data.displaySize.x - let T: float32 = data.displayPos.y - let B: float32 = data.displayPos.y + data.displaySize.y - var ortho_projection: array[4, array[4, float32]] = [ - [ 2.0f/(R-L), 0.0f, 0.0f, 0.0f ], - [ 0.0f, 2.0f/(T-B), 0.0f, 0.0f ], - [ 0.0f, 0.0f, -1.0f, 0.0f ], - [ (R+L)/(L-R), (T+B)/(B-T), 0.0f, 1.0f ], - ] - glUseProgram(gShaderHandle) - glUniform1i(gAttribLocationTex, 0) - glUniformMatrix4fv(gAttribLocationProjMtx, 1, false, ortho_projection[0][0].addr) - - var vaoHandle: uint32 = 0 - glGenVertexArrays(1, vaoHandle.addr) - glBindVertexArray(vaoHandle) - glBindBuffer(GL_ARRAY_BUFFER, gVboHandle) - glEnableVertexAttribArray(gAttribLocationPosition.uint32) - glEnableVertexAttribArray(gAttribLocationUV.uint32) - glEnableVertexAttribArray(gAttribLocationColor.uint32) - glVertexAttribPointer(gAttribLocationPosition.uint32, 2, EGL_FLOAT, false, ImDrawVert.sizeof().int32, cast[pointer](0)) # @TODO: actually calculate offset - glVertexAttribPointer(gAttribLocationUV.uint32, 2, EGL_FLOAT, false, ImDrawVert.sizeof().int32, cast[pointer](8)) - glVertexAttribPointer(gAttribLocationColor.uint32, 4, GL_UNSIGNED_BYTE, true, ImDrawVert.sizeof().int32, cast[pointer](16)) - - let pos = data.displayPos - for n in 0 ..< data.cmdListsCount: - var cmd_list = data.cmdLists.data[n] - var idx_buffer_offset: int = 0 - - glBindBuffer(GL_ARRAY_BUFFER, gVboHandle) - glBufferData(GL_ARRAY_BUFFER, (cmd_list.vtxBuffer.size * ImDrawVert.sizeof()).int32, cmd_list.vtxBuffer.data[0].addr, GL_STREAM_DRAW) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gElementsHandle) - glBufferData(GL_ELEMENT_ARRAY_BUFFER, (cmd_list.idxBuffer.size * ImDrawIdx.sizeof()).int32, cmd_list.idxBuffer.data[0].addr, GL_STREAM_DRAW) - - for cmd_i in 0 ..< cmd_list.cmdBuffer.size: - var pcmd = cmd_list.cmdBuffer.data[cmd_i] - - if pcmd.userCallback != nil: - pcmd.userCallback(cmd_list, pcmd.addr) - else: - var clip_rect = ImVec4(x: pcmd.clipRect.x - pos.x, y: pcmd.clipRect.y - pos.y, z: pcmd.clipRect.z - pos.x, w: pcmd.clipRect.w - pos.y) - if clip_rect.x < fb_width.float32 and clip_rect.y < fb_height.float32 and clip_rect.z >= 0.0f and clip_rect.w >= 0.0f: - glScissor(clip_rect.x.int32, (fb_height.float32 - clip_rect.w).int32, (clip_rect.z - clip_rect.x).int32, (clip_rect.w - clip_rect.y).int32) - glBindTexture(GL_TEXTURE_2D, cast[uint32](pcmd.textureId)) - glDrawElements(GL_TRIANGLES, pcmd.elemCount.int32, if ImDrawIdx.sizeof == 2: GL_UNSIGNED_SHORT else: GL_UNSIGNED_INT, cast[pointer](idx_buffer_offset)) - idx_buffer_offset.inc(pcmd.elemCount.int32 * ImDrawIdx.sizeof()) - - glDeleteVertexArrays(1, vaoHandle.addr) - - # Restore modified GL State - glUseProgram(last_program.uint32) - glBindTexture(GL_TEXTURE_2D, last_texture.uint32) - glActiveTexture(last_active_texture.GLenum) - glBindVertexArray(last_vertex_array.uint32) - glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer.uint32) - glBlendEquationSeparate(last_blend_equation_rgb.GLenum, last_blend_equation_alpha.GLenum) - glBlendFuncSeparate(last_blend_src_rgb.GLenum, last_blend_dst_rgb.GLenum, last_blend_src_alpha.GLenum, last_blend_dst_alpha.GLenum) - - if last_enable_blend: glEnable(GL_BLEND) else: glDisable(GL_BLEND) - if last_enable_cull_face: glEnable(GL_CULL_FACE) else: glDisable(GL_CULL_FACE) - if last_enable_depth_test: glEnable(GL_DEPTH_TEST) else: glDisable(GL_DEPTH_TEST) - if last_enable_scissor_test: glEnable(GL_SCISSOR_TEST) else: glDisable(GL_SCISSOR_TEST) - - glViewport(last_viewport[0], last_viewport[1], last_viewport[2], last_viewport[3]) - glScissor(last_scissor_box[0], last_scissor_box[1], last_scissor_box[2], last_scissor_box[3]) - -proc igOpenGL3DestroyFontsTexture() = - if gFontTexture > 0'u32: - let io = igGetIO() - glDeleteTextures(1, gFontTexture.addr) - io.fonts.texID = cast[ImTextureID](0) - gFontTexture = 0 - -proc igOpenGL3DestroyDeviceObjects() = - if gVboHandle > 0'u32: glDeleteBuffers(1, gVboHandle.addr) - if gElementsHandle > 0'u32: glDeleteBuffers(1, gElementsHandle.addr) - gVboHandle = 0'u32 - gElementsHandle = 0'u32 - - if gShaderHandle > 0'u32 and gVertHandle > 0'u32: glDetachShader(gShaderHandle, gVertHandle) - if gVertHandle > 0'u32: glDeleteShader(gVertHandle) - gVertHandle = 0'u32 - - if gShaderHandle > 0'u32 and gFragHandle > 0'u32: glDetachShader(gShaderHandle, gFragHandle) - if gFragHandle > 0'u32: glDeleteShader(gFragHandle) - gFragHandle = 0'u32 - - if gShaderHandle > 0'u32: glDeleteProgram(gShaderHandle) - gShaderHandle = 0'u32 - - igOpenGL3DestroyFontsTexture() - -proc igOpenGL3Shutdown*() = - igOpenGL3DestroyDeviceObjects() +import std/[os,strutils] + +proc currentSourceDir(): string {.compileTime.} = + result = currentSourcePath().replace("\\", "/") + result = result[0 ..< result.rfind("/")] + +# Set source paths +const CImguiRootPath = joinpath(currentSourceDir() ,"private/cimgui") +const ImguiRootPath = joinPath(CImguiRootPath,"imgui") + +when defined(useFuthark): + const ClangIncludePath = "c:/drvDx/msys32/mingw32/opt/llvm-15/lib/clang/15.0.7/include" + import futhark + importc: + syspath ClangIncludePath + path CImguiRootPath + define "CIMGUI_USE_OPENGL3" + # Important definition CIMGUI_API for Futhark 0.9.3 + define "CIMGUI_API" + "generator/output/cimgui_impl.h" + outputPath "imgui_impl_opengl_defs.nim" +else: + {.push discardable,hint[XDeclaredButNotUsed]:off,hint[User]:off.} + include "imgui_impl_opengl_defs.nim" + {.pop.} + {.passC:"-I" & CImguiRootPath.} + {.passC:"-I" & ImguiRootPath.} + {.passC:"-DCIMGUI_USE_OPENGL3".} + #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} + {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} + {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} + + {.push discardable.} + proc igOpenGL3Init*(glslVersion:string): bool = + if 0 != Imguiimplopengl3init(glslVersion.cstring): + result = true + proc igOpenGL3Init*(): bool = + const glsl_version = "#version 130" # Default is OpenGL 3.3 + igOpenGl3Init(glsl_version) + proc igOpenGL3Shutdown*() = Imguiimplopengl3destroydeviceobjects() + proc igOpenGL3NewFrame*() = Imguiimplopengl3newframe() + proc igOpenGL3RenderDrawData*(data: pointer): cint = Imguiimplopengl3renderdrawdata(cast[ptr cint](data)) + proc igOpengl3DestroyFontsTexture*(): cint = Imguiimplopengl3destroyfontstexture() + proc igOpengl3DestroyDeviceObjects*(): cint = Imguiimplopengl3destroydeviceobjects() + {.pop.} + diff --git a/tests/test.nim b/tests/test.nim index 93e2404..ca7672e 100644 --- a/tests/test.nim +++ b/tests/test.nim @@ -25,7 +25,8 @@ proc main() = #let io = igGetIO() doAssert igGlfwInitForOpenGL(w, true) - doAssert igOpenGL3Init() + + doAssert igOpenGL3Init() # default: glsl_version = "#version 130" igStyleColorsCherry() diff --git a/tools/generator.nim b/tools/generator.nim index a30a36f..dbc5a18 100755 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -1,7 +1,7 @@ # Written by Leonardo Mariscal , 2019 import strutils, json, strformat, tables, - algorithm, sets, re, ./utils + algorithm, sets, re, ./utils, pegs var enums: HashSet[string] var enumsCount: Table[string, int] @@ -399,6 +399,17 @@ proc genProcs(output: var string) = output.add("\n{postProcs}\n".fmt) +proc fixAfter(fname:string) = + var s:seq[string] + for line in fname.lines: + var st = line + if line.contains(peg"'ImDrawIdx*' \s* '=' \s* 'uint16'"): + st = line.replacef(peg"{@'ImDrawIdx*' \s*} '=' \s* 'uint16'","$1= uint32") + # + s.add st + # write result + writeFile(fname,s.join("\n")) + proc igGenerate*() = var output = srcHeader @@ -409,6 +420,7 @@ proc igGenerate*() = output.add("\n" & cherryTheme) writeFile("src/imgui.nim", output) + fixAfter("src/imgui.nim") when isMainModule: igGenerate() diff --git a/tools/utils.nim b/tools/utils.nim index dd61952..89d3cc0 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -40,6 +40,7 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} +{.passC:"-DImDrawIdx=\"unsigned int\"".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): From 8bb483934535d94935680f5c7ff27f19103ef207 Mon Sep 17 00:00:00 2001 From: dinau Date: Sat, 19 Aug 2023 17:52:53 +0900 Subject: [PATCH 13/25] fixed: The issue that can't compile "c" backend Detail: When specify c backend or -d:cimguiDLL, ImDrawIdx is set to uint16 (16bit). When specify cpp backend, ImDrawIdx is set to uint32 (32bit). I --- imgui.nimble | 2 +- src/imgui.nim | 9 +- src/imgui/impl_opengl.nim | 83 +++++---- src/imgui/private/impl_opengl.nim | 298 ++++++++++++++++++++++++++++++ tools/generator.nim | 24 +-- tools/utils.nim | 6 +- 6 files changed, 366 insertions(+), 56 deletions(-) create mode 100644 src/imgui/private/impl_opengl.nim diff --git a/imgui.nimble b/imgui.nimble index 58ecaac..8b3768f 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.8.2" +version = "1.89.8.3" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index eb86ac3..655f761 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -30,6 +30,10 @@ type Size*: cint Capacity*: cint Data*: ptr ptr cschar +when not defined(cpp) or defined(cimguiDLL): + type ImDrawIdx* = uint16 +else: + type ImDrawIdx* = uint32 ## Tentative workaround [end] proc currentSourceDir(): string {.compileTime.} = @@ -37,7 +41,6 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} -{.passC:"-DImDrawIdx=\"unsigned int\"".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): @@ -51,6 +54,7 @@ when not defined(cpp) or defined(cimguiDLL): {.passC: "-DCIMGUI_DEFINE_ENUMS_AND_STRUCTS".} {.pragma: imgui_header, header: "cimgui.h".} else: + {.passC:"-DImDrawIdx=\"unsigned int\"".} {.compile: "imgui/private/cimgui/cimgui.cpp", compile: "imgui/private/cimgui/imgui/imgui.cpp", compile: "imgui/private/cimgui/imgui/imgui_draw.cpp", @@ -1020,7 +1024,6 @@ const ImGuiKey_NamedKey_BEGIN* = 512 type ImBitArrayPtr* = ptr uint32 ImDrawCallback* = proc(parent_list: ptr ImDrawList, cmd: ptr ImDrawCmd): void {.cdecl, varargs.} - ImDrawIdx* = uint32 ImFileHandle* = ptr FILE ImGuiContextHookCallback* = proc(ctx: ptr ImGuiContext, hook: ptr ImGuiContextHook): void {.cdecl, varargs.} ImGuiErrorLogCallback* = proc(user_data: pointer, fmt: cstring): void {.cdecl.} @@ -4074,4 +4077,4 @@ proc igStyleColorsCherry*(dst: ptr ImGuiStyle = nil): void = style.windowPadding.y = 3 style.scrollbarSize = 13 style.frameBorderSize = 1 - style.tabBorderSize = 1 \ No newline at end of file + style.tabBorderSize = 1 diff --git a/src/imgui/impl_opengl.nim b/src/imgui/impl_opengl.nim index 0d67e8e..3c32363 100644 --- a/src/imgui/impl_opengl.nim +++ b/src/imgui/impl_opengl.nim @@ -1,46 +1,49 @@ -import std/[os,strutils] +when not defined(cpp) or defined(cimguiDLL): + include "private/impl_opengl.nim" +else: + import std/[os,strutils] -proc currentSourceDir(): string {.compileTime.} = - result = currentSourcePath().replace("\\", "/") - result = result[0 ..< result.rfind("/")] + proc currentSourceDir(): string {.compileTime.} = + result = currentSourcePath().replace("\\", "/") + result = result[0 ..< result.rfind("/")] # Set source paths -const CImguiRootPath = joinpath(currentSourceDir() ,"private/cimgui") -const ImguiRootPath = joinPath(CImguiRootPath,"imgui") + const CImguiRootPath = joinpath(currentSourceDir() ,"private/cimgui") + const ImguiRootPath = joinPath(CImguiRootPath,"imgui") -when defined(useFuthark): - const ClangIncludePath = "c:/drvDx/msys32/mingw32/opt/llvm-15/lib/clang/15.0.7/include" - import futhark - importc: - syspath ClangIncludePath - path CImguiRootPath - define "CIMGUI_USE_OPENGL3" - # Important definition CIMGUI_API for Futhark 0.9.3 - define "CIMGUI_API" - "generator/output/cimgui_impl.h" - outputPath "imgui_impl_opengl_defs.nim" -else: - {.push discardable,hint[XDeclaredButNotUsed]:off,hint[User]:off.} - include "imgui_impl_opengl_defs.nim" - {.pop.} - {.passC:"-I" & CImguiRootPath.} - {.passC:"-I" & ImguiRootPath.} - {.passC:"-DCIMGUI_USE_OPENGL3".} - #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} - {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} - {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} + when defined(useFuthark): + const ClangIncludePath = "c:/drvDx/msys32/mingw32/opt/llvm-15/lib/clang/15.0.7/include" + import futhark + importc: + syspath ClangIncludePath + path CImguiRootPath + define "CIMGUI_USE_OPENGL3" + # Important definition CIMGUI_API for Futhark 0.9.3 + define "CIMGUI_API" + "generator/output/cimgui_impl.h" + outputPath "imgui_impl_opengl_defs.nim" + else: + {.push discardable,hint[XDeclaredButNotUsed]:off,hint[User]:off.} + include "imgui_impl_opengl_defs.nim" + {.pop.} + {.passC:"-I" & CImguiRootPath.} + {.passC:"-I" & ImguiRootPath.} + {.passC:"-DCIMGUI_USE_OPENGL3".} + #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} + {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} + {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} - {.push discardable.} - proc igOpenGL3Init*(glslVersion:string): bool = - if 0 != Imguiimplopengl3init(glslVersion.cstring): - result = true - proc igOpenGL3Init*(): bool = - const glsl_version = "#version 130" # Default is OpenGL 3.3 - igOpenGl3Init(glsl_version) - proc igOpenGL3Shutdown*() = Imguiimplopengl3destroydeviceobjects() - proc igOpenGL3NewFrame*() = Imguiimplopengl3newframe() - proc igOpenGL3RenderDrawData*(data: pointer): cint = Imguiimplopengl3renderdrawdata(cast[ptr cint](data)) - proc igOpengl3DestroyFontsTexture*(): cint = Imguiimplopengl3destroyfontstexture() - proc igOpengl3DestroyDeviceObjects*(): cint = Imguiimplopengl3destroydeviceobjects() - {.pop.} + {.push discardable.} + proc igOpenGL3Init*(glslVersion:string): bool = + if 0 != Imguiimplopengl3init(glslVersion.cstring): + result = true + proc igOpenGL3Init*(): bool = + const glsl_version = "#version 130" # Default is OpenGL 3.3 + igOpenGl3Init(glsl_version) + proc igOpenGL3Shutdown*() = Imguiimplopengl3destroydeviceobjects() + proc igOpenGL3NewFrame*() = Imguiimplopengl3newframe() + proc igOpenGL3RenderDrawData*(data: pointer): cint = Imguiimplopengl3renderdrawdata(cast[ptr cint](data)) + proc igOpengl3DestroyFontsTexture*(): cint = Imguiimplopengl3destroyfontstexture() + proc igOpengl3DestroyDeviceObjects*(): cint = Imguiimplopengl3destroydeviceobjects() + {.pop.} diff --git a/src/imgui/private/impl_opengl.nim b/src/imgui/private/impl_opengl.nim new file mode 100644 index 0000000..ef4d4bc --- /dev/null +++ b/src/imgui/private/impl_opengl.nim @@ -0,0 +1,298 @@ +# Copyright 2018, NimGL contributors. + +## ImGUI OpenGL (modern OpenGL with shaders / programmatic pipeline) Implementation +## ==== +## Implementation based on the imgui examples implementations. +## Feel free to use and modify this implementation. +## This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..) +## +## HACK: To be honest, there are a lot of things to optimize in here if you have control of every step. + +import ../../imgui, nimgl/opengl + +var + gGlslVersionString: cstring = "#version 330 core" + gFontTexture: uint32 = 0 + gShaderHandle: uint32 = 0 + gVertHandle: uint32 = 0 + gFragHandle: uint32 = 0 + gAttribLocationTex: int32 = 0 + gAttribLocationProjMtx: int32 = 0 + gAttribLocationPosition: int32 = 0 + gAttribLocationUV: int32 = 0 + gAttribLocationColor: int32 = 0 + gVboHandle: uint32 = 0 + gElementsHandle: uint32 = 0 + +proc igOpenGL3Init*(): bool = + ## Initiate Opengl, this proc does nothing here because I assume that you are using modern opengl 3.2>. + ## If you actually need to use lower specs open and issue or PR the fix please. + # @TODO: add opengles support + return true + +proc igOpenGL3CheckProgram(handle: uint32, desc: string) = + var status: int32 + var log_length: int32 + glGetProgramiv(handle, GL_LINK_STATUS, status.addr) + glGetProgramiv(handle, GL_INFO_LOG_LENGTH, log_length.addr) + if status == GL_FALSE.int32: + echo "ERROR: impl_opengl failed to link " & desc + if log_length > 0: + var msg: seq[char] = newSeq[char](log_length) + glGetProgramInfoLog(handle, log_length, nil, msg[0].addr) + for m in msg: + stdout.write(m) + echo "" + +proc igOpenGL3CheckShader(handle: uint32, desc: string) = + var status: int32 + var log_length: int32 + glGetShaderiv(handle, GL_COMPILE_STATUS, status.addr) + glGetShaderiv(handle, GL_INFO_LOG_LENGTH, log_length.addr) + if status == GL_FALSE.int32: + echo "ERROR: impl_opengl failed to compile " & desc + if log_length > 0: + var msg: seq[char] = newSeq[char](log_length) + glGetShaderInfoLog(handle, log_length, nil, msg[0].addr) + for m in msg: + stdout.write(m) + echo "" + +proc igOpenGL3CreateFontsTexture() = + let io = igGetIO() + var text_pixels: ptr uint8 + var text_w: int32 + var text_h: int32 + io.fonts.getTexDataAsRGBA32(text_pixels.addr, text_w.addr, text_h.addr) + + var last_texture: int32 + glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) + glGenTextures(1, gFontTexture.addr) + glBindTexture(GL_TEXTURE_2D, gFontTexture) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR.ord) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR.ord) + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0) + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA.ord, text_w, text_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, text_pixels) + + io.fonts.texID = cast[ImTextureID](gFontTexture) + glBindTexture(GL_TEXTURE_2D, last_texture.uint32) + +proc igOpenGL3CreateDeviceObjects() = + var last_texture: int32 + var last_array_buffer: int32 + var last_vertex_array: int32 + glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) + glGetIntegerv(GL_ARRAY_BUFFER_BINDING, last_array_buffer.addr) + glGetIntegerv(GL_VERTEX_ARRAY_BINDING, last_vertex_array.addr) + + # @NOTE: if you need the other shader versions, PR them please. + var vertex_shader_glsl: cstring = """ +layout (location = 0) in vec2 Position; +layout (location = 1) in vec2 UV; +layout (location = 2) in vec4 Color; +uniform mat4 ProjMtx; +out vec2 Frag_UV; +out vec4 Frag_Color; +void main() { + Frag_UV = UV; + Frag_Color = Color; + gl_Position = ProjMtx * vec4(Position.xy, 0, 1); +} + """ + var fragment_shader_glsl: cstring = """ +in vec2 Frag_UV; +in vec4 Frag_Color; +uniform sampler2D Texture; +layout (location = 0) out vec4 Out_Color; +void main() { + Out_Color = Frag_Color * texture(Texture, Frag_UV.st); +} + """ + vertex_shader_glsl = $gGlslVersionString & "\n" & $vertex_shader_glsl + fragment_shader_glsl = $gGlslVersionString & "\n" & $fragment_shader_glsl + + gVertHandle = glCreateShader(GL_VERTEX_SHADER) + glShaderSource(gVertHandle, 1, vertex_shader_glsl.addr, nil) + glCompileShader(gVertHandle) + igOpenGL3CheckShader(gVertHandle, "vertex shader") + + gFragHandle = glCreateShader(GL_FRAGMENT_SHADER) + glShaderSource(gFragHandle, 1, fragment_shader_glsl.addr, nil) + glCompileShader(gFragHandle) + igOpenGL3CheckShader(gFragHandle, "fragment shader") + + gShaderHandle = glCreateProgram() + glAttachShader(gShaderHandle, gVertHandle) + glAttachShader(gShaderHandle, gFragHandle) + glLinkProgram(gShaderHandle) + igOpenGL3CheckProgram(gShaderHandle, "shader program") + + gAttribLocationTex = glGetUniformLocation(gShaderHandle, "Texture") + gAttribLocationProjMtx = glGetUniformLocation(gShaderHandle, "ProjMtx") + gAttribLocationPosition = glGetAttribLocation(gShaderHandle, "Position") + gAttribLocationUV = glGetAttribLocation(gShaderHandle, "UV") + gAttribLocationColor = glGetAttribLocation(gShaderHandle, "Color") + + glGenBuffers(1, gVboHandle.addr) + glGenBuffers(1, gElementsHandle.addr) + + igOpenGL3CreateFontsTexture() + + glBindTexture(GL_TEXTURE_2D, last_texture.uint32) + glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer.uint32) + glBindVertexArray(last_vertex_array.uint32) + +proc igOpenGL3NewFrame*() = + if gFontTexture == 0: + igOpenGL3CreateDeviceObjects() + +proc igOpenGL3RenderDrawData*(data: ptr ImDrawData) = + let io = igGetIO() + let fb_width = (data.displaySize.x * io.displayFramebufferScale.x).int32 + let fb_height = (data.displaySize.y * io.displayFramebufferScale.y).int32 + if fb_width <= 0 or fb_height <= 0: + return + data.scaleClipRects(io.displayFramebufferScale) + + var + last_active_texture: int32 + last_program: int32 + last_texture: int32 + last_array_buffer: int32 + last_vertex_array: int32 + last_viewport: array[4, int32] + last_scissor_box: array[4, int32] + last_blend_src_rgb: int32 + last_blend_dst_rgb: int32 + last_blend_src_alpha: int32 + last_blend_dst_alpha: int32 + last_blend_equation_rgb: int32 + last_blend_equation_alpha: int32 + last_enable_blend: bool + last_enable_cull_face: bool + last_enable_depth_test: bool + last_enable_scissor_test: bool + + glGetIntegerv(GL_ACTIVE_TEXTURE, last_active_texture.addr) + glActiveTexture(GL_TEXTURE_0) + glGetIntegerv(GL_CURRENT_PROGRAM, last_program.addr) + glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture.addr) + glGetIntegerv(GL_ARRAY_BUFFER_BINDING, last_array_buffer.addr) + glGetIntegerv(GL_VERTEX_ARRAY_BINDING, last_vertex_array.addr) + glGetIntegerv(GL_VIEWPORT, last_viewport[0].addr) + glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box[0].addr) + glGetIntegerv(GL_BLEND_SRC_RGB, last_blend_src_rgb.addr) + glGetIntegerv(GL_BLEND_DST_RGB, last_blend_dst_rgb.addr) + glGetIntegerv(GL_BLEND_SRC_ALPHA, last_blend_src_alpha.addr) + glGetIntegerv(GL_BLEND_DST_ALPHA, last_blend_dst_alpha.addr) + glGetIntegerv(GL_BLEND_EQUATION_RGB, last_blend_equation_rgb.addr) + glGetIntegerv(GL_BLEND_EQUATION_ALPHA, last_blend_equation_alpha.addr) + last_enable_blend = glIsEnabled(GL_BLEND) + last_enable_cull_face = glIsEnabled(GL_CULL_FACE) + last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST) + last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST) + + glEnable(GL_BLEND) + glBlendEquation(GL_FUNC_ADD) + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) + glDisable(GL_CULL_FACE) + glDisable(GL_DEPTH_TEST) + glEnable(GL_SCISSOR_TEST) + + glViewport(0, 0, fb_width, fb_height) + let L: float32 = data.displayPos.x + let R: float32 = data.displayPos.x + data.displaySize.x + let T: float32 = data.displayPos.y + let B: float32 = data.displayPos.y + data.displaySize.y + var ortho_projection: array[4, array[4, float32]] = [ + [ 2.0f/(R-L), 0.0f, 0.0f, 0.0f ], + [ 0.0f, 2.0f/(T-B), 0.0f, 0.0f ], + [ 0.0f, 0.0f, -1.0f, 0.0f ], + [ (R+L)/(L-R), (T+B)/(B-T), 0.0f, 1.0f ], + ] + glUseProgram(gShaderHandle) + glUniform1i(gAttribLocationTex, 0) + glUniformMatrix4fv(gAttribLocationProjMtx, 1, false, ortho_projection[0][0].addr) + + var vaoHandle: uint32 = 0 + glGenVertexArrays(1, vaoHandle.addr) + glBindVertexArray(vaoHandle) + glBindBuffer(GL_ARRAY_BUFFER, gVboHandle) + glEnableVertexAttribArray(gAttribLocationPosition.uint32) + glEnableVertexAttribArray(gAttribLocationUV.uint32) + glEnableVertexAttribArray(gAttribLocationColor.uint32) + glVertexAttribPointer(gAttribLocationPosition.uint32, 2, EGL_FLOAT, false, ImDrawVert.sizeof().int32, cast[pointer](0)) # @TODO: actually calculate offset + glVertexAttribPointer(gAttribLocationUV.uint32, 2, EGL_FLOAT, false, ImDrawVert.sizeof().int32, cast[pointer](8)) + glVertexAttribPointer(gAttribLocationColor.uint32, 4, GL_UNSIGNED_BYTE, true, ImDrawVert.sizeof().int32, cast[pointer](16)) + + let pos = data.displayPos + for n in 0 ..< data.cmdListsCount: + var cmd_list = data.cmdLists.data[n] + var idx_buffer_offset: int = 0 + + glBindBuffer(GL_ARRAY_BUFFER, gVboHandle) + glBufferData(GL_ARRAY_BUFFER, (cmd_list.vtxBuffer.size * ImDrawVert.sizeof()).int32, cmd_list.vtxBuffer.data[0].addr, GL_STREAM_DRAW) + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gElementsHandle) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, (cmd_list.idxBuffer.size * ImDrawIdx.sizeof()).int32, cmd_list.idxBuffer.data[0].addr, GL_STREAM_DRAW) + + for cmd_i in 0 ..< cmd_list.cmdBuffer.size: + var pcmd = cmd_list.cmdBuffer.data[cmd_i] + + if pcmd.userCallback != nil: + pcmd.userCallback(cmd_list, pcmd.addr) + else: + var clip_rect = ImVec4(x: pcmd.clipRect.x - pos.x, y: pcmd.clipRect.y - pos.y, z: pcmd.clipRect.z - pos.x, w: pcmd.clipRect.w - pos.y) + if clip_rect.x < fb_width.float32 and clip_rect.y < fb_height.float32 and clip_rect.z >= 0.0f and clip_rect.w >= 0.0f: + glScissor(clip_rect.x.int32, (fb_height.float32 - clip_rect.w).int32, (clip_rect.z - clip_rect.x).int32, (clip_rect.w - clip_rect.y).int32) + glBindTexture(GL_TEXTURE_2D, cast[uint32](pcmd.textureId)) + glDrawElements(GL_TRIANGLES, pcmd.elemCount.int32, if ImDrawIdx.sizeof == 2: GL_UNSIGNED_SHORT else: GL_UNSIGNED_INT, cast[pointer](idx_buffer_offset)) + idx_buffer_offset.inc(pcmd.elemCount.int32 * ImDrawIdx.sizeof()) + + glDeleteVertexArrays(1, vaoHandle.addr) + + # Restore modified GL State + glUseProgram(last_program.uint32) + glBindTexture(GL_TEXTURE_2D, last_texture.uint32) + glActiveTexture(last_active_texture.GLenum) + glBindVertexArray(last_vertex_array.uint32) + glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer.uint32) + glBlendEquationSeparate(last_blend_equation_rgb.GLenum, last_blend_equation_alpha.GLenum) + glBlendFuncSeparate(last_blend_src_rgb.GLenum, last_blend_dst_rgb.GLenum, last_blend_src_alpha.GLenum, last_blend_dst_alpha.GLenum) + + if last_enable_blend: glEnable(GL_BLEND) else: glDisable(GL_BLEND) + if last_enable_cull_face: glEnable(GL_CULL_FACE) else: glDisable(GL_CULL_FACE) + if last_enable_depth_test: glEnable(GL_DEPTH_TEST) else: glDisable(GL_DEPTH_TEST) + if last_enable_scissor_test: glEnable(GL_SCISSOR_TEST) else: glDisable(GL_SCISSOR_TEST) + + glViewport(last_viewport[0], last_viewport[1], last_viewport[2], last_viewport[3]) + glScissor(last_scissor_box[0], last_scissor_box[1], last_scissor_box[2], last_scissor_box[3]) + +proc igOpenGL3DestroyFontsTexture() = + if gFontTexture > 0'u32: + let io = igGetIO() + glDeleteTextures(1, gFontTexture.addr) + io.fonts.texID = cast[ImTextureID](0) + gFontTexture = 0 + +proc igOpenGL3DestroyDeviceObjects() = + if gVboHandle > 0'u32: glDeleteBuffers(1, gVboHandle.addr) + if gElementsHandle > 0'u32: glDeleteBuffers(1, gElementsHandle.addr) + gVboHandle = 0'u32 + gElementsHandle = 0'u32 + + if gShaderHandle > 0'u32 and gVertHandle > 0'u32: glDetachShader(gShaderHandle, gVertHandle) + if gVertHandle > 0'u32: glDeleteShader(gVertHandle) + gVertHandle = 0'u32 + + if gShaderHandle > 0'u32 and gFragHandle > 0'u32: glDetachShader(gShaderHandle, gFragHandle) + if gFragHandle > 0'u32: glDeleteShader(gFragHandle) + gFragHandle = 0'u32 + + if gShaderHandle > 0'u32: glDeleteProgram(gShaderHandle) + gShaderHandle = 0'u32 + + igOpenGL3DestroyFontsTexture() + +proc igOpenGL3Shutdown*() = + igOpenGL3DestroyDeviceObjects() diff --git a/tools/generator.nim b/tools/generator.nim index dbc5a18..a6820e5 100755 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -1,7 +1,7 @@ # Written by Leonardo Mariscal , 2019 import strutils, json, strformat, tables, - algorithm, sets, re, ./utils, pegs + algorithm, sets, re, ./utils var enums: HashSet[string] var enumsCount: Table[string, int] @@ -195,6 +195,8 @@ proc genTypeDefs(output: var string) = "ImU64", "ImBitArrayForNamedKeys"] if obj.getStr().startsWith("struct") or enums.contains(name) or ignorable.contains(name): continue + if name == "ImDrawIdx": # delete and define in "utils.nim" + continue output.add(" {name}* = {obj.getStr().translateType()}\n".fmt) proc genTypes(output: var string) = @@ -399,16 +401,16 @@ proc genProcs(output: var string) = output.add("\n{postProcs}\n".fmt) -proc fixAfter(fname:string) = - var s:seq[string] - for line in fname.lines: - var st = line - if line.contains(peg"'ImDrawIdx*' \s* '=' \s* 'uint16'"): - st = line.replacef(peg"{@'ImDrawIdx*' \s*} '=' \s* 'uint16'","$1= uint32") - # - s.add st - # write result - writeFile(fname,s.join("\n")) +proc fixAfter(fname:string) = discard + #var s:seq[string] + #for line in fname.lines: + # var st = line + # if line.contains(peg"'ImDrawIdx*' \s* '=' \s* 'uint16'"): + # st = line.replacef(peg"{@'ImDrawIdx*' \s*} '=' \s* 'uint16'","$1= uint32") + # # + # s.add st + ## write result + #writeFile(fname,s.join("\n")) proc igGenerate*() = var output = srcHeader diff --git a/tools/utils.nim b/tools/utils.nim index 89d3cc0..2c1692d 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -33,6 +33,10 @@ type Size*: cint Capacity*: cint Data*: ptr ptr cschar +when not defined(cpp) or defined(cimguiDLL): + type ImDrawIdx* = uint16 +else: + type ImDrawIdx* = uint32 ## Tentative workaround [end] proc currentSourceDir(): string {.compileTime.} = @@ -40,7 +44,6 @@ proc currentSourceDir(): string {.compileTime.} = result = result[0 ..< result.rfind("/")] {.passC: "-I" & currentSourceDir() & "/imgui/private/cimgui" & " -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1".} -{.passC:"-DImDrawIdx=\"unsigned int\"".} when not defined(cpp) or defined(cimguiDLL): when defined(windows): @@ -54,6 +57,7 @@ when not defined(cpp) or defined(cimguiDLL): {.passC: "-DCIMGUI_DEFINE_ENUMS_AND_STRUCTS".} {.pragma: imgui_header, header: "cimgui.h".} else: + {.passC:"-DImDrawIdx=\"unsigned int\"".} {.compile: "imgui/private/cimgui/cimgui.cpp", compile: "imgui/private/cimgui/imgui/imgui.cpp", compile: "imgui/private/cimgui/imgui/imgui_draw.cpp", From fa578402f2eb83f2292132d2012251247b4aa6cf Mon Sep 17 00:00:00 2001 From: dinau Date: Wed, 30 Aug 2023 12:19:14 +0900 Subject: [PATCH 14/25] deleted: test/jp folder --- tests/jp/Makefile | 97 ------------------ tests/jp/REAME.md | 24 ----- tests/jp/config.nims | 32 ------ tests/jp/imgui_test.nim | 211 ---------------------------------------- tests/jp/setupFonts.nim | 54 ---------- 5 files changed, 418 deletions(-) delete mode 100644 tests/jp/Makefile delete mode 100644 tests/jp/REAME.md delete mode 100644 tests/jp/config.nims delete mode 100644 tests/jp/imgui_test.nim delete mode 100644 tests/jp/setupFonts.nim diff --git a/tests/jp/Makefile b/tests/jp/Makefile deleted file mode 100644 index 40b3b81..0000000 --- a/tests/jp/Makefile +++ /dev/null @@ -1,97 +0,0 @@ -# - $ make -# Build "imgui_test.exe" --- test program -# -# - $ make test -# Build test executables and "cimgui.dll" -# -# - $ make dll -# Build "cimgui.dll" that statically linked with libstdc++-6.dll and etc -# -ifeq ($(OS),Windows_NT) - EXE = .exe -endif - -NIMCACHE = .nimcache - -OPT += -d:release -OPT += -d:strip -OPT += --nimcache:$(NIMCACHE) -#OPT += --verbosity:3 - -# All static link -OPT += --passL:-static -# Use cimgui.dll -#OPT += -d:cimguiDLL --passL:-static - -TARGET = imgui_test - -all: - @# All static link - nim cpp $(OPT) $(TARGET) - @# Use cimgui.dll - @#nim c $(OPT) $(TARGET) - -.PHONY: clean test - -clean: - @-rm $(TARGET)$(EXE) - @-rm -fr $(NIMCACHE) - -TEST = test -TNULL = tnull - -test: dll Makefile - nim cpp $(OPT) -o:$(TEST)Cpp$(EXE) ../$(TEST) - nim c $(OPT) -o:$(TEST)$(EXE) ../$(TEST) - @# - nim cpp $(OPT) -o:$(TNULL)Cpp$(EXE) ../$(TNULL) - nim c $(OPT) -o:$(TNULL)$(EXE) ../$(TNULL) - -cleantest: - @- rm test{,Cpp}$(EXE) - @- rm tnull{,Cpp}$(EXE) - -# -CIMGUI_DIR = ../../src/imgui/private/cimgui -#VPATH = $(CIMGUI_DIR),$(CIMGUI_DIR)/imgui - -SRCS += $(CIMGUI_DIR)/cimgui.cpp -SRCS += $(wildcard $(CIMGUI_DIR)/imgui/*.cpp) -OBJS += $(SRCS:.cpp=.o) - -CXXFLAGS += -O2 -fno-exceptions -fno-rtti - -ifeq ($(OS), Windows_NT) - ECHO_MESSAGE = "Windows" - - OUTPUTNAME = cimgui.dll - - CXXFLAGS += -I./imgui/ - CXXFLAGS += -Wall - CXXFLAGS += -shared - LINKFLAGS += -limm32 - # Let include libstdc++-6.dll and etc - CXXFLAGS += -static - # Enable input method (IME) - CXXFLAGS += -DIMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS - # Delele debug info - LINKFLAGS += -s - CFLAGS = $(CXXFLAGS) -endif - -dll:$(OUTPUTNAME) - @echo Build complete for $(ECHO_MESSAGE) - -%.o: %.cpp - $(CXX) $(CXXFLAGS) -c -o $@ $< - -$(OUTPUTNAME):$(OBJS) Makefile - $(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS) - -cleandll: - @-rm $(OUTPUTNAME) - @-rm $(OBJS) - -cleanall: clean cleandll cleantest - -.PHONY: dll cleandll cleanall cleantest diff --git a/tests/jp/REAME.md b/tests/jp/REAME.md deleted file mode 100644 index ce30144..0000000 --- a/tests/jp/REAME.md +++ /dev/null @@ -1,24 +0,0 @@ -### Jp locale test program - -#### Build - ---- - -- Build "imgui_test.exe" --- Test GUI program - - ```sh - $ make - ``` - -- Build executables for test and "cimgui.dll" - - ```sh - $ make test - ``` - -- Build "cimgui.dll" that statically linked with libstdc++-6.dll and etc - - ```sh - $ make dll - ``` - diff --git a/tests/jp/config.nims b/tests/jp/config.nims deleted file mode 100644 index 82e2507..0000000 --- a/tests/jp/config.nims +++ /dev/null @@ -1,32 +0,0 @@ -switch("path", "$projectDir/../../src") - -when (NimMajor, NimMinor, NimPatch) >= (1, 6, 10): - # These lines should delete - switch "warning","HoleEnumConv:off" - switch "warning","CStringConv:off" - switch "warning","PtrToCstringConv:off" - switch "hint","XDeclaredButNotUsed:off" - -when (NimMajor, NimMinor, NimPatch) < (1, 6, 10): - echo "=====================================================" - echo "=== Error! Nim version: Use nim-1.6.10 or later ===" - echo "=====================================================" - quit 1 - -# Enable IME implement for Asia region -import std/[pegs,os,strutils] -when defined(windows): - var fBreak = false - for val in ["LC_ALL","LANG", "LC_CTYPE", "LANGUAGE"]: - const AsiaLocale = [" 'ja' / 'jp' "," 'ko' / 'lr' "," 'zh' / 'cn' "," 'zh' / 'tw' "] - for locale in AsiaLocale: - if getEnv(val).toLowerAscii =~ peg(locale): - {.passC:"-DIMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS".} - {.passL:"-limm32".} - echo "\n=== Enabled: Input Method, current locale is [ ",locale," ] ===\n" - fBreak = true - break - if fBreak: - break - - diff --git a/tests/jp/imgui_test.nim b/tests/jp/imgui_test.nim deleted file mode 100644 index af5fecb..0000000 --- a/tests/jp/imgui_test.nim +++ /dev/null @@ -1,211 +0,0 @@ -# 2023/07 modified -# 2023/02 first -# written by audin. -# -# For Windows10. -# For Linux Debian 11 Bullseye, -# $ sudo apt install xorg-dev libopengl-dev ibgl1-mesa-glx libgl1-mesa-dev - -import imgui, imgui/[impl_opengl, impl_glfw] -import nimgl/[opengl, glfw] -# -import std/[os, strutils] -when defined(windows): - import osDialog -include "setupFonts.nim" - -# メインウインドウのサイズ -const MainWinWidth = 1080 -const MainWinHeight = 800 - -# Global variables -var - show_demo: bool = true # デモ表示 可否 - glfwWin: GLFWWindow - sActiveFontName,sActiveFontTitle:string - fExistMultbytesFonts = false - -var sBuf{.global.}:string = newString(200) - -# Forward definition -proc winMain(hWin:GLFWWindow) -proc startSimpleWindow() - -#-------------- -# main -#-------------- -proc main() = - # GLFWの初期化 開始 - doAssert glfwInit() - defer: glfwTerminate() - - glfwWindowHint(GLFWContextVersionMajor, 3) - glfwWindowHint(GLFWContextVersionMinor, 3) - glfwWindowHint(GLFWOpenglForwardCompat, GLFW_TRUE) - glfwWindowHint(GLFWOpenglProfile, GLFW_OPENGL_CORE_PROFILE) - glfwWindowHint(GLFWResizable, GLFW_TRUE) - - glfwWin = glfwCreateWindow(MainWinWidth, MainWinHeight) - if glfwWin.isNil: - quit(-1) - glfwWin.makeContextCurrent() - defer: glfwWin.destroyWindow() - - glfwSwapInterval(1) # Enable vsync 画面の更新頻度 CPU負荷を低減 - - doAssert glInit() - # ImGuiの初期化 開始 - let context = igCreateContext() - defer: context.igDestroyContext() - - # バックエンドは GLFW + OpenGL - doAssert igGlfwInitForOpenGL(glfwWin, true) - defer: igGlfwShutdown() - doAssert igOpenGL3Init() - defer: igOpenGL3Shutdown() - # - glfwWin.winMain() - -#-------------- -# winMain -#-------------- -proc winMain(hWin:GLFWWindow) = - ## メイン - - # テーマの起動時配色 選択 theme - #igStyleColorsLight() # Windows風 - igStyleColorsDark() # ダーク系1 - #igStyleColorsClassic() # ダーク系2 - #igStyleColorsCherry() # ダーク系3 - # - # 日本語フォントを追加 - (fExistMultbytesFonts,sActiveFontName,sActiveFontTitle) = setupFonts() - # メインループ - while not hWin.windowShouldClose: - glfwPollEvents() - # start imgui frame - igOpenGL3NewFrame() - igGlfwNewFrame() - # - # 動的にフォント変更するならここ - # - igNewFrame() - - if show_demo: # デモ画面の表示 - igShowDemoWindow(show_demo.addr) - - startSimpleWindow() # Simple window start - - igRender() - glClearColor(0.45f, 0.55f, 0.60f, 1.00f) # 背景の色 - glClear(GL_COLOR_BUFFER_BIT) - - igOpenGL3RenderDrawData(igGetDrawData()) - hWin.swapBuffers() - -#------------------- -# helpMaker -#------------------- -proc helpMarker(desc:string) = - igTextDisabled("(?)") - if (igIsItemHovered()): - igBeginTooltip() - igPushTextWrapPos(igGetFontSize() * 35.0f) - igTextUnformatted(desc) - igPopTextWrapPos() - igEndTooltip() - -#------------------- -# showStyleSelector -#------------------- -proc showStyleSelector(label:string) : bool = - var style_idx {.global.}:int32 = -1 - if igCombo(label, addr style_idx, "Dark\0Light\0Classic\0"): - case style_idx - of 0: igStyleColorsDark() - of 1: igStyleColorsLight() - of 2: igStyleColorsClassic() - else: discard - return true - return false - -#------------------- -# startSimpleWindow -#------------------- -proc startSimpleWindow() = - ## 画面左の小さいWindowを描画 - - var - somefloat {.global.} = 0.0'f32 - counter {.global.} = 0'i32 - sFnameSelected {.global.}: string - var pio = igGetIO() - - ### Window開始 - let sTitle = "[ImGui: v$#] テスト by Nim-lang 2023/07" % [$igGetVersion()] - igBegin(sTitle.cstring) - defer: igEnd() - ### テーマの選択 - discard showStyleSelector("テーマ色の選択") - ### フォント選択 コンボボックス - igSeparator() - var fontCurrent = igGetfont() - if igBeginCombo("フォント選択",fontCurrent.getDebugName()): - defer: igEndCombo() - for n in 0..AddFontFromFileTTF(). -- フォントマップは io.Fonts->GetTexDataAsXXXX() 又は io.Fonts->Build()が実行された時に追加される. -- 詳細はFAQ と docs/FONTS.md を読んで下さいs. -- 実行時にフォントの追加と削除が必要なら(例:DPIの変更等) NewFrame()の呼び出し前に行って下さい.""" - ) - ### - igSeparator() - igText("これは日本語テキスト") - igInputText("ここに日本語入力".cstring,sBuf.cstring,sBuf.len.csize_t,0.ImguiInputTextFlags,nil,nil) - igText("出力: ") - igSameLine() - igText(sBuf.cstring) - igSeparator() - igSliderFloat("浮動小数", somefloat.addr, 0.0f, 1.0f) - # - igSeparator() - when defined(windows): - if igButton("ファイルを開く", ImVec2(x: 0, y: 0)): - sFnameSelected = fileDialog(fdOpenFile, path = ".", filename = "*.*", - # filters = "Source[.nim, .nims, .nimble, .c, .cpp] : nim,nims,nimble,c,cpp,m;Header[.h]:h,hpp").cstring - filters="Source:c,cpp,m;Header:h,hpp") - igSameLine() - igText("選択ファイル名 = %s", sFnameSelected.cstring) - # - igSeparator() - igText("描画フレームレート %.3f ms/frame (%.1f FPS)" - , 1000.0f / pio.framerate, pio.framerate) - igText("経過時間 = %.1f [s]", counter.float32 / pio.framerate) - counter.inc - let delay = 600 * 3 - somefloat = (counter mod delay).float32 / delay.float32 - # - igSeparator() - igCheckbox("デモ・ウインドウ表示", show_demo.addr) - -#-------------- -# main -#-------------- -main() - - - -# proc igBeginCombo*(label: cstring, preview_value: cstring, flags: ImGuiComboFlags = 0.ImGuiComboFlags): bool {.importc: "igBeginCombo".} -# proc igSelectable*(label: cstring, selected: bool = false, -# flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, -# size: ImVec2 = ImVec2(x: 0, y: 0).ImVec2): bool {.importc: "igSelectable_Bool".} -# proc igSelectable*(label: cstring, p_selected: ptr bool, -# flags: ImGuiSelectableFlags = 0.ImGuiSelectableFlags, -# size: ImVec2 = ImVec2(x: 0, y: 0).ImVec2): bool {.importc: "igSelectable_BoolPtr".} diff --git a/tests/jp/setupFonts.nim b/tests/jp/setupFonts.nim deleted file mode 100644 index 39ec0b8..0000000 --- a/tests/jp/setupFonts.nim +++ /dev/null @@ -1,54 +0,0 @@ -#import std/[os] - -#-------------- -# point2px -#-------------- -proc point2px(point: float32): cfloat = - ## Convert point to pixel - - ((point * 96) / 72).cfloat - -#-------------- -# setupFonts -#-------------- -type - TFontInfo = object - fontDir,osRootDir:string - fontTable:seq[(string # fontName - ,string # fontTitle - ,float)] # point -when defined(windows): - const fontInfo = TFontInfo( - osRootDir: os.getEnv("windir") # get OS root - ,fontDir: "fonts" - ,fontTable: @[ # 以下全て有効にすると起動が遅くなる - ("meiryob.ttc","メイリオ B",14.0) - ,("meiryo.ttc","メイリオ",14.0) - ,("YuGothM.ttc","遊ゴシック M",11.0) - ,("msgothic.ttc","MS ゴシック",11.0) - # ,("myricam.ttc","MyricaM",11.0) - ]) -else: # For Debian/Ubuntu - const fontInfo = TFontInfo( - osRootDir: "/" - ,fontDir: "usr/share/fonts" - ,fontTable: @[ - ("opentype/ipafont-gothic/ipag.ttf","IPAゴシック",12.0) - ,("opentype/ipafont-gothic/ipam.ttf","IPAゴシック M",12.0)]) - -proc setupFonts*(): (bool,string,string) = - ## return font first file name - - result = (false,"Default","ProggyClean.ttf") # - let io = igGetIO() - var seqFontNames: seq[(string,string)] - for (fontName,fontTitle,point) in fontInfo.fontTable: - let fontFullPath = os.joinPath(fontInfo.osRootDir, fontInfo.fontDir, fontName) - if os.fileExists(fontFullPath): - seqFontNames.add (fontName,fontTitle) - # フォントを追加 - io.fonts.addFontFromFileTTF(fontFullPath.cstring, point.point2px, - nil, io.fonts.getGlyphRangesJapanese()); - if seqFontNames.len > 0: - result = (true,seqFontNames[0][0].extractFilename ,seqFontNames[0][1]) - From ae7b916ca907385cbe3046c7f669dda974d0c8e3 Mon Sep 17 00:00:00 2001 From: dinau Date: Wed, 30 Aug 2023 12:24:26 +0900 Subject: [PATCH 15/25] simplified: impl_opengl.nim --- imgui.nimble | 2 +- src/imgui/imgui_impl_opengl_defs.nim | 59 -------------------- src/imgui/impl_opengl.nim | 80 +++++++++++++++------------- 3 files changed, 45 insertions(+), 96 deletions(-) delete mode 100644 src/imgui/imgui_impl_opengl_defs.nim diff --git a/imgui.nimble b/imgui.nimble index 8b3768f..c1c7081 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.8.3" +version = "1.89.8.4" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui/imgui_impl_opengl_defs.nim b/src/imgui/imgui_impl_opengl_defs.nim deleted file mode 100644 index 479bd43..0000000 --- a/src/imgui/imgui_impl_opengl_defs.nim +++ /dev/null @@ -1,59 +0,0 @@ - -from macros import hint - -when not declared(Imguiimplopengl3init): - proc Imguiimplopengl3init*(glslversion: cstring): cint {.cdecl, - importc: "ImGui_ImplOpenGL3_Init".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3init" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3shutdown): - proc Imguiimplopengl3shutdown*(): void {.cdecl, - importc: "ImGui_ImplOpenGL3_Shutdown".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3shutdown" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3newframe): - proc Imguiimplopengl3newframe*(): void {.cdecl, - importc: "ImGui_ImplOpenGL3_NewFrame".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3newframe" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3renderdrawdata): - proc Imguiimplopengl3renderdrawdata*(drawdata: ptr cint): void {.cdecl, - importc: "ImGui_ImplOpenGL3_RenderDrawData".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3renderdrawdata" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3createfontstexture): - proc Imguiimplopengl3createfontstexture*(): cint {.cdecl, - importc: "ImGui_ImplOpenGL3_CreateFontsTexture".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3createfontstexture" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3destroyfontstexture): - proc Imguiimplopengl3destroyfontstexture*(): void {.cdecl, - importc: "ImGui_ImplOpenGL3_DestroyFontsTexture".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3destroyfontstexture" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3createdeviceobjects): - proc Imguiimplopengl3createdeviceobjects*(): cint {.cdecl, - importc: "ImGui_ImplOpenGL3_CreateDeviceObjects".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3createdeviceobjects" & - " already exists, not redeclaring") -when not declared(Imguiimplopengl3destroydeviceobjects): - proc Imguiimplopengl3destroydeviceobjects*(): void {.cdecl, - importc: "ImGui_ImplOpenGL3_DestroyDeviceObjects".} -else: - static : - hint("Declaration of " & "Imguiimplopengl3destroydeviceobjects" & - " already exists, not redeclaring") \ No newline at end of file diff --git a/src/imgui/impl_opengl.nim b/src/imgui/impl_opengl.nim index 3c32363..44ccf60 100644 --- a/src/imgui/impl_opengl.nim +++ b/src/imgui/impl_opengl.nim @@ -2,48 +2,56 @@ when not defined(cpp) or defined(cimguiDLL): include "private/impl_opengl.nim" else: import std/[os,strutils] - proc currentSourceDir(): string {.compileTime.} = result = currentSourcePath().replace("\\", "/") result = result[0 ..< result.rfind("/")] -# Set source paths + # Set source paths const CImguiRootPath = joinpath(currentSourceDir() ,"private/cimgui") const ImguiRootPath = joinPath(CImguiRootPath,"imgui") - when defined(useFuthark): - const ClangIncludePath = "c:/drvDx/msys32/mingw32/opt/llvm-15/lib/clang/15.0.7/include" - import futhark - importc: - syspath ClangIncludePath - path CImguiRootPath - define "CIMGUI_USE_OPENGL3" - # Important definition CIMGUI_API for Futhark 0.9.3 - define "CIMGUI_API" - "generator/output/cimgui_impl.h" - outputPath "imgui_impl_opengl_defs.nim" - else: - {.push discardable,hint[XDeclaredButNotUsed]:off,hint[User]:off.} - include "imgui_impl_opengl_defs.nim" - {.pop.} - {.passC:"-I" & CImguiRootPath.} - {.passC:"-I" & ImguiRootPath.} - {.passC:"-DCIMGUI_USE_OPENGL3".} - #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} - {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} - {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} + {.passC:"-I" & CImguiRootPath.} + {.passC:"-I" & ImguiRootPath.} + {.passC:"-DCIMGUI_USE_OPENGL3".} + #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} + {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} + {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} - {.push discardable.} - proc igOpenGL3Init*(glslVersion:string): bool = - if 0 != Imguiimplopengl3init(glslVersion.cstring): - result = true - proc igOpenGL3Init*(): bool = - const glsl_version = "#version 130" # Default is OpenGL 3.3 - igOpenGl3Init(glsl_version) - proc igOpenGL3Shutdown*() = Imguiimplopengl3destroydeviceobjects() - proc igOpenGL3NewFrame*() = Imguiimplopengl3newframe() - proc igOpenGL3RenderDrawData*(data: pointer): cint = Imguiimplopengl3renderdrawdata(cast[ptr cint](data)) - proc igOpengl3DestroyFontsTexture*(): cint = Imguiimplopengl3destroyfontstexture() - proc igOpengl3DestroyDeviceObjects*(): cint = Imguiimplopengl3destroydeviceobjects() - {.pop.} + {.push discardable.} + proc ImGuiImplopengl3Init*(glslversion: cstring): cint {.cdecl, importc: "ImGui_ImplOpenGL3_Init".} + proc ImGuiImplopengl3RenderDrawData*(drawdata: ptr cint): void {.cdecl, importc: "ImGui_ImplOpenGL3_RenderDrawData".} + # + proc igOpenGL3Init*(glslVersion:string): bool = + 0 != ImGuiImplOpengl3Init(glslVersion.cstring) + proc igOpenGL3Init*(): bool = + const glsl_version = "#version 130" # Default is OpenGL 3.0 + igOpenGl3Init(glsl_version) + proc igOpenGL3Shutdown*() : void {.cdecl, importc: "ImGui_ImplOpenGL3_Shutdown".} + proc igOpenGL3NewFrame*() : void {.cdecl, importc: "ImGui_ImplOpenGL3_NewFrame".} + proc igOpenGL3RenderDrawData*(data: pointer): cint = + ImGuiImplOpengl3RenderDrawData(cast[ptr cint](data)) + proc igOpengl3CreateFontsTexture*(): cint {.cdecl, importc: "ImGui_ImplOpenGL3_CreateFontsTexture".} + proc igOpengl3DestroyFontsTexture*(): void {.cdecl, importc: "ImGui_ImplOpenGL3_DestroyFontsTexture".} + proc igOpengl3CreateDeviceObjects*(): cint {.cdecl, importc: "ImGui_ImplOpenGL3_CreateDeviceObjects".} + proc igOpengl3DestroyDeviceObjects*():void {.cdecl, importc: "ImGui_ImplOpenGL3_DestroyDeviceObjects".} + {.pop.} +#[ igOpenGl3Init(glsl_version) +//---------------------------------------- +// OpenGL GLSL GLSL +// version version string +//---------------------------------------- +// 2.0 110 "#version 110" +// 2.1 120 "#version 120" +// 3.0 130 "#version 130" +// 3.1 140 "#version 140" +// 3.2 150 "#version 150" +// 3.3 330 "#version 330 core" +// 4.0 400 "#version 400 core" +// 4.1 410 "#version 410 core" +// 4.2 420 "#version 410 core" +// 4.3 430 "#version 430 core" +// ES 2.0 100 "#version 100" = WebGL 1.0 +// ES 3.0 300 "#version 300 es" = WebGL 2.0 +//---------------------------------------- +]# From fb266b5ad660b09eb62c852d9697abe481d8e37b Mon Sep 17 00:00:00 2001 From: dinau Date: Sat, 9 Sep 2023 15:59:26 +0900 Subject: [PATCH 16/25] Changed: Enable VSync to reduce CPU load. --- tests/test.nim | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test.nim b/tests/test.nim index ca7672e..9784c41 100644 --- a/tests/test.nim +++ b/tests/test.nim @@ -18,6 +18,7 @@ proc main() = quit(-1) w.makeContextCurrent() + glfwSwapInterval(1) # Enable Vsync doAssert glInit() From c7d3421fead6406dc29495cd0082273cb1b12f79 Mon Sep 17 00:00:00 2001 From: dinau Date: Sat, 9 Sep 2023 16:00:27 +0900 Subject: [PATCH 17/25] Updated to ImGui v1.89.9 --- imgui.nimble | 2 +- src/imgui.nim | 23 +++++++++++++++++------ src/imgui/private/cimgui | 2 +- 3 files changed, 19 insertions(+), 8 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index c1c7081..b416bdb 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.8.4" +version = "1.89.9" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index 655f761..a4dd86f 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -634,6 +634,7 @@ type WindowingPopup = 6 WindowingUntitled = 7 DockingHideTabBar = 8 + DockingHoldShiftToDock = 9 ImGuiLogType* {.pure, size: int32.sizeof.} = enum None = 0 TTY = 1 @@ -1345,6 +1346,7 @@ type groupStack* {.importc: "GroupStack".}: ImVector[ImGuiGroupData] openPopupStack* {.importc: "OpenPopupStack".}: ImVector[ImGuiPopupData] beginPopupStack* {.importc: "BeginPopupStack".}: ImVector[ImGuiPopupData] + navTreeNodeStack* {.importc: "NavTreeNodeStack".}: ImVector[ImGuiNavTreeNodeData] beginMenuCount* {.importc: "BeginMenuCount".}: int32 viewports* {.importc: "Viewports".}: ImVector[ptr ImGuiViewportP] currentDpiScale* {.importc: "CurrentDpiScale".}: float32 @@ -1466,13 +1468,13 @@ type scrollbarClickDeltaToGrabCenter* {.importc: "ScrollbarClickDeltaToGrabCenter".}: float32 disabledAlphaBackup* {.importc: "DisabledAlphaBackup".}: float32 disabledStackSize* {.importc: "DisabledStackSize".}: int16 + lockMarkEdited* {.importc: "LockMarkEdited".}: int16 tooltipOverrideCount* {.importc: "TooltipOverrideCount".}: int16 clipboardHandlerData* {.importc: "ClipboardHandlerData".}: ImVector[int8] menusIdSubmittedThisFrame* {.importc: "MenusIdSubmittedThisFrame".}: ImVector[ImGuiID] platformImeData* {.importc: "PlatformImeData".}: ImGuiPlatformImeData platformImeDataPrev* {.importc: "PlatformImeDataPrev".}: ImGuiPlatformImeData platformImeViewport* {.importc: "PlatformImeViewport".}: ImGuiID - platformLocaleDecimalPoint* {.importc: "PlatformLocaleDecimalPoint".}: int8 dockContext* {.importc: "DockContext".}: ImGuiDockContext dockNodeWindowMenuHandler* {.importc: "DockNodeWindowMenuHandler".}: proc(ctx: ptr ImGuiContext, node: ptr ImGuiDockNode, tab_bar: ptr ImGuiTabBar): void {.cdecl, varargs.} settingsLoaded* {.importc: "SettingsLoaded".}: bool @@ -1483,7 +1485,7 @@ type settingsTables* {.importc: "SettingsTables".}: ImVector[ImGuiTableSettings] hooks* {.importc: "Hooks".}: ImVector[ImGuiContextHook] hookIdNext* {.importc: "HookIdNext".}: ImGuiID - localizationTable* {.importc: "LocalizationTable".}: array[9, cstring] + localizationTable* {.importc: "LocalizationTable".}: array[10, cstring] logEnabled* {.importc: "LogEnabled".}: bool logType* {.importc: "LogType".}: ImGuiLogType logFile* {.importc: "LogFile".}: ImFileHandle @@ -1642,6 +1644,7 @@ type clipboardUserData* {.importc: "ClipboardUserData".}: pointer setPlatformImeDataFn* {.importc: "SetPlatformImeDataFn".}: proc(viewport: ptr ImGuiViewport, data: ptr ImGuiPlatformImeData): void {.cdecl, varargs.} unusedPadding* {.importc: "_UnusedPadding".}: pointer + platformLocaleDecimalPoint* {.importc: "PlatformLocaleDecimalPoint".}: ImWchar wantCaptureMouse* {.importc: "WantCaptureMouse".}: bool wantCaptureKeyboard* {.importc: "WantCaptureKeyboard".}: bool wantTextInput* {.importc: "WantTextInput".}: bool @@ -1831,6 +1834,10 @@ type distBox* {.importc: "DistBox".}: float32 distCenter* {.importc: "DistCenter".}: float32 distAxial* {.importc: "DistAxial".}: float32 + ImGuiNavTreeNodeData* {.importc: "ImGuiNavTreeNodeData", imgui_header.} = object + id* {.importc: "ID".}: ImGuiID + inFlags* {.importc: "InFlags".}: ImGuiItemFlags + navRect* {.importc: "NavRect".}: ImRect ImGuiNextItemData* {.importc: "ImGuiNextItemData", imgui_header.} = object flags* {.importc: "Flags".}: ImGuiNextItemDataFlags itemFlags* {.importc: "ItemFlags".}: ImGuiItemFlags @@ -2105,6 +2112,7 @@ type rowPosY1* {.importc: "RowPosY1".}: float32 rowPosY2* {.importc: "RowPosY2".}: float32 rowMinHeight* {.importc: "RowMinHeight".}: float32 + rowCellPaddingY* {.importc: "RowCellPaddingY".}: float32 rowTextBaseline* {.importc: "RowTextBaseline".}: float32 rowIndentOffsetX* {.importc: "RowIndentOffsetX".}: float32 rowFlags* {.importc: "RowFlags".}: ImGuiTableRowFlags @@ -2119,7 +2127,6 @@ type minColumnWidth* {.importc: "MinColumnWidth".}: float32 outerPaddingX* {.importc: "OuterPaddingX".}: float32 cellPaddingX* {.importc: "CellPaddingX".}: float32 - cellPaddingY* {.importc: "CellPaddingY".}: float32 cellSpacingX1* {.importc: "CellSpacingX1".}: float32 cellSpacingX2* {.importc: "CellSpacingX2".}: float32 innerWidth* {.importc: "InnerWidth".}: float32 @@ -2321,8 +2328,8 @@ type lastAlpha* {.importc: "LastAlpha".}: float32 lastFocusedHadNavWindow* {.importc: "LastFocusedHadNavWindow".}: bool platformMonitor* {.importc: "PlatformMonitor".}: int16 - drawListsLastFrame* {.importc: "DrawListsLastFrame".}: array[2, int32] - drawLists* {.importc: "DrawLists".}: array[2, ptr ImDrawList] + bgFgDrawListsLastFrame* {.importc: "BgFgDrawListsLastFrame".}: array[2, int32] + bgFgDrawLists* {.importc: "BgFgDrawLists".}: array[2, ptr ImDrawList] drawDataP* {.importc: "DrawDataP".}: ImDrawData drawDataBuilder* {.importc: "DrawDataBuilder".}: ImDrawDataBuilder lastPlatformPos* {.importc: "LastPlatformPos".}: ImVec2 @@ -2838,7 +2845,8 @@ proc fromPositions*(y1: float32, y2: float32, off_min: int32, off_max: int32): I proc begin*(self: ptr ImGuiListClipper, items_count: int32, items_height: float32 = -1.0f): void {.importc: "ImGuiListClipper_Begin".} proc `end`*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_End".} proc newImGuiListClipper*(): void {.importc: "ImGuiListClipper_ImGuiListClipper".} -proc includeRangeByIndices*(self: ptr ImGuiListClipper, item_begin: int32, item_end: int32): void {.importc: "ImGuiListClipper_IncludeRangeByIndices".} +proc includeItemByIndex*(self: ptr ImGuiListClipper, item_index: int32): void {.importc: "ImGuiListClipper_IncludeItemByIndex".} +proc includeItemsByIndex*(self: ptr ImGuiListClipper, item_begin: int32, item_end: int32): void {.importc: "ImGuiListClipper_IncludeItemsByIndex".} proc step*(self: ptr ImGuiListClipper): bool {.importc: "ImGuiListClipper_Step".} proc destroy*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_destroy".} proc calcNextTotalWidth*(self: ptr ImGuiMenuColumns, update_offsets: bool): void {.importc: "ImGuiMenuColumns_CalcNextTotalWidth".} @@ -3209,7 +3217,9 @@ proc igDataTypeCompare*(data_type: ImGuiDataType, arg_1: pointer, arg_2: pointer proc igDataTypeFormatString*(buf: cstring, buf_size: int32, data_type: ImGuiDataType, p_data: pointer, format: cstring): int32 {.importc: "igDataTypeFormatString".} proc igDataTypeGetInfo*(data_type: ImGuiDataType): ptr ImGuiDataTypeInfo {.importc: "igDataTypeGetInfo".} proc igDebugCheckVersionAndDataLayout*(version_str: cstring, sz_io: uint, sz_style: uint, sz_vec2: uint, sz_vec4: uint, sz_drawvert: uint, sz_drawidx: uint): bool {.importc: "igDebugCheckVersionAndDataLayout".} +proc igDebugDrawCursorPos*(col: uint32 = 4278190335'u32): void {.importc: "igDebugDrawCursorPos".} proc igDebugDrawItemRect*(col: uint32 = 4278190335'u32): void {.importc: "igDebugDrawItemRect".} +proc igDebugDrawLineExtents*(col: uint32 = 4278190335'u32): void {.importc: "igDebugDrawLineExtents".} proc igDebugHookIdInfo*(id: ImGuiID, data_type: ImGuiDataType, data_id: pointer, data_id_end: pointer): void {.importc: "igDebugHookIdInfo".} proc igDebugLocateItem*(target_id: ImGuiID): void {.importc: "igDebugLocateItem".} proc igDebugLocateItemOnHover*(target_id: ImGuiID): void {.importc: "igDebugLocateItemOnHover".} @@ -3667,6 +3677,7 @@ proc igNavMoveRequestButNoResultYet*(): bool {.importc: "igNavMoveRequestButNoRe proc igNavMoveRequestCancel*(): void {.importc: "igNavMoveRequestCancel".} proc igNavMoveRequestForward*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags: ImGuiNavMoveFlags, scroll_flags: ImGuiScrollFlags): void {.importc: "igNavMoveRequestForward".} proc igNavMoveRequestResolveWithLastItem*(result: ptr ImGuiNavItemData): void {.importc: "igNavMoveRequestResolveWithLastItem".} +proc igNavMoveRequestResolveWithPastTreeNode*(result: ptr ImGuiNavItemData, tree_node_data: ptr ImGuiNavTreeNodeData): void {.importc: "igNavMoveRequestResolveWithPastTreeNode".} proc igNavMoveRequestSubmit*(move_dir: ImGuiDir, clip_dir: ImGuiDir, move_flags: ImGuiNavMoveFlags, scroll_flags: ImGuiScrollFlags): void {.importc: "igNavMoveRequestSubmit".} proc igNavMoveRequestTryWrapping*(window: ptr ImGuiWindow, move_flags: ImGuiNavMoveFlags): void {.importc: "igNavMoveRequestTryWrapping".} proc igNavUpdateCurrentWindowIsScrollPushableX*(): void {.importc: "igNavUpdateCurrentWindowIsScrollPushableX".} diff --git a/src/imgui/private/cimgui b/src/imgui/private/cimgui index 35fc7d1..44769f6 160000 --- a/src/imgui/private/cimgui +++ b/src/imgui/private/cimgui @@ -1 +1 @@ -Subproject commit 35fc7d191e4d1eb2b41d20fef2298b7d4a65bfdf +Subproject commit 44769f63d49bc747a2291d0e04f44876849de3a5 From 01950d1f6257a02979655bdf7154af6ff7d72b0e Mon Sep 17 00:00:00 2001 From: dinau Date: Fri, 15 Sep 2023 19:01:21 +0900 Subject: [PATCH 18/25] Silent warning --- src/imgui/impl_glfw.nim | 4 ++-- tests/config.nims | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/imgui/impl_glfw.nim b/src/imgui/impl_glfw.nim index 5c4a923..210212a 100644 --- a/src/imgui/impl_glfw.nim +++ b/src/imgui/impl_glfw.nim @@ -30,10 +30,10 @@ var gPrevKeyCallback: GLFWKeyFun = nil gPrevCharCallback: GLFWCharFun = nil -proc igGlfwGetClipboardText(userData: pointer): cstring {.cdecl.} = +proc igGlfwGetClipboardText(userData: pointer): cstring {.cdecl,used.} = cast[GLFWwindow](userData).getClipboardString() -proc igGlfwSetClipboardText(userData: pointer, text: cstring): void {.cdecl.} = +proc igGlfwSetClipboardText(userData: pointer, text: cstring): void {.cdecl,used.} = cast[GLFWwindow](userData).setClipboardString(text) proc igGlfwMouseCallback*(window: GLFWWindow, button: int32, action: int32, mods: int32): void {.cdecl.} = diff --git a/tests/config.nims b/tests/config.nims index 3bb69f8..d085b4b 100644 --- a/tests/config.nims +++ b/tests/config.nims @@ -1 +1,2 @@ -switch("path", "$projectDir/../src") \ No newline at end of file +switch("path", "$projectDir/../src") +switch "warning","HoleEnumConv:off" From 92fe2351558fd69c07fb18272eb4309faedceaea Mon Sep 17 00:00:00 2001 From: dinau Date: Fri, 15 Sep 2023 19:05:11 +0900 Subject: [PATCH 19/25] fixed: Compilation error on (Linux) Debian 12 Bookworm --- src/imgui/impl_opengl.nim | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/imgui/impl_opengl.nim b/src/imgui/impl_opengl.nim index 44ccf60..fc48e0c 100644 --- a/src/imgui/impl_opengl.nim +++ b/src/imgui/impl_opengl.nim @@ -13,8 +13,9 @@ else: {.passC:"-I" & CImguiRootPath.} {.passC:"-I" & ImguiRootPath.} {.passC:"-DCIMGUI_USE_OPENGL3".} - #{.passC:"-DCIMGUI_API=\"extern \"C\"\" ".} - {.passC:""" -DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} + {.passC:"""-DCIMGUI_API="extern \"C\" " """.} + {.passC:"""-DIMGUI_IMPL_API="extern \"C\" " """.} + #{.passC:"""-DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_opengl3.cpp").} {.push discardable.} From 49b4f776ebf805f40187ad19dbb654fe22114dd6 Mon Sep 17 00:00:00 2001 From: dinau Date: Fri, 15 Sep 2023 19:16:41 +0900 Subject: [PATCH 20/25] avoided: Compile error on Linux --- imgui.nimble | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index b416bdb..405326b 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -17,9 +17,11 @@ task gen, "Generate bindings from source": task test, "Create window with imgui demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 exec("nim cpp -r tests/test.nim") - exec("nim c -r tests/test.nim") # requires cimgui.dll + when defined(windows): + exec("nim c -r tests/test.nim") # requires cimgui.dll task ci, "Create window with imgui null demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 exec("nim cpp -r tests/tnull.nim") - exec("nim c -r tests/tnull.nim") # requires cimgui.dll + when defined(windows): + exec("nim c -r tests/tnull.nim") # requires cimgui.dll From 2f8a4b57fef92c2a5b93fc692df67f5e3c22deb8 Mon Sep 17 00:00:00 2001 From: dinau Date: Fri, 15 Sep 2023 20:32:41 +0900 Subject: [PATCH 21/25] fixed: Version error --- imgui.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/imgui.nimble b/imgui.nimble index 405326b..c723805 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.9" +version = "1.89.9.2" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" From ae48a3606b32b987d6c7cc820364d428223815db Mon Sep 17 00:00:00 2001 From: dinau Date: Thu, 21 Sep 2023 20:57:22 +0900 Subject: [PATCH 22/25] added: Return type of constructor --- imgui.nimble | 2 +- src/imgui.nim | 190 ++++++++++++++++++++++---------------------- tools/generator.nim | 8 ++ 3 files changed, 104 insertions(+), 96 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index c723805..eca4c57 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.9.2" +version = "1.89.9.3" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" diff --git a/src/imgui.nim b/src/imgui.nim index a4dd86f..6bfc2c2 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -2583,7 +2583,7 @@ else: proc clearAllBits*(self: ptr uint32): void {.importc: "ImBitArray_ClearAllBits".} proc clearBit*(self: ptr uint32, n: int32): void {.importc: "ImBitArray_ClearBit".} -proc newImBitArray*(): void {.importc: "ImBitArray_ImBitArray".} +proc newImBitArray*(): ptr ImBitArrayPtr {.importc: "ImBitArray_ImBitArray".} proc setAllBits*(self: ptr uint32): void {.importc: "ImBitArray_SetAllBits".} proc setBit*(self: ptr uint32, n: int32): void {.importc: "ImBitArray_SetBit".} proc setBitRange*(self: ptr uint32, n: int32, n2: int32): void {.importc: "ImBitArray_SetBitRange".} @@ -2606,30 +2606,30 @@ proc ptr_from_offset*[T](self: ptr ImChunkStream, off: int32): ptr T {.importc: proc size*(self: ptr ImChunkStream): int32 {.importc: "ImChunkStream_size".} proc swap*(self: ptr ImChunkStream, rhs: ptr ImChunkStream): void {.importc: "ImChunkStream_swap".} proc hSVNonUDT*(pOut: ptr ImColor, h: float32, s: float32, v: float32, a: float32 = 1.0f): void {.importc: "ImColor_HSV".} -proc newImColor*(): void {.importc: "ImColor_ImColor_Nil".} -proc newImColor*(r: float32, g: float32, b: float32, a: float32 = 1.0f): void {.importc: "ImColor_ImColor_Float".} -proc newImColor*(col: ImVec4): void {.importc: "ImColor_ImColor_Vec4".} -proc newImColor*(r: int32, g: int32, b: int32, a: int32 = 255): void {.importc: "ImColor_ImColor_Int".} -proc newImColor*(rgba: uint32): void {.importc: "ImColor_ImColor_U32".} +proc newImColor*(): ptr ImColor {.importc: "ImColor_ImColor_Nil".} +proc newImColor*(r: float32, g: float32, b: float32, a: float32 = 1.0f): ptr ImColor {.importc: "ImColor_ImColor_Float".} +proc newImColor*(col: ImVec4): ptr ImColor {.importc: "ImColor_ImColor_Vec4".} +proc newImColor*(r: int32, g: int32, b: int32, a: int32 = 255): ptr ImColor {.importc: "ImColor_ImColor_Int".} +proc newImColor*(rgba: uint32): ptr ImColor {.importc: "ImColor_ImColor_U32".} proc setHSV*(self: ptr ImColor, h: float32, s: float32, v: float32, a: float32 = 1.0f): void {.importc: "ImColor_SetHSV".} proc destroy*(self: ptr ImColor): void {.importc: "ImColor_destroy".} proc getTexID*(self: ptr ImDrawCmd): ImTextureID {.importc: "ImDrawCmd_GetTexID".} -proc newImDrawCmd*(): void {.importc: "ImDrawCmd_ImDrawCmd".} +proc newImDrawCmd*(): ptr ImDrawCmd {.importc: "ImDrawCmd_ImDrawCmd".} proc destroy*(self: ptr ImDrawCmd): void {.importc: "ImDrawCmd_destroy".} -proc newImDrawDataBuilder*(): void {.importc: "ImDrawDataBuilder_ImDrawDataBuilder".} +proc newImDrawDataBuilder*(): ptr ImDrawDataBuilder {.importc: "ImDrawDataBuilder_ImDrawDataBuilder".} proc destroy*(self: ptr ImDrawDataBuilder): void {.importc: "ImDrawDataBuilder_destroy".} proc addDrawList*(self: ptr ImDrawData, draw_list: ptr ImDrawList): void {.importc: "ImDrawData_AddDrawList".} proc clear*(self: ptr ImDrawData): void {.importc: "ImDrawData_Clear".} proc deIndexAllBuffers*(self: ptr ImDrawData): void {.importc: "ImDrawData_DeIndexAllBuffers".} -proc newImDrawData*(): void {.importc: "ImDrawData_ImDrawData".} +proc newImDrawData*(): ptr ImDrawData {.importc: "ImDrawData_ImDrawData".} proc scaleClipRects*(self: ptr ImDrawData, fb_scale: ImVec2): void {.importc: "ImDrawData_ScaleClipRects".} proc destroy*(self: ptr ImDrawData): void {.importc: "ImDrawData_destroy".} -proc newImDrawListSharedData*(): void {.importc: "ImDrawListSharedData_ImDrawListSharedData".} +proc newImDrawListSharedData*(): ptr ImDrawListSharedData {.importc: "ImDrawListSharedData_ImDrawListSharedData".} proc setCircleTessellationMaxError*(self: ptr ImDrawListSharedData, max_error: float32): void {.importc: "ImDrawListSharedData_SetCircleTessellationMaxError".} proc destroy*(self: ptr ImDrawListSharedData): void {.importc: "ImDrawListSharedData_destroy".} proc clear*(self: ptr ImDrawListSplitter): void {.importc: "ImDrawListSplitter_Clear".} proc clearFreeMemory*(self: ptr ImDrawListSplitter): void {.importc: "ImDrawListSplitter_ClearFreeMemory".} -proc newImDrawListSplitter*(): void {.importc: "ImDrawListSplitter_ImDrawListSplitter".} +proc newImDrawListSplitter*(): ptr ImDrawListSplitter {.importc: "ImDrawListSplitter_ImDrawListSplitter".} proc merge*(self: ptr ImDrawListSplitter, draw_list: ptr ImDrawList): void {.importc: "ImDrawListSplitter_Merge".} proc setCurrentChannel*(self: ptr ImDrawListSplitter, draw_list: ptr ImDrawList, channel_idx: int32): void {.importc: "ImDrawListSplitter_SetCurrentChannel".} proc split*(self: ptr ImDrawListSplitter, draw_list: ptr ImDrawList, count: int32): void {.importc: "ImDrawListSplitter_Split".} @@ -2663,7 +2663,7 @@ proc channelsSplit*(self: ptr ImDrawList, count: int32): void {.importc: "ImDraw proc cloneOutput*(self: ptr ImDrawList): ptr ImDrawList {.importc: "ImDrawList_CloneOutput".} proc getClipRectMaxNonUDT*(pOut: ptr ImVec2, self: ptr ImDrawList): void {.importc: "ImDrawList_GetClipRectMax".} proc getClipRectMinNonUDT*(pOut: ptr ImVec2, self: ptr ImDrawList): void {.importc: "ImDrawList_GetClipRectMin".} -proc newImDrawList*(shared_data: ptr ImDrawListSharedData): void {.importc: "ImDrawList_ImDrawList".} +proc newImDrawList*(shared_data: ptr ImDrawListSharedData): ptr ImDrawList {.importc: "ImDrawList_ImDrawList".} proc pathArcTo*(self: ptr ImDrawList, center: ImVec2, radius: float32, a_min: float32, a_max: float32, num_segments: int32 = 0): void {.importc: "ImDrawList_PathArcTo".} proc pathArcToFast*(self: ptr ImDrawList, center: ImVec2, radius: float32, a_min_of_12: int32, a_max_of_12: int32): void {.importc: "ImDrawList_PathArcToFast".} proc pathBezierCubicCurveTo*(self: ptr ImDrawList, p2: ImVec2, p3: ImVec2, p4: ImVec2, num_segments: int32 = 0): void {.importc: "ImDrawList_PathBezierCubicCurveTo".} @@ -2698,7 +2698,7 @@ proc PopUnusedDrawCmd*(self: ptr ImDrawList): void {.importc: "ImDrawList__PopUn proc ResetForNewFrame*(self: ptr ImDrawList): void {.importc: "ImDrawList__ResetForNewFrame".} proc TryMergeDrawCmds*(self: ptr ImDrawList): void {.importc: "ImDrawList__TryMergeDrawCmds".} proc destroy*(self: ptr ImDrawList): void {.importc: "ImDrawList_destroy".} -proc newImFontAtlasCustomRect*(): void {.importc: "ImFontAtlasCustomRect_ImFontAtlasCustomRect".} +proc newImFontAtlasCustomRect*(): ptr ImFontAtlasCustomRect {.importc: "ImFontAtlasCustomRect_ImFontAtlasCustomRect".} proc isPacked*(self: ptr ImFontAtlasCustomRect): bool {.importc: "ImFontAtlasCustomRect_IsPacked".} proc destroy*(self: ptr ImFontAtlasCustomRect): void {.importc: "ImFontAtlasCustomRect_destroy".} proc addCustomRectFontGlyph*(self: ptr ImFontAtlas, font: ptr ImFont, id: ImWchar, width: int32, height: int32, advance_x: float32, offset: ImVec2 = ImVec2(x: 0, y: 0)): int32 {.importc: "ImFontAtlas_AddCustomRectFontGlyph".} @@ -2728,11 +2728,11 @@ proc getGlyphRangesVietnamese*(self: ptr ImFontAtlas): ptr ImWchar {.importc: "I proc getMouseCursorTexData*(self: ptr ImFontAtlas, cursor: ImGuiMouseCursor, out_offset: ptr ImVec2, out_size: ptr ImVec2, out_uv_border: var array[2, ImVec2], out_uv_fill: var array[2, ImVec2]): bool {.importc: "ImFontAtlas_GetMouseCursorTexData".} proc getTexDataAsAlpha8*(self: ptr ImFontAtlas, out_pixels: ptr ptr uint8, out_width: ptr int32, out_height: ptr int32, out_bytes_per_pixel: ptr int32 = nil): void {.importc: "ImFontAtlas_GetTexDataAsAlpha8".} proc getTexDataAsRGBA32*(self: ptr ImFontAtlas, out_pixels: ptr ptr uint8, out_width: ptr int32, out_height: ptr int32, out_bytes_per_pixel: ptr int32 = nil): void {.importc: "ImFontAtlas_GetTexDataAsRGBA32".} -proc newImFontAtlas*(): void {.importc: "ImFontAtlas_ImFontAtlas".} +proc newImFontAtlas*(): ptr ImFontAtlas {.importc: "ImFontAtlas_ImFontAtlas".} proc isBuilt*(self: ptr ImFontAtlas): bool {.importc: "ImFontAtlas_IsBuilt".} proc setTexID*(self: ptr ImFontAtlas, id: ImTextureID): void {.importc: "ImFontAtlas_SetTexID".} proc destroy*(self: ptr ImFontAtlas): void {.importc: "ImFontAtlas_destroy".} -proc newImFontConfig*(): void {.importc: "ImFontConfig_ImFontConfig".} +proc newImFontConfig*(): ptr ImFontConfig {.importc: "ImFontConfig_ImFontConfig".} proc destroy*(self: ptr ImFontConfig): void {.importc: "ImFontConfig_destroy".} proc addChar*(self: ptr ImFontGlyphRangesBuilder, c: ImWchar): void {.importc: "ImFontGlyphRangesBuilder_AddChar".} proc addRanges*(self: ptr ImFontGlyphRangesBuilder, ranges: ptr ImWchar): void {.importc: "ImFontGlyphRangesBuilder_AddRanges".} @@ -2740,7 +2740,7 @@ proc addText*(self: ptr ImFontGlyphRangesBuilder, text: cstring, text_end: cstri proc buildRanges*(self: ptr ImFontGlyphRangesBuilder, out_ranges: ptr ImVector[ImWchar]): void {.importc: "ImFontGlyphRangesBuilder_BuildRanges".} proc clear*(self: ptr ImFontGlyphRangesBuilder): void {.importc: "ImFontGlyphRangesBuilder_Clear".} proc getBit*(self: ptr ImFontGlyphRangesBuilder, n: uint): bool {.importc: "ImFontGlyphRangesBuilder_GetBit".} -proc newImFontGlyphRangesBuilder*(): void {.importc: "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder".} +proc newImFontGlyphRangesBuilder*(): ptr ImFontGlyphRangesBuilder {.importc: "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder".} proc setBit*(self: ptr ImFontGlyphRangesBuilder, n: uint): void {.importc: "ImFontGlyphRangesBuilder_SetBit".} proc destroy*(self: ptr ImFontGlyphRangesBuilder): void {.importc: "ImFontGlyphRangesBuilder_destroy".} proc addGlyph*(self: ptr ImFont, src_cfg: ptr ImFontConfig, c: ImWchar, x0: float32, y0: float32, x1: float32, y1: float32, u0: float32, v0: float32, u1: float32, v1: float32, advance_x: float32): void {.importc: "ImFont_AddGlyph".} @@ -2754,23 +2754,23 @@ proc findGlyphNoFallback*(self: ptr ImFont, c: ImWchar): ptr ImFontGlyph {.impor proc getCharAdvance*(self: ptr ImFont, c: ImWchar): float32 {.importc: "ImFont_GetCharAdvance".} proc getDebugName*(self: ptr ImFont): cstring {.importc: "ImFont_GetDebugName".} proc growIndex*(self: ptr ImFont, new_size: int32): void {.importc: "ImFont_GrowIndex".} -proc newImFont*(): void {.importc: "ImFont_ImFont".} +proc newImFont*(): ptr ImFont {.importc: "ImFont_ImFont".} proc isGlyphRangeUnused*(self: ptr ImFont, c_begin: uint32, c_last: uint32): bool {.importc: "ImFont_IsGlyphRangeUnused".} proc isLoaded*(self: ptr ImFont): bool {.importc: "ImFont_IsLoaded".} proc renderChar*(self: ptr ImFont, draw_list: ptr ImDrawList, size: float32, pos: ImVec2, col: uint32, c: ImWchar): void {.importc: "ImFont_RenderChar".} proc renderText*(self: ptr ImFont, draw_list: ptr ImDrawList, size: float32, pos: ImVec2, col: uint32, clip_rect: ImVec4, text_begin: cstring, text_end: cstring, wrap_width: float32 = 0.0f, cpu_fine_clip: bool = false): void {.importc: "ImFont_RenderText".} proc setGlyphVisible*(self: ptr ImFont, c: ImWchar, visible: bool): void {.importc: "ImFont_SetGlyphVisible".} proc destroy*(self: ptr ImFont): void {.importc: "ImFont_destroy".} -proc newImGuiComboPreviewData*(): void {.importc: "ImGuiComboPreviewData_ImGuiComboPreviewData".} +proc newImGuiComboPreviewData*(): ptr ImGuiComboPreviewData {.importc: "ImGuiComboPreviewData_ImGuiComboPreviewData".} proc destroy*(self: ptr ImGuiComboPreviewData): void {.importc: "ImGuiComboPreviewData_destroy".} -proc newImGuiContextHook*(): void {.importc: "ImGuiContextHook_ImGuiContextHook".} +proc newImGuiContextHook*(): ptr ImGuiContextHook {.importc: "ImGuiContextHook_ImGuiContextHook".} proc destroy*(self: ptr ImGuiContextHook): void {.importc: "ImGuiContextHook_destroy".} -proc newImGuiContext*(shared_font_atlas: ptr ImFontAtlas): void {.importc: "ImGuiContext_ImGuiContext".} +proc newImGuiContext*(shared_font_atlas: ptr ImFontAtlas): ptr ImGuiContext {.importc: "ImGuiContext_ImGuiContext".} proc destroy*(self: ptr ImGuiContext): void {.importc: "ImGuiContext_destroy".} proc getVarPtr*(self: ptr ImGuiDataVarInfo, parent: pointer): pointer {.importc: "ImGuiDataVarInfo_GetVarPtr".} -proc newImGuiDockContext*(): void {.importc: "ImGuiDockContext_ImGuiDockContext".} +proc newImGuiDockContext*(): ptr ImGuiDockContext {.importc: "ImGuiDockContext_ImGuiDockContext".} proc destroy*(self: ptr ImGuiDockContext): void {.importc: "ImGuiDockContext_destroy".} -proc newImGuiDockNode*(id: ImGuiID): void {.importc: "ImGuiDockNode_ImGuiDockNode".} +proc newImGuiDockNode*(id: ImGuiID): ptr ImGuiDockNode {.importc: "ImGuiDockNode_ImGuiDockNode".} proc isCentralNode*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsCentralNode".} proc isDockSpace*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsDockSpace".} proc isEmpty*(self: ptr ImGuiDockNode): bool {.importc: "ImGuiDockNode_IsEmpty".} @@ -2797,21 +2797,21 @@ proc addMouseViewportEvent*(self: ptr ImGuiIO, id: ImGuiID): void {.importc: "Im proc addMouseWheelEvent*(self: ptr ImGuiIO, wheel_x: float32, wheel_y: float32): void {.importc: "ImGuiIO_AddMouseWheelEvent".} proc clearEventsQueue*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearEventsQueue".} proc clearInputKeys*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_ClearInputKeys".} -proc newImGuiIO*(): void {.importc: "ImGuiIO_ImGuiIO".} +proc newImGuiIO*(): ptr ImGuiIO {.importc: "ImGuiIO_ImGuiIO".} proc setAppAcceptingEvents*(self: ptr ImGuiIO, accepting_events: bool): void {.importc: "ImGuiIO_SetAppAcceptingEvents".} proc setKeyEventNativeData*(self: ptr ImGuiIO, key: ImGuiKey, native_keycode: int32, native_scancode: int32, native_legacy_index: int32 = -1): void {.importc: "ImGuiIO_SetKeyEventNativeData".} proc destroy*(self: ptr ImGuiIO): void {.importc: "ImGuiIO_destroy".} -proc newImGuiInputEvent*(): void {.importc: "ImGuiInputEvent_ImGuiInputEvent".} +proc newImGuiInputEvent*(): ptr ImGuiInputEvent {.importc: "ImGuiInputEvent_ImGuiInputEvent".} proc destroy*(self: ptr ImGuiInputEvent): void {.importc: "ImGuiInputEvent_destroy".} proc clearSelection*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_ClearSelection".} proc deleteChars*(self: ptr ImGuiInputTextCallbackData, pos: int32, bytes_count: int32): void {.importc: "ImGuiInputTextCallbackData_DeleteChars".} proc hasSelection*(self: ptr ImGuiInputTextCallbackData): bool {.importc: "ImGuiInputTextCallbackData_HasSelection".} -proc newImGuiInputTextCallbackData*(): void {.importc: "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData".} +proc newImGuiInputTextCallbackData*(): ptr ImGuiInputTextCallbackData {.importc: "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData".} proc insertChars*(self: ptr ImGuiInputTextCallbackData, pos: int32, text: cstring, text_end: cstring = nil): void {.importc: "ImGuiInputTextCallbackData_InsertChars".} proc selectAll*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_SelectAll".} proc destroy*(self: ptr ImGuiInputTextCallbackData): void {.importc: "ImGuiInputTextCallbackData_destroy".} proc clearFreeMemory*(self: ptr ImGuiInputTextDeactivatedState): void {.importc: "ImGuiInputTextDeactivatedState_ClearFreeMemory".} -proc newImGuiInputTextDeactivatedState*(): void {.importc: "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState".} +proc newImGuiInputTextDeactivatedState*(): ptr ImGuiInputTextDeactivatedState {.importc: "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState".} proc destroy*(self: ptr ImGuiInputTextDeactivatedState): void {.importc: "ImGuiInputTextDeactivatedState_destroy".} proc clearFreeMemory*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_ClearFreeMemory".} proc clearSelection*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_ClearSelection".} @@ -2824,81 +2824,81 @@ proc getSelectionEnd*(self: ptr ImGuiInputTextState): int32 {.importc: "ImGuiInp proc getSelectionStart*(self: ptr ImGuiInputTextState): int32 {.importc: "ImGuiInputTextState_GetSelectionStart".} proc getUndoAvailCount*(self: ptr ImGuiInputTextState): int32 {.importc: "ImGuiInputTextState_GetUndoAvailCount".} proc hasSelection*(self: ptr ImGuiInputTextState): bool {.importc: "ImGuiInputTextState_HasSelection".} -proc newImGuiInputTextState*(): void {.importc: "ImGuiInputTextState_ImGuiInputTextState".} +proc newImGuiInputTextState*(): ptr ImGuiInputTextState {.importc: "ImGuiInputTextState_ImGuiInputTextState".} proc onKeyPressed*(self: ptr ImGuiInputTextState, key: int32): void {.importc: "ImGuiInputTextState_OnKeyPressed".} proc selectAll*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_SelectAll".} proc destroy*(self: ptr ImGuiInputTextState): void {.importc: "ImGuiInputTextState_destroy".} -proc newImGuiKeyOwnerData*(): void {.importc: "ImGuiKeyOwnerData_ImGuiKeyOwnerData".} +proc newImGuiKeyOwnerData*(): ptr ImGuiKeyOwnerData {.importc: "ImGuiKeyOwnerData_ImGuiKeyOwnerData".} proc destroy*(self: ptr ImGuiKeyOwnerData): void {.importc: "ImGuiKeyOwnerData_destroy".} -proc newImGuiKeyRoutingData*(): void {.importc: "ImGuiKeyRoutingData_ImGuiKeyRoutingData".} +proc newImGuiKeyRoutingData*(): ptr ImGuiKeyRoutingData {.importc: "ImGuiKeyRoutingData_ImGuiKeyRoutingData".} proc destroy*(self: ptr ImGuiKeyRoutingData): void {.importc: "ImGuiKeyRoutingData_destroy".} proc clear*(self: ptr ImGuiKeyRoutingTable): void {.importc: "ImGuiKeyRoutingTable_Clear".} -proc newImGuiKeyRoutingTable*(): void {.importc: "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable".} +proc newImGuiKeyRoutingTable*(): ptr ImGuiKeyRoutingTable {.importc: "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable".} proc destroy*(self: ptr ImGuiKeyRoutingTable): void {.importc: "ImGuiKeyRoutingTable_destroy".} -proc newImGuiLastItemData*(): void {.importc: "ImGuiLastItemData_ImGuiLastItemData".} +proc newImGuiLastItemData*(): ptr ImGuiLastItemData {.importc: "ImGuiLastItemData_ImGuiLastItemData".} proc destroy*(self: ptr ImGuiLastItemData): void {.importc: "ImGuiLastItemData_destroy".} -proc newImGuiListClipperData*(): void {.importc: "ImGuiListClipperData_ImGuiListClipperData".} +proc newImGuiListClipperData*(): ptr ImGuiListClipperData {.importc: "ImGuiListClipperData_ImGuiListClipperData".} proc reset*(self: ptr ImGuiListClipperData, clipper: ptr ImGuiListClipper): void {.importc: "ImGuiListClipperData_Reset".} proc destroy*(self: ptr ImGuiListClipperData): void {.importc: "ImGuiListClipperData_destroy".} proc fromIndices*(min: int32, max: int32): ImGuiListClipperRange {.importc: "ImGuiListClipperRange_FromIndices".} proc fromPositions*(y1: float32, y2: float32, off_min: int32, off_max: int32): ImGuiListClipperRange {.importc: "ImGuiListClipperRange_FromPositions".} proc begin*(self: ptr ImGuiListClipper, items_count: int32, items_height: float32 = -1.0f): void {.importc: "ImGuiListClipper_Begin".} proc `end`*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_End".} -proc newImGuiListClipper*(): void {.importc: "ImGuiListClipper_ImGuiListClipper".} +proc newImGuiListClipper*(): ptr ImGuiListClipper {.importc: "ImGuiListClipper_ImGuiListClipper".} proc includeItemByIndex*(self: ptr ImGuiListClipper, item_index: int32): void {.importc: "ImGuiListClipper_IncludeItemByIndex".} proc includeItemsByIndex*(self: ptr ImGuiListClipper, item_begin: int32, item_end: int32): void {.importc: "ImGuiListClipper_IncludeItemsByIndex".} proc step*(self: ptr ImGuiListClipper): bool {.importc: "ImGuiListClipper_Step".} proc destroy*(self: ptr ImGuiListClipper): void {.importc: "ImGuiListClipper_destroy".} proc calcNextTotalWidth*(self: ptr ImGuiMenuColumns, update_offsets: bool): void {.importc: "ImGuiMenuColumns_CalcNextTotalWidth".} proc declColumns*(self: ptr ImGuiMenuColumns, w_icon: float32, w_label: float32, w_shortcut: float32, w_mark: float32): float32 {.importc: "ImGuiMenuColumns_DeclColumns".} -proc newImGuiMenuColumns*(): void {.importc: "ImGuiMenuColumns_ImGuiMenuColumns".} +proc newImGuiMenuColumns*(): ptr ImGuiMenuColumns {.importc: "ImGuiMenuColumns_ImGuiMenuColumns".} proc update*(self: ptr ImGuiMenuColumns, spacing: float32, window_reappearing: bool): void {.importc: "ImGuiMenuColumns_Update".} proc destroy*(self: ptr ImGuiMenuColumns): void {.importc: "ImGuiMenuColumns_destroy".} proc clear*(self: ptr ImGuiNavItemData): void {.importc: "ImGuiNavItemData_Clear".} -proc newImGuiNavItemData*(): void {.importc: "ImGuiNavItemData_ImGuiNavItemData".} +proc newImGuiNavItemData*(): ptr ImGuiNavItemData {.importc: "ImGuiNavItemData_ImGuiNavItemData".} proc destroy*(self: ptr ImGuiNavItemData): void {.importc: "ImGuiNavItemData_destroy".} proc clearFlags*(self: ptr ImGuiNextItemData): void {.importc: "ImGuiNextItemData_ClearFlags".} -proc newImGuiNextItemData*(): void {.importc: "ImGuiNextItemData_ImGuiNextItemData".} +proc newImGuiNextItemData*(): ptr ImGuiNextItemData {.importc: "ImGuiNextItemData_ImGuiNextItemData".} proc destroy*(self: ptr ImGuiNextItemData): void {.importc: "ImGuiNextItemData_destroy".} proc clearFlags*(self: ptr ImGuiNextWindowData): void {.importc: "ImGuiNextWindowData_ClearFlags".} -proc newImGuiNextWindowData*(): void {.importc: "ImGuiNextWindowData_ImGuiNextWindowData".} +proc newImGuiNextWindowData*(): ptr ImGuiNextWindowData {.importc: "ImGuiNextWindowData_ImGuiNextWindowData".} proc destroy*(self: ptr ImGuiNextWindowData): void {.importc: "ImGuiNextWindowData_destroy".} -proc newImGuiOldColumnData*(): void {.importc: "ImGuiOldColumnData_ImGuiOldColumnData".} +proc newImGuiOldColumnData*(): ptr ImGuiOldColumnData {.importc: "ImGuiOldColumnData_ImGuiOldColumnData".} proc destroy*(self: ptr ImGuiOldColumnData): void {.importc: "ImGuiOldColumnData_destroy".} -proc newImGuiOldColumns*(): void {.importc: "ImGuiOldColumns_ImGuiOldColumns".} +proc newImGuiOldColumns*(): ptr ImGuiOldColumns {.importc: "ImGuiOldColumns_ImGuiOldColumns".} proc destroy*(self: ptr ImGuiOldColumns): void {.importc: "ImGuiOldColumns_destroy".} -proc newImGuiOnceUponAFrame*(): void {.importc: "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame".} +proc newImGuiOnceUponAFrame*(): ptr ImGuiOnceUponAFrame {.importc: "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame".} proc destroy*(self: ptr ImGuiOnceUponAFrame): void {.importc: "ImGuiOnceUponAFrame_destroy".} proc clear*(self: ptr ImGuiPayload): void {.importc: "ImGuiPayload_Clear".} -proc newImGuiPayload*(): void {.importc: "ImGuiPayload_ImGuiPayload".} +proc newImGuiPayload*(): ptr ImGuiPayload {.importc: "ImGuiPayload_ImGuiPayload".} proc isDataType*(self: ptr ImGuiPayload, `type`: cstring): bool {.importc: "ImGuiPayload_IsDataType".} proc isDelivery*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsDelivery".} proc isPreview*(self: ptr ImGuiPayload): bool {.importc: "ImGuiPayload_IsPreview".} proc destroy*(self: ptr ImGuiPayload): void {.importc: "ImGuiPayload_destroy".} -proc newImGuiPlatformIO*(): void {.importc: "ImGuiPlatformIO_ImGuiPlatformIO".} +proc newImGuiPlatformIO*(): ptr ImGuiPlatformIO {.importc: "ImGuiPlatformIO_ImGuiPlatformIO".} proc destroy*(self: ptr ImGuiPlatformIO): void {.importc: "ImGuiPlatformIO_destroy".} -proc newImGuiPlatformImeData*(): void {.importc: "ImGuiPlatformImeData_ImGuiPlatformImeData".} +proc newImGuiPlatformImeData*(): ptr ImGuiPlatformImeData {.importc: "ImGuiPlatformImeData_ImGuiPlatformImeData".} proc destroy*(self: ptr ImGuiPlatformImeData): void {.importc: "ImGuiPlatformImeData_destroy".} -proc newImGuiPlatformMonitor*(): void {.importc: "ImGuiPlatformMonitor_ImGuiPlatformMonitor".} +proc newImGuiPlatformMonitor*(): ptr ImGuiPlatformMonitor {.importc: "ImGuiPlatformMonitor_ImGuiPlatformMonitor".} proc destroy*(self: ptr ImGuiPlatformMonitor): void {.importc: "ImGuiPlatformMonitor_destroy".} -proc newImGuiPopupData*(): void {.importc: "ImGuiPopupData_ImGuiPopupData".} +proc newImGuiPopupData*(): ptr ImGuiPopupData {.importc: "ImGuiPopupData_ImGuiPopupData".} proc destroy*(self: ptr ImGuiPopupData): void {.importc: "ImGuiPopupData_destroy".} -proc newImGuiPtrOrIndex*(`ptr`: pointer): void {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr".} -proc newImGuiPtrOrIndex*(index: int32): void {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int".} +proc newImGuiPtrOrIndex*(`ptr`: pointer): ptr ImGuiPtrOrIndex {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr".} +proc newImGuiPtrOrIndex*(index: int32): ptr ImGuiPtrOrIndex {.importc: "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int".} proc destroy*(self: ptr ImGuiPtrOrIndex): void {.importc: "ImGuiPtrOrIndex_destroy".} -proc newImGuiSettingsHandler*(): void {.importc: "ImGuiSettingsHandler_ImGuiSettingsHandler".} +proc newImGuiSettingsHandler*(): ptr ImGuiSettingsHandler {.importc: "ImGuiSettingsHandler_ImGuiSettingsHandler".} proc destroy*(self: ptr ImGuiSettingsHandler): void {.importc: "ImGuiSettingsHandler_destroy".} -proc newImGuiStackLevelInfo*(): void {.importc: "ImGuiStackLevelInfo_ImGuiStackLevelInfo".} +proc newImGuiStackLevelInfo*(): ptr ImGuiStackLevelInfo {.importc: "ImGuiStackLevelInfo_ImGuiStackLevelInfo".} proc destroy*(self: ptr ImGuiStackLevelInfo): void {.importc: "ImGuiStackLevelInfo_destroy".} proc compareWithContextState*(self: ptr ImGuiStackSizes, ctx: ptr ImGuiContext): void {.importc: "ImGuiStackSizes_CompareWithContextState".} -proc newImGuiStackSizes*(): void {.importc: "ImGuiStackSizes_ImGuiStackSizes".} +proc newImGuiStackSizes*(): ptr ImGuiStackSizes {.importc: "ImGuiStackSizes_ImGuiStackSizes".} proc setToContextState*(self: ptr ImGuiStackSizes, ctx: ptr ImGuiContext): void {.importc: "ImGuiStackSizes_SetToContextState".} proc destroy*(self: ptr ImGuiStackSizes): void {.importc: "ImGuiStackSizes_destroy".} -proc newImGuiStackTool*(): void {.importc: "ImGuiStackTool_ImGuiStackTool".} +proc newImGuiStackTool*(): ptr ImGuiStackTool {.importc: "ImGuiStackTool_ImGuiStackTool".} proc destroy*(self: ptr ImGuiStackTool): void {.importc: "ImGuiStackTool_destroy".} -proc newImGuiStoragePair*(key: ImGuiID, val_i: int32): void {.importc: "ImGuiStoragePair_ImGuiStoragePair_Int".} -proc newImGuiStoragePair*(key: ImGuiID, val_f: float32): void {.importc: "ImGuiStoragePair_ImGuiStoragePair_Float".} -proc newImGuiStoragePair*(key: ImGuiID, val_p: pointer): void {.importc: "ImGuiStoragePair_ImGuiStoragePair_Ptr".} +proc newImGuiStoragePair*(key: ImGuiID, val_i: int32): ptr ImGuiStoragePair {.importc: "ImGuiStoragePair_ImGuiStoragePair_Int".} +proc newImGuiStoragePair*(key: ImGuiID, val_f: float32): ptr ImGuiStoragePair {.importc: "ImGuiStoragePair_ImGuiStoragePair_Float".} +proc newImGuiStoragePair*(key: ImGuiID, val_p: pointer): ptr ImGuiStoragePair {.importc: "ImGuiStoragePair_ImGuiStoragePair_Ptr".} proc destroy*(self: ptr ImGuiStoragePair): void {.importc: "ImGuiStoragePair_destroy".} proc buildSortByKey*(self: ptr ImGuiStorage): void {.importc: "ImGuiStorage_BuildSortByKey".} proc clear*(self: ptr ImGuiStorage): void {.importc: "ImGuiStorage_Clear".} @@ -2915,35 +2915,35 @@ proc setBool*(self: ptr ImGuiStorage, key: ImGuiID, val: bool): void {.importc: proc setFloat*(self: ptr ImGuiStorage, key: ImGuiID, val: float32): void {.importc: "ImGuiStorage_SetFloat".} proc setInt*(self: ptr ImGuiStorage, key: ImGuiID, val: int32): void {.importc: "ImGuiStorage_SetInt".} proc setVoidPtr*(self: ptr ImGuiStorage, key: ImGuiID, val: pointer): void {.importc: "ImGuiStorage_SetVoidPtr".} -proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: int32): void {.importc: "ImGuiStyleMod_ImGuiStyleMod_Int".} -proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: float32): void {.importc: "ImGuiStyleMod_ImGuiStyleMod_Float".} -proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: ImVec2): void {.importc: "ImGuiStyleMod_ImGuiStyleMod_Vec2".} +proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: int32): ptr ImGuiStyleMod {.importc: "ImGuiStyleMod_ImGuiStyleMod_Int".} +proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: float32): ptr ImGuiStyleMod {.importc: "ImGuiStyleMod_ImGuiStyleMod_Float".} +proc newImGuiStyleMod*(idx: ImGuiStyleVar, v: ImVec2): ptr ImGuiStyleMod {.importc: "ImGuiStyleMod_ImGuiStyleMod_Vec2".} proc destroy*(self: ptr ImGuiStyleMod): void {.importc: "ImGuiStyleMod_destroy".} -proc newImGuiStyle*(): void {.importc: "ImGuiStyle_ImGuiStyle".} +proc newImGuiStyle*(): ptr ImGuiStyle {.importc: "ImGuiStyle_ImGuiStyle".} proc scaleAllSizes*(self: ptr ImGuiStyle, scale_factor: float32): void {.importc: "ImGuiStyle_ScaleAllSizes".} proc destroy*(self: ptr ImGuiStyle): void {.importc: "ImGuiStyle_destroy".} -proc newImGuiTabBar*(): void {.importc: "ImGuiTabBar_ImGuiTabBar".} +proc newImGuiTabBar*(): ptr ImGuiTabBar {.importc: "ImGuiTabBar_ImGuiTabBar".} proc destroy*(self: ptr ImGuiTabBar): void {.importc: "ImGuiTabBar_destroy".} -proc newImGuiTabItem*(): void {.importc: "ImGuiTabItem_ImGuiTabItem".} +proc newImGuiTabItem*(): ptr ImGuiTabItem {.importc: "ImGuiTabItem_ImGuiTabItem".} proc destroy*(self: ptr ImGuiTabItem): void {.importc: "ImGuiTabItem_destroy".} -proc newImGuiTableColumnSettings*(): void {.importc: "ImGuiTableColumnSettings_ImGuiTableColumnSettings".} +proc newImGuiTableColumnSettings*(): ptr ImGuiTableColumnSettings {.importc: "ImGuiTableColumnSettings_ImGuiTableColumnSettings".} proc destroy*(self: ptr ImGuiTableColumnSettings): void {.importc: "ImGuiTableColumnSettings_destroy".} -proc newImGuiTableColumnSortSpecs*(): void {.importc: "ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs".} +proc newImGuiTableColumnSortSpecs*(): ptr ImGuiTableColumnSortSpecs {.importc: "ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs".} proc destroy*(self: ptr ImGuiTableColumnSortSpecs): void {.importc: "ImGuiTableColumnSortSpecs_destroy".} -proc newImGuiTableColumn*(): void {.importc: "ImGuiTableColumn_ImGuiTableColumn".} +proc newImGuiTableColumn*(): ptr ImGuiTableColumn {.importc: "ImGuiTableColumn_ImGuiTableColumn".} proc destroy*(self: ptr ImGuiTableColumn): void {.importc: "ImGuiTableColumn_destroy".} -proc newImGuiTableInstanceData*(): void {.importc: "ImGuiTableInstanceData_ImGuiTableInstanceData".} +proc newImGuiTableInstanceData*(): ptr ImGuiTableInstanceData {.importc: "ImGuiTableInstanceData_ImGuiTableInstanceData".} proc destroy*(self: ptr ImGuiTableInstanceData): void {.importc: "ImGuiTableInstanceData_destroy".} proc getColumnSettings*(self: ptr ImGuiTableSettings): ptr ImGuiTableColumnSettings {.importc: "ImGuiTableSettings_GetColumnSettings".} -proc newImGuiTableSettings*(): void {.importc: "ImGuiTableSettings_ImGuiTableSettings".} +proc newImGuiTableSettings*(): ptr ImGuiTableSettings {.importc: "ImGuiTableSettings_ImGuiTableSettings".} proc destroy*(self: ptr ImGuiTableSettings): void {.importc: "ImGuiTableSettings_destroy".} -proc newImGuiTableSortSpecs*(): void {.importc: "ImGuiTableSortSpecs_ImGuiTableSortSpecs".} +proc newImGuiTableSortSpecs*(): ptr ImGuiTableSortSpecs {.importc: "ImGuiTableSortSpecs_ImGuiTableSortSpecs".} proc destroy*(self: ptr ImGuiTableSortSpecs): void {.importc: "ImGuiTableSortSpecs_destroy".} -proc newImGuiTableTempData*(): void {.importc: "ImGuiTableTempData_ImGuiTableTempData".} +proc newImGuiTableTempData*(): ptr ImGuiTableTempData {.importc: "ImGuiTableTempData_ImGuiTableTempData".} proc destroy*(self: ptr ImGuiTableTempData): void {.importc: "ImGuiTableTempData_destroy".} -proc newImGuiTable*(): void {.importc: "ImGuiTable_ImGuiTable".} +proc newImGuiTable*(): ptr ImGuiTable {.importc: "ImGuiTable_ImGuiTable".} proc destroy*(self: ptr ImGuiTable): void {.importc: "ImGuiTable_destroy".} -proc newImGuiTextBuffer*(): void {.importc: "ImGuiTextBuffer_ImGuiTextBuffer".} +proc newImGuiTextBuffer*(): ptr ImGuiTextBuffer {.importc: "ImGuiTextBuffer_ImGuiTextBuffer".} proc append*(self: ptr ImGuiTextBuffer, str: cstring, str_end: cstring = nil): void {.importc: "ImGuiTextBuffer_append".} proc appendf*(self: ptr ImGuiTextBuffer, fmt: cstring): void {.importc: "ImGuiTextBuffer_appendf", varargs.} proc appendfv*(self: ptr ImGuiTextBuffer, fmt: cstring): void {.importc: "ImGuiTextBuffer_appendfv", varargs.} @@ -2958,7 +2958,7 @@ proc size*(self: ptr ImGuiTextBuffer): int32 {.importc: "ImGuiTextBuffer_size".} proc build*(self: ptr ImGuiTextFilter): void {.importc: "ImGuiTextFilter_Build".} proc clear*(self: ptr ImGuiTextFilter): void {.importc: "ImGuiTextFilter_Clear".} proc draw*(self: ptr ImGuiTextFilter, label: cstring = "Filter(inc,-exc)", width: float32 = 0.0f): bool {.importc: "ImGuiTextFilter_Draw".} -proc newImGuiTextFilter*(default_filter: cstring = ""): void {.importc: "ImGuiTextFilter_ImGuiTextFilter".} +proc newImGuiTextFilter*(default_filter: cstring = ""): ptr ImGuiTextFilter {.importc: "ImGuiTextFilter_ImGuiTextFilter".} proc isActive*(self: ptr ImGuiTextFilter): bool {.importc: "ImGuiTextFilter_IsActive".} proc passFilter*(self: ptr ImGuiTextFilter, text: cstring, text_end: cstring = nil): bool {.importc: "ImGuiTextFilter_PassFilter".} proc destroy*(self: ptr ImGuiTextFilter): void {.importc: "ImGuiTextFilter_destroy".} @@ -2967,8 +2967,8 @@ proc clear*(self: ptr ImGuiTextIndex): void {.importc: "ImGuiTextIndex_clear".} proc get_line_begin*(self: ptr ImGuiTextIndex, base: cstring, n: int32): cstring {.importc: "ImGuiTextIndex_get_line_begin".} proc get_line_end*(self: ptr ImGuiTextIndex, base: cstring, n: int32): cstring {.importc: "ImGuiTextIndex_get_line_end".} proc size*(self: ptr ImGuiTextIndex): int32 {.importc: "ImGuiTextIndex_size".} -proc newImGuiTextRange*(): void {.importc: "ImGuiTextRange_ImGuiTextRange_Nil".} -proc newImGuiTextRange*(b: cstring, e: cstring): void {.importc: "ImGuiTextRange_ImGuiTextRange_Str".} +proc newImGuiTextRange*(): ptr ImGuiTextRange {.importc: "ImGuiTextRange_ImGuiTextRange_Nil".} +proc newImGuiTextRange*(b: cstring, e: cstring): ptr ImGuiTextRange {.importc: "ImGuiTextRange_ImGuiTextRange_Str".} proc destroy*(self: ptr ImGuiTextRange): void {.importc: "ImGuiTextRange_destroy".} proc empty*(self: ptr ImGuiTextRange): bool {.importc: "ImGuiTextRange_empty".} proc split*(self: ptr ImGuiTextRange, separator: int8, `out`: ptr ImVector[ImGuiTextRange]): void {.importc: "ImGuiTextRange_split".} @@ -2978,24 +2978,24 @@ proc clearRequestFlags*(self: ptr ImGuiViewportP): void {.importc: "ImGuiViewpor proc getBuildWorkRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetBuildWorkRect".} proc getMainRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetMainRect".} proc getWorkRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_GetWorkRect".} -proc newImGuiViewportP*(): void {.importc: "ImGuiViewportP_ImGuiViewportP".} +proc newImGuiViewportP*(): ptr ImGuiViewportP {.importc: "ImGuiViewportP_ImGuiViewportP".} proc updateWorkRect*(self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_UpdateWorkRect".} proc destroy*(self: ptr ImGuiViewportP): void {.importc: "ImGuiViewportP_destroy".} proc getCenterNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewport): void {.importc: "ImGuiViewport_GetCenter".} proc getWorkCenterNonUDT*(pOut: ptr ImVec2, self: ptr ImGuiViewport): void {.importc: "ImGuiViewport_GetWorkCenter".} -proc newImGuiViewport*(): void {.importc: "ImGuiViewport_ImGuiViewport".} +proc newImGuiViewport*(): ptr ImGuiViewport {.importc: "ImGuiViewport_ImGuiViewport".} proc destroy*(self: ptr ImGuiViewport): void {.importc: "ImGuiViewport_destroy".} -proc newImGuiWindowClass*(): void {.importc: "ImGuiWindowClass_ImGuiWindowClass".} +proc newImGuiWindowClass*(): ptr ImGuiWindowClass {.importc: "ImGuiWindowClass_ImGuiWindowClass".} proc destroy*(self: ptr ImGuiWindowClass): void {.importc: "ImGuiWindowClass_destroy".} proc getName*(self: ptr ImGuiWindowSettings): cstring {.importc: "ImGuiWindowSettings_GetName".} -proc newImGuiWindowSettings*(): void {.importc: "ImGuiWindowSettings_ImGuiWindowSettings".} +proc newImGuiWindowSettings*(): ptr ImGuiWindowSettings {.importc: "ImGuiWindowSettings_ImGuiWindowSettings".} proc destroy*(self: ptr ImGuiWindowSettings): void {.importc: "ImGuiWindowSettings_destroy".} proc calcFontSize*(self: ptr ImGuiWindow): float32 {.importc: "ImGuiWindow_CalcFontSize".} proc getID*(self: ptr ImGuiWindow, str: cstring, str_end: cstring = nil): ImGuiID {.importc: "ImGuiWindow_GetID_Str".} proc getID*(self: ptr ImGuiWindow, `ptr`: pointer): ImGuiID {.importc: "ImGuiWindow_GetID_Ptr".} proc getID*(self: ptr ImGuiWindow, n: int32): ImGuiID {.importc: "ImGuiWindow_GetID_Int".} proc getIDFromRectangle*(self: ptr ImGuiWindow, r_abs: ImRect): ImGuiID {.importc: "ImGuiWindow_GetIDFromRectangle".} -proc newImGuiWindow*(context: ptr ImGuiContext, name: cstring): void {.importc: "ImGuiWindow_ImGuiWindow".} +proc newImGuiWindow*(context: ptr ImGuiContext, name: cstring): ptr ImGuiWindow {.importc: "ImGuiWindow_ImGuiWindow".} proc menuBarHeight*(self: ptr ImGuiWindow): float32 {.importc: "ImGuiWindow_MenuBarHeight".} proc menuBarRectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiWindow): void {.importc: "ImGuiWindow_MenuBarRect".} proc rectNonUDT*(pOut: ptr ImRect, self: ptr ImGuiWindow): void {.importc: "ImGuiWindow_Rect".} @@ -3012,7 +3012,7 @@ proc getByKey*[T](self: ptr ImPool, key: ImGuiID): ptr T {.importc: "ImPool_GetB proc getIndex*[T](self: ptr ImPool, p: ptr T): ImPoolIdx {.importc: "ImPool_GetIndex".} proc getMapSize*(self: ptr ImPool): int32 {.importc: "ImPool_GetMapSize".} proc getOrAddByKey*[T](self: ptr ImPool, key: ImGuiID): ptr T {.importc: "ImPool_GetOrAddByKey".} -proc newImPool*(): void {.importc: "ImPool_ImPool".} +proc newImPool*(): ptr ImPool {.importc: "ImPool_ImPool".} proc remove*[T](self: ptr ImPool, key: ImGuiID, p: ptr T): void {.importc: "ImPool_Remove_TPtr".} proc remove*(self: ptr ImPool, key: ImGuiID, idx: ImPoolIdx): void {.importc: "ImPool_Remove_PoolIdx".} proc reserve*(self: ptr ImPool, capacity: int32): void {.importc: "ImPool_Reserve".} @@ -3036,10 +3036,10 @@ proc getSizeNonUDT*(pOut: ptr ImVec2, self: ptr ImRect): void {.importc: "ImRect proc getTLNonUDT*(pOut: ptr ImVec2, self: ptr ImRect): void {.importc: "ImRect_GetTL".} proc getTRNonUDT*(pOut: ptr ImVec2, self: ptr ImRect): void {.importc: "ImRect_GetTR".} proc getWidth*(self: ptr ImRect): float32 {.importc: "ImRect_GetWidth".} -proc newImRect*(): void {.importc: "ImRect_ImRect_Nil".} -proc newImRect*(min: ImVec2, max: ImVec2): void {.importc: "ImRect_ImRect_Vec2".} -proc newImRect*(v: ImVec4): void {.importc: "ImRect_ImRect_Vec4".} -proc newImRect*(x1: float32, y1: float32, x2: float32, y2: float32): void {.importc: "ImRect_ImRect_Float".} +proc newImRect*(): ptr ImRect {.importc: "ImRect_ImRect_Nil".} +proc newImRect*(min: ImVec2, max: ImVec2): ptr ImRect {.importc: "ImRect_ImRect_Vec2".} +proc newImRect*(v: ImVec4): ptr ImRect {.importc: "ImRect_ImRect_Vec4".} +proc newImRect*(x1: float32, y1: float32, x2: float32, y2: float32): ptr ImRect {.importc: "ImRect_ImRect_Float".} proc isInverted*(self: ptr ImRect): bool {.importc: "ImRect_IsInverted".} proc overlaps*(self: ptr ImRect, r: ImRect): bool {.importc: "ImRect_Overlaps".} proc toVec4NonUDT*(pOut: ptr ImVec4, self: ptr ImRect): void {.importc: "ImRect_ToVec4".} @@ -3050,13 +3050,13 @@ proc destroy*(self: ptr ImRect): void {.importc: "ImRect_destroy".} proc getArenaSizeInBytes*(self: ptr ImSpanAllocator): int32 {.importc: "ImSpanAllocator_GetArenaSizeInBytes".} proc getSpanPtrBegin*(self: ptr ImSpanAllocator, n: int32): pointer {.importc: "ImSpanAllocator_GetSpanPtrBegin".} proc getSpanPtrEnd*(self: ptr ImSpanAllocator, n: int32): pointer {.importc: "ImSpanAllocator_GetSpanPtrEnd".} -proc newImSpanAllocator*(): void {.importc: "ImSpanAllocator_ImSpanAllocator".} +proc newImSpanAllocator*(): ptr ImSpanAllocator {.importc: "ImSpanAllocator_ImSpanAllocator".} proc reserve*(self: ptr ImSpanAllocator, n: int32, sz: uint, a: int32 = 4): void {.importc: "ImSpanAllocator_Reserve".} proc setArenaBasePtr*(self: ptr ImSpanAllocator, base_ptr: pointer): void {.importc: "ImSpanAllocator_SetArenaBasePtr".} proc destroy*(self: ptr ImSpanAllocator): void {.importc: "ImSpanAllocator_destroy".} -proc newImSpan*(): void {.importc: "ImSpan_ImSpan_Nil".} -proc newImSpan*[T](data: ptr T, size: int32): void {.importc: "ImSpan_ImSpan_TPtrInt".} -proc newImSpan*[T](data: ptr T, data_end: ptr T): void {.importc: "ImSpan_ImSpan_TPtrTPtr".} +proc newImSpan*(): ptr ImSpan {.importc: "ImSpan_ImSpan_Nil".} +proc newImSpan*[T](data: ptr T, size: int32): ptr ImSpan {.importc: "ImSpan_ImSpan_TPtrInt".} +proc newImSpan*[T](data: ptr T, data_end: ptr T): ptr ImSpan {.importc: "ImSpan_ImSpan_TPtrTPtr".} proc begin*[T](self: ptr ImSpan): ptr T {.importc: "ImSpan_begin_Nil".} proc destroy*(self: ptr ImSpan): void {.importc: "ImSpan_destroy".} proc `end`*[T](self: ptr ImSpan): ptr T {.importc: "ImSpan_end_Nil".} @@ -3065,18 +3065,18 @@ proc set*[T](self: ptr ImSpan, data: ptr T, size: int32): void {.importc: "ImSpa proc set*[T](self: ptr ImSpan, data: ptr T, data_end: ptr T): void {.importc: "ImSpan_set_TPtr".} proc size*(self: ptr ImSpan): int32 {.importc: "ImSpan_size".} proc size_in_bytes*(self: ptr ImSpan): int32 {.importc: "ImSpan_size_in_bytes".} -proc newImVec1*(): void {.importc: "ImVec1_ImVec1_Nil".} -proc newImVec1*(x: float32): void {.importc: "ImVec1_ImVec1_Float".} +proc newImVec1*(): ptr ImVec1 {.importc: "ImVec1_ImVec1_Nil".} +proc newImVec1*(x: float32): ptr ImVec1 {.importc: "ImVec1_ImVec1_Float".} proc destroy*(self: ptr ImVec1): void {.importc: "ImVec1_destroy".} -proc newImVec2*(): void {.importc: "ImVec2_ImVec2_Nil".} -proc newImVec2*(x: float32, y: float32): void {.importc: "ImVec2_ImVec2_Float".} +proc newImVec2*(): ptr ImVec2 {.importc: "ImVec2_ImVec2_Nil".} +proc newImVec2*(x: float32, y: float32): ptr ImVec2 {.importc: "ImVec2_ImVec2_Float".} proc destroy*(self: ptr ImVec2): void {.importc: "ImVec2_destroy".} -proc newImVec2ih*(): void {.importc: "ImVec2ih_ImVec2ih_Nil".} -proc newImVec2ih*(x: int16, y: int16): void {.importc: "ImVec2ih_ImVec2ih_short".} -proc newImVec2ih*(rhs: ImVec2): void {.importc: "ImVec2ih_ImVec2ih_Vec2".} +proc newImVec2ih*(): ptr ImVec2ih {.importc: "ImVec2ih_ImVec2ih_Nil".} +proc newImVec2ih*(x: int16, y: int16): ptr ImVec2ih {.importc: "ImVec2ih_ImVec2ih_short".} +proc newImVec2ih*(rhs: ImVec2): ptr ImVec2ih {.importc: "ImVec2ih_ImVec2ih_Vec2".} proc destroy*(self: ptr ImVec2ih): void {.importc: "ImVec2ih_destroy".} -proc newImVec4*(): void {.importc: "ImVec4_ImVec4_Nil".} -proc newImVec4*(x: float32, y: float32, z: float32, w: float32): void {.importc: "ImVec4_ImVec4_Float".} +proc newImVec4*(): ptr ImVec4 {.importc: "ImVec4_ImVec4_Nil".} +proc newImVec4*(x: float32, y: float32, z: float32, w: float32): ptr ImVec4 {.importc: "ImVec4_ImVec4_Float".} proc destroy*(self: ptr ImVec4): void {.importc: "ImVec4_destroy".} proc grow_capacity*(self: ptr ImVector, sz: int32): int32 {.importc: "ImVector__grow_capacity".} proc back*[T](self: ptr ImVector): ptr T {.importc: "ImVector_back_Nil".} diff --git a/tools/generator.nim b/tools/generator.nim index a6820e5..ec6ac17 100755 --- a/tools/generator.nim +++ b/tools/generator.nim @@ -262,6 +262,7 @@ proc genProcs(output: var string) = for name, obj in data.pairs: var isNonUDT = false + var isConstructor = false var nonUDTNumber = 0 for variation in obj: if variation.contains("nonUDT"): @@ -290,6 +291,7 @@ proc genProcs(output: var string) = if funcname.startsWith("ImVector"): continue funcname = "new" & funcname.capitalizeAscii() + isConstructor = true if funcname.isUpper(): funcname = funcname.normalize() @@ -377,6 +379,12 @@ proc genProcs(output: var string) = isGeneric = true if argRet == "explicit": argRet = "ptr ImVec2ih" # Ugly solution for a temporal problem + if isConstructor: + # Here "funcname" is assumed "newConstrucorName" so, + var retType = funcname.split("new")[1] + if retType == "ImBitArray": # Exception + retType &= "Ptr" + argRet = "ptr " & retType output.add(if isGeneric: "[T](" else: "(") output.add(argsOutput) From 9dd7705caff048fcef9a5a5a8ac4c809994f9cef Mon Sep 17 00:00:00 2001 From: dinau Date: Sat, 23 Sep 2023 13:58:58 +0900 Subject: [PATCH 23/25] Small change --- imgui.nimble | 6 ++---- src/imgui/impl_glfw.nim | 4 ++-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/imgui.nimble b/imgui.nimble index eca4c57..38696d5 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -17,11 +17,9 @@ task gen, "Generate bindings from source": task test, "Create window with imgui demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 exec("nim cpp -r tests/test.nim") - when defined(windows): - exec("nim c -r tests/test.nim") # requires cimgui.dll + exec("nim c -r tests/test.nim") # requires cimgui.dll or cimgui.so task ci, "Create window with imgui null demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 exec("nim cpp -r tests/tnull.nim") - when defined(windows): - exec("nim c -r tests/tnull.nim") # requires cimgui.dll + exec("nim c -r tests/tnull.nim") # requires cimgui.dll or cimgui.so diff --git a/src/imgui/impl_glfw.nim b/src/imgui/impl_glfw.nim index 210212a..92eafaa 100644 --- a/src/imgui/impl_glfw.nim +++ b/src/imgui/impl_glfw.nim @@ -30,10 +30,10 @@ var gPrevKeyCallback: GLFWKeyFun = nil gPrevCharCallback: GLFWCharFun = nil -proc igGlfwGetClipboardText(userData: pointer): cstring {.cdecl,used.} = +proc igGlfwGetClipboardText*(userData: pointer): cstring {.cdecl.} = cast[GLFWwindow](userData).getClipboardString() -proc igGlfwSetClipboardText(userData: pointer, text: cstring): void {.cdecl,used.} = +proc igGlfwSetClipboardText*(userData: pointer, text: cstring): void {.cdecl.} = cast[GLFWwindow](userData).setClipboardString(text) proc igGlfwMouseCallback*(window: GLFWWindow, button: int32, action: int32, mods: int32): void {.cdecl.} = From 4412ded013fa9b386c32392f2cb5f8cb8af1b6d9 Mon Sep 17 00:00:00 2001 From: dinau Date: Sat, 23 Sep 2023 14:30:10 +0900 Subject: [PATCH 24/25] fixed version to 1.89.9.4 in imgui.nimble --- imgui.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/imgui.nimble b/imgui.nimble index 38696d5..8c1ce1b 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.9.3" +version = "1.89.9.4" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" From 1d5b65d1329344faecb5efe48827e25f8288972e Mon Sep 17 00:00:00 2001 From: dinau Date: Tue, 19 Dec 2023 12:10:54 +0900 Subject: [PATCH 25/25] impl_glfw.nim: Introduce new driver for GLFW. --- imgui.nimble | 4 +- src/imgui.nim | 4 +- src/imgui/impl_glfw.nim | 235 ++++---------------------------- src/imgui/private/impl_glfw.nim | 208 ++++++++++++++++++++++++++++ tests/config.nims | 4 + tests/test.nim | 80 ++++++++--- tools/utils.nim | 4 +- 7 files changed, 308 insertions(+), 231 deletions(-) create mode 100644 src/imgui/private/impl_glfw.nim diff --git a/imgui.nimble b/imgui.nimble index 8c1ce1b..88d7da5 100755 --- a/imgui.nimble +++ b/imgui.nimble @@ -1,6 +1,6 @@ # Package -version = "1.89.9.4" +version = "1.89.9.5" author = "Leonardo Mariscal" description = "ImGui bindings for Nim" license = "MIT" @@ -16,7 +16,7 @@ task gen, "Generate bindings from source": task test, "Create window with imgui demo": requires "nimgl@#1.0" # Please https://github.com/nim-lang/nimble/issues/482 - exec("nim cpp -r tests/test.nim") + exec("nim cpp -r --passL:-static tests/test.nim") exec("nim c -r tests/test.nim") # requires cimgui.dll or cimgui.so task ci, "Create window with imgui null demo": diff --git a/src/imgui.nim b/src/imgui.nim index 6bfc2c2..9647184 100755 --- a/src/imgui.nim +++ b/src/imgui.nim @@ -2575,7 +2575,7 @@ type redo_char_point* {.importc: "redo_char_point".}: int32 # Procs -{.push warning[HoleEnumConv]: off.} +#{.push warning[HoleEnumConv]: off.} when not defined(cpp) or defined(cimguiDLL): {.push dynlib: imgui_dll, cdecl, discardable.} else: @@ -4011,7 +4011,7 @@ proc igWindowRectAbsToRelNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: I proc igWindowRectRelToAbsNonUDT*(pOut: ptr ImRect, window: ptr ImGuiWindow, r: ImRect): void {.importc: "igWindowRectRelToAbs".} {.pop.} # push dynlib / nodecl, etc... -{.pop.} # push warning[HoleEnumConv]: off +#{.pop.} # push warning[HoleEnumConv]: off proc igStyleColorsCherry*(dst: ptr ImGuiStyle = nil): void = diff --git a/src/imgui/impl_glfw.nim b/src/imgui/impl_glfw.nim index 92eafaa..c246bb3 100644 --- a/src/imgui/impl_glfw.nim +++ b/src/imgui/impl_glfw.nim @@ -1,208 +1,27 @@ -# Copyright 2018, NimGL contributors. - -## ImGUI GLFW Implementation -## ==== -## Implementation based on the imgui examples implementations. -## Feel free to use and modify this implementation. -## This needs to be used along with a Renderer. - -import ../imgui, nimgl/glfw - -when defined(windows): - import nimgl/glfw/native - -type - GlfwClientApi = enum - igGlfwClientApiUnkown - igGlfwClientApiOpenGl - igGlfwClientApiVulkan - -var - gWindow: GLFWwindow - gClientApi = igGlfwClientApiUnkown - gTime: float64 = 0.0f - gMouseJustPressed: array[5, bool] - gMouseCursors: array[ImGuiMouseCursor.high.int32 + 1, GLFWCursor] - - # Store previous callbacks so they can be chained - gPrevMouseButtonCallback: GLFWMousebuttonFun = nil - gPrevScrollCallback: GLFWScrollFun = nil - gPrevKeyCallback: GLFWKeyFun = nil - gPrevCharCallback: GLFWCharFun = nil - -proc igGlfwGetClipboardText*(userData: pointer): cstring {.cdecl.} = - cast[GLFWwindow](userData).getClipboardString() - -proc igGlfwSetClipboardText*(userData: pointer, text: cstring): void {.cdecl.} = - cast[GLFWwindow](userData).setClipboardString(text) - -proc igGlfwMouseCallback*(window: GLFWWindow, button: int32, action: int32, mods: int32): void {.cdecl.} = - if gPrevMouseButtonCallback != nil: - gPrevMouseButtonCallback(window, button, action, mods) - - if action == GLFWPress and button.ord >= 0 and button.ord < gMouseJustPressed.len: - gMouseJustPressed[button.ord] = true - -proc igGlfwScrollCallback*(window: GLFWWindow, xoff: float64, yoff: float64): void {.cdecl.} = - if gPrevScrollCallback != nil: - gPrevScrollCallback(window, xoff, yoff) - - let io = igGetIO() - io.mouseWheelH += xoff.float32 - io.mouseWheel += yoff.float32 - -proc igGlfwKeyCallback*(window: GLFWWindow, key: int32, scancode: int32, action: int32, mods: int32): void {.cdecl.} = - if gPrevKeyCallback != nil: - gPrevKeyCallback(window, key, scancode, action, mods) - - let io = igGetIO() - if key.ord < 511 and key.ord >= 0: - if action == GLFWPress: - io.keysDown[key.ord] = true - elif action == GLFWRelease: - io.keysDown[key.ord] = false - - io.keyCtrl = io.keysDown[GLFWKey.LeftControl.ord] or io.keysDown[GLFWKey.RightControl.ord] - io.keyShift = io.keysDown[GLFWKey.LeftShift.ord] or io.keysDown[GLFWKey.RightShift.ord] - io.keyAlt = io.keysDown[GLFWKey.LeftAlt.ord] or io.keysDown[GLFWKey.RightAlt.ord] - io.keySuper = io.keysDown[GLFWKey.LeftSuper.ord] or io.keysDown[GLFWKey.RightSuper.ord] - -proc igGlfwCharCallback*(window: GLFWWindow, code: uint32): void {.cdecl.} = - if gPrevCharCallback != nil: - gPrevCharCallback(window, code) - - let io = igGetIO() - if code > 0'u32 and code < 0x10000'u32: - io.addInputCharacter(cast[ImWchar](code)) - -proc igGlfwInstallCallbacks(window: GLFWwindow) = - # The already set callback proc should be returned. Store these and and chain callbacks. - gPrevMouseButtonCallback = gWindow.setMouseButtonCallback(igGlfwMouseCallback) - gPrevScrollCallback = gWindow.setScrollCallback(igGlfwScrollCallback) - gPrevKeyCallback = gWindow.setKeyCallback(igGlfwKeyCallback) - gPrevCharCallback = gWindow.setCharCallback(igGlfwCharCallback) - -proc igGlfwInit(window: GLFWwindow, installCallbacks: bool, clientApi: GlfwClientApi): bool = - gWindow = window - gTime = 0.0f - - let io = igGetIO() - io.backendFlags = (io.backendFlags.int32 or ImGuiBackendFlags.HasMouseCursors.int32).ImGuiBackendFlags - io.backendFlags = (io.backendFlags.int32 or ImGuiBackendFlags.HasSetMousePos.int32).ImGuiBackendFlags - - io.keyMap[ImGuiKey.Tab.int32] = GLFWKey.Tab - io.keyMap[ImGuiKey.LeftArrow.int32] = GLFWKey.Left - io.keyMap[ImGuiKey.RightArrow.int32] = GLFWKey.Right - io.keyMap[ImGuiKey.UpArrow.int32] = GLFWKey.Up - io.keyMap[ImGuiKey.DownArrow.int32] = GLFWKey.Down - io.keyMap[ImGuiKey.PageUp.int32] = GLFWKey.PageUp - io.keyMap[ImGuiKey.PageDown.int32] = GLFWKey.PageDown - io.keyMap[ImGuiKey.Home.int32] = GLFWKey.Home - io.keyMap[ImGuiKey.End.int32] = GLFWKey.End - io.keyMap[ImGuiKey.Insert.int32] = GLFWKey.Insert - io.keyMap[ImGuiKey.Delete.int32] = GLFWKey.Delete - io.keyMap[ImGuiKey.Backspace.int32] = GLFWKey.Backspace - io.keyMap[ImGuiKey.Space.int32] = GLFWKey.Space - io.keyMap[ImGuiKey.Enter.int32] = GLFWKey.Enter - io.keyMap[ImGuiKey.Escape.int32] = GLFWKey.Escape - io.keyMap[ImGuiKey.A.int32] = GLFWKey.A - io.keyMap[ImGuiKey.C.int32] = GLFWKey.C - io.keyMap[ImGuiKey.V.int32] = GLFWKey.V - io.keyMap[ImGuiKey.X.int32] = GLFWKey.X - io.keyMap[ImGuiKey.Y.int32] = GLFWKey.Y - io.keyMap[ImGuiKey.Z.int32] = GLFWKey.Z - - # HELP: If you know how to convert char * to const char * through Nim pragmas - # and types, I would love to know. - when not defined(cpp): - io.setClipboardTextFn = igGlfwSetClipboardText - io.getClipboardTextFn = igGlfwGetClipboardText - io.clipboardUserData = gWindow - when defined windows: - var viewPort = igGetMainViewport() # CIMGUI_API ImGuiViewport* igGetMainViewport() - viewPort.platformhandleRaw = gWindow.getWin32Window() - #io.imeWindowHandle = gWindow.getWin32Window() # Obsoleted ? - - gMouseCursors[ImGuiMouseCursor.Arrow.int32] = glfwCreateStandardCursor(GLFWArrowCursor) - gMouseCursors[ImGuiMouseCursor.TextInput.int32] = glfwCreateStandardCursor(GLFWIbeamCursor) - gMouseCursors[ImGuiMouseCursor.ResizeAll.int32] = glfwCreateStandardCursor(GLFWArrowCursor) - gMouseCursors[ImGuiMouseCursor.ResizeNS.int32] = glfwCreateStandardCursor(GLFWVresizeCursor) - gMouseCursors[ImGuiMouseCursor.ResizeEW.int32] = glfwCreateStandardCursor(GLFWHresizeCursor) - gMouseCursors[ImGuiMouseCursor.ResizeNESW.int32] = glfwCreateStandardCursor(GLFWArrowCursor) - gMouseCursors[ImGuiMouseCursor.ResizeNWSE.int32] = glfwCreateStandardCursor(GLFWArrowCursor) - gMouseCursors[ImGuiMouseCursor.Hand.int32] = glfwCreateStandardCursor(GLFWHandCursor) - - if installCallbacks: - igGlfwInstallCallbacks(window) - - gClientApi = clientApi - return true - -proc igGlfwInitForOpenGL*(window: GLFWwindow, installCallbacks: bool): bool = - igGlfwInit(window, installCallbacks, igGlfwClientApiOpenGL) - -# @TODO: Vulkan support - -proc igGlfwUpdateMousePosAndButtons() = - let io = igGetIO() - for i in 0 ..< io.mouseDown.len: - io.mouseDown[i] = gMouseJustPressed[i] or gWindow.getMouseButton(i.int32) != 0 - gMouseJustPressed[i] = false - - let mousePosBackup = io.mousePos - io.mousePos = ImVec2(x: -high(float32), y: -high(float32)) - - when defined(emscripten): # TODO: actually add support for all the library with emscripten - let focused = true - else: - let focused = gWindow.getWindowAttrib(GLFWFocused) != 0 - - if focused: - if io.wantSetMousePos: - gWindow.setCursorPos(mousePosBackup.x, mousePosBackup.y) - else: - var mouseX: float64 - var mouseY: float64 - gWindow.getCursorPos(mouseX.addr, mouseY.addr) - io.mousePos = ImVec2(x: mouseX.float32, y: mouseY.float32) - -proc igGlfwUpdateMouseCursor() = - let io = igGetIO() - if ((io.configFlags.int32 and ImGuiConfigFlags.NoMouseCursorChange.int32) == 1) or (gWindow.getInputMode(GLFWCursorSpecial) == GLFWCursorDisabled): - return - - var igCursor: ImGuiMouseCursor = igGetMouseCursor() - if igCursor == ImGuiMouseCursor.None or io.mouseDrawCursor: - gWindow.setInputMode(GLFWCursorSpecial, GLFWCursorHidden) - else: - gWindow.setCursor(gMouseCursors[igCursor.int32]) - gWindow.setInputMode(GLFWCursorSpecial, GLFWCursorNormal) - -proc igGlfwNewFrame*() = - let io = igGetIO() - assert io.fonts.isBuilt() - - var w: int32 - var h: int32 - var displayW: int32 - var displayH: int32 - - gWindow.getWindowSize(w.addr, h.addr) - gWindow.getFramebufferSize(displayW.addr, displayH.addr) - io.displaySize = ImVec2(x: w.float32, y: h.float32) - io.displayFramebufferScale = ImVec2(x: if w > 0: displayW.float32 / w.float32 else: 0.0f, y: if h > 0: displayH.float32 / h.float32 else: 0.0f) - - let currentTime = glfwGetTime() - io.deltaTime = if gTime > 0.0f: (currentTime - gTime).float32 else: (1.0f / 60.0f).float32 - gTime = currentTime - - igGlfwUpdateMousePosAndButtons() - igGlfwUpdateMouseCursor() - - # @TODO: gamepad mapping - -proc igGlfwShutdown*() = - for i in 0 ..< ImGuiMouseCursor.high.int32 + 1: - gMouseCursors[i].destroyCursor() - gMouseCursors[i] = nil - gClientApi = igGlfwClientApiUnkown +# Set source path +when not defined(cpp) or defined(cimguiDLL): + include "private/impl_glfw.nim" +else: + import std/[os,strutils] + import nimgl/[glfw] + + proc currentSourceDir(): string {.compileTime.} = + result = currentSourcePath().replace("\\", "/") + result = result[0 ..< result.rfind("/")] + + const CImguiRootPath = joinpath(currentSourceDir() ,"private/cimgui") + const ImguiRootPath = joinPath(CImguiRootPath,"imgui") + {.passC:"-I" & CImguiRootPath.} + {.passC:"-I" & ImguiRootPath.} + {.passC:"-DCIMGUI_USE_OPENGL3".} + {.passC:"""-DCIMGUI_API="extern \"C\" " """.} + {.passC:"""-DIMGUI_IMPL_API="extern \"C\" " """.} + #{.passC:"""-DIMGUI_IMPL_API="extern \"C\" __declspec(dllexport)" """.} + {.compile:joinPath(ImguiRootPath,"backends","imgui_impl_glfw.cpp").} + + #-------------- + # Public procs + #-------------- + proc igGlfwInitForOpenGL*(window: Glfwwindow; installcallbacks: bool): bool {.cdecl, importc: "ImGui_ImplGlfw_InitForOpenGL".} + proc igGlfwNewFrame*(): void {.cdecl, importc: "ImGui_ImplGlfw_NewFrame".} + proc igGlfwShutDown*(): void {.cdecl, importc: "ImGui_ImplGlfw_Shutdown".} diff --git a/src/imgui/private/impl_glfw.nim b/src/imgui/private/impl_glfw.nim new file mode 100644 index 0000000..c874300 --- /dev/null +++ b/src/imgui/private/impl_glfw.nim @@ -0,0 +1,208 @@ +# Copyright 2018, NimGL contributors. + +## ImGUI GLFW Implementation +## ==== +## Implementation based on the imgui examples implementations. +## Feel free to use and modify this implementation. +## This needs to be used along with a Renderer. + +import ../../imgui, nimgl/glfw + +when defined(windows): + import nimgl/glfw/native + +type + GlfwClientApi = enum + igGlfwClientApiUnkown + igGlfwClientApiOpenGl + igGlfwClientApiVulkan + +var + gWindow: GLFWwindow + gClientApi = igGlfwClientApiUnkown + gTime: float64 = 0.0f + gMouseJustPressed: array[5, bool] + gMouseCursors: array[ImGuiMouseCursor.high.int32 + 1, GLFWCursor] + + # Store previous callbacks so they can be chained + gPrevMouseButtonCallback: GLFWMousebuttonFun = nil + gPrevScrollCallback: GLFWScrollFun = nil + gPrevKeyCallback: GLFWKeyFun = nil + gPrevCharCallback: GLFWCharFun = nil + +proc igGlfwGetClipboardText*(userData: pointer): cstring {.cdecl.} = + cast[GLFWwindow](userData).getClipboardString() + +proc igGlfwSetClipboardText*(userData: pointer, text: cstring): void {.cdecl.} = + cast[GLFWwindow](userData).setClipboardString(text) + +proc igGlfwMouseCallback*(window: GLFWWindow, button: int32, action: int32, mods: int32): void {.cdecl.} = + if gPrevMouseButtonCallback != nil: + gPrevMouseButtonCallback(window, button, action, mods) + + if action == GLFWPress and button.ord >= 0 and button.ord < gMouseJustPressed.len: + gMouseJustPressed[button.ord] = true + +proc igGlfwScrollCallback*(window: GLFWWindow, xoff: float64, yoff: float64): void {.cdecl.} = + if gPrevScrollCallback != nil: + gPrevScrollCallback(window, xoff, yoff) + + let io = igGetIO() + io.mouseWheelH += xoff.float32 + io.mouseWheel += yoff.float32 + +proc igGlfwKeyCallback*(window: GLFWWindow, key: int32, scancode: int32, action: int32, mods: int32): void {.cdecl.} = + if gPrevKeyCallback != nil: + gPrevKeyCallback(window, key, scancode, action, mods) + + let io = igGetIO() + if key.ord < 511 and key.ord >= 0: + if action == GLFWPress: + io.keysDown[key.ord] = true + elif action == GLFWRelease: + io.keysDown[key.ord] = false + + io.keyCtrl = io.keysDown[GLFWKey.LeftControl.ord] or io.keysDown[GLFWKey.RightControl.ord] + io.keyShift = io.keysDown[GLFWKey.LeftShift.ord] or io.keysDown[GLFWKey.RightShift.ord] + io.keyAlt = io.keysDown[GLFWKey.LeftAlt.ord] or io.keysDown[GLFWKey.RightAlt.ord] + io.keySuper = io.keysDown[GLFWKey.LeftSuper.ord] or io.keysDown[GLFWKey.RightSuper.ord] + +proc igGlfwCharCallback*(window: GLFWWindow, code: uint32): void {.cdecl.} = + if gPrevCharCallback != nil: + gPrevCharCallback(window, code) + + let io = igGetIO() + if code > 0'u32 and code < 0x10000'u32: + io.addInputCharacter(cast[ImWchar](code)) + +proc igGlfwInstallCallbacks(window: GLFWwindow) = + # The already set callback proc should be returned. Store these and and chain callbacks. + gPrevMouseButtonCallback = gWindow.setMouseButtonCallback(igGlfwMouseCallback) + gPrevScrollCallback = gWindow.setScrollCallback(igGlfwScrollCallback) + gPrevKeyCallback = gWindow.setKeyCallback(igGlfwKeyCallback) + gPrevCharCallback = gWindow.setCharCallback(igGlfwCharCallback) + +proc igGlfwInit(window: GLFWwindow, installCallbacks: bool, clientApi: GlfwClientApi): bool = + gWindow = window + gTime = 0.0f + + let io = igGetIO() + io.backendFlags = (io.backendFlags.int32 or ImGuiBackendFlags.HasMouseCursors.int32).ImGuiBackendFlags + io.backendFlags = (io.backendFlags.int32 or ImGuiBackendFlags.HasSetMousePos.int32).ImGuiBackendFlags + + io.keyMap[ImGuiKey.Tab.int32] = GLFWKey.Tab + io.keyMap[ImGuiKey.LeftArrow.int32] = GLFWKey.Left + io.keyMap[ImGuiKey.RightArrow.int32] = GLFWKey.Right + io.keyMap[ImGuiKey.UpArrow.int32] = GLFWKey.Up + io.keyMap[ImGuiKey.DownArrow.int32] = GLFWKey.Down + io.keyMap[ImGuiKey.PageUp.int32] = GLFWKey.PageUp + io.keyMap[ImGuiKey.PageDown.int32] = GLFWKey.PageDown + io.keyMap[ImGuiKey.Home.int32] = GLFWKey.Home + io.keyMap[ImGuiKey.End.int32] = GLFWKey.End + io.keyMap[ImGuiKey.Insert.int32] = GLFWKey.Insert + io.keyMap[ImGuiKey.Delete.int32] = GLFWKey.Delete + io.keyMap[ImGuiKey.Backspace.int32] = GLFWKey.Backspace + io.keyMap[ImGuiKey.Space.int32] = GLFWKey.Space + io.keyMap[ImGuiKey.Enter.int32] = GLFWKey.Enter + io.keyMap[ImGuiKey.Escape.int32] = GLFWKey.Escape + io.keyMap[ImGuiKey.A.int32] = GLFWKey.A + io.keyMap[ImGuiKey.C.int32] = GLFWKey.C + io.keyMap[ImGuiKey.V.int32] = GLFWKey.V + io.keyMap[ImGuiKey.X.int32] = GLFWKey.X + io.keyMap[ImGuiKey.Y.int32] = GLFWKey.Y + io.keyMap[ImGuiKey.Z.int32] = GLFWKey.Z + + # HELP: If you know how to convert char * to const char * through Nim pragmas + # and types, I would love to know. + when not defined(cpp): + io.setClipboardTextFn = igGlfwSetClipboardText + io.getClipboardTextFn = igGlfwGetClipboardText + io.clipboardUserData = gWindow + when defined windows: + var viewPort = igGetMainViewport() # CIMGUI_API ImGuiViewport* igGetMainViewport() + viewPort.platformhandleRaw = gWindow.getWin32Window() + #io.imeWindowHandle = gWindow.getWin32Window() # Obsoleted ? + + gMouseCursors[ImGuiMouseCursor.Arrow.int32] = glfwCreateStandardCursor(GLFWArrowCursor) + gMouseCursors[ImGuiMouseCursor.TextInput.int32] = glfwCreateStandardCursor(GLFWIbeamCursor) + gMouseCursors[ImGuiMouseCursor.ResizeAll.int32] = glfwCreateStandardCursor(GLFWArrowCursor) + gMouseCursors[ImGuiMouseCursor.ResizeNS.int32] = glfwCreateStandardCursor(GLFWVresizeCursor) + gMouseCursors[ImGuiMouseCursor.ResizeEW.int32] = glfwCreateStandardCursor(GLFWHresizeCursor) + gMouseCursors[ImGuiMouseCursor.ResizeNESW.int32] = glfwCreateStandardCursor(GLFWArrowCursor) + gMouseCursors[ImGuiMouseCursor.ResizeNWSE.int32] = glfwCreateStandardCursor(GLFWArrowCursor) + gMouseCursors[ImGuiMouseCursor.Hand.int32] = glfwCreateStandardCursor(GLFWHandCursor) + + if installCallbacks: + igGlfwInstallCallbacks(window) + + gClientApi = clientApi + return true + +proc igGlfwInitForOpenGL*(window: GLFWwindow, installCallbacks: bool): bool = + igGlfwInit(window, installCallbacks, igGlfwClientApiOpenGL) + +# @TODO: Vulkan support + +proc igGlfwUpdateMousePosAndButtons() = + let io = igGetIO() + for i in 0 ..< io.mouseDown.len: + io.mouseDown[i] = gMouseJustPressed[i] or gWindow.getMouseButton(i.int32) != 0 + gMouseJustPressed[i] = false + + let mousePosBackup = io.mousePos + io.mousePos = ImVec2(x: -high(float32), y: -high(float32)) + + when defined(emscripten): # TODO: actually add support for all the library with emscripten + let focused = true + else: + let focused = gWindow.getWindowAttrib(GLFWFocused) != 0 + + if focused: + if io.wantSetMousePos: + gWindow.setCursorPos(mousePosBackup.x, mousePosBackup.y) + else: + var mouseX: float64 + var mouseY: float64 + gWindow.getCursorPos(mouseX.addr, mouseY.addr) + io.mousePos = ImVec2(x: mouseX.float32, y: mouseY.float32) + +proc igGlfwUpdateMouseCursor() = + let io = igGetIO() + if ((io.configFlags.int32 and ImGuiConfigFlags.NoMouseCursorChange.int32) == 1) or (gWindow.getInputMode(GLFWCursorSpecial) == GLFWCursorDisabled): + return + + var igCursor: ImGuiMouseCursor = igGetMouseCursor() + if igCursor == ImGuiMouseCursor.None or io.mouseDrawCursor: + gWindow.setInputMode(GLFWCursorSpecial, GLFWCursorHidden) + else: + gWindow.setCursor(gMouseCursors[igCursor.int32]) + gWindow.setInputMode(GLFWCursorSpecial, GLFWCursorNormal) + +proc igGlfwNewFrame*() = + let io = igGetIO() + assert io.fonts.isBuilt() + + var w: int32 + var h: int32 + var displayW: int32 + var displayH: int32 + + gWindow.getWindowSize(w.addr, h.addr) + gWindow.getFramebufferSize(displayW.addr, displayH.addr) + io.displaySize = ImVec2(x: w.float32, y: h.float32) + io.displayFramebufferScale = ImVec2(x: if w > 0: displayW.float32 / w.float32 else: 0.0f, y: if h > 0: displayH.float32 / h.float32 else: 0.0f) + + let currentTime = glfwGetTime() + io.deltaTime = if gTime > 0.0f: (currentTime - gTime).float32 else: (1.0f / 60.0f).float32 + gTime = currentTime + + igGlfwUpdateMousePosAndButtons() + igGlfwUpdateMouseCursor() + + # @TODO: gamepad mapping + +proc igGlfwShutdown*() = + for i in 0 ..< ImGuiMouseCursor.high.int32 + 1: + gMouseCursors[i].destroyCursor() + gMouseCursors[i] = nil + gClientApi = igGlfwClientApiUnkown diff --git a/tests/config.nims b/tests/config.nims index d085b4b..3ba2295 100644 --- a/tests/config.nims +++ b/tests/config.nims @@ -1,2 +1,6 @@ switch("path", "$projectDir/../src") switch "warning","HoleEnumConv:off" + + +switch "define","release" +switch "nimcache",".nimcache" diff --git a/tests/test.nim b/tests/test.nim index 9784c41..63ec6e6 100644 --- a/tests/test.nim +++ b/tests/test.nim @@ -1,8 +1,33 @@ +# Modified: Added docking and transparent viewport options by audin (2023/10) # Copyright 2019, NimGL contributors. import imgui, imgui/[impl_opengl, impl_glfw] import nimgl/[opengl, glfw] +#-------------- +# Configration +#-------------- + +# .--------------------------------------------..---------.-----------------------.------------ +# | Combination of flags || | Viewport | +# |--------------------------------------------||---------|-----------------------|------------ +# | fViewport | fDocking | TransparentViewport || Docking | Transparent | Outside | Description +# |:---------:|:--------:|:-------------------:||:-------:|:-----------:|:-------:| ----------- +# | false | false | false || - | - | - | +# | false | true | false || v | - | - | (Default): Only docking +# | true | - | false || v | - | v | Doncking and outside of viewport +# | - | - | true || v | v | - | Transparent Viewport and docking +# `-----------'----------'---------------------'`---------'-------------'---------'------------- +var + fDocking = true + fViewport = false + TransparentViewport = false + # +block: + if TransparentViewport: + fViewport = true + if fViewport: + fDocking = true proc main() = doAssert glfwInit() @@ -12,8 +37,10 @@ proc main() = glfwWindowHint(GLFWOpenglForwardCompat, GLFW_TRUE) glfwWindowHint(GLFWOpenglProfile, GLFW_OPENGL_CORE_PROFILE) glfwWindowHint(GLFWResizable, GLFW_TRUE) + if TransparentViewport: + glfwWindowHint(GLFWVisible, GLFW_FALSE) - var w: GLFWWindow = glfwCreateWindow(1280, 720) + var w: GLFWWindow = glfwCreateWindow(1080, 720) if w == nil: quit(-1) @@ -23,15 +50,26 @@ proc main() = doAssert glInit() let context = igCreateContext() - #let io = igGetIO() + var pio = igGetIO() + if fDocking: + pio.configFlags = (pio.configFlags.cint or DockingEnable.cint).ImGuiConfigFlags + if fViewport: + pio.configFlags = (pio.configFlags.cint or ViewportsEnable.cint).ImGuiConfigFlags + pio.configViewports_NoAutomerge = true doAssert igGlfwInitForOpenGL(w, true) - doAssert igOpenGL3Init() # default: glsl_version = "#version 130" + var clearColor:ImVec4 + if TransparentViewport: + clearColor = ImVec4(x:0f, y:0f, z:0f, w:0.0f) # Transparent + else: + clearColor = ImVec4(x:0.25f, y:0.65f, z:0.85f, w:1.0f) + igStyleColorsCherry() var show_demo: bool = true + var showFirstWindow = true var somefloat: float32 = 0.0f var counter: int32 = 0 @@ -45,31 +83,39 @@ proc main() = if show_demo: igShowDemoWindow(show_demo.addr) - # Simple window - igBegin("Hello, world!") + if showFirstWindow: + # Simple window + igBegin("Hello, world!",showFirstWindow.addr) - igText("This is some useful text.") - igCheckbox("Demo Window", show_demo.addr) + igText("This is some useful text.") + igCheckbox("Demo Window", show_demo.addr) - igSliderFloat("float", somefloat.addr, 0.0f, 1.0f) + igSliderFloat("float", somefloat.addr, 0.0f, 1.0f) - if igButton("Button", ImVec2(x: 0, y: 0)): - counter.inc - igSameLine() - igText("counter = %d", counter) + if igButton("Button", ImVec2(x: 0, y: 0)): + counter.inc + igSameLine() + igText("counter = %d", counter) - igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / igGetIO().framerate, igGetIO().framerate) - igEnd() - # End simple window + igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / igGetIO().framerate, igGetIO().framerate) + igEnd() + # End simple window igRender() - glClearColor(0.45f, 0.55f, 0.60f, 1.00f) + glClearColor(clearColor.x,clearColor.y,clearColor.z,clearColor.w) glClear(GL_COLOR_BUFFER_BIT) - igOpenGL3RenderDrawData(igGetDrawData()) + if 0 != (pio.configFlags.cint and ViewportsEnable.cint): + var backup_current_window = glfwGetCurrentContext() + igUpdatePlatformWindows() + igRenderPlatformWindowsDefault(nil, nil) + backup_current_window.makeContextCurrent() + w.swapBuffers() + if not showFirstWindow and not show_demo: + w.setWindowShouldClose(true) # End program igOpenGL3Shutdown() igGlfwShutdown() diff --git a/tools/utils.nim b/tools/utils.nim index 2c1692d..847deb8 100755 --- a/tools/utils.nim +++ b/tools/utils.nim @@ -119,7 +119,7 @@ const notDefinedStructs* = """ const preProcs* = """ # Procs -{.push warning[HoleEnumConv]: off.} +#{.push warning[HoleEnumConv]: off.} when not defined(cpp) or defined(cimguiDLL): {.push dynlib: imgui_dll, cdecl, discardable.} else: @@ -128,7 +128,7 @@ else: const postProcs* = """ {.pop.} # push dynlib / nodecl, etc... -{.pop.} # push warning[HoleEnumConv]: off +#{.pop.} # push warning[HoleEnumConv]: off """ let reservedWordsDictionary* = [