Contains some manual changes and "disables" some files that contain uncompilable codeinternals
parent
a3eb3bba92
commit
42d750d85f
97 changed files with 10472 additions and 0 deletions
@ -0,0 +1,43 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImBitVector |
||||
{ |
||||
public ImVector Storage; |
||||
} |
||||
public unsafe partial struct ImBitVectorPtr |
||||
{ |
||||
public ImBitVector* NativePtr { get; } |
||||
public ImBitVectorPtr(ImBitVector* nativePtr) => NativePtr = nativePtr; |
||||
public ImBitVectorPtr(IntPtr nativePtr) => NativePtr = (ImBitVector*)nativePtr; |
||||
public static implicit operator ImBitVectorPtr(ImBitVector* nativePtr) => new ImBitVectorPtr(nativePtr); |
||||
public static implicit operator ImBitVector* (ImBitVectorPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImBitVectorPtr(IntPtr nativePtr) => new ImBitVectorPtr(nativePtr); |
||||
public ImVector<uint> Storage => new ImVector<uint>(NativePtr->Storage); |
||||
public void Clear() |
||||
{ |
||||
ImGuiNative.ImBitVector_Clear((ImBitVector*)(NativePtr)); |
||||
} |
||||
public void ClearBit(int n) |
||||
{ |
||||
ImGuiNative.ImBitVector_ClearBit((ImBitVector*)(NativePtr), n); |
||||
} |
||||
public void Create(int sz) |
||||
{ |
||||
ImGuiNative.ImBitVector_Create((ImBitVector*)(NativePtr), sz); |
||||
} |
||||
public void SetBit(int n) |
||||
{ |
||||
ImGuiNative.ImBitVector_SetBit((ImBitVector*)(NativePtr), n); |
||||
} |
||||
public bool TestBit(int n) |
||||
{ |
||||
byte ret = ImGuiNative.ImBitVector_TestBit((ImBitVector*)(NativePtr), n); |
||||
return ret != 0; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImDrawDataBuilder |
||||
{ |
||||
public ImVector Layers_0; |
||||
public ImVector Layers_1; |
||||
} |
||||
public unsafe partial struct ImDrawDataBuilderPtr |
||||
{ |
||||
public ImDrawDataBuilder* NativePtr { get; } |
||||
public ImDrawDataBuilderPtr(ImDrawDataBuilder* nativePtr) => NativePtr = nativePtr; |
||||
public ImDrawDataBuilderPtr(IntPtr nativePtr) => NativePtr = (ImDrawDataBuilder*)nativePtr; |
||||
public static implicit operator ImDrawDataBuilderPtr(ImDrawDataBuilder* nativePtr) => new ImDrawDataBuilderPtr(nativePtr); |
||||
public static implicit operator ImDrawDataBuilder* (ImDrawDataBuilderPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImDrawDataBuilderPtr(IntPtr nativePtr) => new ImDrawDataBuilderPtr(nativePtr); |
||||
public RangeAccessor<ImVector> Layers => new RangeAccessor<ImVector>(&NativePtr->Layers_0, 2); |
||||
public void Clear() |
||||
{ |
||||
ImGuiNative.ImDrawDataBuilder_Clear((ImDrawDataBuilder*)(NativePtr)); |
||||
} |
||||
public void ClearFreeMemory() |
||||
{ |
||||
ImGuiNative.ImDrawDataBuilder_ClearFreeMemory((ImDrawDataBuilder*)(NativePtr)); |
||||
} |
||||
public void FlattenIntoSingleLayer() |
||||
{ |
||||
ImGuiNative.ImDrawDataBuilder_FlattenIntoSingleLayer((ImDrawDataBuilder*)(NativePtr)); |
||||
} |
||||
public int GetDrawListCount() |
||||
{ |
||||
int ret = ImGuiNative.ImDrawDataBuilder_GetDrawListCount((ImDrawDataBuilder*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,97 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImDrawListSharedData |
||||
{ |
||||
public Vector2 TexUvWhitePixel; |
||||
public ImFont* Font; |
||||
public float FontSize; |
||||
public float CurveTessellationTol; |
||||
public float CircleSegmentMaxError; |
||||
public Vector4 ClipRectFullscreen; |
||||
public ImDrawListFlags InitialFlags; |
||||
public Vector2 ArcFastVtx_0; |
||||
public Vector2 ArcFastVtx_1; |
||||
public Vector2 ArcFastVtx_2; |
||||
public Vector2 ArcFastVtx_3; |
||||
public Vector2 ArcFastVtx_4; |
||||
public Vector2 ArcFastVtx_5; |
||||
public Vector2 ArcFastVtx_6; |
||||
public Vector2 ArcFastVtx_7; |
||||
public Vector2 ArcFastVtx_8; |
||||
public Vector2 ArcFastVtx_9; |
||||
public Vector2 ArcFastVtx_10; |
||||
public Vector2 ArcFastVtx_11; |
||||
public Vector2 ArcFastVtx_12; |
||||
public Vector2 ArcFastVtx_13; |
||||
public Vector2 ArcFastVtx_14; |
||||
public Vector2 ArcFastVtx_15; |
||||
public Vector2 ArcFastVtx_16; |
||||
public Vector2 ArcFastVtx_17; |
||||
public Vector2 ArcFastVtx_18; |
||||
public Vector2 ArcFastVtx_19; |
||||
public Vector2 ArcFastVtx_20; |
||||
public Vector2 ArcFastVtx_21; |
||||
public Vector2 ArcFastVtx_22; |
||||
public Vector2 ArcFastVtx_23; |
||||
public Vector2 ArcFastVtx_24; |
||||
public Vector2 ArcFastVtx_25; |
||||
public Vector2 ArcFastVtx_26; |
||||
public Vector2 ArcFastVtx_27; |
||||
public Vector2 ArcFastVtx_28; |
||||
public Vector2 ArcFastVtx_29; |
||||
public Vector2 ArcFastVtx_30; |
||||
public Vector2 ArcFastVtx_31; |
||||
public Vector2 ArcFastVtx_32; |
||||
public Vector2 ArcFastVtx_33; |
||||
public Vector2 ArcFastVtx_34; |
||||
public Vector2 ArcFastVtx_35; |
||||
public Vector2 ArcFastVtx_36; |
||||
public Vector2 ArcFastVtx_37; |
||||
public Vector2 ArcFastVtx_38; |
||||
public Vector2 ArcFastVtx_39; |
||||
public Vector2 ArcFastVtx_40; |
||||
public Vector2 ArcFastVtx_41; |
||||
public Vector2 ArcFastVtx_42; |
||||
public Vector2 ArcFastVtx_43; |
||||
public Vector2 ArcFastVtx_44; |
||||
public Vector2 ArcFastVtx_45; |
||||
public Vector2 ArcFastVtx_46; |
||||
public Vector2 ArcFastVtx_47; |
||||
public float ArcFastRadiusCutoff; |
||||
public fixed byte CircleSegmentCounts[64]; |
||||
public Vector4* TexUvLines; |
||||
} |
||||
public unsafe partial struct ImDrawListSharedDataPtr |
||||
{ |
||||
public ImDrawListSharedData* NativePtr { get; } |
||||
public ImDrawListSharedDataPtr(ImDrawListSharedData* nativePtr) => NativePtr = nativePtr; |
||||
public ImDrawListSharedDataPtr(IntPtr nativePtr) => NativePtr = (ImDrawListSharedData*)nativePtr; |
||||
public static implicit operator ImDrawListSharedDataPtr(ImDrawListSharedData* nativePtr) => new ImDrawListSharedDataPtr(nativePtr); |
||||
public static implicit operator ImDrawListSharedData* (ImDrawListSharedDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImDrawListSharedDataPtr(IntPtr nativePtr) => new ImDrawListSharedDataPtr(nativePtr); |
||||
public ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvWhitePixel); |
||||
public ImFontPtr Font => new ImFontPtr(NativePtr->Font); |
||||
public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize); |
||||
public ref float CurveTessellationTol => ref Unsafe.AsRef<float>(&NativePtr->CurveTessellationTol); |
||||
public ref float CircleSegmentMaxError => ref Unsafe.AsRef<float>(&NativePtr->CircleSegmentMaxError); |
||||
public ref Vector4 ClipRectFullscreen => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRectFullscreen); |
||||
public ref ImDrawListFlags InitialFlags => ref Unsafe.AsRef<ImDrawListFlags>(&NativePtr->InitialFlags); |
||||
public RangeAccessor<Vector2> ArcFastVtx => new RangeAccessor<Vector2>(&NativePtr->ArcFastVtx_0, 48); |
||||
public ref float ArcFastRadiusCutoff => ref Unsafe.AsRef<float>(&NativePtr->ArcFastRadiusCutoff); |
||||
public RangeAccessor<byte> CircleSegmentCounts => new RangeAccessor<byte>(NativePtr->CircleSegmentCounts, 64); |
||||
public IntPtr TexUvLines { get => (IntPtr)NativePtr->TexUvLines; set => NativePtr->TexUvLines = (Vector4*)value; } |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImDrawListSharedData_destroy((IntPtr)(NativePtr)); |
||||
} |
||||
public void SetCircleTessellationMaxError(float max_error) |
||||
{ |
||||
ImGuiNative.ImDrawListSharedData_SetCircleTessellationMaxError((IntPtr)(NativePtr), max_error); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImFontBuilderIO |
||||
{ |
||||
public IntPtr FontBuilder_Build; |
||||
} |
||||
public unsafe partial struct ImFontBuilderIOPtr |
||||
{ |
||||
public ImFontBuilderIO* NativePtr { get; } |
||||
public ImFontBuilderIOPtr(ImFontBuilderIO* nativePtr) => NativePtr = nativePtr; |
||||
public ImFontBuilderIOPtr(IntPtr nativePtr) => NativePtr = (ImFontBuilderIO*)nativePtr; |
||||
public static implicit operator ImFontBuilderIOPtr(ImFontBuilderIO* nativePtr) => new ImFontBuilderIOPtr(nativePtr); |
||||
public static implicit operator ImFontBuilderIO* (ImFontBuilderIOPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImFontBuilderIOPtr(IntPtr nativePtr) => new ImFontBuilderIOPtr(nativePtr); |
||||
public ref IntPtr FontBuilder_Build => ref Unsafe.AsRef<IntPtr>(&NativePtr->FontBuilder_Build); |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,11 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiActivateFlags |
||||
{ |
||||
None = 0, |
||||
PreferInput = 1, |
||||
PreferTweak = 2, |
||||
TryToPreserveState = 4, |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiAxis |
||||
{ |
||||
None = -1, |
||||
X = 0, |
||||
Y = 1, |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiButtonFlagsPrivate |
||||
{ |
||||
ImGuiButtonFlags_PressedOnClick = 16, |
||||
ImGuiButtonFlags_PressedOnClickRelease = 32, |
||||
ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 64, |
||||
ImGuiButtonFlags_PressedOnRelease = 128, |
||||
ImGuiButtonFlags_PressedOnDoubleClick = 256, |
||||
ImGuiButtonFlags_PressedOnDragDropHold = 512, |
||||
ImGuiButtonFlags_Repeat = 1024, |
||||
ImGuiButtonFlags_FlattenChildren = 2048, |
||||
ImGuiButtonFlags_AllowItemOverlap = 4096, |
||||
ImGuiButtonFlags_DontClosePopups = 8192, |
||||
ImGuiButtonFlags_AlignTextBaseLine = 32768, |
||||
ImGuiButtonFlags_NoKeyModifiers = 65536, |
||||
ImGuiButtonFlags_NoHoldingActiveId = 131072, |
||||
ImGuiButtonFlags_NoNavFocus = 262144, |
||||
ImGuiButtonFlags_NoHoveredOnFocus = 524288, |
||||
ImGuiButtonFlags_PressedOnMask = 1008, |
||||
ImGuiButtonFlags_PressedOnDefault = 32, |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiColorMod |
||||
{ |
||||
public ImGuiCol Col; |
||||
public Vector4 BackupValue; |
||||
} |
||||
public unsafe partial struct ImGuiColorModPtr |
||||
{ |
||||
public ImGuiColorMod* NativePtr { get; } |
||||
public ImGuiColorModPtr(ImGuiColorMod* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiColorModPtr(IntPtr nativePtr) => NativePtr = (ImGuiColorMod*)nativePtr; |
||||
public static implicit operator ImGuiColorModPtr(ImGuiColorMod* nativePtr) => new ImGuiColorModPtr(nativePtr); |
||||
public static implicit operator ImGuiColorMod* (ImGuiColorModPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiColorModPtr(IntPtr nativePtr) => new ImGuiColorModPtr(nativePtr); |
||||
public ref ImGuiCol Col => ref Unsafe.AsRef<ImGuiCol>(&NativePtr->Col); |
||||
public ref Vector4 BackupValue => ref Unsafe.AsRef<Vector4>(&NativePtr->BackupValue); |
||||
} |
||||
} |
||||
@ -0,0 +1,8 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiComboFlagsPrivate |
||||
{ |
||||
ImGuiComboFlags_CustomPreview = 1048576, |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiComboPreviewData |
||||
{ |
||||
public ImRect PreviewRect; |
||||
public Vector2 BackupCursorPos; |
||||
public Vector2 BackupCursorMaxPos; |
||||
public Vector2 BackupCursorPosPrevLine; |
||||
public float BackupPrevLineTextBaseOffset; |
||||
public ImGuiLayoutType BackupLayout; |
||||
} |
||||
public unsafe partial struct ImGuiComboPreviewDataPtr |
||||
{ |
||||
public ImGuiComboPreviewData* NativePtr { get; } |
||||
public ImGuiComboPreviewDataPtr(ImGuiComboPreviewData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiComboPreviewDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiComboPreviewData*)nativePtr; |
||||
public static implicit operator ImGuiComboPreviewDataPtr(ImGuiComboPreviewData* nativePtr) => new ImGuiComboPreviewDataPtr(nativePtr); |
||||
public static implicit operator ImGuiComboPreviewData* (ImGuiComboPreviewDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiComboPreviewDataPtr(IntPtr nativePtr) => new ImGuiComboPreviewDataPtr(nativePtr); |
||||
public ref ImRect PreviewRect => ref Unsafe.AsRef<ImRect>(&NativePtr->PreviewRect); |
||||
public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos); |
||||
public ref Vector2 BackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorMaxPos); |
||||
public ref Vector2 BackupCursorPosPrevLine => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPosPrevLine); |
||||
public ref float BackupPrevLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->BackupPrevLineTextBaseOffset); |
||||
public ref ImGuiLayoutType BackupLayout => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->BackupLayout); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiComboPreviewData_destroy((ImGuiComboPreviewData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,488 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiContext |
||||
{ |
||||
public byte Initialized; |
||||
public byte FontAtlasOwnedByContext; |
||||
public ImGuiIO IO; |
||||
public ImGuiPlatformIO PlatformIO; |
||||
public ImVector InputEventsQueue; |
||||
public ImVector InputEventsTrail; |
||||
public ImGuiStyle Style; |
||||
public ImGuiConfigFlags ConfigFlagsCurrFrame; |
||||
public ImGuiConfigFlags ConfigFlagsLastFrame; |
||||
public ImFont* Font; |
||||
public float FontSize; |
||||
public float FontBaseSize; |
||||
public IntPtr DrawListSharedData; |
||||
public double Time; |
||||
public int FrameCount; |
||||
public int FrameCountEnded; |
||||
public int FrameCountPlatformEnded; |
||||
public int FrameCountRendered; |
||||
public byte WithinFrameScope; |
||||
public byte WithinFrameScopeWithImplicitWindow; |
||||
public byte WithinEndChild; |
||||
public byte GcCompactAll; |
||||
public byte TestEngineHookItems; |
||||
public void* TestEngine; |
||||
public ImVector Windows; |
||||
public ImVector WindowsFocusOrder; |
||||
public ImVector WindowsTempSortBuffer; |
||||
public ImVector CurrentWindowStack; |
||||
public ImGuiStorage WindowsById; |
||||
public int WindowsActiveCount; |
||||
public Vector2 WindowsHoverPadding; |
||||
public ImGuiWindow* CurrentWindow; |
||||
public ImGuiWindow* HoveredWindow; |
||||
public ImGuiWindow* HoveredWindowUnderMovingWindow; |
||||
public ImGuiDockNode* HoveredDockNode; |
||||
public ImGuiWindow* MovingWindow; |
||||
public ImGuiWindow* WheelingWindow; |
||||
public Vector2 WheelingWindowRefMousePos; |
||||
public float WheelingWindowTimer; |
||||
public uint DebugHookIdInfo; |
||||
public uint HoveredId; |
||||
public uint HoveredIdPreviousFrame; |
||||
public byte HoveredIdAllowOverlap; |
||||
public byte HoveredIdUsingMouseWheel; |
||||
public byte HoveredIdPreviousFrameUsingMouseWheel; |
||||
public byte HoveredIdDisabled; |
||||
public float HoveredIdTimer; |
||||
public float HoveredIdNotActiveTimer; |
||||
public uint ActiveId; |
||||
public uint ActiveIdIsAlive; |
||||
public float ActiveIdTimer; |
||||
public byte ActiveIdIsJustActivated; |
||||
public byte ActiveIdAllowOverlap; |
||||
public byte ActiveIdNoClearOnFocusLoss; |
||||
public byte ActiveIdHasBeenPressedBefore; |
||||
public byte ActiveIdHasBeenEditedBefore; |
||||
public byte ActiveIdHasBeenEditedThisFrame; |
||||
public Vector2 ActiveIdClickOffset; |
||||
public ImGuiWindow* ActiveIdWindow; |
||||
public ImGuiInputSource ActiveIdSource; |
||||
public int ActiveIdMouseButton; |
||||
public uint ActiveIdPreviousFrame; |
||||
public byte ActiveIdPreviousFrameIsAlive; |
||||
public byte ActiveIdPreviousFrameHasBeenEditedBefore; |
||||
public ImGuiWindow* ActiveIdPreviousFrameWindow; |
||||
public uint LastActiveId; |
||||
public float LastActiveIdTimer; |
||||
public byte ActiveIdUsingMouseWheel; |
||||
public uint ActiveIdUsingNavDirMask; |
||||
public uint ActiveIdUsingNavInputMask; |
||||
public ImBitArrayForNamedKeys ActiveIdUsingKeyInputMask; |
||||
public ImGuiItemFlags CurrentItemFlags; |
||||
public ImGuiNextItemData NextItemData; |
||||
public ImGuiLastItemData LastItemData; |
||||
public ImGuiNextWindowData NextWindowData; |
||||
public ImVector ColorStack; |
||||
public ImVector StyleVarStack; |
||||
public ImVector FontStack; |
||||
public ImVector FocusScopeStack; |
||||
public ImVector ItemFlagsStack; |
||||
public ImVector GroupStack; |
||||
public ImVector OpenPopupStack; |
||||
public ImVector BeginPopupStack; |
||||
public int BeginMenuCount; |
||||
public ImVector Viewports; |
||||
public float CurrentDpiScale; |
||||
public ImGuiViewportP* CurrentViewport; |
||||
public ImGuiViewportP* MouseViewport; |
||||
public ImGuiViewportP* MouseLastHoveredViewport; |
||||
public uint PlatformLastFocusedViewportId; |
||||
public ImGuiPlatformMonitor FallbackMonitor; |
||||
public int ViewportFrontMostStampCount; |
||||
public ImGuiWindow* NavWindow; |
||||
public uint NavId; |
||||
public uint NavFocusScopeId; |
||||
public uint NavActivateId; |
||||
public uint NavActivateDownId; |
||||
public uint NavActivatePressedId; |
||||
public uint NavActivateInputId; |
||||
public ImGuiActivateFlags NavActivateFlags; |
||||
public uint NavJustMovedToId; |
||||
public uint NavJustMovedToFocusScopeId; |
||||
public ImGuiModFlags NavJustMovedToKeyMods; |
||||
public uint NavNextActivateId; |
||||
public ImGuiActivateFlags NavNextActivateFlags; |
||||
public ImGuiInputSource NavInputSource; |
||||
public ImGuiNavLayer NavLayer; |
||||
public byte NavIdIsAlive; |
||||
public byte NavMousePosDirty; |
||||
public byte NavDisableHighlight; |
||||
public byte NavDisableMouseHover; |
||||
public byte NavAnyRequest; |
||||
public byte NavInitRequest; |
||||
public byte NavInitRequestFromMove; |
||||
public uint NavInitResultId; |
||||
public ImRect NavInitResultRectRel; |
||||
public byte NavMoveSubmitted; |
||||
public byte NavMoveScoringItems; |
||||
public byte NavMoveForwardToNextFrame; |
||||
public ImGuiNavMoveFlags NavMoveFlags; |
||||
public ImGuiScrollFlags NavMoveScrollFlags; |
||||
public ImGuiModFlags NavMoveKeyMods; |
||||
public ImGuiDir NavMoveDir; |
||||
public ImGuiDir NavMoveDirForDebug; |
||||
public ImGuiDir NavMoveClipDir; |
||||
public ImRect NavScoringRect; |
||||
public ImRect NavScoringNoClipRect; |
||||
public int NavScoringDebugCount; |
||||
public int NavTabbingDir; |
||||
public int NavTabbingCounter; |
||||
public ImGuiNavItemData NavMoveResultLocal; |
||||
public ImGuiNavItemData NavMoveResultLocalVisible; |
||||
public ImGuiNavItemData NavMoveResultOther; |
||||
public ImGuiNavItemData NavTabbingResultFirst; |
||||
public ImGuiWindow* NavWindowingTarget; |
||||
public ImGuiWindow* NavWindowingTargetAnim; |
||||
public ImGuiWindow* NavWindowingListWindow; |
||||
public float NavWindowingTimer; |
||||
public float NavWindowingHighlightAlpha; |
||||
public byte NavWindowingToggleLayer; |
||||
public float DimBgRatio; |
||||
public ImGuiMouseCursor MouseCursor; |
||||
public byte DragDropActive; |
||||
public byte DragDropWithinSource; |
||||
public byte DragDropWithinTarget; |
||||
public ImGuiDragDropFlags DragDropSourceFlags; |
||||
public int DragDropSourceFrameCount; |
||||
public int DragDropMouseButton; |
||||
public ImGuiPayload DragDropPayload; |
||||
public ImRect DragDropTargetRect; |
||||
public uint DragDropTargetId; |
||||
public ImGuiDragDropFlags DragDropAcceptFlags; |
||||
public float DragDropAcceptIdCurrRectSurface; |
||||
public uint DragDropAcceptIdCurr; |
||||
public uint DragDropAcceptIdPrev; |
||||
public int DragDropAcceptFrameCount; |
||||
public uint DragDropHoldJustPressedId; |
||||
public ImVector DragDropPayloadBufHeap; |
||||
public fixed byte DragDropPayloadBufLocal[16]; |
||||
public int ClipperTempDataStacked; |
||||
public ImVector ClipperTempData; |
||||
public ImGuiTable* CurrentTable; |
||||
public int TablesTempDataStacked; |
||||
public ImVector TablesTempData; |
||||
public ImPool_ImGuiTable Tables; |
||||
public ImVector TablesLastTimeActive; |
||||
public ImVector DrawChannelsTempMergeBuffer; |
||||
public ImGuiTabBar* CurrentTabBar; |
||||
public ImPool_ImGuiTabBar TabBars; |
||||
public ImVector CurrentTabBarStack; |
||||
public ImVector ShrinkWidthBuffer; |
||||
public Vector2 MouseLastValidPos; |
||||
public ImGuiInputTextState InputTextState; |
||||
public ImFont InputTextPasswordFont; |
||||
public uint TempInputId; |
||||
public ImGuiColorEditFlags ColorEditOptions; |
||||
public float ColorEditLastHue; |
||||
public float ColorEditLastSat; |
||||
public uint ColorEditLastColor; |
||||
public Vector4 ColorPickerRef; |
||||
public ImGuiComboPreviewData ComboPreviewData; |
||||
public float SliderGrabClickOffset; |
||||
public float SliderCurrentAccum; |
||||
public byte SliderCurrentAccumDirty; |
||||
public byte DragCurrentAccumDirty; |
||||
public float DragCurrentAccum; |
||||
public float DragSpeedDefaultRatio; |
||||
public float ScrollbarClickDeltaToGrabCenter; |
||||
public float DisabledAlphaBackup; |
||||
public short DisabledStackSize; |
||||
public short TooltipOverrideCount; |
||||
public float TooltipSlowDelay; |
||||
public ImVector ClipboardHandlerData; |
||||
public ImVector MenusIdSubmittedThisFrame; |
||||
public ImGuiPlatformImeData PlatformImeData; |
||||
public ImGuiPlatformImeData PlatformImeDataPrev; |
||||
public uint PlatformImeViewport; |
||||
public byte PlatformLocaleDecimalPoint; |
||||
public ImGuiDockContext DockContext; |
||||
public byte SettingsLoaded; |
||||
public float SettingsDirtyTimer; |
||||
public ImGuiTextBuffer SettingsIniData; |
||||
public ImVector SettingsHandlers; |
||||
public ImChunkStream SettingsWindows; |
||||
public ImChunkStream SettingsTables; |
||||
public ImVector Hooks; |
||||
public uint HookIdNext; |
||||
public byte LogEnabled; |
||||
public ImGuiLogType LogType; |
||||
public IntPtr LogFile; |
||||
public ImGuiTextBuffer LogBuffer; |
||||
public byte* LogNextPrefix; |
||||
public byte* LogNextSuffix; |
||||
public float LogLinePosY; |
||||
public byte LogLineFirstItem; |
||||
public int LogDepthRef; |
||||
public int LogDepthToExpand; |
||||
public int LogDepthToExpandDefault; |
||||
public ImGuiDebugLogFlags DebugLogFlags; |
||||
public ImGuiTextBuffer DebugLogBuf; |
||||
public byte DebugItemPickerActive; |
||||
public uint DebugItemPickerBreakId; |
||||
public ImGuiMetricsConfig DebugMetricsConfig; |
||||
public ImGuiStackTool DebugStackTool; |
||||
public fixed float FramerateSecPerFrame[120]; |
||||
public int FramerateSecPerFrameIdx; |
||||
public int FramerateSecPerFrameCount; |
||||
public float FramerateSecPerFrameAccum; |
||||
public int WantCaptureMouseNextFrame; |
||||
public int WantCaptureKeyboardNextFrame; |
||||
public int WantTextInputNextFrame; |
||||
public ImVector TempBuffer; |
||||
} |
||||
public unsafe partial struct ImGuiContextPtr |
||||
{ |
||||
public ImGuiContext* NativePtr { get; } |
||||
public ImGuiContextPtr(ImGuiContext* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiContextPtr(IntPtr nativePtr) => NativePtr = (ImGuiContext*)nativePtr; |
||||
public static implicit operator ImGuiContextPtr(ImGuiContext* nativePtr) => new ImGuiContextPtr(nativePtr); |
||||
public static implicit operator ImGuiContext* (ImGuiContextPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiContextPtr(IntPtr nativePtr) => new ImGuiContextPtr(nativePtr); |
||||
public ref bool Initialized => ref Unsafe.AsRef<bool>(&NativePtr->Initialized); |
||||
public ref bool FontAtlasOwnedByContext => ref Unsafe.AsRef<bool>(&NativePtr->FontAtlasOwnedByContext); |
||||
public ref ImGuiIO IO => ref Unsafe.AsRef<ImGuiIO>(&NativePtr->IO); |
||||
public ref ImGuiPlatformIO PlatformIO => ref Unsafe.AsRef<ImGuiPlatformIO>(&NativePtr->PlatformIO); |
||||
public ImPtrVector<ImGuiInputEventPtr> InputEventsQueue => new ImPtrVector<ImGuiInputEventPtr>(NativePtr->InputEventsQueue, Unsafe.SizeOf<ImGuiInputEvent>()); |
||||
public ImPtrVector<ImGuiInputEventPtr> InputEventsTrail => new ImPtrVector<ImGuiInputEventPtr>(NativePtr->InputEventsTrail, Unsafe.SizeOf<ImGuiInputEvent>()); |
||||
public ref ImGuiStyle Style => ref Unsafe.AsRef<ImGuiStyle>(&NativePtr->Style); |
||||
public ref ImGuiConfigFlags ConfigFlagsCurrFrame => ref Unsafe.AsRef<ImGuiConfigFlags>(&NativePtr->ConfigFlagsCurrFrame); |
||||
public ref ImGuiConfigFlags ConfigFlagsLastFrame => ref Unsafe.AsRef<ImGuiConfigFlags>(&NativePtr->ConfigFlagsLastFrame); |
||||
public ImFontPtr Font => new ImFontPtr(NativePtr->Font); |
||||
public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize); |
||||
public ref float FontBaseSize => ref Unsafe.AsRef<float>(&NativePtr->FontBaseSize); |
||||
public ref IntPtr DrawListSharedData => ref Unsafe.AsRef<IntPtr>(&NativePtr->DrawListSharedData); |
||||
public ref double Time => ref Unsafe.AsRef<double>(&NativePtr->Time); |
||||
public ref int FrameCount => ref Unsafe.AsRef<int>(&NativePtr->FrameCount); |
||||
public ref int FrameCountEnded => ref Unsafe.AsRef<int>(&NativePtr->FrameCountEnded); |
||||
public ref int FrameCountPlatformEnded => ref Unsafe.AsRef<int>(&NativePtr->FrameCountPlatformEnded); |
||||
public ref int FrameCountRendered => ref Unsafe.AsRef<int>(&NativePtr->FrameCountRendered); |
||||
public ref bool WithinFrameScope => ref Unsafe.AsRef<bool>(&NativePtr->WithinFrameScope); |
||||
public ref bool WithinFrameScopeWithImplicitWindow => ref Unsafe.AsRef<bool>(&NativePtr->WithinFrameScopeWithImplicitWindow); |
||||
public ref bool WithinEndChild => ref Unsafe.AsRef<bool>(&NativePtr->WithinEndChild); |
||||
public ref bool GcCompactAll => ref Unsafe.AsRef<bool>(&NativePtr->GcCompactAll); |
||||
public ref bool TestEngineHookItems => ref Unsafe.AsRef<bool>(&NativePtr->TestEngineHookItems); |
||||
public IntPtr TestEngine { get => (IntPtr)NativePtr->TestEngine; set => NativePtr->TestEngine = (void*)value; } |
||||
public ImVector<ImGuiWindowPtr> Windows => new ImVector<ImGuiWindowPtr>(NativePtr->Windows); |
||||
public ImVector<ImGuiWindowPtr> WindowsFocusOrder => new ImVector<ImGuiWindowPtr>(NativePtr->WindowsFocusOrder); |
||||
public ImVector<ImGuiWindowPtr> WindowsTempSortBuffer => new ImVector<ImGuiWindowPtr>(NativePtr->WindowsTempSortBuffer); |
||||
public ImPtrVector<ImGuiWindowStackDataPtr> CurrentWindowStack => new ImPtrVector<ImGuiWindowStackDataPtr>(NativePtr->CurrentWindowStack, Unsafe.SizeOf<ImGuiWindowStackData>()); |
||||
public ref ImGuiStorage WindowsById => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->WindowsById); |
||||
public ref int WindowsActiveCount => ref Unsafe.AsRef<int>(&NativePtr->WindowsActiveCount); |
||||
public ref Vector2 WindowsHoverPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowsHoverPadding); |
||||
public ImGuiWindowPtr CurrentWindow => new ImGuiWindowPtr(NativePtr->CurrentWindow); |
||||
public ImGuiWindowPtr HoveredWindow => new ImGuiWindowPtr(NativePtr->HoveredWindow); |
||||
public ImGuiWindowPtr HoveredWindowUnderMovingWindow => new ImGuiWindowPtr(NativePtr->HoveredWindowUnderMovingWindow); |
||||
public ImGuiDockNodePtr HoveredDockNode => new ImGuiDockNodePtr(NativePtr->HoveredDockNode); |
||||
public ImGuiWindowPtr MovingWindow => new ImGuiWindowPtr(NativePtr->MovingWindow); |
||||
public ImGuiWindowPtr WheelingWindow => new ImGuiWindowPtr(NativePtr->WheelingWindow); |
||||
public ref Vector2 WheelingWindowRefMousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->WheelingWindowRefMousePos); |
||||
public ref float WheelingWindowTimer => ref Unsafe.AsRef<float>(&NativePtr->WheelingWindowTimer); |
||||
public ref uint DebugHookIdInfo => ref Unsafe.AsRef<uint>(&NativePtr->DebugHookIdInfo); |
||||
public ref uint HoveredId => ref Unsafe.AsRef<uint>(&NativePtr->HoveredId); |
||||
public ref uint HoveredIdPreviousFrame => ref Unsafe.AsRef<uint>(&NativePtr->HoveredIdPreviousFrame); |
||||
public ref bool HoveredIdAllowOverlap => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdAllowOverlap); |
||||
public ref bool HoveredIdUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdUsingMouseWheel); |
||||
public ref bool HoveredIdPreviousFrameUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdPreviousFrameUsingMouseWheel); |
||||
public ref bool HoveredIdDisabled => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdDisabled); |
||||
public ref float HoveredIdTimer => ref Unsafe.AsRef<float>(&NativePtr->HoveredIdTimer); |
||||
public ref float HoveredIdNotActiveTimer => ref Unsafe.AsRef<float>(&NativePtr->HoveredIdNotActiveTimer); |
||||
public ref uint ActiveId => ref Unsafe.AsRef<uint>(&NativePtr->ActiveId); |
||||
public ref uint ActiveIdIsAlive => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdIsAlive); |
||||
public ref float ActiveIdTimer => ref Unsafe.AsRef<float>(&NativePtr->ActiveIdTimer); |
||||
public ref bool ActiveIdIsJustActivated => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdIsJustActivated); |
||||
public ref bool ActiveIdAllowOverlap => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdAllowOverlap); |
||||
public ref bool ActiveIdNoClearOnFocusLoss => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdNoClearOnFocusLoss); |
||||
public ref bool ActiveIdHasBeenPressedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenPressedBefore); |
||||
public ref bool ActiveIdHasBeenEditedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenEditedBefore); |
||||
public ref bool ActiveIdHasBeenEditedThisFrame => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenEditedThisFrame); |
||||
public ref Vector2 ActiveIdClickOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->ActiveIdClickOffset); |
||||
public ImGuiWindowPtr ActiveIdWindow => new ImGuiWindowPtr(NativePtr->ActiveIdWindow); |
||||
public ref ImGuiInputSource ActiveIdSource => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->ActiveIdSource); |
||||
public ref int ActiveIdMouseButton => ref Unsafe.AsRef<int>(&NativePtr->ActiveIdMouseButton); |
||||
public ref uint ActiveIdPreviousFrame => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdPreviousFrame); |
||||
public ref bool ActiveIdPreviousFrameIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdPreviousFrameIsAlive); |
||||
public ref bool ActiveIdPreviousFrameHasBeenEditedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdPreviousFrameHasBeenEditedBefore); |
||||
public ImGuiWindowPtr ActiveIdPreviousFrameWindow => new ImGuiWindowPtr(NativePtr->ActiveIdPreviousFrameWindow); |
||||
public ref uint LastActiveId => ref Unsafe.AsRef<uint>(&NativePtr->LastActiveId); |
||||
public ref float LastActiveIdTimer => ref Unsafe.AsRef<float>(&NativePtr->LastActiveIdTimer); |
||||
public ref bool ActiveIdUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdUsingMouseWheel); |
||||
public ref uint ActiveIdUsingNavDirMask => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdUsingNavDirMask); |
||||
public ref uint ActiveIdUsingNavInputMask => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdUsingNavInputMask); |
||||
public ref ImBitArrayForNamedKeys ActiveIdUsingKeyInputMask => ref Unsafe.AsRef<ImBitArrayForNamedKeys>(&NativePtr->ActiveIdUsingKeyInputMask); |
||||
public ref ImGuiItemFlags CurrentItemFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->CurrentItemFlags); |
||||
public ref ImGuiNextItemData NextItemData => ref Unsafe.AsRef<ImGuiNextItemData>(&NativePtr->NextItemData); |
||||
public ref ImGuiLastItemData LastItemData => ref Unsafe.AsRef<ImGuiLastItemData>(&NativePtr->LastItemData); |
||||
public ref ImGuiNextWindowData NextWindowData => ref Unsafe.AsRef<ImGuiNextWindowData>(&NativePtr->NextWindowData); |
||||
public ImPtrVector<ImGuiColorModPtr> ColorStack => new ImPtrVector<ImGuiColorModPtr>(NativePtr->ColorStack, Unsafe.SizeOf<ImGuiColorMod>()); |
||||
public ImPtrVector<ImGuiStyleModPtr> StyleVarStack => new ImPtrVector<ImGuiStyleModPtr>(NativePtr->StyleVarStack, Unsafe.SizeOf<ImGuiStyleMod>()); |
||||
public ImVector<ImFontPtr> FontStack => new ImVector<ImFontPtr>(NativePtr->FontStack); |
||||
public ImVector<uint> FocusScopeStack => new ImVector<uint>(NativePtr->FocusScopeStack); |
||||
public ImPtrVector<ImGuiItemFlagsPtr> ItemFlagsStack => new ImPtrVector<ImGuiItemFlagsPtr>(NativePtr->ItemFlagsStack, Unsafe.SizeOf<ImGuiItemFlags>()); |
||||
public ImPtrVector<ImGuiGroupDataPtr> GroupStack => new ImPtrVector<ImGuiGroupDataPtr>(NativePtr->GroupStack, Unsafe.SizeOf<ImGuiGroupData>()); |
||||
public ImPtrVector<ImGuiPopupDataPtr> OpenPopupStack => new ImPtrVector<ImGuiPopupDataPtr>(NativePtr->OpenPopupStack, Unsafe.SizeOf<ImGuiPopupData>()); |
||||
public ImPtrVector<ImGuiPopupDataPtr> BeginPopupStack => new ImPtrVector<ImGuiPopupDataPtr>(NativePtr->BeginPopupStack, Unsafe.SizeOf<ImGuiPopupData>()); |
||||
public ref int BeginMenuCount => ref Unsafe.AsRef<int>(&NativePtr->BeginMenuCount); |
||||
public ImVector<ImGuiViewportPPtr> Viewports => new ImVector<ImGuiViewportPPtr>(NativePtr->Viewports); |
||||
public ref float CurrentDpiScale => ref Unsafe.AsRef<float>(&NativePtr->CurrentDpiScale); |
||||
public ImGuiViewportPPtr CurrentViewport => new ImGuiViewportPPtr(NativePtr->CurrentViewport); |
||||
public ImGuiViewportPPtr MouseViewport => new ImGuiViewportPPtr(NativePtr->MouseViewport); |
||||
public ImGuiViewportPPtr MouseLastHoveredViewport => new ImGuiViewportPPtr(NativePtr->MouseLastHoveredViewport); |
||||
public ref uint PlatformLastFocusedViewportId => ref Unsafe.AsRef<uint>(&NativePtr->PlatformLastFocusedViewportId); |
||||
public ref ImGuiPlatformMonitor FallbackMonitor => ref Unsafe.AsRef<ImGuiPlatformMonitor>(&NativePtr->FallbackMonitor); |
||||
public ref int ViewportFrontMostStampCount => ref Unsafe.AsRef<int>(&NativePtr->ViewportFrontMostStampCount); |
||||
public ImGuiWindowPtr NavWindow => new ImGuiWindowPtr(NativePtr->NavWindow); |
||||
public ref uint NavId => ref Unsafe.AsRef<uint>(&NativePtr->NavId); |
||||
public ref uint NavFocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->NavFocusScopeId); |
||||
public ref uint NavActivateId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateId); |
||||
public ref uint NavActivateDownId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateDownId); |
||||
public ref uint NavActivatePressedId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivatePressedId); |
||||
public ref uint NavActivateInputId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateInputId); |
||||
public ref ImGuiActivateFlags NavActivateFlags => ref Unsafe.AsRef<ImGuiActivateFlags>(&NativePtr->NavActivateFlags); |
||||
public ref uint NavJustMovedToId => ref Unsafe.AsRef<uint>(&NativePtr->NavJustMovedToId); |
||||
public ref uint NavJustMovedToFocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->NavJustMovedToFocusScopeId); |
||||
public ref ImGuiModFlags NavJustMovedToKeyMods => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->NavJustMovedToKeyMods); |
||||
public ref uint NavNextActivateId => ref Unsafe.AsRef<uint>(&NativePtr->NavNextActivateId); |
||||
public ref ImGuiActivateFlags NavNextActivateFlags => ref Unsafe.AsRef<ImGuiActivateFlags>(&NativePtr->NavNextActivateFlags); |
||||
public ref ImGuiInputSource NavInputSource => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->NavInputSource); |
||||
public ref ImGuiNavLayer NavLayer => ref Unsafe.AsRef<ImGuiNavLayer>(&NativePtr->NavLayer); |
||||
public ref bool NavIdIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->NavIdIsAlive); |
||||
public ref bool NavMousePosDirty => ref Unsafe.AsRef<bool>(&NativePtr->NavMousePosDirty); |
||||
public ref bool NavDisableHighlight => ref Unsafe.AsRef<bool>(&NativePtr->NavDisableHighlight); |
||||
public ref bool NavDisableMouseHover => ref Unsafe.AsRef<bool>(&NativePtr->NavDisableMouseHover); |
||||
public ref bool NavAnyRequest => ref Unsafe.AsRef<bool>(&NativePtr->NavAnyRequest); |
||||
public ref bool NavInitRequest => ref Unsafe.AsRef<bool>(&NativePtr->NavInitRequest); |
||||
public ref bool NavInitRequestFromMove => ref Unsafe.AsRef<bool>(&NativePtr->NavInitRequestFromMove); |
||||
public ref uint NavInitResultId => ref Unsafe.AsRef<uint>(&NativePtr->NavInitResultId); |
||||
public ref ImRect NavInitResultRectRel => ref Unsafe.AsRef<ImRect>(&NativePtr->NavInitResultRectRel); |
||||
public ref bool NavMoveSubmitted => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveSubmitted); |
||||
public ref bool NavMoveScoringItems => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveScoringItems); |
||||
public ref bool NavMoveForwardToNextFrame => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveForwardToNextFrame); |
||||
public ref ImGuiNavMoveFlags NavMoveFlags => ref Unsafe.AsRef<ImGuiNavMoveFlags>(&NativePtr->NavMoveFlags); |
||||
public ref ImGuiScrollFlags NavMoveScrollFlags => ref Unsafe.AsRef<ImGuiScrollFlags>(&NativePtr->NavMoveScrollFlags); |
||||
public ref ImGuiModFlags NavMoveKeyMods => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->NavMoveKeyMods); |
||||
public ref ImGuiDir NavMoveDir => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveDir); |
||||
public ref ImGuiDir NavMoveDirForDebug => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveDirForDebug); |
||||
public ref ImGuiDir NavMoveClipDir => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveClipDir); |
||||
public ref ImRect NavScoringRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavScoringRect); |
||||
public ref ImRect NavScoringNoClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavScoringNoClipRect); |
||||
public ref int NavScoringDebugCount => ref Unsafe.AsRef<int>(&NativePtr->NavScoringDebugCount); |
||||
public ref int NavTabbingDir => ref Unsafe.AsRef<int>(&NativePtr->NavTabbingDir); |
||||
public ref int NavTabbingCounter => ref Unsafe.AsRef<int>(&NativePtr->NavTabbingCounter); |
||||
public ref ImGuiNavItemData NavMoveResultLocal => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultLocal); |
||||
public ref ImGuiNavItemData NavMoveResultLocalVisible => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultLocalVisible); |
||||
public ref ImGuiNavItemData NavMoveResultOther => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultOther); |
||||
public ref ImGuiNavItemData NavTabbingResultFirst => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavTabbingResultFirst); |
||||
public ImGuiWindowPtr NavWindowingTarget => new ImGuiWindowPtr(NativePtr->NavWindowingTarget); |
||||
public ImGuiWindowPtr NavWindowingTargetAnim => new ImGuiWindowPtr(NativePtr->NavWindowingTargetAnim); |
||||
public ImGuiWindowPtr NavWindowingListWindow => new ImGuiWindowPtr(NativePtr->NavWindowingListWindow); |
||||
public ref float NavWindowingTimer => ref Unsafe.AsRef<float>(&NativePtr->NavWindowingTimer); |
||||
public ref float NavWindowingHighlightAlpha => ref Unsafe.AsRef<float>(&NativePtr->NavWindowingHighlightAlpha); |
||||
public ref bool NavWindowingToggleLayer => ref Unsafe.AsRef<bool>(&NativePtr->NavWindowingToggleLayer); |
||||
public ref float DimBgRatio => ref Unsafe.AsRef<float>(&NativePtr->DimBgRatio); |
||||
public ref ImGuiMouseCursor MouseCursor => ref Unsafe.AsRef<ImGuiMouseCursor>(&NativePtr->MouseCursor); |
||||
public ref bool DragDropActive => ref Unsafe.AsRef<bool>(&NativePtr->DragDropActive); |
||||
public ref bool DragDropWithinSource => ref Unsafe.AsRef<bool>(&NativePtr->DragDropWithinSource); |
||||
public ref bool DragDropWithinTarget => ref Unsafe.AsRef<bool>(&NativePtr->DragDropWithinTarget); |
||||
public ref ImGuiDragDropFlags DragDropSourceFlags => ref Unsafe.AsRef<ImGuiDragDropFlags>(&NativePtr->DragDropSourceFlags); |
||||
public ref int DragDropSourceFrameCount => ref Unsafe.AsRef<int>(&NativePtr->DragDropSourceFrameCount); |
||||
public ref int DragDropMouseButton => ref Unsafe.AsRef<int>(&NativePtr->DragDropMouseButton); |
||||
public ref ImGuiPayload DragDropPayload => ref Unsafe.AsRef<ImGuiPayload>(&NativePtr->DragDropPayload); |
||||
public ref ImRect DragDropTargetRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DragDropTargetRect); |
||||
public ref uint DragDropTargetId => ref Unsafe.AsRef<uint>(&NativePtr->DragDropTargetId); |
||||
public ref ImGuiDragDropFlags DragDropAcceptFlags => ref Unsafe.AsRef<ImGuiDragDropFlags>(&NativePtr->DragDropAcceptFlags); |
||||
public ref float DragDropAcceptIdCurrRectSurface => ref Unsafe.AsRef<float>(&NativePtr->DragDropAcceptIdCurrRectSurface); |
||||
public ref uint DragDropAcceptIdCurr => ref Unsafe.AsRef<uint>(&NativePtr->DragDropAcceptIdCurr); |
||||
public ref uint DragDropAcceptIdPrev => ref Unsafe.AsRef<uint>(&NativePtr->DragDropAcceptIdPrev); |
||||
public ref int DragDropAcceptFrameCount => ref Unsafe.AsRef<int>(&NativePtr->DragDropAcceptFrameCount); |
||||
public ref uint DragDropHoldJustPressedId => ref Unsafe.AsRef<uint>(&NativePtr->DragDropHoldJustPressedId); |
||||
public ImVector<byte> DragDropPayloadBufHeap => new ImVector<byte>(NativePtr->DragDropPayloadBufHeap); |
||||
public RangeAccessor<byte> DragDropPayloadBufLocal => new RangeAccessor<byte>(NativePtr->DragDropPayloadBufLocal, 16); |
||||
public ref int ClipperTempDataStacked => ref Unsafe.AsRef<int>(&NativePtr->ClipperTempDataStacked); |
||||
public ImPtrVector<ImGuiListClipperDataPtr> ClipperTempData => new ImPtrVector<ImGuiListClipperDataPtr>(NativePtr->ClipperTempData, Unsafe.SizeOf<ImGuiListClipperData>()); |
||||
public ImGuiTablePtr CurrentTable => new ImGuiTablePtr(NativePtr->CurrentTable); |
||||
public ref int TablesTempDataStacked => ref Unsafe.AsRef<int>(&NativePtr->TablesTempDataStacked); |
||||
public ImPtrVector<ImGuiTableTempDataPtr> TablesTempData => new ImPtrVector<ImGuiTableTempDataPtr>(NativePtr->TablesTempData, Unsafe.SizeOf<ImGuiTableTempData>()); |
||||
public ref ImPool_ImGuiTable Tables => ref Unsafe.AsRef<ImPool_ImGuiTable>(&NativePtr->Tables); |
||||
public ImVector<float> TablesLastTimeActive => new ImVector<float>(NativePtr->TablesLastTimeActive); |
||||
public ImPtrVector<ImDrawChannelPtr> DrawChannelsTempMergeBuffer => new ImPtrVector<ImDrawChannelPtr>(NativePtr->DrawChannelsTempMergeBuffer, Unsafe.SizeOf<ImDrawChannel>()); |
||||
public ImGuiTabBarPtr CurrentTabBar => new ImGuiTabBarPtr(NativePtr->CurrentTabBar); |
||||
public ref ImPool_ImGuiTabBar TabBars => ref Unsafe.AsRef<ImPool_ImGuiTabBar>(&NativePtr->TabBars); |
||||
public ImPtrVector<ImGuiPtrOrIndexPtr> CurrentTabBarStack => new ImPtrVector<ImGuiPtrOrIndexPtr>(NativePtr->CurrentTabBarStack, Unsafe.SizeOf<ImGuiPtrOrIndex>()); |
||||
public ImPtrVector<ImGuiShrinkWidthItemPtr> ShrinkWidthBuffer => new ImPtrVector<ImGuiShrinkWidthItemPtr>(NativePtr->ShrinkWidthBuffer, Unsafe.SizeOf<ImGuiShrinkWidthItem>()); |
||||
public ref Vector2 MouseLastValidPos => ref Unsafe.AsRef<Vector2>(&NativePtr->MouseLastValidPos); |
||||
public ref ImGuiInputTextState InputTextState => ref Unsafe.AsRef<ImGuiInputTextState>(&NativePtr->InputTextState); |
||||
public ref ImFont InputTextPasswordFont => ref Unsafe.AsRef<ImFont>(&NativePtr->InputTextPasswordFont); |
||||
public ref uint TempInputId => ref Unsafe.AsRef<uint>(&NativePtr->TempInputId); |
||||
public ref ImGuiColorEditFlags ColorEditOptions => ref Unsafe.AsRef<ImGuiColorEditFlags>(&NativePtr->ColorEditOptions); |
||||
public ref float ColorEditLastHue => ref Unsafe.AsRef<float>(&NativePtr->ColorEditLastHue); |
||||
public ref float ColorEditLastSat => ref Unsafe.AsRef<float>(&NativePtr->ColorEditLastSat); |
||||
public ref uint ColorEditLastColor => ref Unsafe.AsRef<uint>(&NativePtr->ColorEditLastColor); |
||||
public ref Vector4 ColorPickerRef => ref Unsafe.AsRef<Vector4>(&NativePtr->ColorPickerRef); |
||||
public ref ImGuiComboPreviewData ComboPreviewData => ref Unsafe.AsRef<ImGuiComboPreviewData>(&NativePtr->ComboPreviewData); |
||||
public ref float SliderGrabClickOffset => ref Unsafe.AsRef<float>(&NativePtr->SliderGrabClickOffset); |
||||
public ref float SliderCurrentAccum => ref Unsafe.AsRef<float>(&NativePtr->SliderCurrentAccum); |
||||
public ref bool SliderCurrentAccumDirty => ref Unsafe.AsRef<bool>(&NativePtr->SliderCurrentAccumDirty); |
||||
public ref bool DragCurrentAccumDirty => ref Unsafe.AsRef<bool>(&NativePtr->DragCurrentAccumDirty); |
||||
public ref float DragCurrentAccum => ref Unsafe.AsRef<float>(&NativePtr->DragCurrentAccum); |
||||
public ref float DragSpeedDefaultRatio => ref Unsafe.AsRef<float>(&NativePtr->DragSpeedDefaultRatio); |
||||
public ref float ScrollbarClickDeltaToGrabCenter => ref Unsafe.AsRef<float>(&NativePtr->ScrollbarClickDeltaToGrabCenter); |
||||
public ref float DisabledAlphaBackup => ref Unsafe.AsRef<float>(&NativePtr->DisabledAlphaBackup); |
||||
public ref short DisabledStackSize => ref Unsafe.AsRef<short>(&NativePtr->DisabledStackSize); |
||||
public ref short TooltipOverrideCount => ref Unsafe.AsRef<short>(&NativePtr->TooltipOverrideCount); |
||||
public ref float TooltipSlowDelay => ref Unsafe.AsRef<float>(&NativePtr->TooltipSlowDelay); |
||||
public ImVector<byte> ClipboardHandlerData => new ImVector<byte>(NativePtr->ClipboardHandlerData); |
||||
public ImVector<uint> MenusIdSubmittedThisFrame => new ImVector<uint>(NativePtr->MenusIdSubmittedThisFrame); |
||||
public ref ImGuiPlatformImeData PlatformImeData => ref Unsafe.AsRef<ImGuiPlatformImeData>(&NativePtr->PlatformImeData); |
||||
public ref ImGuiPlatformImeData PlatformImeDataPrev => ref Unsafe.AsRef<ImGuiPlatformImeData>(&NativePtr->PlatformImeDataPrev); |
||||
public ref uint PlatformImeViewport => ref Unsafe.AsRef<uint>(&NativePtr->PlatformImeViewport); |
||||
public ref byte PlatformLocaleDecimalPoint => ref Unsafe.AsRef<byte>(&NativePtr->PlatformLocaleDecimalPoint); |
||||
public ref ImGuiDockContext DockContext => ref Unsafe.AsRef<ImGuiDockContext>(&NativePtr->DockContext); |
||||
public ref bool SettingsLoaded => ref Unsafe.AsRef<bool>(&NativePtr->SettingsLoaded); |
||||
public ref float SettingsDirtyTimer => ref Unsafe.AsRef<float>(&NativePtr->SettingsDirtyTimer); |
||||
public ref ImGuiTextBuffer SettingsIniData => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->SettingsIniData); |
||||
public ImPtrVector<ImGuiSettingsHandlerPtr> SettingsHandlers => new ImPtrVector<ImGuiSettingsHandlerPtr>(NativePtr->SettingsHandlers, Unsafe.SizeOf<ImGuiSettingsHandler>()); |
||||
public ref ImChunkStream SettingsWindows => ref Unsafe.AsRef<ImChunkStream>(&NativePtr->SettingsWindows); |
||||
public ref ImChunkStream SettingsTables => ref Unsafe.AsRef<ImChunkStream>(&NativePtr->SettingsTables); |
||||
public ImPtrVector<ImGuiContextHookPtr> Hooks => new ImPtrVector<ImGuiContextHookPtr>(NativePtr->Hooks, Unsafe.SizeOf<ImGuiContextHook>()); |
||||
public ref uint HookIdNext => ref Unsafe.AsRef<uint>(&NativePtr->HookIdNext); |
||||
public ref bool LogEnabled => ref Unsafe.AsRef<bool>(&NativePtr->LogEnabled); |
||||
public ref ImGuiLogType LogType => ref Unsafe.AsRef<ImGuiLogType>(&NativePtr->LogType); |
||||
public ref IntPtr LogFile => ref Unsafe.AsRef<IntPtr>(&NativePtr->LogFile); |
||||
public ref ImGuiTextBuffer LogBuffer => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->LogBuffer); |
||||
public IntPtr LogNextPrefix { get => (IntPtr)NativePtr->LogNextPrefix; set => NativePtr->LogNextPrefix = (byte*)value; } |
||||
public IntPtr LogNextSuffix { get => (IntPtr)NativePtr->LogNextSuffix; set => NativePtr->LogNextSuffix = (byte*)value; } |
||||
public ref float LogLinePosY => ref Unsafe.AsRef<float>(&NativePtr->LogLinePosY); |
||||
public ref bool LogLineFirstItem => ref Unsafe.AsRef<bool>(&NativePtr->LogLineFirstItem); |
||||
public ref int LogDepthRef => ref Unsafe.AsRef<int>(&NativePtr->LogDepthRef); |
||||
public ref int LogDepthToExpand => ref Unsafe.AsRef<int>(&NativePtr->LogDepthToExpand); |
||||
public ref int LogDepthToExpandDefault => ref Unsafe.AsRef<int>(&NativePtr->LogDepthToExpandDefault); |
||||
public ref ImGuiDebugLogFlags DebugLogFlags => ref Unsafe.AsRef<ImGuiDebugLogFlags>(&NativePtr->DebugLogFlags); |
||||
public ref ImGuiTextBuffer DebugLogBuf => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->DebugLogBuf); |
||||
public ref bool DebugItemPickerActive => ref Unsafe.AsRef<bool>(&NativePtr->DebugItemPickerActive); |
||||
public ref uint DebugItemPickerBreakId => ref Unsafe.AsRef<uint>(&NativePtr->DebugItemPickerBreakId); |
||||
public ref ImGuiMetricsConfig DebugMetricsConfig => ref Unsafe.AsRef<ImGuiMetricsConfig>(&NativePtr->DebugMetricsConfig); |
||||
public ref ImGuiStackTool DebugStackTool => ref Unsafe.AsRef<ImGuiStackTool>(&NativePtr->DebugStackTool); |
||||
public RangeAccessor<float> FramerateSecPerFrame => new RangeAccessor<float>(NativePtr->FramerateSecPerFrame, 120); |
||||
public ref int FramerateSecPerFrameIdx => ref Unsafe.AsRef<int>(&NativePtr->FramerateSecPerFrameIdx); |
||||
public ref int FramerateSecPerFrameCount => ref Unsafe.AsRef<int>(&NativePtr->FramerateSecPerFrameCount); |
||||
public ref float FramerateSecPerFrameAccum => ref Unsafe.AsRef<float>(&NativePtr->FramerateSecPerFrameAccum); |
||||
public ref int WantCaptureMouseNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantCaptureMouseNextFrame); |
||||
public ref int WantCaptureKeyboardNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantCaptureKeyboardNextFrame); |
||||
public ref int WantTextInputNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantTextInputNextFrame); |
||||
public ImVector<byte> TempBuffer => new ImVector<byte>(NativePtr->TempBuffer); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiContext_destroy((IntPtr)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiContextHook |
||||
{ |
||||
public uint HookId; |
||||
public ImGuiContextHookType Type; |
||||
public uint Owner; |
||||
public IntPtr Callback; |
||||
public void* UserData; |
||||
} |
||||
public unsafe partial struct ImGuiContextHookPtr |
||||
{ |
||||
public ImGuiContextHook* NativePtr { get; } |
||||
public ImGuiContextHookPtr(ImGuiContextHook* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiContextHookPtr(IntPtr nativePtr) => NativePtr = (ImGuiContextHook*)nativePtr; |
||||
public static implicit operator ImGuiContextHookPtr(ImGuiContextHook* nativePtr) => new ImGuiContextHookPtr(nativePtr); |
||||
public static implicit operator ImGuiContextHook* (ImGuiContextHookPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiContextHookPtr(IntPtr nativePtr) => new ImGuiContextHookPtr(nativePtr); |
||||
public ref uint HookId => ref Unsafe.AsRef<uint>(&NativePtr->HookId); |
||||
public ref ImGuiContextHookType Type => ref Unsafe.AsRef<ImGuiContextHookType>(&NativePtr->Type); |
||||
public ref uint Owner => ref Unsafe.AsRef<uint>(&NativePtr->Owner); |
||||
public ref IntPtr Callback => ref Unsafe.AsRef<IntPtr>(&NativePtr->Callback); |
||||
public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; } |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiContextHook_destroy((ImGuiContextHook*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,14 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiContextHookType |
||||
{ |
||||
NewFramePre = 0, |
||||
NewFramePost = 1, |
||||
EndFramePre = 2, |
||||
EndFramePost = 3, |
||||
RenderPre = 4, |
||||
RenderPost = 5, |
||||
Shutdown = 6, |
||||
PendingRemoval = 7, |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiDataAuthority |
||||
{ |
||||
Auto = 0, |
||||
DockNode = 1, |
||||
Window = 2, |
||||
} |
||||
} |
||||
@ -0,0 +1,28 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiDataTypeInfo |
||||
{ |
||||
public uint Size; |
||||
public byte* Name; |
||||
public byte* PrintFmt; |
||||
public byte* ScanFmt; |
||||
} |
||||
public unsafe partial struct ImGuiDataTypeInfoPtr |
||||
{ |
||||
public ImGuiDataTypeInfo* NativePtr { get; } |
||||
public ImGuiDataTypeInfoPtr(ImGuiDataTypeInfo* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiDataTypeInfoPtr(IntPtr nativePtr) => NativePtr = (ImGuiDataTypeInfo*)nativePtr; |
||||
public static implicit operator ImGuiDataTypeInfoPtr(ImGuiDataTypeInfo* nativePtr) => new ImGuiDataTypeInfoPtr(nativePtr); |
||||
public static implicit operator ImGuiDataTypeInfo* (ImGuiDataTypeInfoPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiDataTypeInfoPtr(IntPtr nativePtr) => new ImGuiDataTypeInfoPtr(nativePtr); |
||||
public ref uint Size => ref Unsafe.AsRef<uint>(&NativePtr->Size); |
||||
public NullTerminatedString Name => new NullTerminatedString(NativePtr->Name); |
||||
public IntPtr PrintFmt { get => (IntPtr)NativePtr->PrintFmt; set => NativePtr->PrintFmt = (byte*)value; } |
||||
public IntPtr ScanFmt { get => (IntPtr)NativePtr->ScanFmt; set => NativePtr->ScanFmt = (byte*)value; } |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiDataTypePrivate |
||||
{ |
||||
ImGuiDataType_String = 11, |
||||
ImGuiDataType_Pointer = 12, |
||||
ImGuiDataType_ID = 13, |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiDataTypeTempStorage |
||||
{ |
||||
public fixed byte Data[8]; |
||||
} |
||||
public unsafe partial struct ImGuiDataTypeTempStoragePtr |
||||
{ |
||||
public ImGuiDataTypeTempStorage* NativePtr { get; } |
||||
public ImGuiDataTypeTempStoragePtr(ImGuiDataTypeTempStorage* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiDataTypeTempStoragePtr(IntPtr nativePtr) => NativePtr = (ImGuiDataTypeTempStorage*)nativePtr; |
||||
public static implicit operator ImGuiDataTypeTempStoragePtr(ImGuiDataTypeTempStorage* nativePtr) => new ImGuiDataTypeTempStoragePtr(nativePtr); |
||||
public static implicit operator ImGuiDataTypeTempStorage* (ImGuiDataTypeTempStoragePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiDataTypeTempStoragePtr(IntPtr nativePtr) => new ImGuiDataTypeTempStoragePtr(nativePtr); |
||||
public RangeAccessor<byte> Data => new RangeAccessor<byte>(NativePtr->Data, 8); |
||||
} |
||||
} |
||||
@ -0,0 +1,17 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiDebugLogFlags |
||||
{ |
||||
None = 0, |
||||
EventActiveId = 1, |
||||
EventFocus = 2, |
||||
EventPopup = 4, |
||||
EventNav = 8, |
||||
EventIO = 16, |
||||
EventDocking = 32, |
||||
EventViewport = 64, |
||||
EventMask = 127, |
||||
OutputToTTY = 1024, |
||||
} |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiDockContext |
||||
{ |
||||
public ImGuiStorage Nodes; |
||||
public ImVector Requests; |
||||
public ImVector NodesSettings; |
||||
public byte WantFullRebuild; |
||||
} |
||||
public unsafe partial struct ImGuiDockContextPtr |
||||
{ |
||||
public ImGuiDockContext* NativePtr { get; } |
||||
public ImGuiDockContextPtr(ImGuiDockContext* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiDockContextPtr(IntPtr nativePtr) => NativePtr = (ImGuiDockContext*)nativePtr; |
||||
public static implicit operator ImGuiDockContextPtr(ImGuiDockContext* nativePtr) => new ImGuiDockContextPtr(nativePtr); |
||||
public static implicit operator ImGuiDockContext* (ImGuiDockContextPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiDockContextPtr(IntPtr nativePtr) => new ImGuiDockContextPtr(nativePtr); |
||||
public ref ImGuiStorage Nodes => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->Nodes); |
||||
public ImVector<IntPtr> Requests => new ImVector<IntPtr>(NativePtr->Requests); |
||||
public ImVector<IntPtr> NodesSettings => new ImVector<IntPtr>(NativePtr->NodesSettings); |
||||
public ref bool WantFullRebuild => ref Unsafe.AsRef<bool>(&NativePtr->WantFullRebuild); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiDockContext_destroy((ImGuiDockContext*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,166 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiDockNode |
||||
{ |
||||
public uint ID; |
||||
public ImGuiDockNodeFlags SharedFlags; |
||||
public ImGuiDockNodeFlags LocalFlags; |
||||
public ImGuiDockNodeFlags LocalFlagsInWindows; |
||||
public ImGuiDockNodeFlags MergedFlags; |
||||
public ImGuiDockNodeState State; |
||||
public ImGuiDockNode* ParentNode; |
||||
public ImGuiDockNode* ChildNodes_0; |
||||
public ImGuiDockNode* ChildNodes_1; |
||||
public ImVector Windows; |
||||
public ImGuiTabBar* TabBar; |
||||
public Vector2 Pos; |
||||
public Vector2 Size; |
||||
public Vector2 SizeRef; |
||||
public ImGuiAxis SplitAxis; |
||||
public ImGuiWindowClass WindowClass; |
||||
public uint LastBgColor; |
||||
public ImGuiWindow* HostWindow; |
||||
public ImGuiWindow* VisibleWindow; |
||||
public ImGuiDockNode* CentralNode; |
||||
public ImGuiDockNode* OnlyNodeWithWindows; |
||||
public int CountNodeWithWindows; |
||||
public int LastFrameAlive; |
||||
public int LastFrameActive; |
||||
public int LastFrameFocused; |
||||
public uint LastFocusedNodeId; |
||||
public uint SelectedTabId; |
||||
public uint WantCloseTabId; |
||||
public ImGuiDataAuthority AuthorityForPos; |
||||
public ImGuiDataAuthority AuthorityForSize; |
||||
public ImGuiDataAuthority AuthorityForViewport; |
||||
public byte IsVisible; |
||||
public byte IsFocused; |
||||
public byte IsBgDrawnThisFrame; |
||||
public byte HasCloseButton; |
||||
public byte HasWindowMenuButton; |
||||
public byte HasCentralNodeChild; |
||||
public byte WantCloseAll; |
||||
public byte WantLockSizeOnce; |
||||
public byte WantMouseMove; |
||||
public byte WantHiddenTabBarUpdate; |
||||
public byte WantHiddenTabBarToggle; |
||||
} |
||||
public unsafe partial struct ImGuiDockNodePtr |
||||
{ |
||||
public ImGuiDockNode* NativePtr { get; } |
||||
public ImGuiDockNodePtr(ImGuiDockNode* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiDockNodePtr(IntPtr nativePtr) => NativePtr = (ImGuiDockNode*)nativePtr; |
||||
public static implicit operator ImGuiDockNodePtr(ImGuiDockNode* nativePtr) => new ImGuiDockNodePtr(nativePtr); |
||||
public static implicit operator ImGuiDockNode* (ImGuiDockNodePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiDockNodePtr(IntPtr nativePtr) => new ImGuiDockNodePtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiDockNodeFlags SharedFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->SharedFlags); |
||||
public ref ImGuiDockNodeFlags LocalFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->LocalFlags); |
||||
public ref ImGuiDockNodeFlags LocalFlagsInWindows => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->LocalFlagsInWindows); |
||||
public ref ImGuiDockNodeFlags MergedFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->MergedFlags); |
||||
public ref ImGuiDockNodeState State => ref Unsafe.AsRef<ImGuiDockNodeState>(&NativePtr->State); |
||||
public ImGuiDockNodePtr ParentNode => new ImGuiDockNodePtr(NativePtr->ParentNode); |
||||
public RangeAccessor<IntPtr> ChildNodes => new RangeAccessor<IntPtr>(&NativePtr->ChildNodes_0, 2); |
||||
public ImVector<ImGuiWindowPtr> Windows => new ImVector<ImGuiWindowPtr>(NativePtr->Windows); |
||||
public ImGuiTabBarPtr TabBar => new ImGuiTabBarPtr(NativePtr->TabBar); |
||||
public ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos); |
||||
public ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size); |
||||
public ref Vector2 SizeRef => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeRef); |
||||
public ref ImGuiAxis SplitAxis => ref Unsafe.AsRef<ImGuiAxis>(&NativePtr->SplitAxis); |
||||
public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass); |
||||
public ref uint LastBgColor => ref Unsafe.AsRef<uint>(&NativePtr->LastBgColor); |
||||
public ImGuiWindowPtr HostWindow => new ImGuiWindowPtr(NativePtr->HostWindow); |
||||
public ImGuiWindowPtr VisibleWindow => new ImGuiWindowPtr(NativePtr->VisibleWindow); |
||||
public ImGuiDockNodePtr CentralNode => new ImGuiDockNodePtr(NativePtr->CentralNode); |
||||
public ImGuiDockNodePtr OnlyNodeWithWindows => new ImGuiDockNodePtr(NativePtr->OnlyNodeWithWindows); |
||||
public ref int CountNodeWithWindows => ref Unsafe.AsRef<int>(&NativePtr->CountNodeWithWindows); |
||||
public ref int LastFrameAlive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameAlive); |
||||
public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive); |
||||
public ref int LastFrameFocused => ref Unsafe.AsRef<int>(&NativePtr->LastFrameFocused); |
||||
public ref uint LastFocusedNodeId => ref Unsafe.AsRef<uint>(&NativePtr->LastFocusedNodeId); |
||||
public ref uint SelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->SelectedTabId); |
||||
public ref uint WantCloseTabId => ref Unsafe.AsRef<uint>(&NativePtr->WantCloseTabId); |
||||
public ref ImGuiDataAuthority AuthorityForPos => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForPos); |
||||
public ref ImGuiDataAuthority AuthorityForSize => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForSize); |
||||
public ref ImGuiDataAuthority AuthorityForViewport => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForViewport); |
||||
public ref bool IsVisible => ref Unsafe.AsRef<bool>(&NativePtr->IsVisible); |
||||
public ref bool IsFocused => ref Unsafe.AsRef<bool>(&NativePtr->IsFocused); |
||||
public ref bool IsBgDrawnThisFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsBgDrawnThisFrame); |
||||
public ref bool HasCloseButton => ref Unsafe.AsRef<bool>(&NativePtr->HasCloseButton); |
||||
public ref bool HasWindowMenuButton => ref Unsafe.AsRef<bool>(&NativePtr->HasWindowMenuButton); |
||||
public ref bool HasCentralNodeChild => ref Unsafe.AsRef<bool>(&NativePtr->HasCentralNodeChild); |
||||
public ref bool WantCloseAll => ref Unsafe.AsRef<bool>(&NativePtr->WantCloseAll); |
||||
public ref bool WantLockSizeOnce => ref Unsafe.AsRef<bool>(&NativePtr->WantLockSizeOnce); |
||||
public ref bool WantMouseMove => ref Unsafe.AsRef<bool>(&NativePtr->WantMouseMove); |
||||
public ref bool WantHiddenTabBarUpdate => ref Unsafe.AsRef<bool>(&NativePtr->WantHiddenTabBarUpdate); |
||||
public ref bool WantHiddenTabBarToggle => ref Unsafe.AsRef<bool>(&NativePtr->WantHiddenTabBarToggle); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiDockNode_destroy((ImGuiDockNode*)(NativePtr)); |
||||
} |
||||
public bool IsCentralNode() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsCentralNode((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsDockSpace() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsDockSpace((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsEmpty() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsEmpty((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsFloatingNode() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsFloatingNode((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsHiddenTabBar() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsHiddenTabBar((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsLeafNode() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsLeafNode((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsNoTabBar() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsNoTabBar((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsRootNode() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsRootNode((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool IsSplitNode() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiDockNode_IsSplitNode((ImGuiDockNode*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public ImRect Rect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiDockNode_Rect(&__retval, (ImGuiDockNode*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public void SetLocalFlags(ImGuiDockNodeFlags flags) |
||||
{ |
||||
ImGuiNative.ImGuiDockNode_SetLocalFlags((ImGuiDockNode*)(NativePtr), flags); |
||||
} |
||||
public void UpdateMergedFlags() |
||||
{ |
||||
ImGuiNative.ImGuiDockNode_UpdateMergedFlags((ImGuiDockNode*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiDockNodeFlagsPrivate |
||||
{ |
||||
ImGuiDockNodeFlags_DockSpace = 1024, |
||||
ImGuiDockNodeFlags_CentralNode = 2048, |
||||
ImGuiDockNodeFlags_NoTabBar = 4096, |
||||
ImGuiDockNodeFlags_HiddenTabBar = 8192, |
||||
ImGuiDockNodeFlags_NoWindowMenuButton = 16384, |
||||
ImGuiDockNodeFlags_NoCloseButton = 32768, |
||||
ImGuiDockNodeFlags_NoDocking = 65536, |
||||
ImGuiDockNodeFlags_NoDockingSplitMe = 131072, |
||||
ImGuiDockNodeFlags_NoDockingSplitOther = 262144, |
||||
ImGuiDockNodeFlags_NoDockingOverMe = 524288, |
||||
ImGuiDockNodeFlags_NoDockingOverOther = 1048576, |
||||
ImGuiDockNodeFlags_NoDockingOverEmpty = 2097152, |
||||
ImGuiDockNodeFlags_NoResizeX = 4194304, |
||||
ImGuiDockNodeFlags_NoResizeY = 8388608, |
||||
ImGuiDockNodeFlags_SharedFlagsInheritMask = -1, |
||||
ImGuiDockNodeFlags_NoResizeFlagsMask = 12582944, |
||||
ImGuiDockNodeFlags_LocalFlagsMask = 12713072, |
||||
ImGuiDockNodeFlags_LocalFlagsTransferMask = 12712048, |
||||
ImGuiDockNodeFlags_SavedFlagsMask = 12712992, |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiDockNodeState |
||||
{ |
||||
Unknown = 0, |
||||
HostWindowHiddenBecauseSingleWindow = 1, |
||||
HostWindowHiddenBecauseWindowsAreResizing = 2, |
||||
HostWindowVisible = 3, |
||||
} |
||||
} |
||||
@ -0,0 +1,42 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiGroupData |
||||
{ |
||||
public uint WindowID; |
||||
public Vector2 BackupCursorPos; |
||||
public Vector2 BackupCursorMaxPos; |
||||
public ImVec1 BackupIndent; |
||||
public ImVec1 BackupGroupOffset; |
||||
public Vector2 BackupCurrLineSize; |
||||
public float BackupCurrLineTextBaseOffset; |
||||
public uint BackupActiveIdIsAlive; |
||||
public byte BackupActiveIdPreviousFrameIsAlive; |
||||
public byte BackupHoveredIdIsAlive; |
||||
public byte EmitItem; |
||||
} |
||||
public unsafe partial struct ImGuiGroupDataPtr |
||||
{ |
||||
public ImGuiGroupData* NativePtr { get; } |
||||
public ImGuiGroupDataPtr(ImGuiGroupData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiGroupDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiGroupData*)nativePtr; |
||||
public static implicit operator ImGuiGroupDataPtr(ImGuiGroupData* nativePtr) => new ImGuiGroupDataPtr(nativePtr); |
||||
public static implicit operator ImGuiGroupData* (ImGuiGroupDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiGroupDataPtr(IntPtr nativePtr) => new ImGuiGroupDataPtr(nativePtr); |
||||
public ref uint WindowID => ref Unsafe.AsRef<uint>(&NativePtr->WindowID); |
||||
public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos); |
||||
public ref Vector2 BackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorMaxPos); |
||||
public ref ImVec1 BackupIndent => ref Unsafe.AsRef<ImVec1>(&NativePtr->BackupIndent); |
||||
public ref ImVec1 BackupGroupOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->BackupGroupOffset); |
||||
public ref Vector2 BackupCurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCurrLineSize); |
||||
public ref float BackupCurrLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->BackupCurrLineTextBaseOffset); |
||||
public ref uint BackupActiveIdIsAlive => ref Unsafe.AsRef<uint>(&NativePtr->BackupActiveIdIsAlive); |
||||
public ref bool BackupActiveIdPreviousFrameIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->BackupActiveIdPreviousFrameIsAlive); |
||||
public ref bool BackupHoveredIdIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->BackupHoveredIdIsAlive); |
||||
public ref bool EmitItem => ref Unsafe.AsRef<bool>(&NativePtr->EmitItem); |
||||
} |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEvent |
||||
{ |
||||
public ImGuiInputEventType Type; |
||||
public ImGuiInputSource Source; |
||||
public union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;} ; |
||||
public byte AddedByTestEngine; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventPtr |
||||
{ |
||||
public ImGuiInputEvent* NativePtr { get; } |
||||
public ImGuiInputEventPtr(ImGuiInputEvent* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEvent*)nativePtr; |
||||
public static implicit operator ImGuiInputEventPtr(ImGuiInputEvent* nativePtr) => new ImGuiInputEventPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEvent* (ImGuiInputEventPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventPtr(IntPtr nativePtr) => new ImGuiInputEventPtr(nativePtr); |
||||
public ref ImGuiInputEventType Type => ref Unsafe.AsRef<ImGuiInputEventType>(&NativePtr->Type); |
||||
public ref ImGuiInputSource Source => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->Source); |
||||
public ref union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;} => ref Unsafe.AsRef<union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;}>(&NativePtr->); |
||||
public ref bool AddedByTestEngine => ref Unsafe.AsRef<bool>(&NativePtr->AddedByTestEngine); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiInputEvent_destroy((ImGuiInputEvent*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventAppFocused |
||||
{ |
||||
public byte Focused; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventAppFocusedPtr |
||||
{ |
||||
public ImGuiInputEventAppFocused* NativePtr { get; } |
||||
public ImGuiInputEventAppFocusedPtr(ImGuiInputEventAppFocused* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventAppFocusedPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventAppFocused*)nativePtr; |
||||
public static implicit operator ImGuiInputEventAppFocusedPtr(ImGuiInputEventAppFocused* nativePtr) => new ImGuiInputEventAppFocusedPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventAppFocused* (ImGuiInputEventAppFocusedPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventAppFocusedPtr(IntPtr nativePtr) => new ImGuiInputEventAppFocusedPtr(nativePtr); |
||||
public ref bool Focused => ref Unsafe.AsRef<bool>(&NativePtr->Focused); |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventKey |
||||
{ |
||||
public ImGuiKey Key; |
||||
public byte Down; |
||||
public float AnalogValue; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventKeyPtr |
||||
{ |
||||
public ImGuiInputEventKey* NativePtr { get; } |
||||
public ImGuiInputEventKeyPtr(ImGuiInputEventKey* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventKeyPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventKey*)nativePtr; |
||||
public static implicit operator ImGuiInputEventKeyPtr(ImGuiInputEventKey* nativePtr) => new ImGuiInputEventKeyPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventKey* (ImGuiInputEventKeyPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventKeyPtr(IntPtr nativePtr) => new ImGuiInputEventKeyPtr(nativePtr); |
||||
public ref ImGuiKey Key => ref Unsafe.AsRef<ImGuiKey>(&NativePtr->Key); |
||||
public ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down); |
||||
public ref float AnalogValue => ref Unsafe.AsRef<float>(&NativePtr->AnalogValue); |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventMouseButton |
||||
{ |
||||
public int Button; |
||||
public byte Down; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventMouseButtonPtr |
||||
{ |
||||
public ImGuiInputEventMouseButton* NativePtr { get; } |
||||
public ImGuiInputEventMouseButtonPtr(ImGuiInputEventMouseButton* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventMouseButtonPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseButton*)nativePtr; |
||||
public static implicit operator ImGuiInputEventMouseButtonPtr(ImGuiInputEventMouseButton* nativePtr) => new ImGuiInputEventMouseButtonPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventMouseButton* (ImGuiInputEventMouseButtonPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventMouseButtonPtr(IntPtr nativePtr) => new ImGuiInputEventMouseButtonPtr(nativePtr); |
||||
public ref int Button => ref Unsafe.AsRef<int>(&NativePtr->Button); |
||||
public ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down); |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventMousePos |
||||
{ |
||||
public float PosX; |
||||
public float PosY; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventMousePosPtr |
||||
{ |
||||
public ImGuiInputEventMousePos* NativePtr { get; } |
||||
public ImGuiInputEventMousePosPtr(ImGuiInputEventMousePos* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventMousePosPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMousePos*)nativePtr; |
||||
public static implicit operator ImGuiInputEventMousePosPtr(ImGuiInputEventMousePos* nativePtr) => new ImGuiInputEventMousePosPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventMousePos* (ImGuiInputEventMousePosPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventMousePosPtr(IntPtr nativePtr) => new ImGuiInputEventMousePosPtr(nativePtr); |
||||
public ref float PosX => ref Unsafe.AsRef<float>(&NativePtr->PosX); |
||||
public ref float PosY => ref Unsafe.AsRef<float>(&NativePtr->PosY); |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventMouseViewport |
||||
{ |
||||
public uint HoveredViewportID; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventMouseViewportPtr |
||||
{ |
||||
public ImGuiInputEventMouseViewport* NativePtr { get; } |
||||
public ImGuiInputEventMouseViewportPtr(ImGuiInputEventMouseViewport* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventMouseViewportPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseViewport*)nativePtr; |
||||
public static implicit operator ImGuiInputEventMouseViewportPtr(ImGuiInputEventMouseViewport* nativePtr) => new ImGuiInputEventMouseViewportPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventMouseViewport* (ImGuiInputEventMouseViewportPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventMouseViewportPtr(IntPtr nativePtr) => new ImGuiInputEventMouseViewportPtr(nativePtr); |
||||
public ref uint HoveredViewportID => ref Unsafe.AsRef<uint>(&NativePtr->HoveredViewportID); |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventMouseWheel |
||||
{ |
||||
public float WheelX; |
||||
public float WheelY; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventMouseWheelPtr |
||||
{ |
||||
public ImGuiInputEventMouseWheel* NativePtr { get; } |
||||
public ImGuiInputEventMouseWheelPtr(ImGuiInputEventMouseWheel* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventMouseWheelPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseWheel*)nativePtr; |
||||
public static implicit operator ImGuiInputEventMouseWheelPtr(ImGuiInputEventMouseWheel* nativePtr) => new ImGuiInputEventMouseWheelPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventMouseWheel* (ImGuiInputEventMouseWheelPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventMouseWheelPtr(IntPtr nativePtr) => new ImGuiInputEventMouseWheelPtr(nativePtr); |
||||
public ref float WheelX => ref Unsafe.AsRef<float>(&NativePtr->WheelX); |
||||
public ref float WheelY => ref Unsafe.AsRef<float>(&NativePtr->WheelY); |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputEventText |
||||
{ |
||||
public uint Char; |
||||
} |
||||
public unsafe partial struct ImGuiInputEventTextPtr |
||||
{ |
||||
public ImGuiInputEventText* NativePtr { get; } |
||||
public ImGuiInputEventTextPtr(ImGuiInputEventText* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputEventTextPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventText*)nativePtr; |
||||
public static implicit operator ImGuiInputEventTextPtr(ImGuiInputEventText* nativePtr) => new ImGuiInputEventTextPtr(nativePtr); |
||||
public static implicit operator ImGuiInputEventText* (ImGuiInputEventTextPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputEventTextPtr(IntPtr nativePtr) => new ImGuiInputEventTextPtr(nativePtr); |
||||
public ref uint Char => ref Unsafe.AsRef<uint>(&NativePtr->Char); |
||||
} |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiInputEventType |
||||
{ |
||||
None = 0, |
||||
MousePos = 1, |
||||
MouseWheel = 2, |
||||
MouseButton = 3, |
||||
MouseViewport = 4, |
||||
Key = 5, |
||||
Text = 6, |
||||
Focus = 7, |
||||
COUNT = 8, |
||||
} |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiInputSource |
||||
{ |
||||
None = 0, |
||||
Mouse = 1, |
||||
Keyboard = 2, |
||||
Gamepad = 3, |
||||
Clipboard = 4, |
||||
Nav = 5, |
||||
COUNT = 6, |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiInputTextFlagsPrivate |
||||
{ |
||||
ImGuiInputTextFlags_Multiline = 67108864, |
||||
ImGuiInputTextFlags_NoMarkEdited = 134217728, |
||||
ImGuiInputTextFlags_MergedItem = 268435456, |
||||
} |
||||
} |
||||
@ -0,0 +1,112 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiInputTextState |
||||
{ |
||||
public uint ID; |
||||
public int CurLenW; |
||||
public int CurLenA; |
||||
public ImVector TextW; |
||||
public ImVector TextA; |
||||
public ImVector InitialTextA; |
||||
public byte TextAIsValid; |
||||
public int BufCapacityA; |
||||
public float ScrollX; |
||||
public STB_TexteditState Stb; |
||||
public float CursorAnim; |
||||
public byte CursorFollow; |
||||
public byte SelectedAllMouseLock; |
||||
public byte Edited; |
||||
public ImGuiInputTextFlags Flags; |
||||
} |
||||
public unsafe partial struct ImGuiInputTextStatePtr |
||||
{ |
||||
public ImGuiInputTextState* NativePtr { get; } |
||||
public ImGuiInputTextStatePtr(ImGuiInputTextState* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiInputTextStatePtr(IntPtr nativePtr) => NativePtr = (ImGuiInputTextState*)nativePtr; |
||||
public static implicit operator ImGuiInputTextStatePtr(ImGuiInputTextState* nativePtr) => new ImGuiInputTextStatePtr(nativePtr); |
||||
public static implicit operator ImGuiInputTextState* (ImGuiInputTextStatePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiInputTextStatePtr(IntPtr nativePtr) => new ImGuiInputTextStatePtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref int CurLenW => ref Unsafe.AsRef<int>(&NativePtr->CurLenW); |
||||
public ref int CurLenA => ref Unsafe.AsRef<int>(&NativePtr->CurLenA); |
||||
public ImVector<ushort> TextW => new ImVector<ushort>(NativePtr->TextW); |
||||
public ImVector<byte> TextA => new ImVector<byte>(NativePtr->TextA); |
||||
public ImVector<byte> InitialTextA => new ImVector<byte>(NativePtr->InitialTextA); |
||||
public ref bool TextAIsValid => ref Unsafe.AsRef<bool>(&NativePtr->TextAIsValid); |
||||
public ref int BufCapacityA => ref Unsafe.AsRef<int>(&NativePtr->BufCapacityA); |
||||
public ref float ScrollX => ref Unsafe.AsRef<float>(&NativePtr->ScrollX); |
||||
public ref STB_TexteditState Stb => ref Unsafe.AsRef<STB_TexteditState>(&NativePtr->Stb); |
||||
public ref float CursorAnim => ref Unsafe.AsRef<float>(&NativePtr->CursorAnim); |
||||
public ref bool CursorFollow => ref Unsafe.AsRef<bool>(&NativePtr->CursorFollow); |
||||
public ref bool SelectedAllMouseLock => ref Unsafe.AsRef<bool>(&NativePtr->SelectedAllMouseLock); |
||||
public ref bool Edited => ref Unsafe.AsRef<bool>(&NativePtr->Edited); |
||||
public ref ImGuiInputTextFlags Flags => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->Flags); |
||||
public void ClearFreeMemory() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_ClearFreeMemory((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public void ClearSelection() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_ClearSelection((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public void ClearText() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_ClearText((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public void CursorAnimReset() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_CursorAnimReset((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public void CursorClamp() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_CursorClamp((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_destroy((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
public int GetCursorPos() |
||||
{ |
||||
int ret = ImGuiNative.ImGuiInputTextState_GetCursorPos((ImGuiInputTextState*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public int GetRedoAvailCount() |
||||
{ |
||||
int ret = ImGuiNative.ImGuiInputTextState_GetRedoAvailCount((ImGuiInputTextState*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public int GetSelectionEnd() |
||||
{ |
||||
int ret = ImGuiNative.ImGuiInputTextState_GetSelectionEnd((ImGuiInputTextState*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public int GetSelectionStart() |
||||
{ |
||||
int ret = ImGuiNative.ImGuiInputTextState_GetSelectionStart((ImGuiInputTextState*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public int GetUndoAvailCount() |
||||
{ |
||||
int ret = ImGuiNative.ImGuiInputTextState_GetUndoAvailCount((ImGuiInputTextState*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public bool HasSelection() |
||||
{ |
||||
byte ret = ImGuiNative.ImGuiInputTextState_HasSelection((ImGuiInputTextState*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public void OnKeyPressed(int key) |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_OnKeyPressed((ImGuiInputTextState*)(NativePtr), key); |
||||
} |
||||
public void SelectAll() |
||||
{ |
||||
ImGuiNative.ImGuiInputTextState_SelectAll((ImGuiInputTextState*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,17 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiItemFlags |
||||
{ |
||||
None = 0, |
||||
NoTabStop = 1, |
||||
ButtonRepeat = 2, |
||||
Disabled = 4, |
||||
NoNav = 8, |
||||
NoNavDefaultFocus = 16, |
||||
SelectableDontClosePopup = 32, |
||||
MixedValue = 64, |
||||
ReadOnly = 128, |
||||
Inputable = 256, |
||||
} |
||||
} |
||||
@ -0,0 +1,17 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiItemStatusFlags |
||||
{ |
||||
None = 0, |
||||
HoveredRect = 1, |
||||
HasDisplayRect = 2, |
||||
Edited = 4, |
||||
ToggledSelection = 8, |
||||
ToggledOpen = 16, |
||||
HasDeactivated = 32, |
||||
Deactivated = 64, |
||||
HoveredWindow = 128, |
||||
FocusedByTabbing = 256, |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiKeyPrivate |
||||
{ |
||||
ImGuiKey_LegacyNativeKey_BEGIN = 0, |
||||
ImGuiKey_LegacyNativeKey_END = 512, |
||||
ImGuiKey_Gamepad_BEGIN = 617, |
||||
ImGuiKey_Gamepad_END = 641, |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiLastItemData |
||||
{ |
||||
public uint ID; |
||||
public ImGuiItemFlags InFlags; |
||||
public ImGuiItemStatusFlags StatusFlags; |
||||
public ImRect Rect; |
||||
public ImRect NavRect; |
||||
public ImRect DisplayRect; |
||||
} |
||||
public unsafe partial struct ImGuiLastItemDataPtr |
||||
{ |
||||
public ImGuiLastItemData* NativePtr { get; } |
||||
public ImGuiLastItemDataPtr(ImGuiLastItemData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiLastItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiLastItemData*)nativePtr; |
||||
public static implicit operator ImGuiLastItemDataPtr(ImGuiLastItemData* nativePtr) => new ImGuiLastItemDataPtr(nativePtr); |
||||
public static implicit operator ImGuiLastItemData* (ImGuiLastItemDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiLastItemDataPtr(IntPtr nativePtr) => new ImGuiLastItemDataPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiItemFlags InFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->InFlags); |
||||
public ref ImGuiItemStatusFlags StatusFlags => ref Unsafe.AsRef<ImGuiItemStatusFlags>(&NativePtr->StatusFlags); |
||||
public ref ImRect Rect => ref Unsafe.AsRef<ImRect>(&NativePtr->Rect); |
||||
public ref ImRect NavRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavRect); |
||||
public ref ImRect DisplayRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DisplayRect); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiLastItemData_destroy((ImGuiLastItemData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,8 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiLayoutType |
||||
{ |
||||
Horizontal = 0, |
||||
Vertical = 1, |
||||
} |
||||
} |
||||
@ -0,0 +1,39 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiListClipperData |
||||
{ |
||||
public ImGuiListClipper* ListClipper; |
||||
public float LossynessOffset; |
||||
public int StepNo; |
||||
public int ItemsFrozen; |
||||
public ImVector Ranges; |
||||
} |
||||
public unsafe partial struct ImGuiListClipperDataPtr |
||||
{ |
||||
public ImGuiListClipperData* NativePtr { get; } |
||||
public ImGuiListClipperDataPtr(ImGuiListClipperData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiListClipperDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiListClipperData*)nativePtr; |
||||
public static implicit operator ImGuiListClipperDataPtr(ImGuiListClipperData* nativePtr) => new ImGuiListClipperDataPtr(nativePtr); |
||||
public static implicit operator ImGuiListClipperData* (ImGuiListClipperDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiListClipperDataPtr(IntPtr nativePtr) => new ImGuiListClipperDataPtr(nativePtr); |
||||
public ImGuiListClipperPtr ListClipper => new ImGuiListClipperPtr(NativePtr->ListClipper); |
||||
public ref float LossynessOffset => ref Unsafe.AsRef<float>(&NativePtr->LossynessOffset); |
||||
public ref int StepNo => ref Unsafe.AsRef<int>(&NativePtr->StepNo); |
||||
public ref int ItemsFrozen => ref Unsafe.AsRef<int>(&NativePtr->ItemsFrozen); |
||||
public ImPtrVector<ImGuiListClipperRangePtr> Ranges => new ImPtrVector<ImGuiListClipperRangePtr>(NativePtr->Ranges, Unsafe.SizeOf<ImGuiListClipperRange>()); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiListClipperData_destroy((ImGuiListClipperData*)(NativePtr)); |
||||
} |
||||
public void Reset(ImGuiListClipperPtr clipper) |
||||
{ |
||||
ImGuiListClipper* native_clipper = clipper.NativePtr; |
||||
ImGuiNative.ImGuiListClipperData_Reset((ImGuiListClipperData*)(NativePtr), native_clipper); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiListClipperRange |
||||
{ |
||||
public int Min; |
||||
public int Max; |
||||
public byte PosToIndexConvert; |
||||
public sbyte PosToIndexOffsetMin; |
||||
public sbyte PosToIndexOffsetMax; |
||||
} |
||||
public unsafe partial struct ImGuiListClipperRangePtr |
||||
{ |
||||
public ImGuiListClipperRange* NativePtr { get; } |
||||
public ImGuiListClipperRangePtr(ImGuiListClipperRange* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiListClipperRangePtr(IntPtr nativePtr) => NativePtr = (ImGuiListClipperRange*)nativePtr; |
||||
public static implicit operator ImGuiListClipperRangePtr(ImGuiListClipperRange* nativePtr) => new ImGuiListClipperRangePtr(nativePtr); |
||||
public static implicit operator ImGuiListClipperRange* (ImGuiListClipperRangePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiListClipperRangePtr(IntPtr nativePtr) => new ImGuiListClipperRangePtr(nativePtr); |
||||
public ref int Min => ref Unsafe.AsRef<int>(&NativePtr->Min); |
||||
public ref int Max => ref Unsafe.AsRef<int>(&NativePtr->Max); |
||||
public ref bool PosToIndexConvert => ref Unsafe.AsRef<bool>(&NativePtr->PosToIndexConvert); |
||||
public ref sbyte PosToIndexOffsetMin => ref Unsafe.AsRef<sbyte>(&NativePtr->PosToIndexOffsetMin); |
||||
public ref sbyte PosToIndexOffsetMax => ref Unsafe.AsRef<sbyte>(&NativePtr->PosToIndexOffsetMax); |
||||
public ImGuiListClipperRange FromIndices(int min, int max) |
||||
{ |
||||
ImGuiListClipperRange ret = ImGuiNative.ImGuiListClipperRange_FromIndices(min, max); |
||||
return ret; |
||||
} |
||||
public ImGuiListClipperRange FromPositions(float y1, float y2, int off_min, int off_max) |
||||
{ |
||||
ImGuiListClipperRange ret = ImGuiNative.ImGuiListClipperRange_FromPositions(y1, y2, off_min, off_max); |
||||
return ret; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,11 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiLogType |
||||
{ |
||||
None = 0, |
||||
TTY = 1, |
||||
File = 2, |
||||
Buffer = 3, |
||||
Clipboard = 4, |
||||
} |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiMenuColumns |
||||
{ |
||||
public uint TotalWidth; |
||||
public uint NextTotalWidth; |
||||
public ushort Spacing; |
||||
public ushort OffsetIcon; |
||||
public ushort OffsetLabel; |
||||
public ushort OffsetShortcut; |
||||
public ushort OffsetMark; |
||||
public fixed ushort Widths[4]; |
||||
} |
||||
public unsafe partial struct ImGuiMenuColumnsPtr |
||||
{ |
||||
public ImGuiMenuColumns* NativePtr { get; } |
||||
public ImGuiMenuColumnsPtr(ImGuiMenuColumns* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiMenuColumnsPtr(IntPtr nativePtr) => NativePtr = (ImGuiMenuColumns*)nativePtr; |
||||
public static implicit operator ImGuiMenuColumnsPtr(ImGuiMenuColumns* nativePtr) => new ImGuiMenuColumnsPtr(nativePtr); |
||||
public static implicit operator ImGuiMenuColumns* (ImGuiMenuColumnsPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiMenuColumnsPtr(IntPtr nativePtr) => new ImGuiMenuColumnsPtr(nativePtr); |
||||
public ref uint TotalWidth => ref Unsafe.AsRef<uint>(&NativePtr->TotalWidth); |
||||
public ref uint NextTotalWidth => ref Unsafe.AsRef<uint>(&NativePtr->NextTotalWidth); |
||||
public ref ushort Spacing => ref Unsafe.AsRef<ushort>(&NativePtr->Spacing); |
||||
public ref ushort OffsetIcon => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetIcon); |
||||
public ref ushort OffsetLabel => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetLabel); |
||||
public ref ushort OffsetShortcut => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetShortcut); |
||||
public ref ushort OffsetMark => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetMark); |
||||
public RangeAccessor<ushort> Widths => new RangeAccessor<ushort>(NativePtr->Widths, 4); |
||||
public void CalcNextTotalWidth(bool update_offsets) |
||||
{ |
||||
byte native_update_offsets = update_offsets ? (byte)1 : (byte)0; |
||||
ImGuiNative.ImGuiMenuColumns_CalcNextTotalWidth((ImGuiMenuColumns*)(NativePtr), native_update_offsets); |
||||
} |
||||
public float DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark) |
||||
{ |
||||
float ret = ImGuiNative.ImGuiMenuColumns_DeclColumns((ImGuiMenuColumns*)(NativePtr), w_icon, w_label, w_shortcut, w_mark); |
||||
return ret; |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiMenuColumns_destroy((ImGuiMenuColumns*)(NativePtr)); |
||||
} |
||||
public void Update(float spacing, bool window_reappearing) |
||||
{ |
||||
byte native_window_reappearing = window_reappearing ? (byte)1 : (byte)0; |
||||
ImGuiNative.ImGuiMenuColumns_Update((ImGuiMenuColumns*)(NativePtr), spacing, native_window_reappearing); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,44 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiMetricsConfig |
||||
{ |
||||
public byte ShowDebugLog; |
||||
public byte ShowStackTool; |
||||
public byte ShowWindowsRects; |
||||
public byte ShowWindowsBeginOrder; |
||||
public byte ShowTablesRects; |
||||
public byte ShowDrawCmdMesh; |
||||
public byte ShowDrawCmdBoundingBoxes; |
||||
public byte ShowDockingNodes; |
||||
public int ShowWindowsRectsType; |
||||
public int ShowTablesRectsType; |
||||
} |
||||
public unsafe partial struct ImGuiMetricsConfigPtr |
||||
{ |
||||
public ImGuiMetricsConfig* NativePtr { get; } |
||||
public ImGuiMetricsConfigPtr(ImGuiMetricsConfig* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiMetricsConfigPtr(IntPtr nativePtr) => NativePtr = (ImGuiMetricsConfig*)nativePtr; |
||||
public static implicit operator ImGuiMetricsConfigPtr(ImGuiMetricsConfig* nativePtr) => new ImGuiMetricsConfigPtr(nativePtr); |
||||
public static implicit operator ImGuiMetricsConfig* (ImGuiMetricsConfigPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiMetricsConfigPtr(IntPtr nativePtr) => new ImGuiMetricsConfigPtr(nativePtr); |
||||
public ref bool ShowDebugLog => ref Unsafe.AsRef<bool>(&NativePtr->ShowDebugLog); |
||||
public ref bool ShowStackTool => ref Unsafe.AsRef<bool>(&NativePtr->ShowStackTool); |
||||
public ref bool ShowWindowsRects => ref Unsafe.AsRef<bool>(&NativePtr->ShowWindowsRects); |
||||
public ref bool ShowWindowsBeginOrder => ref Unsafe.AsRef<bool>(&NativePtr->ShowWindowsBeginOrder); |
||||
public ref bool ShowTablesRects => ref Unsafe.AsRef<bool>(&NativePtr->ShowTablesRects); |
||||
public ref bool ShowDrawCmdMesh => ref Unsafe.AsRef<bool>(&NativePtr->ShowDrawCmdMesh); |
||||
public ref bool ShowDrawCmdBoundingBoxes => ref Unsafe.AsRef<bool>(&NativePtr->ShowDrawCmdBoundingBoxes); |
||||
public ref bool ShowDockingNodes => ref Unsafe.AsRef<bool>(&NativePtr->ShowDockingNodes); |
||||
public ref int ShowWindowsRectsType => ref Unsafe.AsRef<int>(&NativePtr->ShowWindowsRectsType); |
||||
public ref int ShowTablesRectsType => ref Unsafe.AsRef<int>(&NativePtr->ShowTablesRectsType); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiMetricsConfig_destroy((ImGuiMetricsConfig*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,12 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiNavDirSourceFlags |
||||
{ |
||||
None = 0, |
||||
RawKeyboard = 1, |
||||
Keyboard = 2, |
||||
PadDPad = 4, |
||||
PadLStick = 8, |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiNavHighlightFlags |
||||
{ |
||||
None = 0, |
||||
TypeDefault = 1, |
||||
TypeThin = 2, |
||||
AlwaysDraw = 4, |
||||
NoRounding = 8, |
||||
} |
||||
} |
||||
@ -0,0 +1,44 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiNavItemData |
||||
{ |
||||
public ImGuiWindow* Window; |
||||
public uint ID; |
||||
public uint FocusScopeId; |
||||
public ImRect RectRel; |
||||
public ImGuiItemFlags InFlags; |
||||
public float DistBox; |
||||
public float DistCenter; |
||||
public float DistAxial; |
||||
} |
||||
public unsafe partial struct ImGuiNavItemDataPtr |
||||
{ |
||||
public ImGuiNavItemData* NativePtr { get; } |
||||
public ImGuiNavItemDataPtr(ImGuiNavItemData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiNavItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNavItemData*)nativePtr; |
||||
public static implicit operator ImGuiNavItemDataPtr(ImGuiNavItemData* nativePtr) => new ImGuiNavItemDataPtr(nativePtr); |
||||
public static implicit operator ImGuiNavItemData* (ImGuiNavItemDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiNavItemDataPtr(IntPtr nativePtr) => new ImGuiNavItemDataPtr(nativePtr); |
||||
public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref uint FocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->FocusScopeId); |
||||
public ref ImRect RectRel => ref Unsafe.AsRef<ImRect>(&NativePtr->RectRel); |
||||
public ref ImGuiItemFlags InFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->InFlags); |
||||
public ref float DistBox => ref Unsafe.AsRef<float>(&NativePtr->DistBox); |
||||
public ref float DistCenter => ref Unsafe.AsRef<float>(&NativePtr->DistCenter); |
||||
public ref float DistAxial => ref Unsafe.AsRef<float>(&NativePtr->DistAxial); |
||||
public void Clear() |
||||
{ |
||||
ImGuiNative.ImGuiNavItemData_Clear((ImGuiNavItemData*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiNavItemData_destroy((ImGuiNavItemData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiNavLayer |
||||
{ |
||||
Main = 0, |
||||
Menu = 1, |
||||
COUNT = 2, |
||||
} |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiNavMoveFlags |
||||
{ |
||||
None = 0, |
||||
LoopX = 1, |
||||
LoopY = 2, |
||||
WrapX = 4, |
||||
WrapY = 8, |
||||
AllowCurrentNavId = 16, |
||||
AlsoScoreVisibleSet = 32, |
||||
ScrollToEdgeY = 64, |
||||
Forwarded = 128, |
||||
DebugNoResult = 256, |
||||
FocusApi = 512, |
||||
Tabbing = 1024, |
||||
Activate = 2048, |
||||
DontSetNavHighlight = 4096, |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiNavReadMode |
||||
{ |
||||
Down = 0, |
||||
Pressed = 1, |
||||
Released = 2, |
||||
Repeat = 3, |
||||
RepeatSlow = 4, |
||||
RepeatFast = 5, |
||||
} |
||||
} |
||||
@ -0,0 +1,38 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiNextItemData |
||||
{ |
||||
public ImGuiNextItemDataFlags Flags; |
||||
public float Width; |
||||
public uint FocusScopeId; |
||||
public ImGuiCond OpenCond; |
||||
public byte OpenVal; |
||||
} |
||||
public unsafe partial struct ImGuiNextItemDataPtr |
||||
{ |
||||
public ImGuiNextItemData* NativePtr { get; } |
||||
public ImGuiNextItemDataPtr(ImGuiNextItemData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiNextItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNextItemData*)nativePtr; |
||||
public static implicit operator ImGuiNextItemDataPtr(ImGuiNextItemData* nativePtr) => new ImGuiNextItemDataPtr(nativePtr); |
||||
public static implicit operator ImGuiNextItemData* (ImGuiNextItemDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiNextItemDataPtr(IntPtr nativePtr) => new ImGuiNextItemDataPtr(nativePtr); |
||||
public ref ImGuiNextItemDataFlags Flags => ref Unsafe.AsRef<ImGuiNextItemDataFlags>(&NativePtr->Flags); |
||||
public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width); |
||||
public ref uint FocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->FocusScopeId); |
||||
public ref ImGuiCond OpenCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->OpenCond); |
||||
public ref bool OpenVal => ref Unsafe.AsRef<bool>(&NativePtr->OpenVal); |
||||
public void ClearFlags() |
||||
{ |
||||
ImGuiNative.ImGuiNextItemData_ClearFlags((ImGuiNextItemData*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiNextItemData_destroy((ImGuiNextItemData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiNextItemDataFlags |
||||
{ |
||||
None = 0, |
||||
HasWidth = 1, |
||||
HasOpen = 2, |
||||
} |
||||
} |
||||
@ -0,0 +1,68 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiNextWindowData |
||||
{ |
||||
public ImGuiNextWindowDataFlags Flags; |
||||
public ImGuiCond PosCond; |
||||
public ImGuiCond SizeCond; |
||||
public ImGuiCond CollapsedCond; |
||||
public ImGuiCond DockCond; |
||||
public Vector2 PosVal; |
||||
public Vector2 PosPivotVal; |
||||
public Vector2 SizeVal; |
||||
public Vector2 ContentSizeVal; |
||||
public Vector2 ScrollVal; |
||||
public byte PosUndock; |
||||
public byte CollapsedVal; |
||||
public ImRect SizeConstraintRect; |
||||
public ImGuiSizeCallback SizeCallback; |
||||
public void* SizeCallbackUserData; |
||||
public float BgAlphaVal; |
||||
public uint ViewportId; |
||||
public uint DockId; |
||||
public ImGuiWindowClass WindowClass; |
||||
public Vector2 MenuBarOffsetMinVal; |
||||
} |
||||
public unsafe partial struct ImGuiNextWindowDataPtr |
||||
{ |
||||
public ImGuiNextWindowData* NativePtr { get; } |
||||
public ImGuiNextWindowDataPtr(ImGuiNextWindowData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiNextWindowDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNextWindowData*)nativePtr; |
||||
public static implicit operator ImGuiNextWindowDataPtr(ImGuiNextWindowData* nativePtr) => new ImGuiNextWindowDataPtr(nativePtr); |
||||
public static implicit operator ImGuiNextWindowData* (ImGuiNextWindowDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiNextWindowDataPtr(IntPtr nativePtr) => new ImGuiNextWindowDataPtr(nativePtr); |
||||
public ref ImGuiNextWindowDataFlags Flags => ref Unsafe.AsRef<ImGuiNextWindowDataFlags>(&NativePtr->Flags); |
||||
public ref ImGuiCond PosCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->PosCond); |
||||
public ref ImGuiCond SizeCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SizeCond); |
||||
public ref ImGuiCond CollapsedCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->CollapsedCond); |
||||
public ref ImGuiCond DockCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->DockCond); |
||||
public ref Vector2 PosVal => ref Unsafe.AsRef<Vector2>(&NativePtr->PosVal); |
||||
public ref Vector2 PosPivotVal => ref Unsafe.AsRef<Vector2>(&NativePtr->PosPivotVal); |
||||
public ref Vector2 SizeVal => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeVal); |
||||
public ref Vector2 ContentSizeVal => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeVal); |
||||
public ref Vector2 ScrollVal => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollVal); |
||||
public ref bool PosUndock => ref Unsafe.AsRef<bool>(&NativePtr->PosUndock); |
||||
public ref bool CollapsedVal => ref Unsafe.AsRef<bool>(&NativePtr->CollapsedVal); |
||||
public ref ImRect SizeConstraintRect => ref Unsafe.AsRef<ImRect>(&NativePtr->SizeConstraintRect); |
||||
public ref ImGuiSizeCallback SizeCallback => ref Unsafe.AsRef<ImGuiSizeCallback>(&NativePtr->SizeCallback); |
||||
public IntPtr SizeCallbackUserData { get => (IntPtr)NativePtr->SizeCallbackUserData; set => NativePtr->SizeCallbackUserData = (void*)value; } |
||||
public ref float BgAlphaVal => ref Unsafe.AsRef<float>(&NativePtr->BgAlphaVal); |
||||
public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId); |
||||
public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId); |
||||
public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass); |
||||
public ref Vector2 MenuBarOffsetMinVal => ref Unsafe.AsRef<Vector2>(&NativePtr->MenuBarOffsetMinVal); |
||||
public void ClearFlags() |
||||
{ |
||||
ImGuiNative.ImGuiNextWindowData_ClearFlags((ImGuiNextWindowData*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiNextWindowData_destroy((ImGuiNextWindowData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiNextWindowDataFlags |
||||
{ |
||||
None = 0, |
||||
HasPos = 1, |
||||
HasSize = 2, |
||||
HasContentSize = 4, |
||||
HasCollapsed = 8, |
||||
HasSizeConstraint = 16, |
||||
HasFocus = 32, |
||||
HasBgAlpha = 64, |
||||
HasScroll = 128, |
||||
HasViewport = 256, |
||||
HasDock = 512, |
||||
HasWindowClass = 1024, |
||||
} |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiOldColumnData |
||||
{ |
||||
public float OffsetNorm; |
||||
public float OffsetNormBeforeResize; |
||||
public ImGuiOldColumnFlags Flags; |
||||
public ImRect ClipRect; |
||||
} |
||||
public unsafe partial struct ImGuiOldColumnDataPtr |
||||
{ |
||||
public ImGuiOldColumnData* NativePtr { get; } |
||||
public ImGuiOldColumnDataPtr(ImGuiOldColumnData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiOldColumnDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiOldColumnData*)nativePtr; |
||||
public static implicit operator ImGuiOldColumnDataPtr(ImGuiOldColumnData* nativePtr) => new ImGuiOldColumnDataPtr(nativePtr); |
||||
public static implicit operator ImGuiOldColumnData* (ImGuiOldColumnDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiOldColumnDataPtr(IntPtr nativePtr) => new ImGuiOldColumnDataPtr(nativePtr); |
||||
public ref float OffsetNorm => ref Unsafe.AsRef<float>(&NativePtr->OffsetNorm); |
||||
public ref float OffsetNormBeforeResize => ref Unsafe.AsRef<float>(&NativePtr->OffsetNormBeforeResize); |
||||
public ref ImGuiOldColumnFlags Flags => ref Unsafe.AsRef<ImGuiOldColumnFlags>(&NativePtr->Flags); |
||||
public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiOldColumnData_destroy((ImGuiOldColumnData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiOldColumnFlags |
||||
{ |
||||
None = 0, |
||||
NoBorder = 1, |
||||
NoResize = 2, |
||||
NoPreserveWidths = 4, |
||||
NoForceWithinWindow = 8, |
||||
GrowParentContentsSize = 16, |
||||
} |
||||
} |
||||
@ -0,0 +1,58 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiOldColumns |
||||
{ |
||||
public uint ID; |
||||
public ImGuiOldColumnFlags Flags; |
||||
public byte IsFirstFrame; |
||||
public byte IsBeingResized; |
||||
public int Current; |
||||
public int Count; |
||||
public float OffMinX; |
||||
public float OffMaxX; |
||||
public float LineMinY; |
||||
public float LineMaxY; |
||||
public float HostCursorPosY; |
||||
public float HostCursorMaxPosX; |
||||
public ImRect HostInitialClipRect; |
||||
public ImRect HostBackupClipRect; |
||||
public ImRect HostBackupParentWorkRect; |
||||
public ImVector Columns; |
||||
public ImDrawListSplitter Splitter; |
||||
} |
||||
public unsafe partial struct ImGuiOldColumnsPtr |
||||
{ |
||||
public ImGuiOldColumns* NativePtr { get; } |
||||
public ImGuiOldColumnsPtr(ImGuiOldColumns* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiOldColumnsPtr(IntPtr nativePtr) => NativePtr = (ImGuiOldColumns*)nativePtr; |
||||
public static implicit operator ImGuiOldColumnsPtr(ImGuiOldColumns* nativePtr) => new ImGuiOldColumnsPtr(nativePtr); |
||||
public static implicit operator ImGuiOldColumns* (ImGuiOldColumnsPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiOldColumnsPtr(IntPtr nativePtr) => new ImGuiOldColumnsPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiOldColumnFlags Flags => ref Unsafe.AsRef<ImGuiOldColumnFlags>(&NativePtr->Flags); |
||||
public ref bool IsFirstFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsFirstFrame); |
||||
public ref bool IsBeingResized => ref Unsafe.AsRef<bool>(&NativePtr->IsBeingResized); |
||||
public ref int Current => ref Unsafe.AsRef<int>(&NativePtr->Current); |
||||
public ref int Count => ref Unsafe.AsRef<int>(&NativePtr->Count); |
||||
public ref float OffMinX => ref Unsafe.AsRef<float>(&NativePtr->OffMinX); |
||||
public ref float OffMaxX => ref Unsafe.AsRef<float>(&NativePtr->OffMaxX); |
||||
public ref float LineMinY => ref Unsafe.AsRef<float>(&NativePtr->LineMinY); |
||||
public ref float LineMaxY => ref Unsafe.AsRef<float>(&NativePtr->LineMaxY); |
||||
public ref float HostCursorPosY => ref Unsafe.AsRef<float>(&NativePtr->HostCursorPosY); |
||||
public ref float HostCursorMaxPosX => ref Unsafe.AsRef<float>(&NativePtr->HostCursorMaxPosX); |
||||
public ref ImRect HostInitialClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostInitialClipRect); |
||||
public ref ImRect HostBackupClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupClipRect); |
||||
public ref ImRect HostBackupParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupParentWorkRect); |
||||
public ImPtrVector<ImGuiOldColumnDataPtr> Columns => new ImPtrVector<ImGuiOldColumnDataPtr>(NativePtr->Columns, Unsafe.SizeOf<ImGuiOldColumnData>()); |
||||
public ref ImDrawListSplitter Splitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->Splitter); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiOldColumns_destroy((ImGuiOldColumns*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,8 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiPlotType |
||||
{ |
||||
Lines = 0, |
||||
Histogram = 1, |
||||
} |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiPopupData |
||||
{ |
||||
public uint PopupId; |
||||
public ImGuiWindow* Window; |
||||
public ImGuiWindow* SourceWindow; |
||||
public int ParentNavLayer; |
||||
public int OpenFrameCount; |
||||
public uint OpenParentId; |
||||
public Vector2 OpenPopupPos; |
||||
public Vector2 OpenMousePos; |
||||
} |
||||
public unsafe partial struct ImGuiPopupDataPtr |
||||
{ |
||||
public ImGuiPopupData* NativePtr { get; } |
||||
public ImGuiPopupDataPtr(ImGuiPopupData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiPopupDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiPopupData*)nativePtr; |
||||
public static implicit operator ImGuiPopupDataPtr(ImGuiPopupData* nativePtr) => new ImGuiPopupDataPtr(nativePtr); |
||||
public static implicit operator ImGuiPopupData* (ImGuiPopupDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiPopupDataPtr(IntPtr nativePtr) => new ImGuiPopupDataPtr(nativePtr); |
||||
public ref uint PopupId => ref Unsafe.AsRef<uint>(&NativePtr->PopupId); |
||||
public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window); |
||||
public ImGuiWindowPtr SourceWindow => new ImGuiWindowPtr(NativePtr->SourceWindow); |
||||
public ref int ParentNavLayer => ref Unsafe.AsRef<int>(&NativePtr->ParentNavLayer); |
||||
public ref int OpenFrameCount => ref Unsafe.AsRef<int>(&NativePtr->OpenFrameCount); |
||||
public ref uint OpenParentId => ref Unsafe.AsRef<uint>(&NativePtr->OpenParentId); |
||||
public ref Vector2 OpenPopupPos => ref Unsafe.AsRef<Vector2>(&NativePtr->OpenPopupPos); |
||||
public ref Vector2 OpenMousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->OpenMousePos); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiPopupData_destroy((ImGuiPopupData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiPopupPositionPolicy |
||||
{ |
||||
Default = 0, |
||||
ComboBox = 1, |
||||
Tooltip = 2, |
||||
} |
||||
} |
||||
@ -0,0 +1,28 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiPtrOrIndex |
||||
{ |
||||
public void* Ptr; |
||||
public int Index; |
||||
} |
||||
public unsafe partial struct ImGuiPtrOrIndexPtr |
||||
{ |
||||
public ImGuiPtrOrIndex* NativePtr { get; } |
||||
public ImGuiPtrOrIndexPtr(ImGuiPtrOrIndex* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiPtrOrIndexPtr(IntPtr nativePtr) => NativePtr = (ImGuiPtrOrIndex*)nativePtr; |
||||
public static implicit operator ImGuiPtrOrIndexPtr(ImGuiPtrOrIndex* nativePtr) => new ImGuiPtrOrIndexPtr(nativePtr); |
||||
public static implicit operator ImGuiPtrOrIndex* (ImGuiPtrOrIndexPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiPtrOrIndexPtr(IntPtr nativePtr) => new ImGuiPtrOrIndexPtr(nativePtr); |
||||
public IntPtr Ptr { get => (IntPtr)NativePtr->Ptr; set => NativePtr->Ptr = (void*)value; } |
||||
public ref int Index => ref Unsafe.AsRef<int>(&NativePtr->Index); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiPtrOrIndex_destroy((ImGuiPtrOrIndex*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,17 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiScrollFlags |
||||
{ |
||||
None = 0, |
||||
KeepVisibleEdgeX = 1, |
||||
KeepVisibleEdgeY = 2, |
||||
KeepVisibleCenterX = 4, |
||||
KeepVisibleCenterY = 8, |
||||
AlwaysCenterX = 16, |
||||
AlwaysCenterY = 32, |
||||
NoScrollParent = 64, |
||||
MaskX = 21, |
||||
MaskY = 42, |
||||
} |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiSelectableFlagsPrivate |
||||
{ |
||||
ImGuiSelectableFlags_NoHoldingActiveID = 1048576, |
||||
ImGuiSelectableFlags_SelectOnNav = 2097152, |
||||
ImGuiSelectableFlags_SelectOnClick = 4194304, |
||||
ImGuiSelectableFlags_SelectOnRelease = 8388608, |
||||
ImGuiSelectableFlags_SpanAvailWidth = 16777216, |
||||
ImGuiSelectableFlags_DrawHoveredWhenHeld = 33554432, |
||||
ImGuiSelectableFlags_SetNavIdOnHover = 67108864, |
||||
ImGuiSelectableFlags_NoPadWithHalfSpacing = 134217728, |
||||
} |
||||
} |
||||
@ -0,0 +1,11 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiSeparatorFlags |
||||
{ |
||||
None = 0, |
||||
Horizontal = 1, |
||||
Vertical = 2, |
||||
SpanAllColumns = 4, |
||||
} |
||||
} |
||||
@ -0,0 +1,42 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiSettingsHandler |
||||
{ |
||||
public byte* TypeName; |
||||
public uint TypeHash; |
||||
public IntPtr ClearAllFn; |
||||
public IntPtr ReadInitFn; |
||||
public IntPtr ReadOpenFn; |
||||
public IntPtr ReadLineFn; |
||||
public IntPtr ApplyAllFn; |
||||
public IntPtr WriteAllFn; |
||||
public void* UserData; |
||||
} |
||||
public unsafe partial struct ImGuiSettingsHandlerPtr |
||||
{ |
||||
public ImGuiSettingsHandler* NativePtr { get; } |
||||
public ImGuiSettingsHandlerPtr(ImGuiSettingsHandler* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiSettingsHandlerPtr(IntPtr nativePtr) => NativePtr = (ImGuiSettingsHandler*)nativePtr; |
||||
public static implicit operator ImGuiSettingsHandlerPtr(ImGuiSettingsHandler* nativePtr) => new ImGuiSettingsHandlerPtr(nativePtr); |
||||
public static implicit operator ImGuiSettingsHandler* (ImGuiSettingsHandlerPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiSettingsHandlerPtr(IntPtr nativePtr) => new ImGuiSettingsHandlerPtr(nativePtr); |
||||
public NullTerminatedString TypeName => new NullTerminatedString(NativePtr->TypeName); |
||||
public ref uint TypeHash => ref Unsafe.AsRef<uint>(&NativePtr->TypeHash); |
||||
public ref IntPtr ClearAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ClearAllFn); |
||||
public ref IntPtr ReadInitFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadInitFn); |
||||
public ref IntPtr ReadOpenFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadOpenFn); |
||||
public ref IntPtr ReadLineFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadLineFn); |
||||
public ref IntPtr ApplyAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ApplyAllFn); |
||||
public ref IntPtr WriteAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->WriteAllFn); |
||||
public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; } |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiSettingsHandler_destroy((ImGuiSettingsHandler*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiShrinkWidthItem |
||||
{ |
||||
public int Index; |
||||
public float Width; |
||||
public float InitialWidth; |
||||
} |
||||
public unsafe partial struct ImGuiShrinkWidthItemPtr |
||||
{ |
||||
public ImGuiShrinkWidthItem* NativePtr { get; } |
||||
public ImGuiShrinkWidthItemPtr(ImGuiShrinkWidthItem* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiShrinkWidthItemPtr(IntPtr nativePtr) => NativePtr = (ImGuiShrinkWidthItem*)nativePtr; |
||||
public static implicit operator ImGuiShrinkWidthItemPtr(ImGuiShrinkWidthItem* nativePtr) => new ImGuiShrinkWidthItemPtr(nativePtr); |
||||
public static implicit operator ImGuiShrinkWidthItem* (ImGuiShrinkWidthItemPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiShrinkWidthItemPtr(IntPtr nativePtr) => new ImGuiShrinkWidthItemPtr(nativePtr); |
||||
public ref int Index => ref Unsafe.AsRef<int>(&NativePtr->Index); |
||||
public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width); |
||||
public ref float InitialWidth => ref Unsafe.AsRef<float>(&NativePtr->InitialWidth); |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiSliderFlagsPrivate |
||||
{ |
||||
ImGuiSliderFlags_Vertical = 1048576, |
||||
ImGuiSliderFlags_ReadOnly = 2097152, |
||||
} |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiStackLevelInfo |
||||
{ |
||||
public uint ID; |
||||
public sbyte QueryFrameCount; |
||||
public byte QuerySuccess; |
||||
public ImGuiDataType DataType; |
||||
public fixed byte Desc[57]; |
||||
} |
||||
public unsafe partial struct ImGuiStackLevelInfoPtr |
||||
{ |
||||
public ImGuiStackLevelInfo* NativePtr { get; } |
||||
public ImGuiStackLevelInfoPtr(ImGuiStackLevelInfo* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiStackLevelInfoPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackLevelInfo*)nativePtr; |
||||
public static implicit operator ImGuiStackLevelInfoPtr(ImGuiStackLevelInfo* nativePtr) => new ImGuiStackLevelInfoPtr(nativePtr); |
||||
public static implicit operator ImGuiStackLevelInfo* (ImGuiStackLevelInfoPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiStackLevelInfoPtr(IntPtr nativePtr) => new ImGuiStackLevelInfoPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref sbyte QueryFrameCount => ref Unsafe.AsRef<sbyte>(&NativePtr->QueryFrameCount); |
||||
public ref bool QuerySuccess => ref Unsafe.AsRef<bool>(&NativePtr->QuerySuccess); |
||||
public ref ImGuiDataType DataType => ref Unsafe.AsRef<ImGuiDataType>(&NativePtr->DataType); |
||||
public RangeAccessor<byte> Desc => new RangeAccessor<byte>(NativePtr->Desc, 57); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiStackLevelInfo_destroy((ImGuiStackLevelInfo*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,50 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiStackSizes |
||||
{ |
||||
public short SizeOfIDStack; |
||||
public short SizeOfColorStack; |
||||
public short SizeOfStyleVarStack; |
||||
public short SizeOfFontStack; |
||||
public short SizeOfFocusScopeStack; |
||||
public short SizeOfGroupStack; |
||||
public short SizeOfItemFlagsStack; |
||||
public short SizeOfBeginPopupStack; |
||||
public short SizeOfDisabledStack; |
||||
} |
||||
public unsafe partial struct ImGuiStackSizesPtr |
||||
{ |
||||
public ImGuiStackSizes* NativePtr { get; } |
||||
public ImGuiStackSizesPtr(ImGuiStackSizes* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiStackSizesPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackSizes*)nativePtr; |
||||
public static implicit operator ImGuiStackSizesPtr(ImGuiStackSizes* nativePtr) => new ImGuiStackSizesPtr(nativePtr); |
||||
public static implicit operator ImGuiStackSizes* (ImGuiStackSizesPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiStackSizesPtr(IntPtr nativePtr) => new ImGuiStackSizesPtr(nativePtr); |
||||
public ref short SizeOfIDStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfIDStack); |
||||
public ref short SizeOfColorStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfColorStack); |
||||
public ref short SizeOfStyleVarStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfStyleVarStack); |
||||
public ref short SizeOfFontStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfFontStack); |
||||
public ref short SizeOfFocusScopeStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfFocusScopeStack); |
||||
public ref short SizeOfGroupStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfGroupStack); |
||||
public ref short SizeOfItemFlagsStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfItemFlagsStack); |
||||
public ref short SizeOfBeginPopupStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfBeginPopupStack); |
||||
public ref short SizeOfDisabledStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfDisabledStack); |
||||
public void CompareWithCurrentState() |
||||
{ |
||||
ImGuiNative.ImGuiStackSizes_CompareWithCurrentState((ImGuiStackSizes*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiStackSizes_destroy((ImGuiStackSizes*)(NativePtr)); |
||||
} |
||||
public void SetToCurrentState() |
||||
{ |
||||
ImGuiNative.ImGuiStackSizes_SetToCurrentState((ImGuiStackSizes*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiStackTool |
||||
{ |
||||
public int LastActiveFrame; |
||||
public int StackLevel; |
||||
public uint QueryId; |
||||
public ImVector Results; |
||||
public byte CopyToClipboardOnCtrlC; |
||||
public float CopyToClipboardLastTime; |
||||
} |
||||
public unsafe partial struct ImGuiStackToolPtr |
||||
{ |
||||
public ImGuiStackTool* NativePtr { get; } |
||||
public ImGuiStackToolPtr(ImGuiStackTool* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiStackToolPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackTool*)nativePtr; |
||||
public static implicit operator ImGuiStackToolPtr(ImGuiStackTool* nativePtr) => new ImGuiStackToolPtr(nativePtr); |
||||
public static implicit operator ImGuiStackTool* (ImGuiStackToolPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiStackToolPtr(IntPtr nativePtr) => new ImGuiStackToolPtr(nativePtr); |
||||
public ref int LastActiveFrame => ref Unsafe.AsRef<int>(&NativePtr->LastActiveFrame); |
||||
public ref int StackLevel => ref Unsafe.AsRef<int>(&NativePtr->StackLevel); |
||||
public ref uint QueryId => ref Unsafe.AsRef<uint>(&NativePtr->QueryId); |
||||
public ImPtrVector<ImGuiStackLevelInfoPtr> Results => new ImPtrVector<ImGuiStackLevelInfoPtr>(NativePtr->Results, Unsafe.SizeOf<ImGuiStackLevelInfo>()); |
||||
public ref bool CopyToClipboardOnCtrlC => ref Unsafe.AsRef<bool>(&NativePtr->CopyToClipboardOnCtrlC); |
||||
public ref float CopyToClipboardLastTime => ref Unsafe.AsRef<float>(&NativePtr->CopyToClipboardLastTime); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiStackTool_destroy((ImGuiStackTool*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,98 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTabBar |
||||
{ |
||||
public ImVector Tabs; |
||||
public ImGuiTabBarFlags Flags; |
||||
public uint ID; |
||||
public uint SelectedTabId; |
||||
public uint NextSelectedTabId; |
||||
public uint VisibleTabId; |
||||
public int CurrFrameVisible; |
||||
public int PrevFrameVisible; |
||||
public ImRect BarRect; |
||||
public float CurrTabsContentsHeight; |
||||
public float PrevTabsContentsHeight; |
||||
public float WidthAllTabs; |
||||
public float WidthAllTabsIdeal; |
||||
public float ScrollingAnim; |
||||
public float ScrollingTarget; |
||||
public float ScrollingTargetDistToVisibility; |
||||
public float ScrollingSpeed; |
||||
public float ScrollingRectMinX; |
||||
public float ScrollingRectMaxX; |
||||
public uint ReorderRequestTabId; |
||||
public short ReorderRequestOffset; |
||||
public sbyte BeginCount; |
||||
public byte WantLayout; |
||||
public byte VisibleTabWasSubmitted; |
||||
public byte TabsAddedNew; |
||||
public short TabsActiveCount; |
||||
public short LastTabItemIdx; |
||||
public float ItemSpacingY; |
||||
public Vector2 FramePadding; |
||||
public Vector2 BackupCursorPos; |
||||
public ImGuiTextBuffer TabsNames; |
||||
} |
||||
public unsafe partial struct ImGuiTabBarPtr |
||||
{ |
||||
public ImGuiTabBar* NativePtr { get; } |
||||
public ImGuiTabBarPtr(ImGuiTabBar* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTabBarPtr(IntPtr nativePtr) => NativePtr = (ImGuiTabBar*)nativePtr; |
||||
public static implicit operator ImGuiTabBarPtr(ImGuiTabBar* nativePtr) => new ImGuiTabBarPtr(nativePtr); |
||||
public static implicit operator ImGuiTabBar* (ImGuiTabBarPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTabBarPtr(IntPtr nativePtr) => new ImGuiTabBarPtr(nativePtr); |
||||
public ImPtrVector<ImGuiTabItemPtr> Tabs => new ImPtrVector<ImGuiTabItemPtr>(NativePtr->Tabs, Unsafe.SizeOf<ImGuiTabItem>()); |
||||
public ref ImGuiTabBarFlags Flags => ref Unsafe.AsRef<ImGuiTabBarFlags>(&NativePtr->Flags); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref uint SelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->SelectedTabId); |
||||
public ref uint NextSelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->NextSelectedTabId); |
||||
public ref uint VisibleTabId => ref Unsafe.AsRef<uint>(&NativePtr->VisibleTabId); |
||||
public ref int CurrFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->CurrFrameVisible); |
||||
public ref int PrevFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->PrevFrameVisible); |
||||
public ref ImRect BarRect => ref Unsafe.AsRef<ImRect>(&NativePtr->BarRect); |
||||
public ref float CurrTabsContentsHeight => ref Unsafe.AsRef<float>(&NativePtr->CurrTabsContentsHeight); |
||||
public ref float PrevTabsContentsHeight => ref Unsafe.AsRef<float>(&NativePtr->PrevTabsContentsHeight); |
||||
public ref float WidthAllTabs => ref Unsafe.AsRef<float>(&NativePtr->WidthAllTabs); |
||||
public ref float WidthAllTabsIdeal => ref Unsafe.AsRef<float>(&NativePtr->WidthAllTabsIdeal); |
||||
public ref float ScrollingAnim => ref Unsafe.AsRef<float>(&NativePtr->ScrollingAnim); |
||||
public ref float ScrollingTarget => ref Unsafe.AsRef<float>(&NativePtr->ScrollingTarget); |
||||
public ref float ScrollingTargetDistToVisibility => ref Unsafe.AsRef<float>(&NativePtr->ScrollingTargetDistToVisibility); |
||||
public ref float ScrollingSpeed => ref Unsafe.AsRef<float>(&NativePtr->ScrollingSpeed); |
||||
public ref float ScrollingRectMinX => ref Unsafe.AsRef<float>(&NativePtr->ScrollingRectMinX); |
||||
public ref float ScrollingRectMaxX => ref Unsafe.AsRef<float>(&NativePtr->ScrollingRectMaxX); |
||||
public ref uint ReorderRequestTabId => ref Unsafe.AsRef<uint>(&NativePtr->ReorderRequestTabId); |
||||
public ref short ReorderRequestOffset => ref Unsafe.AsRef<short>(&NativePtr->ReorderRequestOffset); |
||||
public ref sbyte BeginCount => ref Unsafe.AsRef<sbyte>(&NativePtr->BeginCount); |
||||
public ref bool WantLayout => ref Unsafe.AsRef<bool>(&NativePtr->WantLayout); |
||||
public ref bool VisibleTabWasSubmitted => ref Unsafe.AsRef<bool>(&NativePtr->VisibleTabWasSubmitted); |
||||
public ref bool TabsAddedNew => ref Unsafe.AsRef<bool>(&NativePtr->TabsAddedNew); |
||||
public ref short TabsActiveCount => ref Unsafe.AsRef<short>(&NativePtr->TabsActiveCount); |
||||
public ref short LastTabItemIdx => ref Unsafe.AsRef<short>(&NativePtr->LastTabItemIdx); |
||||
public ref float ItemSpacingY => ref Unsafe.AsRef<float>(&NativePtr->ItemSpacingY); |
||||
public ref Vector2 FramePadding => ref Unsafe.AsRef<Vector2>(&NativePtr->FramePadding); |
||||
public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos); |
||||
public ref ImGuiTextBuffer TabsNames => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->TabsNames); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTabBar_destroy((ImGuiTabBar*)(NativePtr)); |
||||
} |
||||
public string GetTabName(ImGuiTabItemPtr tab) |
||||
{ |
||||
ImGuiTabItem* native_tab = tab.NativePtr; |
||||
byte* ret = ImGuiNative.ImGuiTabBar_GetTabName((ImGuiTabBar*)(NativePtr), native_tab); |
||||
return Util.StringFromPtr(ret); |
||||
} |
||||
public int GetTabOrder(ImGuiTabItemPtr tab) |
||||
{ |
||||
ImGuiTabItem* native_tab = tab.NativePtr; |
||||
int ret = ImGuiNative.ImGuiTabBar_GetTabOrder((ImGuiTabBar*)(NativePtr), native_tab); |
||||
return ret; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiTabBarFlagsPrivate |
||||
{ |
||||
ImGuiTabBarFlags_DockNode = 1048576, |
||||
ImGuiTabBarFlags_IsFocused = 2097152, |
||||
ImGuiTabBarFlags_SaveSettings = 4194304, |
||||
} |
||||
} |
||||
@ -0,0 +1,50 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTabItem |
||||
{ |
||||
public uint ID; |
||||
public ImGuiTabItemFlags Flags; |
||||
public ImGuiWindow* Window; |
||||
public int LastFrameVisible; |
||||
public int LastFrameSelected; |
||||
public float Offset; |
||||
public float Width; |
||||
public float ContentWidth; |
||||
public float RequestedWidth; |
||||
public int NameOffset; |
||||
public short BeginOrder; |
||||
public short IndexDuringLayout; |
||||
public byte WantClose; |
||||
} |
||||
public unsafe partial struct ImGuiTabItemPtr |
||||
{ |
||||
public ImGuiTabItem* NativePtr { get; } |
||||
public ImGuiTabItemPtr(ImGuiTabItem* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTabItemPtr(IntPtr nativePtr) => NativePtr = (ImGuiTabItem*)nativePtr; |
||||
public static implicit operator ImGuiTabItemPtr(ImGuiTabItem* nativePtr) => new ImGuiTabItemPtr(nativePtr); |
||||
public static implicit operator ImGuiTabItem* (ImGuiTabItemPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTabItemPtr(IntPtr nativePtr) => new ImGuiTabItemPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiTabItemFlags Flags => ref Unsafe.AsRef<ImGuiTabItemFlags>(&NativePtr->Flags); |
||||
public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window); |
||||
public ref int LastFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->LastFrameVisible); |
||||
public ref int LastFrameSelected => ref Unsafe.AsRef<int>(&NativePtr->LastFrameSelected); |
||||
public ref float Offset => ref Unsafe.AsRef<float>(&NativePtr->Offset); |
||||
public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width); |
||||
public ref float ContentWidth => ref Unsafe.AsRef<float>(&NativePtr->ContentWidth); |
||||
public ref float RequestedWidth => ref Unsafe.AsRef<float>(&NativePtr->RequestedWidth); |
||||
public ref int NameOffset => ref Unsafe.AsRef<int>(&NativePtr->NameOffset); |
||||
public ref short BeginOrder => ref Unsafe.AsRef<short>(&NativePtr->BeginOrder); |
||||
public ref short IndexDuringLayout => ref Unsafe.AsRef<short>(&NativePtr->IndexDuringLayout); |
||||
public ref bool WantClose => ref Unsafe.AsRef<bool>(&NativePtr->WantClose); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTabItem_destroy((ImGuiTabItem*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiTabItemFlagsPrivate |
||||
{ |
||||
ImGuiTabItemFlags_SectionMask = 192, |
||||
ImGuiTabItemFlags_NoCloseButton = 1048576, |
||||
ImGuiTabItemFlags_Button = 2097152, |
||||
ImGuiTabItemFlags_Unsorted = 4194304, |
||||
ImGuiTabItemFlags_Preview = 8388608, |
||||
} |
||||
} |
||||
@ -0,0 +1,232 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTable |
||||
{ |
||||
public uint ID; |
||||
public ImGuiTableFlags Flags; |
||||
public void* RawData; |
||||
public ImGuiTableTempData* TempData; |
||||
public (IntPtr, IntPtr) Columns; |
||||
public (IntPtr, IntPtr) DisplayOrderToIndex; |
||||
public (IntPtr, IntPtr) RowCellData; |
||||
public ulong EnabledMaskByDisplayOrder; |
||||
public ulong EnabledMaskByIndex; |
||||
public ulong VisibleMaskByIndex; |
||||
public ulong RequestOutputMaskByIndex; |
||||
public ImGuiTableFlags SettingsLoadedFlags; |
||||
public int SettingsOffset; |
||||
public int LastFrameActive; |
||||
public int ColumnsCount; |
||||
public int CurrentRow; |
||||
public int CurrentColumn; |
||||
public short InstanceCurrent; |
||||
public short InstanceInteracted; |
||||
public float RowPosY1; |
||||
public float RowPosY2; |
||||
public float RowMinHeight; |
||||
public float RowTextBaseline; |
||||
public float RowIndentOffsetX; |
||||
public ImGuiTableRowFlags RowFlags; |
||||
public ImGuiTableRowFlags LastRowFlags; |
||||
public int RowBgColorCounter; |
||||
public fixed uint RowBgColor[2]; |
||||
public uint BorderColorStrong; |
||||
public uint BorderColorLight; |
||||
public float BorderX1; |
||||
public float BorderX2; |
||||
public float HostIndentX; |
||||
public float MinColumnWidth; |
||||
public float OuterPaddingX; |
||||
public float CellPaddingX; |
||||
public float CellPaddingY; |
||||
public float CellSpacingX1; |
||||
public float CellSpacingX2; |
||||
public float InnerWidth; |
||||
public float ColumnsGivenWidth; |
||||
public float ColumnsAutoFitWidth; |
||||
public float ColumnsStretchSumWeights; |
||||
public float ResizedColumnNextWidth; |
||||
public float ResizeLockMinContentsX2; |
||||
public float RefScale; |
||||
public ImRect OuterRect; |
||||
public ImRect InnerRect; |
||||
public ImRect WorkRect; |
||||
public ImRect InnerClipRect; |
||||
public ImRect BgClipRect; |
||||
public ImRect Bg0ClipRectForDrawCmd; |
||||
public ImRect Bg2ClipRectForDrawCmd; |
||||
public ImRect HostClipRect; |
||||
public ImRect HostBackupInnerClipRect; |
||||
public ImGuiWindow* OuterWindow; |
||||
public ImGuiWindow* InnerWindow; |
||||
public ImGuiTextBuffer ColumnsNames; |
||||
public ImDrawListSplitter* DrawSplitter; |
||||
public ImGuiTableInstanceData InstanceDataFirst; |
||||
public ImVector InstanceDataExtra; |
||||
public ImGuiTableColumnSortSpecs SortSpecsSingle; |
||||
public ImVector SortSpecsMulti; |
||||
public ImGuiTableSortSpecs SortSpecs; |
||||
public sbyte SortSpecsCount; |
||||
public sbyte ColumnsEnabledCount; |
||||
public sbyte ColumnsEnabledFixedCount; |
||||
public sbyte DeclColumnsCount; |
||||
public sbyte HoveredColumnBody; |
||||
public sbyte HoveredColumnBorder; |
||||
public sbyte AutoFitSingleColumn; |
||||
public sbyte ResizedColumn; |
||||
public sbyte LastResizedColumn; |
||||
public sbyte HeldHeaderColumn; |
||||
public sbyte ReorderColumn; |
||||
public sbyte ReorderColumnDir; |
||||
public sbyte LeftMostEnabledColumn; |
||||
public sbyte RightMostEnabledColumn; |
||||
public sbyte LeftMostStretchedColumn; |
||||
public sbyte RightMostStretchedColumn; |
||||
public sbyte ContextPopupColumn; |
||||
public sbyte FreezeRowsRequest; |
||||
public sbyte FreezeRowsCount; |
||||
public sbyte FreezeColumnsRequest; |
||||
public sbyte FreezeColumnsCount; |
||||
public sbyte RowCellDataCurrent; |
||||
public byte DummyDrawChannel; |
||||
public byte Bg2DrawChannelCurrent; |
||||
public byte Bg2DrawChannelUnfrozen; |
||||
public byte IsLayoutLocked; |
||||
public byte IsInsideRow; |
||||
public byte IsInitializing; |
||||
public byte IsSortSpecsDirty; |
||||
public byte IsUsingHeaders; |
||||
public byte IsContextPopupOpen; |
||||
public byte IsSettingsRequestLoad; |
||||
public byte IsSettingsDirty; |
||||
public byte IsDefaultDisplayOrder; |
||||
public byte IsResetAllRequest; |
||||
public byte IsResetDisplayOrderRequest; |
||||
public byte IsUnfrozenRows; |
||||
public byte IsDefaultSizingPolicy; |
||||
public byte MemoryCompacted; |
||||
public byte HostSkipItems; |
||||
} |
||||
public unsafe partial struct ImGuiTablePtr |
||||
{ |
||||
public ImGuiTable* NativePtr { get; } |
||||
public ImGuiTablePtr(ImGuiTable* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTablePtr(IntPtr nativePtr) => NativePtr = (ImGuiTable*)nativePtr; |
||||
public static implicit operator ImGuiTablePtr(ImGuiTable* nativePtr) => new ImGuiTablePtr(nativePtr); |
||||
public static implicit operator ImGuiTable* (ImGuiTablePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTablePtr(IntPtr nativePtr) => new ImGuiTablePtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiTableFlags Flags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->Flags); |
||||
public IntPtr RawData { get => (IntPtr)NativePtr->RawData; set => NativePtr->RawData = (void*)value; } |
||||
public ImGuiTableTempDataPtr TempData => new ImGuiTableTempDataPtr(NativePtr->TempData); |
||||
public ref (IntPtr, IntPtr) Columns => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->Columns); |
||||
public ref (IntPtr, IntPtr) DisplayOrderToIndex => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->DisplayOrderToIndex); |
||||
public ref (IntPtr, IntPtr) RowCellData => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->RowCellData); |
||||
public ref ulong EnabledMaskByDisplayOrder => ref Unsafe.AsRef<ulong>(&NativePtr->EnabledMaskByDisplayOrder); |
||||
public ref ulong EnabledMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->EnabledMaskByIndex); |
||||
public ref ulong VisibleMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->VisibleMaskByIndex); |
||||
public ref ulong RequestOutputMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->RequestOutputMaskByIndex); |
||||
public ref ImGuiTableFlags SettingsLoadedFlags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->SettingsLoadedFlags); |
||||
public ref int SettingsOffset => ref Unsafe.AsRef<int>(&NativePtr->SettingsOffset); |
||||
public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive); |
||||
public ref int ColumnsCount => ref Unsafe.AsRef<int>(&NativePtr->ColumnsCount); |
||||
public ref int CurrentRow => ref Unsafe.AsRef<int>(&NativePtr->CurrentRow); |
||||
public ref int CurrentColumn => ref Unsafe.AsRef<int>(&NativePtr->CurrentColumn); |
||||
public ref short InstanceCurrent => ref Unsafe.AsRef<short>(&NativePtr->InstanceCurrent); |
||||
public ref short InstanceInteracted => ref Unsafe.AsRef<short>(&NativePtr->InstanceInteracted); |
||||
public ref float RowPosY1 => ref Unsafe.AsRef<float>(&NativePtr->RowPosY1); |
||||
public ref float RowPosY2 => ref Unsafe.AsRef<float>(&NativePtr->RowPosY2); |
||||
public ref float RowMinHeight => ref Unsafe.AsRef<float>(&NativePtr->RowMinHeight); |
||||
public ref float RowTextBaseline => ref Unsafe.AsRef<float>(&NativePtr->RowTextBaseline); |
||||
public ref float RowIndentOffsetX => ref Unsafe.AsRef<float>(&NativePtr->RowIndentOffsetX); |
||||
public ref ImGuiTableRowFlags RowFlags => ref Unsafe.AsRef<ImGuiTableRowFlags>(&NativePtr->RowFlags); |
||||
public ref ImGuiTableRowFlags LastRowFlags => ref Unsafe.AsRef<ImGuiTableRowFlags>(&NativePtr->LastRowFlags); |
||||
public ref int RowBgColorCounter => ref Unsafe.AsRef<int>(&NativePtr->RowBgColorCounter); |
||||
public RangeAccessor<uint> RowBgColor => new RangeAccessor<uint>(NativePtr->RowBgColor, 2); |
||||
public ref uint BorderColorStrong => ref Unsafe.AsRef<uint>(&NativePtr->BorderColorStrong); |
||||
public ref uint BorderColorLight => ref Unsafe.AsRef<uint>(&NativePtr->BorderColorLight); |
||||
public ref float BorderX1 => ref Unsafe.AsRef<float>(&NativePtr->BorderX1); |
||||
public ref float BorderX2 => ref Unsafe.AsRef<float>(&NativePtr->BorderX2); |
||||
public ref float HostIndentX => ref Unsafe.AsRef<float>(&NativePtr->HostIndentX); |
||||
public ref float MinColumnWidth => ref Unsafe.AsRef<float>(&NativePtr->MinColumnWidth); |
||||
public ref float OuterPaddingX => ref Unsafe.AsRef<float>(&NativePtr->OuterPaddingX); |
||||
public ref float CellPaddingX => ref Unsafe.AsRef<float>(&NativePtr->CellPaddingX); |
||||
public ref float CellPaddingY => ref Unsafe.AsRef<float>(&NativePtr->CellPaddingY); |
||||
public ref float CellSpacingX1 => ref Unsafe.AsRef<float>(&NativePtr->CellSpacingX1); |
||||
public ref float CellSpacingX2 => ref Unsafe.AsRef<float>(&NativePtr->CellSpacingX2); |
||||
public ref float InnerWidth => ref Unsafe.AsRef<float>(&NativePtr->InnerWidth); |
||||
public ref float ColumnsGivenWidth => ref Unsafe.AsRef<float>(&NativePtr->ColumnsGivenWidth); |
||||
public ref float ColumnsAutoFitWidth => ref Unsafe.AsRef<float>(&NativePtr->ColumnsAutoFitWidth); |
||||
public ref float ColumnsStretchSumWeights => ref Unsafe.AsRef<float>(&NativePtr->ColumnsStretchSumWeights); |
||||
public ref float ResizedColumnNextWidth => ref Unsafe.AsRef<float>(&NativePtr->ResizedColumnNextWidth); |
||||
public ref float ResizeLockMinContentsX2 => ref Unsafe.AsRef<float>(&NativePtr->ResizeLockMinContentsX2); |
||||
public ref float RefScale => ref Unsafe.AsRef<float>(&NativePtr->RefScale); |
||||
public ref ImRect OuterRect => ref Unsafe.AsRef<ImRect>(&NativePtr->OuterRect); |
||||
public ref ImRect InnerRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerRect); |
||||
public ref ImRect WorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->WorkRect); |
||||
public ref ImRect InnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerClipRect); |
||||
public ref ImRect BgClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->BgClipRect); |
||||
public ref ImRect Bg0ClipRectForDrawCmd => ref Unsafe.AsRef<ImRect>(&NativePtr->Bg0ClipRectForDrawCmd); |
||||
public ref ImRect Bg2ClipRectForDrawCmd => ref Unsafe.AsRef<ImRect>(&NativePtr->Bg2ClipRectForDrawCmd); |
||||
public ref ImRect HostClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostClipRect); |
||||
public ref ImRect HostBackupInnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupInnerClipRect); |
||||
public ImGuiWindowPtr OuterWindow => new ImGuiWindowPtr(NativePtr->OuterWindow); |
||||
public ImGuiWindowPtr InnerWindow => new ImGuiWindowPtr(NativePtr->InnerWindow); |
||||
public ref ImGuiTextBuffer ColumnsNames => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->ColumnsNames); |
||||
public ImDrawListSplitterPtr DrawSplitter => new ImDrawListSplitterPtr(NativePtr->DrawSplitter); |
||||
public ref ImGuiTableInstanceData InstanceDataFirst => ref Unsafe.AsRef<ImGuiTableInstanceData>(&NativePtr->InstanceDataFirst); |
||||
public ImPtrVector<ImGuiTableInstanceDataPtr> InstanceDataExtra => new ImPtrVector<ImGuiTableInstanceDataPtr>(NativePtr->InstanceDataExtra, Unsafe.SizeOf<ImGuiTableInstanceData>()); |
||||
public ref ImGuiTableColumnSortSpecs SortSpecsSingle => ref Unsafe.AsRef<ImGuiTableColumnSortSpecs>(&NativePtr->SortSpecsSingle); |
||||
public ImPtrVector<ImGuiTableColumnSortSpecsPtr> SortSpecsMulti => new ImPtrVector<ImGuiTableColumnSortSpecsPtr>(NativePtr->SortSpecsMulti, Unsafe.SizeOf<ImGuiTableColumnSortSpecs>()); |
||||
public ref ImGuiTableSortSpecs SortSpecs => ref Unsafe.AsRef<ImGuiTableSortSpecs>(&NativePtr->SortSpecs); |
||||
public ref sbyte SortSpecsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->SortSpecsCount); |
||||
public ref sbyte ColumnsEnabledCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsEnabledCount); |
||||
public ref sbyte ColumnsEnabledFixedCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsEnabledFixedCount); |
||||
public ref sbyte DeclColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->DeclColumnsCount); |
||||
public ref sbyte HoveredColumnBody => ref Unsafe.AsRef<sbyte>(&NativePtr->HoveredColumnBody); |
||||
public ref sbyte HoveredColumnBorder => ref Unsafe.AsRef<sbyte>(&NativePtr->HoveredColumnBorder); |
||||
public ref sbyte AutoFitSingleColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitSingleColumn); |
||||
public ref sbyte ResizedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ResizedColumn); |
||||
public ref sbyte LastResizedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LastResizedColumn); |
||||
public ref sbyte HeldHeaderColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->HeldHeaderColumn); |
||||
public ref sbyte ReorderColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ReorderColumn); |
||||
public ref sbyte ReorderColumnDir => ref Unsafe.AsRef<sbyte>(&NativePtr->ReorderColumnDir); |
||||
public ref sbyte LeftMostEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LeftMostEnabledColumn); |
||||
public ref sbyte RightMostEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->RightMostEnabledColumn); |
||||
public ref sbyte LeftMostStretchedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LeftMostStretchedColumn); |
||||
public ref sbyte RightMostStretchedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->RightMostStretchedColumn); |
||||
public ref sbyte ContextPopupColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ContextPopupColumn); |
||||
public ref sbyte FreezeRowsRequest => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeRowsRequest); |
||||
public ref sbyte FreezeRowsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeRowsCount); |
||||
public ref sbyte FreezeColumnsRequest => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeColumnsRequest); |
||||
public ref sbyte FreezeColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeColumnsCount); |
||||
public ref sbyte RowCellDataCurrent => ref Unsafe.AsRef<sbyte>(&NativePtr->RowCellDataCurrent); |
||||
public ref byte DummyDrawChannel => ref Unsafe.AsRef<byte>(&NativePtr->DummyDrawChannel); |
||||
public ref byte Bg2DrawChannelCurrent => ref Unsafe.AsRef<byte>(&NativePtr->Bg2DrawChannelCurrent); |
||||
public ref byte Bg2DrawChannelUnfrozen => ref Unsafe.AsRef<byte>(&NativePtr->Bg2DrawChannelUnfrozen); |
||||
public ref bool IsLayoutLocked => ref Unsafe.AsRef<bool>(&NativePtr->IsLayoutLocked); |
||||
public ref bool IsInsideRow => ref Unsafe.AsRef<bool>(&NativePtr->IsInsideRow); |
||||
public ref bool IsInitializing => ref Unsafe.AsRef<bool>(&NativePtr->IsInitializing); |
||||
public ref bool IsSortSpecsDirty => ref Unsafe.AsRef<bool>(&NativePtr->IsSortSpecsDirty); |
||||
public ref bool IsUsingHeaders => ref Unsafe.AsRef<bool>(&NativePtr->IsUsingHeaders); |
||||
public ref bool IsContextPopupOpen => ref Unsafe.AsRef<bool>(&NativePtr->IsContextPopupOpen); |
||||
public ref bool IsSettingsRequestLoad => ref Unsafe.AsRef<bool>(&NativePtr->IsSettingsRequestLoad); |
||||
public ref bool IsSettingsDirty => ref Unsafe.AsRef<bool>(&NativePtr->IsSettingsDirty); |
||||
public ref bool IsDefaultDisplayOrder => ref Unsafe.AsRef<bool>(&NativePtr->IsDefaultDisplayOrder); |
||||
public ref bool IsResetAllRequest => ref Unsafe.AsRef<bool>(&NativePtr->IsResetAllRequest); |
||||
public ref bool IsResetDisplayOrderRequest => ref Unsafe.AsRef<bool>(&NativePtr->IsResetDisplayOrderRequest); |
||||
public ref bool IsUnfrozenRows => ref Unsafe.AsRef<bool>(&NativePtr->IsUnfrozenRows); |
||||
public ref bool IsDefaultSizingPolicy => ref Unsafe.AsRef<bool>(&NativePtr->IsDefaultSizingPolicy); |
||||
public ref bool MemoryCompacted => ref Unsafe.AsRef<bool>(&NativePtr->MemoryCompacted); |
||||
public ref bool HostSkipItems => ref Unsafe.AsRef<bool>(&NativePtr->HostSkipItems); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTable_destroy((ImGuiTable*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableCellData |
||||
{ |
||||
public uint BgColor; |
||||
public sbyte Column; |
||||
} |
||||
public unsafe partial struct ImGuiTableCellDataPtr |
||||
{ |
||||
public ImGuiTableCellData* NativePtr { get; } |
||||
public ImGuiTableCellDataPtr(ImGuiTableCellData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableCellDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableCellData*)nativePtr; |
||||
public static implicit operator ImGuiTableCellDataPtr(ImGuiTableCellData* nativePtr) => new ImGuiTableCellDataPtr(nativePtr); |
||||
public static implicit operator ImGuiTableCellData* (ImGuiTableCellDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableCellDataPtr(IntPtr nativePtr) => new ImGuiTableCellDataPtr(nativePtr); |
||||
public ref uint BgColor => ref Unsafe.AsRef<uint>(&NativePtr->BgColor); |
||||
public ref sbyte Column => ref Unsafe.AsRef<sbyte>(&NativePtr->Column); |
||||
} |
||||
} |
||||
@ -0,0 +1,106 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableColumn |
||||
{ |
||||
public ImGuiTableColumnFlags Flags; |
||||
public float WidthGiven; |
||||
public float MinX; |
||||
public float MaxX; |
||||
public float WidthRequest; |
||||
public float WidthAuto; |
||||
public float StretchWeight; |
||||
public float InitStretchWeightOrWidth; |
||||
public ImRect ClipRect; |
||||
public uint UserID; |
||||
public float WorkMinX; |
||||
public float WorkMaxX; |
||||
public float ItemWidth; |
||||
public float ContentMaxXFrozen; |
||||
public float ContentMaxXUnfrozen; |
||||
public float ContentMaxXHeadersUsed; |
||||
public float ContentMaxXHeadersIdeal; |
||||
public short NameOffset; |
||||
public sbyte DisplayOrder; |
||||
public sbyte IndexWithinEnabledSet; |
||||
public sbyte PrevEnabledColumn; |
||||
public sbyte NextEnabledColumn; |
||||
public sbyte SortOrder; |
||||
public byte DrawChannelCurrent; |
||||
public byte DrawChannelFrozen; |
||||
public byte DrawChannelUnfrozen; |
||||
public byte IsEnabled; |
||||
public byte IsUserEnabled; |
||||
public byte IsUserEnabledNextFrame; |
||||
public byte IsVisibleX; |
||||
public byte IsVisibleY; |
||||
public byte IsRequestOutput; |
||||
public byte IsSkipItems; |
||||
public byte IsPreserveWidthAuto; |
||||
public sbyte NavLayerCurrent; |
||||
public byte AutoFitQueue; |
||||
public byte CannotSkipItemsQueue; |
||||
public byte SortDirection; |
||||
public byte SortDirectionsAvailCount; |
||||
public byte SortDirectionsAvailMask; |
||||
public byte SortDirectionsAvailList; |
||||
} |
||||
public unsafe partial struct ImGuiTableColumnPtr |
||||
{ |
||||
public ImGuiTableColumn* NativePtr { get; } |
||||
public ImGuiTableColumnPtr(ImGuiTableColumn* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableColumnPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableColumn*)nativePtr; |
||||
public static implicit operator ImGuiTableColumnPtr(ImGuiTableColumn* nativePtr) => new ImGuiTableColumnPtr(nativePtr); |
||||
public static implicit operator ImGuiTableColumn* (ImGuiTableColumnPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableColumnPtr(IntPtr nativePtr) => new ImGuiTableColumnPtr(nativePtr); |
||||
public ref ImGuiTableColumnFlags Flags => ref Unsafe.AsRef<ImGuiTableColumnFlags>(&NativePtr->Flags); |
||||
public ref float WidthGiven => ref Unsafe.AsRef<float>(&NativePtr->WidthGiven); |
||||
public ref float MinX => ref Unsafe.AsRef<float>(&NativePtr->MinX); |
||||
public ref float MaxX => ref Unsafe.AsRef<float>(&NativePtr->MaxX); |
||||
public ref float WidthRequest => ref Unsafe.AsRef<float>(&NativePtr->WidthRequest); |
||||
public ref float WidthAuto => ref Unsafe.AsRef<float>(&NativePtr->WidthAuto); |
||||
public ref float StretchWeight => ref Unsafe.AsRef<float>(&NativePtr->StretchWeight); |
||||
public ref float InitStretchWeightOrWidth => ref Unsafe.AsRef<float>(&NativePtr->InitStretchWeightOrWidth); |
||||
public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect); |
||||
public ref uint UserID => ref Unsafe.AsRef<uint>(&NativePtr->UserID); |
||||
public ref float WorkMinX => ref Unsafe.AsRef<float>(&NativePtr->WorkMinX); |
||||
public ref float WorkMaxX => ref Unsafe.AsRef<float>(&NativePtr->WorkMaxX); |
||||
public ref float ItemWidth => ref Unsafe.AsRef<float>(&NativePtr->ItemWidth); |
||||
public ref float ContentMaxXFrozen => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXFrozen); |
||||
public ref float ContentMaxXUnfrozen => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXUnfrozen); |
||||
public ref float ContentMaxXHeadersUsed => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXHeadersUsed); |
||||
public ref float ContentMaxXHeadersIdeal => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXHeadersIdeal); |
||||
public ref short NameOffset => ref Unsafe.AsRef<short>(&NativePtr->NameOffset); |
||||
public ref sbyte DisplayOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->DisplayOrder); |
||||
public ref sbyte IndexWithinEnabledSet => ref Unsafe.AsRef<sbyte>(&NativePtr->IndexWithinEnabledSet); |
||||
public ref sbyte PrevEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->PrevEnabledColumn); |
||||
public ref sbyte NextEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->NextEnabledColumn); |
||||
public ref sbyte SortOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->SortOrder); |
||||
public ref byte DrawChannelCurrent => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelCurrent); |
||||
public ref byte DrawChannelFrozen => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelFrozen); |
||||
public ref byte DrawChannelUnfrozen => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelUnfrozen); |
||||
public ref bool IsEnabled => ref Unsafe.AsRef<bool>(&NativePtr->IsEnabled); |
||||
public ref bool IsUserEnabled => ref Unsafe.AsRef<bool>(&NativePtr->IsUserEnabled); |
||||
public ref bool IsUserEnabledNextFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsUserEnabledNextFrame); |
||||
public ref bool IsVisibleX => ref Unsafe.AsRef<bool>(&NativePtr->IsVisibleX); |
||||
public ref bool IsVisibleY => ref Unsafe.AsRef<bool>(&NativePtr->IsVisibleY); |
||||
public ref bool IsRequestOutput => ref Unsafe.AsRef<bool>(&NativePtr->IsRequestOutput); |
||||
public ref bool IsSkipItems => ref Unsafe.AsRef<bool>(&NativePtr->IsSkipItems); |
||||
public ref bool IsPreserveWidthAuto => ref Unsafe.AsRef<bool>(&NativePtr->IsPreserveWidthAuto); |
||||
public ref sbyte NavLayerCurrent => ref Unsafe.AsRef<sbyte>(&NativePtr->NavLayerCurrent); |
||||
public ref byte AutoFitQueue => ref Unsafe.AsRef<byte>(&NativePtr->AutoFitQueue); |
||||
public ref byte CannotSkipItemsQueue => ref Unsafe.AsRef<byte>(&NativePtr->CannotSkipItemsQueue); |
||||
public ref byte SortDirection => ref Unsafe.AsRef<byte>(&NativePtr->SortDirection); |
||||
public ref byte SortDirectionsAvailCount => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailCount); |
||||
public ref byte SortDirectionsAvailMask => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailMask); |
||||
public ref byte SortDirectionsAvailList => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailList); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTableColumn_destroy((ImGuiTableColumn*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableColumnSettings |
||||
{ |
||||
public float WidthOrWeight; |
||||
public uint UserID; |
||||
public sbyte Index; |
||||
public sbyte DisplayOrder; |
||||
public sbyte SortOrder; |
||||
public byte SortDirection; |
||||
public byte IsEnabled; |
||||
public byte IsStretch; |
||||
} |
||||
public unsafe partial struct ImGuiTableColumnSettingsPtr |
||||
{ |
||||
public ImGuiTableColumnSettings* NativePtr { get; } |
||||
public ImGuiTableColumnSettingsPtr(ImGuiTableColumnSettings* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableColumnSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableColumnSettings*)nativePtr; |
||||
public static implicit operator ImGuiTableColumnSettingsPtr(ImGuiTableColumnSettings* nativePtr) => new ImGuiTableColumnSettingsPtr(nativePtr); |
||||
public static implicit operator ImGuiTableColumnSettings* (ImGuiTableColumnSettingsPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableColumnSettingsPtr(IntPtr nativePtr) => new ImGuiTableColumnSettingsPtr(nativePtr); |
||||
public ref float WidthOrWeight => ref Unsafe.AsRef<float>(&NativePtr->WidthOrWeight); |
||||
public ref uint UserID => ref Unsafe.AsRef<uint>(&NativePtr->UserID); |
||||
public ref sbyte Index => ref Unsafe.AsRef<sbyte>(&NativePtr->Index); |
||||
public ref sbyte DisplayOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->DisplayOrder); |
||||
public ref sbyte SortOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->SortOrder); |
||||
public ref byte SortDirection => ref Unsafe.AsRef<byte>(&NativePtr->SortDirection); |
||||
public ref byte IsEnabled => ref Unsafe.AsRef<byte>(&NativePtr->IsEnabled); |
||||
public ref byte IsStretch => ref Unsafe.AsRef<byte>(&NativePtr->IsStretch); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTableColumnSettings_destroy((ImGuiTableColumnSettings*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,28 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableInstanceData |
||||
{ |
||||
public float LastOuterHeight; |
||||
public float LastFirstRowHeight; |
||||
} |
||||
public unsafe partial struct ImGuiTableInstanceDataPtr |
||||
{ |
||||
public ImGuiTableInstanceData* NativePtr { get; } |
||||
public ImGuiTableInstanceDataPtr(ImGuiTableInstanceData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableInstanceDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableInstanceData*)nativePtr; |
||||
public static implicit operator ImGuiTableInstanceDataPtr(ImGuiTableInstanceData* nativePtr) => new ImGuiTableInstanceDataPtr(nativePtr); |
||||
public static implicit operator ImGuiTableInstanceData* (ImGuiTableInstanceDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableInstanceDataPtr(IntPtr nativePtr) => new ImGuiTableInstanceDataPtr(nativePtr); |
||||
public ref float LastOuterHeight => ref Unsafe.AsRef<float>(&NativePtr->LastOuterHeight); |
||||
public ref float LastFirstRowHeight => ref Unsafe.AsRef<float>(&NativePtr->LastFirstRowHeight); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTableInstanceData_destroy((ImGuiTableInstanceData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,41 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableSettings |
||||
{ |
||||
public uint ID; |
||||
public ImGuiTableFlags SaveFlags; |
||||
public float RefScale; |
||||
public sbyte ColumnsCount; |
||||
public sbyte ColumnsCountMax; |
||||
public byte WantApply; |
||||
} |
||||
public unsafe partial struct ImGuiTableSettingsPtr |
||||
{ |
||||
public ImGuiTableSettings* NativePtr { get; } |
||||
public ImGuiTableSettingsPtr(ImGuiTableSettings* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableSettings*)nativePtr; |
||||
public static implicit operator ImGuiTableSettingsPtr(ImGuiTableSettings* nativePtr) => new ImGuiTableSettingsPtr(nativePtr); |
||||
public static implicit operator ImGuiTableSettings* (ImGuiTableSettingsPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableSettingsPtr(IntPtr nativePtr) => new ImGuiTableSettingsPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiTableFlags SaveFlags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->SaveFlags); |
||||
public ref float RefScale => ref Unsafe.AsRef<float>(&NativePtr->RefScale); |
||||
public ref sbyte ColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsCount); |
||||
public ref sbyte ColumnsCountMax => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsCountMax); |
||||
public ref bool WantApply => ref Unsafe.AsRef<bool>(&NativePtr->WantApply); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTableSettings_destroy((ImGuiTableSettings*)(NativePtr)); |
||||
} |
||||
public ImGuiTableColumnSettingsPtr GetColumnSettings() |
||||
{ |
||||
ImGuiTableColumnSettings* ret = ImGuiNative.ImGuiTableSettings_GetColumnSettings((ImGuiTableSettings*)(NativePtr)); |
||||
return new ImGuiTableColumnSettingsPtr(ret); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,48 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiTableTempData |
||||
{ |
||||
public int TableIndex; |
||||
public float LastTimeActive; |
||||
public Vector2 UserOuterSize; |
||||
public ImDrawListSplitter DrawSplitter; |
||||
public ImRect HostBackupWorkRect; |
||||
public ImRect HostBackupParentWorkRect; |
||||
public Vector2 HostBackupPrevLineSize; |
||||
public Vector2 HostBackupCurrLineSize; |
||||
public Vector2 HostBackupCursorMaxPos; |
||||
public ImVec1 HostBackupColumnsOffset; |
||||
public float HostBackupItemWidth; |
||||
public int HostBackupItemWidthStackSize; |
||||
} |
||||
public unsafe partial struct ImGuiTableTempDataPtr |
||||
{ |
||||
public ImGuiTableTempData* NativePtr { get; } |
||||
public ImGuiTableTempDataPtr(ImGuiTableTempData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiTableTempDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableTempData*)nativePtr; |
||||
public static implicit operator ImGuiTableTempDataPtr(ImGuiTableTempData* nativePtr) => new ImGuiTableTempDataPtr(nativePtr); |
||||
public static implicit operator ImGuiTableTempData* (ImGuiTableTempDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiTableTempDataPtr(IntPtr nativePtr) => new ImGuiTableTempDataPtr(nativePtr); |
||||
public ref int TableIndex => ref Unsafe.AsRef<int>(&NativePtr->TableIndex); |
||||
public ref float LastTimeActive => ref Unsafe.AsRef<float>(&NativePtr->LastTimeActive); |
||||
public ref Vector2 UserOuterSize => ref Unsafe.AsRef<Vector2>(&NativePtr->UserOuterSize); |
||||
public ref ImDrawListSplitter DrawSplitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->DrawSplitter); |
||||
public ref ImRect HostBackupWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupWorkRect); |
||||
public ref ImRect HostBackupParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupParentWorkRect); |
||||
public ref Vector2 HostBackupPrevLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupPrevLineSize); |
||||
public ref Vector2 HostBackupCurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupCurrLineSize); |
||||
public ref Vector2 HostBackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupCursorMaxPos); |
||||
public ref ImVec1 HostBackupColumnsOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->HostBackupColumnsOffset); |
||||
public ref float HostBackupItemWidth => ref Unsafe.AsRef<float>(&NativePtr->HostBackupItemWidth); |
||||
public ref int HostBackupItemWidthStackSize => ref Unsafe.AsRef<int>(&NativePtr->HostBackupItemWidthStackSize); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiTableTempData_destroy((ImGuiTableTempData*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiTextFlags |
||||
{ |
||||
None = 0, |
||||
NoWidthForLargeClippedText = 1, |
||||
} |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiTooltipFlags |
||||
{ |
||||
None = 0, |
||||
OverridePreviousTooltip = 1, |
||||
} |
||||
} |
||||
@ -0,0 +1,8 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
[System.Flags] |
||||
public enum ImGuiTreeNodeFlagsPrivate |
||||
{ |
||||
ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1048576, |
||||
} |
||||
} |
||||
@ -0,0 +1,107 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiViewportP |
||||
{ |
||||
public ImGuiViewport _ImGuiViewport; |
||||
public int Idx; |
||||
public int LastFrameActive; |
||||
public int LastFrontMostStampCount; |
||||
public uint LastNameHash; |
||||
public Vector2 LastPos; |
||||
public float Alpha; |
||||
public float LastAlpha; |
||||
public short PlatformMonitor; |
||||
public byte PlatformWindowCreated; |
||||
public ImGuiWindow* Window; |
||||
public fixed int DrawListsLastFrame[2]; |
||||
public ImDrawList* DrawLists_0; |
||||
public ImDrawList* DrawLists_1; |
||||
public ImDrawData DrawDataP; |
||||
public ImDrawDataBuilder DrawDataBuilder; |
||||
public Vector2 LastPlatformPos; |
||||
public Vector2 LastPlatformSize; |
||||
public Vector2 LastRendererSize; |
||||
public Vector2 WorkOffsetMin; |
||||
public Vector2 WorkOffsetMax; |
||||
public Vector2 BuildWorkOffsetMin; |
||||
public Vector2 BuildWorkOffsetMax; |
||||
} |
||||
public unsafe partial struct ImGuiViewportPPtr |
||||
{ |
||||
public ImGuiViewportP* NativePtr { get; } |
||||
public ImGuiViewportPPtr(ImGuiViewportP* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiViewportPPtr(IntPtr nativePtr) => NativePtr = (ImGuiViewportP*)nativePtr; |
||||
public static implicit operator ImGuiViewportPPtr(ImGuiViewportP* nativePtr) => new ImGuiViewportPPtr(nativePtr); |
||||
public static implicit operator ImGuiViewportP* (ImGuiViewportPPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiViewportPPtr(IntPtr nativePtr) => new ImGuiViewportPPtr(nativePtr); |
||||
public ref ImGuiViewport _ImGuiViewport => ref Unsafe.AsRef<ImGuiViewport>(&NativePtr->_ImGuiViewport); |
||||
public ref int Idx => ref Unsafe.AsRef<int>(&NativePtr->Idx); |
||||
public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive); |
||||
public ref int LastFrontMostStampCount => ref Unsafe.AsRef<int>(&NativePtr->LastFrontMostStampCount); |
||||
public ref uint LastNameHash => ref Unsafe.AsRef<uint>(&NativePtr->LastNameHash); |
||||
public ref Vector2 LastPos => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPos); |
||||
public ref float Alpha => ref Unsafe.AsRef<float>(&NativePtr->Alpha); |
||||
public ref float LastAlpha => ref Unsafe.AsRef<float>(&NativePtr->LastAlpha); |
||||
public ref short PlatformMonitor => ref Unsafe.AsRef<short>(&NativePtr->PlatformMonitor); |
||||
public ref bool PlatformWindowCreated => ref Unsafe.AsRef<bool>(&NativePtr->PlatformWindowCreated); |
||||
public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window); |
||||
public RangeAccessor<int> DrawListsLastFrame => new RangeAccessor<int>(NativePtr->DrawListsLastFrame, 2); |
||||
public RangeAccessor<IntPtr> DrawLists => new RangeAccessor<IntPtr>(&NativePtr->DrawLists_0, 2); |
||||
public ref ImDrawData DrawDataP => ref Unsafe.AsRef<ImDrawData>(&NativePtr->DrawDataP); |
||||
public ref ImDrawDataBuilder DrawDataBuilder => ref Unsafe.AsRef<ImDrawDataBuilder>(&NativePtr->DrawDataBuilder); |
||||
public ref Vector2 LastPlatformPos => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPlatformPos); |
||||
public ref Vector2 LastPlatformSize => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPlatformSize); |
||||
public ref Vector2 LastRendererSize => ref Unsafe.AsRef<Vector2>(&NativePtr->LastRendererSize); |
||||
public ref Vector2 WorkOffsetMin => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkOffsetMin); |
||||
public ref Vector2 WorkOffsetMax => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkOffsetMax); |
||||
public ref Vector2 BuildWorkOffsetMin => ref Unsafe.AsRef<Vector2>(&NativePtr->BuildWorkOffsetMin); |
||||
public ref Vector2 BuildWorkOffsetMax => ref Unsafe.AsRef<Vector2>(&NativePtr->BuildWorkOffsetMax); |
||||
public Vector2 CalcWorkRectPos(Vector2 off_min) |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImGuiViewportP_CalcWorkRectPos(&__retval, (ImGuiViewportP*)(NativePtr), off_min); |
||||
return __retval; |
||||
} |
||||
public Vector2 CalcWorkRectSize(Vector2 off_min, Vector2 off_max) |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImGuiViewportP_CalcWorkRectSize(&__retval, (ImGuiViewportP*)(NativePtr), off_min, off_max); |
||||
return __retval; |
||||
} |
||||
public void ClearRequestFlags() |
||||
{ |
||||
ImGuiNative.ImGuiViewportP_ClearRequestFlags((ImGuiViewportP*)(NativePtr)); |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiViewportP_destroy((ImGuiViewportP*)(NativePtr)); |
||||
} |
||||
public ImRect GetBuildWorkRect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiViewportP_GetBuildWorkRect(&__retval, (ImGuiViewportP*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public ImRect GetMainRect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiViewportP_GetMainRect(&__retval, (ImGuiViewportP*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public ImRect GetWorkRect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiViewportP_GetWorkRect(&__retval, (ImGuiViewportP*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public void UpdateWorkRect() |
||||
{ |
||||
ImGuiNative.ImGuiViewportP_UpdateWorkRect((ImGuiViewportP*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,320 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiWindow |
||||
{ |
||||
public byte* Name; |
||||
public uint ID; |
||||
public ImGuiWindowFlags Flags; |
||||
public ImGuiWindowFlags FlagsPreviousFrame; |
||||
public ImGuiWindowClass WindowClass; |
||||
public ImGuiViewportP* Viewport; |
||||
public uint ViewportId; |
||||
public Vector2 ViewportPos; |
||||
public int ViewportAllowPlatformMonitorExtend; |
||||
public Vector2 Pos; |
||||
public Vector2 Size; |
||||
public Vector2 SizeFull; |
||||
public Vector2 ContentSize; |
||||
public Vector2 ContentSizeIdeal; |
||||
public Vector2 ContentSizeExplicit; |
||||
public Vector2 WindowPadding; |
||||
public float WindowRounding; |
||||
public float WindowBorderSize; |
||||
public int NameBufLen; |
||||
public uint MoveId; |
||||
public uint TabId; |
||||
public uint ChildId; |
||||
public Vector2 Scroll; |
||||
public Vector2 ScrollMax; |
||||
public Vector2 ScrollTarget; |
||||
public Vector2 ScrollTargetCenterRatio; |
||||
public Vector2 ScrollTargetEdgeSnapDist; |
||||
public Vector2 ScrollbarSizes; |
||||
public byte ScrollbarX; |
||||
public byte ScrollbarY; |
||||
public byte ViewportOwned; |
||||
public byte Active; |
||||
public byte WasActive; |
||||
public byte WriteAccessed; |
||||
public byte Collapsed; |
||||
public byte WantCollapseToggle; |
||||
public byte SkipItems; |
||||
public byte Appearing; |
||||
public byte Hidden; |
||||
public byte IsFallbackWindow; |
||||
public byte IsExplicitChild; |
||||
public byte HasCloseButton; |
||||
public sbyte ResizeBorderHeld; |
||||
public short BeginCount; |
||||
public short BeginOrderWithinParent; |
||||
public short BeginOrderWithinContext; |
||||
public short FocusOrder; |
||||
public uint PopupId; |
||||
public sbyte AutoFitFramesX; |
||||
public sbyte AutoFitFramesY; |
||||
public sbyte AutoFitChildAxises; |
||||
public byte AutoFitOnlyGrows; |
||||
public ImGuiDir AutoPosLastDirection; |
||||
public sbyte HiddenFramesCanSkipItems; |
||||
public sbyte HiddenFramesCannotSkipItems; |
||||
public sbyte HiddenFramesForRenderOnly; |
||||
public sbyte DisableInputsFrames; |
||||
public ImGuiCond SetWindowPosAllowFlags; |
||||
public ImGuiCond SetWindowSizeAllowFlags; |
||||
public ImGuiCond SetWindowCollapsedAllowFlags; |
||||
public ImGuiCond SetWindowDockAllowFlags; |
||||
public Vector2 SetWindowPosVal; |
||||
public Vector2 SetWindowPosPivot; |
||||
public ImVector IDStack; |
||||
public ImGuiWindowTempData DC; |
||||
public ImRect OuterRectClipped; |
||||
public ImRect InnerRect; |
||||
public ImRect InnerClipRect; |
||||
public ImRect WorkRect; |
||||
public ImRect ParentWorkRect; |
||||
public ImRect ClipRect; |
||||
public ImRect ContentRegionRect; |
||||
public ImVec2ih HitTestHoleSize; |
||||
public ImVec2ih HitTestHoleOffset; |
||||
public int LastFrameActive; |
||||
public int LastFrameJustFocused; |
||||
public float LastTimeActive; |
||||
public float ItemWidthDefault; |
||||
public ImGuiStorage StateStorage; |
||||
public ImVector ColumnsStorage; |
||||
public float FontWindowScale; |
||||
public float FontDpiScale; |
||||
public int SettingsOffset; |
||||
public ImDrawList* DrawList; |
||||
public ImDrawList DrawListInst; |
||||
public ImGuiWindow* ParentWindow; |
||||
public ImGuiWindow* ParentWindowInBeginStack; |
||||
public ImGuiWindow* RootWindow; |
||||
public ImGuiWindow* RootWindowPopupTree; |
||||
public ImGuiWindow* RootWindowDockTree; |
||||
public ImGuiWindow* RootWindowForTitleBarHighlight; |
||||
public ImGuiWindow* RootWindowForNav; |
||||
public ImGuiWindow* NavLastChildNavWindow; |
||||
public fixed uint NavLastIds[2]; |
||||
public ImRect NavRectRel_0; |
||||
public ImRect NavRectRel_1; |
||||
public int MemoryDrawListIdxCapacity; |
||||
public int MemoryDrawListVtxCapacity; |
||||
public byte MemoryCompacted; |
||||
public byte DockIsActive; |
||||
public byte DockNodeIsVisible; |
||||
public byte DockTabIsVisible; |
||||
public byte DockTabWantClose; |
||||
public short DockOrder; |
||||
public ImGuiWindowDockStyle DockStyle; |
||||
public ImGuiDockNode* DockNode; |
||||
public ImGuiDockNode* DockNodeAsHost; |
||||
public uint DockId; |
||||
public ImGuiItemStatusFlags DockTabItemStatusFlags; |
||||
public ImRect DockTabItemRect; |
||||
} |
||||
public unsafe partial struct ImGuiWindowPtr |
||||
{ |
||||
public ImGuiWindow* NativePtr { get; } |
||||
public ImGuiWindowPtr(ImGuiWindow* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiWindowPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindow*)nativePtr; |
||||
public static implicit operator ImGuiWindowPtr(ImGuiWindow* nativePtr) => new ImGuiWindowPtr(nativePtr); |
||||
public static implicit operator ImGuiWindow* (ImGuiWindowPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiWindowPtr(IntPtr nativePtr) => new ImGuiWindowPtr(nativePtr); |
||||
public NullTerminatedString Name => new NullTerminatedString(NativePtr->Name); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImGuiWindowFlags Flags => ref Unsafe.AsRef<ImGuiWindowFlags>(&NativePtr->Flags); |
||||
public ref ImGuiWindowFlags FlagsPreviousFrame => ref Unsafe.AsRef<ImGuiWindowFlags>(&NativePtr->FlagsPreviousFrame); |
||||
public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass); |
||||
public ImGuiViewportPPtr Viewport => new ImGuiViewportPPtr(NativePtr->Viewport); |
||||
public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId); |
||||
public ref Vector2 ViewportPos => ref Unsafe.AsRef<Vector2>(&NativePtr->ViewportPos); |
||||
public ref int ViewportAllowPlatformMonitorExtend => ref Unsafe.AsRef<int>(&NativePtr->ViewportAllowPlatformMonitorExtend); |
||||
public ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos); |
||||
public ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size); |
||||
public ref Vector2 SizeFull => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeFull); |
||||
public ref Vector2 ContentSize => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSize); |
||||
public ref Vector2 ContentSizeIdeal => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeIdeal); |
||||
public ref Vector2 ContentSizeExplicit => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeExplicit); |
||||
public ref Vector2 WindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowPadding); |
||||
public ref float WindowRounding => ref Unsafe.AsRef<float>(&NativePtr->WindowRounding); |
||||
public ref float WindowBorderSize => ref Unsafe.AsRef<float>(&NativePtr->WindowBorderSize); |
||||
public ref int NameBufLen => ref Unsafe.AsRef<int>(&NativePtr->NameBufLen); |
||||
public ref uint MoveId => ref Unsafe.AsRef<uint>(&NativePtr->MoveId); |
||||
public ref uint TabId => ref Unsafe.AsRef<uint>(&NativePtr->TabId); |
||||
public ref uint ChildId => ref Unsafe.AsRef<uint>(&NativePtr->ChildId); |
||||
public ref Vector2 Scroll => ref Unsafe.AsRef<Vector2>(&NativePtr->Scroll); |
||||
public ref Vector2 ScrollMax => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollMax); |
||||
public ref Vector2 ScrollTarget => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTarget); |
||||
public ref Vector2 ScrollTargetCenterRatio => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTargetCenterRatio); |
||||
public ref Vector2 ScrollTargetEdgeSnapDist => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTargetEdgeSnapDist); |
||||
public ref Vector2 ScrollbarSizes => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollbarSizes); |
||||
public ref bool ScrollbarX => ref Unsafe.AsRef<bool>(&NativePtr->ScrollbarX); |
||||
public ref bool ScrollbarY => ref Unsafe.AsRef<bool>(&NativePtr->ScrollbarY); |
||||
public ref bool ViewportOwned => ref Unsafe.AsRef<bool>(&NativePtr->ViewportOwned); |
||||
public ref bool Active => ref Unsafe.AsRef<bool>(&NativePtr->Active); |
||||
public ref bool WasActive => ref Unsafe.AsRef<bool>(&NativePtr->WasActive); |
||||
public ref bool WriteAccessed => ref Unsafe.AsRef<bool>(&NativePtr->WriteAccessed); |
||||
public ref bool Collapsed => ref Unsafe.AsRef<bool>(&NativePtr->Collapsed); |
||||
public ref bool WantCollapseToggle => ref Unsafe.AsRef<bool>(&NativePtr->WantCollapseToggle); |
||||
public ref bool SkipItems => ref Unsafe.AsRef<bool>(&NativePtr->SkipItems); |
||||
public ref bool Appearing => ref Unsafe.AsRef<bool>(&NativePtr->Appearing); |
||||
public ref bool Hidden => ref Unsafe.AsRef<bool>(&NativePtr->Hidden); |
||||
public ref bool IsFallbackWindow => ref Unsafe.AsRef<bool>(&NativePtr->IsFallbackWindow); |
||||
public ref bool IsExplicitChild => ref Unsafe.AsRef<bool>(&NativePtr->IsExplicitChild); |
||||
public ref bool HasCloseButton => ref Unsafe.AsRef<bool>(&NativePtr->HasCloseButton); |
||||
public ref sbyte ResizeBorderHeld => ref Unsafe.AsRef<sbyte>(&NativePtr->ResizeBorderHeld); |
||||
public ref short BeginCount => ref Unsafe.AsRef<short>(&NativePtr->BeginCount); |
||||
public ref short BeginOrderWithinParent => ref Unsafe.AsRef<short>(&NativePtr->BeginOrderWithinParent); |
||||
public ref short BeginOrderWithinContext => ref Unsafe.AsRef<short>(&NativePtr->BeginOrderWithinContext); |
||||
public ref short FocusOrder => ref Unsafe.AsRef<short>(&NativePtr->FocusOrder); |
||||
public ref uint PopupId => ref Unsafe.AsRef<uint>(&NativePtr->PopupId); |
||||
public ref sbyte AutoFitFramesX => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitFramesX); |
||||
public ref sbyte AutoFitFramesY => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitFramesY); |
||||
public ref sbyte AutoFitChildAxises => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitChildAxises); |
||||
public ref bool AutoFitOnlyGrows => ref Unsafe.AsRef<bool>(&NativePtr->AutoFitOnlyGrows); |
||||
public ref ImGuiDir AutoPosLastDirection => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->AutoPosLastDirection); |
||||
public ref sbyte HiddenFramesCanSkipItems => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesCanSkipItems); |
||||
public ref sbyte HiddenFramesCannotSkipItems => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesCannotSkipItems); |
||||
public ref sbyte HiddenFramesForRenderOnly => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesForRenderOnly); |
||||
public ref sbyte DisableInputsFrames => ref Unsafe.AsRef<sbyte>(&NativePtr->DisableInputsFrames); |
||||
public ref ImGuiCond SetWindowPosAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowPosAllowFlags); |
||||
public ref ImGuiCond SetWindowSizeAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowSizeAllowFlags); |
||||
public ref ImGuiCond SetWindowCollapsedAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowCollapsedAllowFlags); |
||||
public ref ImGuiCond SetWindowDockAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowDockAllowFlags); |
||||
public ref Vector2 SetWindowPosVal => ref Unsafe.AsRef<Vector2>(&NativePtr->SetWindowPosVal); |
||||
public ref Vector2 SetWindowPosPivot => ref Unsafe.AsRef<Vector2>(&NativePtr->SetWindowPosPivot); |
||||
public ImVector<uint> IDStack => new ImVector<uint>(NativePtr->IDStack); |
||||
public ref ImGuiWindowTempData DC => ref Unsafe.AsRef<ImGuiWindowTempData>(&NativePtr->DC); |
||||
public ref ImRect OuterRectClipped => ref Unsafe.AsRef<ImRect>(&NativePtr->OuterRectClipped); |
||||
public ref ImRect InnerRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerRect); |
||||
public ref ImRect InnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerClipRect); |
||||
public ref ImRect WorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->WorkRect); |
||||
public ref ImRect ParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ParentWorkRect); |
||||
public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect); |
||||
public ref ImRect ContentRegionRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ContentRegionRect); |
||||
public ref ImVec2ih HitTestHoleSize => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->HitTestHoleSize); |
||||
public ref ImVec2ih HitTestHoleOffset => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->HitTestHoleOffset); |
||||
public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive); |
||||
public ref int LastFrameJustFocused => ref Unsafe.AsRef<int>(&NativePtr->LastFrameJustFocused); |
||||
public ref float LastTimeActive => ref Unsafe.AsRef<float>(&NativePtr->LastTimeActive); |
||||
public ref float ItemWidthDefault => ref Unsafe.AsRef<float>(&NativePtr->ItemWidthDefault); |
||||
public ref ImGuiStorage StateStorage => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->StateStorage); |
||||
public ImPtrVector<ImGuiOldColumnsPtr> ColumnsStorage => new ImPtrVector<ImGuiOldColumnsPtr>(NativePtr->ColumnsStorage, Unsafe.SizeOf<ImGuiOldColumns>()); |
||||
public ref float FontWindowScale => ref Unsafe.AsRef<float>(&NativePtr->FontWindowScale); |
||||
public ref float FontDpiScale => ref Unsafe.AsRef<float>(&NativePtr->FontDpiScale); |
||||
public ref int SettingsOffset => ref Unsafe.AsRef<int>(&NativePtr->SettingsOffset); |
||||
public ImDrawListPtr DrawList => new ImDrawListPtr(NativePtr->DrawList); |
||||
public ref ImDrawList DrawListInst => ref Unsafe.AsRef<ImDrawList>(&NativePtr->DrawListInst); |
||||
public ImGuiWindowPtr ParentWindow => new ImGuiWindowPtr(NativePtr->ParentWindow); |
||||
public ImGuiWindowPtr ParentWindowInBeginStack => new ImGuiWindowPtr(NativePtr->ParentWindowInBeginStack); |
||||
public ImGuiWindowPtr RootWindow => new ImGuiWindowPtr(NativePtr->RootWindow); |
||||
public ImGuiWindowPtr RootWindowPopupTree => new ImGuiWindowPtr(NativePtr->RootWindowPopupTree); |
||||
public ImGuiWindowPtr RootWindowDockTree => new ImGuiWindowPtr(NativePtr->RootWindowDockTree); |
||||
public ImGuiWindowPtr RootWindowForTitleBarHighlight => new ImGuiWindowPtr(NativePtr->RootWindowForTitleBarHighlight); |
||||
public ImGuiWindowPtr RootWindowForNav => new ImGuiWindowPtr(NativePtr->RootWindowForNav); |
||||
public ImGuiWindowPtr NavLastChildNavWindow => new ImGuiWindowPtr(NativePtr->NavLastChildNavWindow); |
||||
public RangeAccessor<uint> NavLastIds => new RangeAccessor<uint>(NativePtr->NavLastIds, 2); |
||||
public RangeAccessor<ImRect> NavRectRel => new RangeAccessor<ImRect>(&NativePtr->NavRectRel_0, 2); |
||||
public ref int MemoryDrawListIdxCapacity => ref Unsafe.AsRef<int>(&NativePtr->MemoryDrawListIdxCapacity); |
||||
public ref int MemoryDrawListVtxCapacity => ref Unsafe.AsRef<int>(&NativePtr->MemoryDrawListVtxCapacity); |
||||
public ref bool MemoryCompacted => ref Unsafe.AsRef<bool>(&NativePtr->MemoryCompacted); |
||||
public ref bool DockIsActive => ref Unsafe.AsRef<bool>(&NativePtr->DockIsActive); |
||||
public ref bool DockNodeIsVisible => ref Unsafe.AsRef<bool>(&NativePtr->DockNodeIsVisible); |
||||
public ref bool DockTabIsVisible => ref Unsafe.AsRef<bool>(&NativePtr->DockTabIsVisible); |
||||
public ref bool DockTabWantClose => ref Unsafe.AsRef<bool>(&NativePtr->DockTabWantClose); |
||||
public ref short DockOrder => ref Unsafe.AsRef<short>(&NativePtr->DockOrder); |
||||
public ref ImGuiWindowDockStyle DockStyle => ref Unsafe.AsRef<ImGuiWindowDockStyle>(&NativePtr->DockStyle); |
||||
public ImGuiDockNodePtr DockNode => new ImGuiDockNodePtr(NativePtr->DockNode); |
||||
public ImGuiDockNodePtr DockNodeAsHost => new ImGuiDockNodePtr(NativePtr->DockNodeAsHost); |
||||
public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId); |
||||
public ref ImGuiItemStatusFlags DockTabItemStatusFlags => ref Unsafe.AsRef<ImGuiItemStatusFlags>(&NativePtr->DockTabItemStatusFlags); |
||||
public ref ImRect DockTabItemRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DockTabItemRect); |
||||
public float CalcFontSize() |
||||
{ |
||||
float ret = ImGuiNative.ImGuiWindow_CalcFontSize((ImGuiWindow*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiWindow_destroy((ImGuiWindow*)(NativePtr)); |
||||
} |
||||
public uint GetID(string str) |
||||
{ |
||||
byte* native_str; |
||||
int str_byteCount = 0; |
||||
if (str != null) |
||||
{ |
||||
str_byteCount = Encoding.UTF8.GetByteCount(str); |
||||
if (str_byteCount > Util.StackAllocationSizeLimit) |
||||
{ |
||||
native_str = Util.Allocate(str_byteCount + 1); |
||||
} |
||||
else |
||||
{ |
||||
byte* native_str_stackBytes = stackalloc byte[str_byteCount + 1]; |
||||
native_str = native_str_stackBytes; |
||||
} |
||||
int native_str_offset = Util.GetUtf8(str, native_str, str_byteCount); |
||||
native_str[native_str_offset] = 0; |
||||
} |
||||
else { native_str = null; } |
||||
byte* native_str_end = null; |
||||
uint ret = ImGuiNative.ImGuiWindow_GetID_Str((ImGuiWindow*)(NativePtr), native_str, native_str_end); |
||||
if (str_byteCount > Util.StackAllocationSizeLimit) |
||||
{ |
||||
Util.Free(native_str); |
||||
} |
||||
return ret; |
||||
} |
||||
public uint GetID(IntPtr ptr) |
||||
{ |
||||
void* native_ptr = (void*)ptr.ToPointer(); |
||||
uint ret = ImGuiNative.ImGuiWindow_GetID_Ptr((ImGuiWindow*)(NativePtr), native_ptr); |
||||
return ret; |
||||
} |
||||
public uint GetID(int n) |
||||
{ |
||||
uint ret = ImGuiNative.ImGuiWindow_GetID_Int((ImGuiWindow*)(NativePtr), n); |
||||
return ret; |
||||
} |
||||
public uint GetIDFromRectangle(ImRect r_abs) |
||||
{ |
||||
uint ret = ImGuiNative.ImGuiWindow_GetIDFromRectangle((ImGuiWindow*)(NativePtr), r_abs); |
||||
return ret; |
||||
} |
||||
public float MenuBarHeight() |
||||
{ |
||||
float ret = ImGuiNative.ImGuiWindow_MenuBarHeight((ImGuiWindow*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public ImRect MenuBarRect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiWindow_MenuBarRect(&__retval, (ImGuiWindow*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public ImRect Rect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiWindow_Rect(&__retval, (ImGuiWindow*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public float TitleBarHeight() |
||||
{ |
||||
float ret = ImGuiNative.ImGuiWindow_TitleBarHeight((ImGuiWindow*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public ImRect TitleBarRect() |
||||
{ |
||||
ImRect __retval; |
||||
ImGuiNative.ImGuiWindow_TitleBarRect(&__retval, (ImGuiWindow*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiWindowDockStyle |
||||
{ |
||||
public fixed uint Colors[6]; |
||||
} |
||||
public unsafe partial struct ImGuiWindowDockStylePtr |
||||
{ |
||||
public ImGuiWindowDockStyle* NativePtr { get; } |
||||
public ImGuiWindowDockStylePtr(ImGuiWindowDockStyle* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiWindowDockStylePtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowDockStyle*)nativePtr; |
||||
public static implicit operator ImGuiWindowDockStylePtr(ImGuiWindowDockStyle* nativePtr) => new ImGuiWindowDockStylePtr(nativePtr); |
||||
public static implicit operator ImGuiWindowDockStyle* (ImGuiWindowDockStylePtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiWindowDockStylePtr(IntPtr nativePtr) => new ImGuiWindowDockStylePtr(nativePtr); |
||||
public RangeAccessor<uint> Colors => new RangeAccessor<uint>(NativePtr->Colors, 6); |
||||
} |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
namespace ImGuiNET |
||||
{ |
||||
public enum ImGuiWindowDockStyleCol |
||||
{ |
||||
Text = 0, |
||||
Tab = 1, |
||||
TabHovered = 2, |
||||
TabActive = 3, |
||||
TabUnfocused = 4, |
||||
TabUnfocusedActive = 5, |
||||
COUNT = 6, |
||||
} |
||||
} |
||||
@ -0,0 +1,49 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiWindowSettings |
||||
{ |
||||
public uint ID; |
||||
public ImVec2ih Pos; |
||||
public ImVec2ih Size; |
||||
public ImVec2ih ViewportPos; |
||||
public uint ViewportId; |
||||
public uint DockId; |
||||
public uint ClassId; |
||||
public short DockOrder; |
||||
public byte Collapsed; |
||||
public byte WantApply; |
||||
} |
||||
public unsafe partial struct ImGuiWindowSettingsPtr |
||||
{ |
||||
public ImGuiWindowSettings* NativePtr { get; } |
||||
public ImGuiWindowSettingsPtr(ImGuiWindowSettings* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiWindowSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowSettings*)nativePtr; |
||||
public static implicit operator ImGuiWindowSettingsPtr(ImGuiWindowSettings* nativePtr) => new ImGuiWindowSettingsPtr(nativePtr); |
||||
public static implicit operator ImGuiWindowSettings* (ImGuiWindowSettingsPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiWindowSettingsPtr(IntPtr nativePtr) => new ImGuiWindowSettingsPtr(nativePtr); |
||||
public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID); |
||||
public ref ImVec2ih Pos => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->Pos); |
||||
public ref ImVec2ih Size => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->Size); |
||||
public ref ImVec2ih ViewportPos => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->ViewportPos); |
||||
public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId); |
||||
public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId); |
||||
public ref uint ClassId => ref Unsafe.AsRef<uint>(&NativePtr->ClassId); |
||||
public ref short DockOrder => ref Unsafe.AsRef<short>(&NativePtr->DockOrder); |
||||
public ref bool Collapsed => ref Unsafe.AsRef<bool>(&NativePtr->Collapsed); |
||||
public ref bool WantApply => ref Unsafe.AsRef<bool>(&NativePtr->WantApply); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImGuiWindowSettings_destroy((ImGuiWindowSettings*)(NativePtr)); |
||||
} |
||||
public string GetName() |
||||
{ |
||||
byte* ret = ImGuiNative.ImGuiWindowSettings_GetName((ImGuiWindowSettings*)(NativePtr)); |
||||
return Util.StringFromPtr(ret); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiWindowStackData |
||||
{ |
||||
public ImGuiWindow* Window; |
||||
public ImGuiLastItemData ParentLastItemDataBackup; |
||||
public ImGuiStackSizes StackSizesOnBegin; |
||||
} |
||||
public unsafe partial struct ImGuiWindowStackDataPtr |
||||
{ |
||||
public ImGuiWindowStackData* NativePtr { get; } |
||||
public ImGuiWindowStackDataPtr(ImGuiWindowStackData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiWindowStackDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowStackData*)nativePtr; |
||||
public static implicit operator ImGuiWindowStackDataPtr(ImGuiWindowStackData* nativePtr) => new ImGuiWindowStackDataPtr(nativePtr); |
||||
public static implicit operator ImGuiWindowStackData* (ImGuiWindowStackDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiWindowStackDataPtr(IntPtr nativePtr) => new ImGuiWindowStackDataPtr(nativePtr); |
||||
public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window); |
||||
public ref ImGuiLastItemData ParentLastItemDataBackup => ref Unsafe.AsRef<ImGuiLastItemData>(&NativePtr->ParentLastItemDataBackup); |
||||
public ref ImGuiStackSizes StackSizesOnBegin => ref Unsafe.AsRef<ImGuiStackSizes>(&NativePtr->StackSizesOnBegin); |
||||
} |
||||
} |
||||
@ -0,0 +1,90 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImGuiWindowTempData |
||||
{ |
||||
public Vector2 CursorPos; |
||||
public Vector2 CursorPosPrevLine; |
||||
public Vector2 CursorStartPos; |
||||
public Vector2 CursorMaxPos; |
||||
public Vector2 IdealMaxPos; |
||||
public Vector2 CurrLineSize; |
||||
public Vector2 PrevLineSize; |
||||
public float CurrLineTextBaseOffset; |
||||
public float PrevLineTextBaseOffset; |
||||
public byte IsSameLine; |
||||
public ImVec1 Indent; |
||||
public ImVec1 ColumnsOffset; |
||||
public ImVec1 GroupOffset; |
||||
public Vector2 CursorStartPosLossyness; |
||||
public ImGuiNavLayer NavLayerCurrent; |
||||
public short NavLayersActiveMask; |
||||
public short NavLayersActiveMaskNext; |
||||
public uint NavFocusScopeIdCurrent; |
||||
public byte NavHideHighlightOneFrame; |
||||
public byte NavHasScroll; |
||||
public byte MenuBarAppending; |
||||
public Vector2 MenuBarOffset; |
||||
public ImGuiMenuColumns MenuColumns; |
||||
public int TreeDepth; |
||||
public uint TreeJumpToParentOnPopMask; |
||||
public ImVector ChildWindows; |
||||
public ImGuiStorage* StateStorage; |
||||
public ImGuiOldColumns* CurrentColumns; |
||||
public int CurrentTableIdx; |
||||
public ImGuiLayoutType LayoutType; |
||||
public ImGuiLayoutType ParentLayoutType; |
||||
public float ItemWidth; |
||||
public float TextWrapPos; |
||||
public ImVector ItemWidthStack; |
||||
public ImVector TextWrapPosStack; |
||||
} |
||||
public unsafe partial struct ImGuiWindowTempDataPtr |
||||
{ |
||||
public ImGuiWindowTempData* NativePtr { get; } |
||||
public ImGuiWindowTempDataPtr(ImGuiWindowTempData* nativePtr) => NativePtr = nativePtr; |
||||
public ImGuiWindowTempDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowTempData*)nativePtr; |
||||
public static implicit operator ImGuiWindowTempDataPtr(ImGuiWindowTempData* nativePtr) => new ImGuiWindowTempDataPtr(nativePtr); |
||||
public static implicit operator ImGuiWindowTempData* (ImGuiWindowTempDataPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImGuiWindowTempDataPtr(IntPtr nativePtr) => new ImGuiWindowTempDataPtr(nativePtr); |
||||
public ref Vector2 CursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorPos); |
||||
public ref Vector2 CursorPosPrevLine => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorPosPrevLine); |
||||
public ref Vector2 CursorStartPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorStartPos); |
||||
public ref Vector2 CursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorMaxPos); |
||||
public ref Vector2 IdealMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->IdealMaxPos); |
||||
public ref Vector2 CurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->CurrLineSize); |
||||
public ref Vector2 PrevLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PrevLineSize); |
||||
public ref float CurrLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->CurrLineTextBaseOffset); |
||||
public ref float PrevLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->PrevLineTextBaseOffset); |
||||
public ref bool IsSameLine => ref Unsafe.AsRef<bool>(&NativePtr->IsSameLine); |
||||
public ref ImVec1 Indent => ref Unsafe.AsRef<ImVec1>(&NativePtr->Indent); |
||||
public ref ImVec1 ColumnsOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->ColumnsOffset); |
||||
public ref ImVec1 GroupOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->GroupOffset); |
||||
public ref Vector2 CursorStartPosLossyness => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorStartPosLossyness); |
||||
public ref ImGuiNavLayer NavLayerCurrent => ref Unsafe.AsRef<ImGuiNavLayer>(&NativePtr->NavLayerCurrent); |
||||
public ref short NavLayersActiveMask => ref Unsafe.AsRef<short>(&NativePtr->NavLayersActiveMask); |
||||
public ref short NavLayersActiveMaskNext => ref Unsafe.AsRef<short>(&NativePtr->NavLayersActiveMaskNext); |
||||
public ref uint NavFocusScopeIdCurrent => ref Unsafe.AsRef<uint>(&NativePtr->NavFocusScopeIdCurrent); |
||||
public ref bool NavHideHighlightOneFrame => ref Unsafe.AsRef<bool>(&NativePtr->NavHideHighlightOneFrame); |
||||
public ref bool NavHasScroll => ref Unsafe.AsRef<bool>(&NativePtr->NavHasScroll); |
||||
public ref bool MenuBarAppending => ref Unsafe.AsRef<bool>(&NativePtr->MenuBarAppending); |
||||
public ref Vector2 MenuBarOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->MenuBarOffset); |
||||
public ref ImGuiMenuColumns MenuColumns => ref Unsafe.AsRef<ImGuiMenuColumns>(&NativePtr->MenuColumns); |
||||
public ref int TreeDepth => ref Unsafe.AsRef<int>(&NativePtr->TreeDepth); |
||||
public ref uint TreeJumpToParentOnPopMask => ref Unsafe.AsRef<uint>(&NativePtr->TreeJumpToParentOnPopMask); |
||||
public ImVector<ImGuiWindowPtr> ChildWindows => new ImVector<ImGuiWindowPtr>(NativePtr->ChildWindows); |
||||
public ImGuiStoragePtr StateStorage => new ImGuiStoragePtr(NativePtr->StateStorage); |
||||
public ImGuiOldColumnsPtr CurrentColumns => new ImGuiOldColumnsPtr(NativePtr->CurrentColumns); |
||||
public ref int CurrentTableIdx => ref Unsafe.AsRef<int>(&NativePtr->CurrentTableIdx); |
||||
public ref ImGuiLayoutType LayoutType => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->LayoutType); |
||||
public ref ImGuiLayoutType ParentLayoutType => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->ParentLayoutType); |
||||
public ref float ItemWidth => ref Unsafe.AsRef<float>(&NativePtr->ItemWidth); |
||||
public ref float TextWrapPos => ref Unsafe.AsRef<float>(&NativePtr->TextWrapPos); |
||||
public ImVector<float> ItemWidthStack => new ImVector<float>(NativePtr->ItemWidthStack); |
||||
public ImVector<float> TextWrapPosStack => new ImVector<float>(NativePtr->TextWrapPosStack); |
||||
} |
||||
} |
||||
@ -0,0 +1,145 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImRect |
||||
{ |
||||
public Vector2 Min; |
||||
public Vector2 Max; |
||||
} |
||||
public unsafe partial struct ImRectPtr |
||||
{ |
||||
public ImRect* NativePtr { get; } |
||||
public ImRectPtr(ImRect* nativePtr) => NativePtr = nativePtr; |
||||
public ImRectPtr(IntPtr nativePtr) => NativePtr = (ImRect*)nativePtr; |
||||
public static implicit operator ImRectPtr(ImRect* nativePtr) => new ImRectPtr(nativePtr); |
||||
public static implicit operator ImRect* (ImRectPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImRectPtr(IntPtr nativePtr) => new ImRectPtr(nativePtr); |
||||
public ref Vector2 Min => ref Unsafe.AsRef<Vector2>(&NativePtr->Min); |
||||
public ref Vector2 Max => ref Unsafe.AsRef<Vector2>(&NativePtr->Max); |
||||
public void Add(Vector2 p) |
||||
{ |
||||
ImGuiNative.ImRect_Add_Vec2((ImRect*)(NativePtr), p); |
||||
} |
||||
public void Add(ImRect r) |
||||
{ |
||||
ImGuiNative.ImRect_Add_Rect((ImRect*)(NativePtr), r); |
||||
} |
||||
public void ClipWith(ImRect r) |
||||
{ |
||||
ImGuiNative.ImRect_ClipWith((ImRect*)(NativePtr), r); |
||||
} |
||||
public void ClipWithFull(ImRect r) |
||||
{ |
||||
ImGuiNative.ImRect_ClipWithFull((ImRect*)(NativePtr), r); |
||||
} |
||||
public bool Contains(Vector2 p) |
||||
{ |
||||
byte ret = ImGuiNative.ImRect_Contains_Vec2((ImRect*)(NativePtr), p); |
||||
return ret != 0; |
||||
} |
||||
public bool Contains(ImRect r) |
||||
{ |
||||
byte ret = ImGuiNative.ImRect_Contains_Rect((ImRect*)(NativePtr), r); |
||||
return ret != 0; |
||||
} |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImRect_destroy((ImRect*)(NativePtr)); |
||||
} |
||||
public void Expand(float amount) |
||||
{ |
||||
ImGuiNative.ImRect_Expand_Float((ImRect*)(NativePtr), amount); |
||||
} |
||||
public void Expand(Vector2 amount) |
||||
{ |
||||
ImGuiNative.ImRect_Expand_Vec2((ImRect*)(NativePtr), amount); |
||||
} |
||||
public void Floor() |
||||
{ |
||||
ImGuiNative.ImRect_Floor((ImRect*)(NativePtr)); |
||||
} |
||||
public float GetArea() |
||||
{ |
||||
float ret = ImGuiNative.ImRect_GetArea((ImRect*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public Vector2 GetBL() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetBL(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public Vector2 GetBR() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetBR(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public Vector2 GetCenter() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetCenter(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public float GetHeight() |
||||
{ |
||||
float ret = ImGuiNative.ImRect_GetHeight((ImRect*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public Vector2 GetSize() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetSize(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public Vector2 GetTL() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetTL(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public Vector2 GetTR() |
||||
{ |
||||
Vector2 __retval; |
||||
ImGuiNative.ImRect_GetTR(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public float GetWidth() |
||||
{ |
||||
float ret = ImGuiNative.ImRect_GetWidth((ImRect*)(NativePtr)); |
||||
return ret; |
||||
} |
||||
public bool IsInverted() |
||||
{ |
||||
byte ret = ImGuiNative.ImRect_IsInverted((ImRect*)(NativePtr)); |
||||
return ret != 0; |
||||
} |
||||
public bool Overlaps(ImRect r) |
||||
{ |
||||
byte ret = ImGuiNative.ImRect_Overlaps((ImRect*)(NativePtr), r); |
||||
return ret != 0; |
||||
} |
||||
public Vector4 ToVec4() |
||||
{ |
||||
Vector4 __retval; |
||||
ImGuiNative.ImRect_ToVec4(&__retval, (ImRect*)(NativePtr)); |
||||
return __retval; |
||||
} |
||||
public void Translate(Vector2 d) |
||||
{ |
||||
ImGuiNative.ImRect_Translate((ImRect*)(NativePtr), d); |
||||
} |
||||
public void TranslateX(float dx) |
||||
{ |
||||
ImGuiNative.ImRect_TranslateX((ImRect*)(NativePtr), dx); |
||||
} |
||||
public void TranslateY(float dy) |
||||
{ |
||||
ImGuiNative.ImRect_TranslateY((ImRect*)(NativePtr), dy); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImVec1 |
||||
{ |
||||
public float x; |
||||
} |
||||
public unsafe partial struct ImVec1Ptr |
||||
{ |
||||
public ImVec1* NativePtr { get; } |
||||
public ImVec1Ptr(ImVec1* nativePtr) => NativePtr = nativePtr; |
||||
public ImVec1Ptr(IntPtr nativePtr) => NativePtr = (ImVec1*)nativePtr; |
||||
public static implicit operator ImVec1Ptr(ImVec1* nativePtr) => new ImVec1Ptr(nativePtr); |
||||
public static implicit operator ImVec1* (ImVec1Ptr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImVec1Ptr(IntPtr nativePtr) => new ImVec1Ptr(nativePtr); |
||||
public ref float x => ref Unsafe.AsRef<float>(&NativePtr->x); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImVec1_destroy((ImVec1*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,28 @@ |
||||
using System; |
||||
using System.Numerics; |
||||
using System.Runtime.CompilerServices; |
||||
using System.Text; |
||||
|
||||
namespace ImGuiNET.Internal |
||||
{ |
||||
public unsafe partial struct ImVec2ih |
||||
{ |
||||
public short x; |
||||
public short y; |
||||
} |
||||
public unsafe partial struct ImVec2ihPtr |
||||
{ |
||||
public ImVec2ih* NativePtr { get; } |
||||
public ImVec2ihPtr(ImVec2ih* nativePtr) => NativePtr = nativePtr; |
||||
public ImVec2ihPtr(IntPtr nativePtr) => NativePtr = (ImVec2ih*)nativePtr; |
||||
public static implicit operator ImVec2ihPtr(ImVec2ih* nativePtr) => new ImVec2ihPtr(nativePtr); |
||||
public static implicit operator ImVec2ih* (ImVec2ihPtr wrappedPtr) => wrappedPtr.NativePtr; |
||||
public static implicit operator ImVec2ihPtr(IntPtr nativePtr) => new ImVec2ihPtr(nativePtr); |
||||
public ref short x => ref Unsafe.AsRef<short>(&NativePtr->x); |
||||
public ref short y => ref Unsafe.AsRef<short>(&NativePtr->y); |
||||
public void Destroy() |
||||
{ |
||||
ImGuiNative.ImVec2ih_destroy((ImVec2ih*)(NativePtr)); |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue