Generated code files for ImPlot.NET, ImNodes.NET and ImGuizmo.NET

src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs

@@ -0,0 +1,233 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImGuizmo
+    {
+        public static void BeginFrame()
+        {
+            ImGuizmoNative.ImGuizmo_BeginFrame();
+        }
+        public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, ref float scale)
+        {
+            fixed (float* native_matrix = &matrix)
+            {
+                fixed (float* native_translation = &translation)
+                {
+                    fixed (float* native_rotation = &rotation)
+                    {
+                        fixed (float* native_scale = &scale)
+                        {
+                            ImGuizmoNative.ImGuizmo_DecomposeMatrixToComponents(native_matrix, native_translation, native_rotation, native_scale);
+                        }
+                    }
+                }
+            }
+        }
+        public static void DrawCubes(ref float view, ref float projection, ref float matrices, int matrixCount)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrices = &matrices)
+                    {
+                        ImGuizmoNative.ImGuizmo_DrawCubes(native_view, native_projection, native_matrices, matrixCount);
+                    }
+                }
+            }
+        }
+        public static void DrawGrid(ref float view, ref float projection, ref float matrix, float gridSize)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        ImGuizmoNative.ImGuizmo_DrawGrid(native_view, native_projection, native_matrix, gridSize);
+                    }
+                }
+            }
+        }
+        public static void Enable(bool enable)
+        {
+            byte native_enable = enable ? (byte)1 : (byte)0;
+            ImGuizmoNative.ImGuizmo_Enable(native_enable);
+        }
+        public static bool IsOver()
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsOverNil();
+            return ret != 0;
+        }
+        public static bool IsOver(OPERATION op)
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsOverOPERATION(op);
+            return ret != 0;
+        }
+        public static bool IsUsing()
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsUsing();
+            return ret != 0;
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix)
+        {
+            float* deltaMatrix = null;
+            float* snap = null;
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, deltaMatrix, snap, localBounds, boundsSnap);
+                        return ret != 0;
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix)
+        {
+            float* snap = null;
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, snap, localBounds, boundsSnap);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap)
+        {
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, localBounds, boundsSnap);
+                                return ret != 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
+        {
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                fixed (float* native_localBounds = &localBounds)
+                                {
+                                    byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, native_localBounds, boundsSnap);
+                                    return ret != 0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, ref float boundsSnap)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                fixed (float* native_localBounds = &localBounds)
+                                {
+                                    fixed (float* native_boundsSnap = &boundsSnap)
+                                    {
+                                        byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, native_localBounds, native_boundsSnap);
+                                        return ret != 0;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, ref float matrix)
+        {
+            fixed (float* native_translation = &translation)
+            {
+                fixed (float* native_rotation = &rotation)
+                {
+                    fixed (float* native_scale = &scale)
+                    {
+                        fixed (float* native_matrix = &matrix)
+                        {
+                            ImGuizmoNative.ImGuizmo_RecomposeMatrixFromComponents(native_translation, native_rotation, native_scale, native_matrix);
+                        }
+                    }
+                }
+            }
+        }
+        public static void SetDrawlist()
+        {
+            ImDrawList* drawlist = null;
+            ImGuizmoNative.ImGuizmo_SetDrawlist(drawlist);
+        }
+        public static void SetDrawlist(ImDrawListPtr drawlist)
+        {
+            ImDrawList* native_drawlist = drawlist.NativePtr;
+            ImGuizmoNative.ImGuizmo_SetDrawlist(native_drawlist);
+        }
+        public static void SetID(int id)
+        {
+            ImGuizmoNative.ImGuizmo_SetID(id);
+        }
+        public static void SetOrthographic(bool isOrthographic)
+        {
+            byte native_isOrthographic = isOrthographic ? (byte)1 : (byte)0;
+            ImGuizmoNative.ImGuizmo_SetOrthographic(native_isOrthographic);
+        }
+        public static void SetRect(float x, float y, float width, float height)
+        {
+            ImGuizmoNative.ImGuizmo_SetRect(x, y, width, height);
+        }
+        public static void ViewManipulate(ref float view, float length, Vector2 position, Vector2 size, uint backgroundColor)
+        {
+            fixed (float* native_view = &view)
+            {
+                ImGuizmoNative.ImGuizmo_ViewManipulate(native_view, length, position, size, backgroundColor);
+            }
+        }
+    }
+}

src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImGuizmoNative
+    {
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_BeginFrame();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, float* scale);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DrawCubes(float* view, float* projection, float* matrices, int matrixCount);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DrawGrid(float* view, float* projection, float* matrix, float gridSize);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_Enable(byte enable);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsOverNil();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsOverOPERATION(OPERATION op);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsUsing();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_Manipulate(float* view, float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, float* matrix);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetDrawlist(ImDrawList* drawlist);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetID(int id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetOrthographic(byte isOrthographic);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetRect(float x, float y, float width, float height);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_ViewManipulate(float* view, float length, Vector2 position, Vector2 size, uint backgroundColor);
+    }
+}

src/ImGuizmo.NET/Generated/MODE.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    public enum MODE
+    {
+        LOCAL = 0,
+        WORLD = 1,
+    }
+}

src/ImGuizmo.NET/Generated/OPERATION.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum OPERATION
+    {
+        TRANSLATE = 0,
+        ROTATE = 1,
+        SCALE = 2,
+        BOUNDS = 3,
+    }
+}

src/ImNodes.NET/Generated/AttributeFlags.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum AttributeFlags
+    {
+        _None = 0,
+        _EnableLinkDetachWithDragClick = 1 << 0,
+        _EnableLinkCreationOnSnap = 1 << 1,
+    }
+}

src/ImNodes.NET/Generated/ColorStyle.gen.cs

@@ -0,0 +1,23 @@
+namespace ImGuiNET
+{
+    public enum ColorStyle
+    {
+        _NodeBackground = 0,
+        _NodeBackgroundHovered = 1,
+        _NodeBackgroundSelected = 2,
+        _NodeOutline = 3,
+        _TitleBar = 4,
+        _TitleBarHovered = 5,
+        _TitleBarSelected = 6,
+        _Link = 7,
+        _LinkHovered = 8,
+        _LinkSelected = 9,
+        _Pin = 10,
+        _PinHovered = 11,
+        _BoxSelector = 12,
+        _BoxSelectorOutline = 13,
+        _GridBackground = 14,
+        _GridLine = 15,
+        _Count = 16,
+    }
+}

src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct EmulateThreeButtonMouse
+    {
+        public byte enabled;
+        public byte* modifier;
+    }
+    public unsafe partial struct EmulateThreeButtonMousePtr
+    {
+        public EmulateThreeButtonMouse* NativePtr { get; }
+        public EmulateThreeButtonMousePtr(EmulateThreeButtonMouse* nativePtr) => NativePtr = nativePtr;
+        public EmulateThreeButtonMousePtr(IntPtr nativePtr) => NativePtr = (EmulateThreeButtonMouse*)nativePtr;
+        public static implicit operator EmulateThreeButtonMousePtr(EmulateThreeButtonMouse* nativePtr) => new EmulateThreeButtonMousePtr(nativePtr);
+        public static implicit operator EmulateThreeButtonMouse* (EmulateThreeButtonMousePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator EmulateThreeButtonMousePtr(IntPtr nativePtr) => new EmulateThreeButtonMousePtr(nativePtr);
+        public ref bool enabled => ref Unsafe.AsRef<bool>(&NativePtr->enabled);
+        public IntPtr modifier { get => (IntPtr)NativePtr->modifier; set => NativePtr->modifier = (byte*)value; }
+        public void Destroy()
+        {
+            ImNodesNative.EmulateThreeButtonMouse_destroy((EmulateThreeButtonMouse*)(NativePtr));
+        }
+    }
+}

src/ImNodes.NET/Generated/IO.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct IO
+    {
+        public EmulateThreeButtonMouse emulate_three_button_mouse;
+        public LinkDetachWithModifierClick link_detach_with_modifier_click;
+    }
+    public unsafe partial struct IOPtr
+    {
+        public IO* NativePtr { get; }
+        public IOPtr(IO* nativePtr) => NativePtr = nativePtr;
+        public IOPtr(IntPtr nativePtr) => NativePtr = (IO*)nativePtr;
+        public static implicit operator IOPtr(IO* nativePtr) => new IOPtr(nativePtr);
+        public static implicit operator IO* (IOPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator IOPtr(IntPtr nativePtr) => new IOPtr(nativePtr);
+        public ref EmulateThreeButtonMouse emulate_three_button_mouse => ref Unsafe.AsRef<EmulateThreeButtonMouse>(&NativePtr->emulate_three_button_mouse);
+        public ref LinkDetachWithModifierClick link_detach_with_modifier_click => ref Unsafe.AsRef<LinkDetachWithModifierClick>(&NativePtr->link_detach_with_modifier_click);
+        public void Destroy()
+        {
+            ImNodesNative.IO_destroy((IO*)(NativePtr));
+        }
+    }
+}

src/ImNodes.NET/Generated/ImNodes.gen.cs

@@ -0,0 +1,564 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImNodes
+    {
+        public static void BeginInputAttribute(int id)
+        {
+            PinShape shape = PinShape._CircleFilled;
+            ImNodesNative.imnodes_BeginInputAttribute(id, shape);
+        }
+        public static void BeginInputAttribute(int id, PinShape shape)
+        {
+            ImNodesNative.imnodes_BeginInputAttribute(id, shape);
+        }
+        public static void BeginNode(int id)
+        {
+            ImNodesNative.imnodes_BeginNode(id);
+        }
+        public static void BeginNodeEditor()
+        {
+            ImNodesNative.imnodes_BeginNodeEditor();
+        }
+        public static void BeginNodeTitleBar()
+        {
+            ImNodesNative.imnodes_BeginNodeTitleBar();
+        }
+        public static void BeginOutputAttribute(int id)
+        {
+            PinShape shape = PinShape._CircleFilled;
+            ImNodesNative.imnodes_BeginOutputAttribute(id, shape);
+        }
+        public static void BeginOutputAttribute(int id, PinShape shape)
+        {
+            ImNodesNative.imnodes_BeginOutputAttribute(id, shape);
+        }
+        public static void BeginStaticAttribute(int id)
+        {
+            ImNodesNative.imnodes_BeginStaticAttribute(id);
+        }
+        public static void ClearLinkSelection()
+        {
+            ImNodesNative.imnodes_ClearLinkSelection();
+        }
+        public static void ClearNodeSelection()
+        {
+            ImNodesNative.imnodes_ClearNodeSelection();
+        }
+        public static IntPtr EditorContextCreate()
+        {
+            IntPtr ret = ImNodesNative.imnodes_EditorContextCreate();
+            return ret;
+        }
+        public static void EditorContextFree(IntPtr noname1)
+        {
+            ImNodesNative.imnodes_EditorContextFree(noname1);
+        }
+        public static Vector2 EditorContextGetPanning()
+        {
+            Vector2 __retval;
+            ImNodesNative.imnodes_EditorContextGetPanning(&__retval);
+            return __retval;
+        }
+        public static void EditorContextMoveToNode(int node_id)
+        {
+            ImNodesNative.imnodes_EditorContextMoveToNode(node_id);
+        }
+        public static void EditorContextResetPanning(Vector2 pos)
+        {
+            ImNodesNative.imnodes_EditorContextResetPanning(pos);
+        }
+        public static void EditorContextSet(IntPtr noname1)
+        {
+            ImNodesNative.imnodes_EditorContextSet(noname1);
+        }
+        public static void EndInputAttribute()
+        {
+            ImNodesNative.imnodes_EndInputAttribute();
+        }
+        public static void EndNode()
+        {
+            ImNodesNative.imnodes_EndNode();
+        }
+        public static void EndNodeEditor()
+        {
+            ImNodesNative.imnodes_EndNodeEditor();
+        }
+        public static void EndNodeTitleBar()
+        {
+            ImNodesNative.imnodes_EndNodeTitleBar();
+        }
+        public static void EndOutputAttribute()
+        {
+            ImNodesNative.imnodes_EndOutputAttribute();
+        }
+        public static void EndStaticAttribute()
+        {
+            ImNodesNative.imnodes_EndStaticAttribute();
+        }
+        public static IO* GetIO()
+        {
+            IO* ret = ImNodesNative.imnodes_GetIO();
+            return ret;
+        }
+        public static Vector2 GetNodeDimensions(int id)
+        {
+            Vector2 __retval;
+            ImNodesNative.imnodes_GetNodeDimensions(&__retval, id);
+            return __retval;
+        }
+        public static Vector2 GetNodeEditorSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            ImNodesNative.imnodes_GetNodeEditorSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static Vector2 GetNodeGridSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            ImNodesNative.imnodes_GetNodeGridSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static Vector2 GetNodeScreenSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            ImNodesNative.imnodes_GetNodeScreenSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static void GetSelectedLinks(ref int link_ids)
+        {
+            fixed (int* native_link_ids = &link_ids)
+            {
+                ImNodesNative.imnodes_GetSelectedLinks(native_link_ids);
+            }
+        }
+        public static void GetSelectedNodes(ref int node_ids)
+        {
+            fixed (int* native_node_ids = &node_ids)
+            {
+                ImNodesNative.imnodes_GetSelectedNodes(native_node_ids);
+            }
+        }
+        public static Style* GetStyle()
+        {
+            Style* ret = ImNodesNative.imnodes_GetStyle();
+            return ret;
+        }
+        public static void Initialize()
+        {
+            ImNodesNative.imnodes_Initialize();
+        }
+        public static bool IsAnyAttributeActive()
+        {
+            int* attribute_id = null;
+            byte ret = ImNodesNative.imnodes_IsAnyAttributeActive(attribute_id);
+            return ret != 0;
+        }
+        public static bool IsAnyAttributeActive(ref int attribute_id)
+        {
+            fixed (int* native_attribute_id = &attribute_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsAnyAttributeActive(native_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsAttributeActive()
+        {
+            byte ret = ImNodesNative.imnodes_IsAttributeActive();
+            return ret != 0;
+        }
+        public static bool IsEditorHovered()
+        {
+            byte ret = ImNodesNative.imnodes_IsEditorHovered();
+            return ret != 0;
+        }
+        public static bool IsLinkCreated(ref int started_at_attribute_id, ref int ended_at_attribute_id)
+        {
+            byte* created_from_snap = null;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                {
+                    byte ret = ImNodesNative.imnodes_IsLinkCreatedBoolPtr(native_started_at_attribute_id, native_ended_at_attribute_id, created_from_snap);
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_attribute_id, ref int ended_at_attribute_id, ref bool created_from_snap)
+        {
+            byte native_created_from_snap_val = created_from_snap ? (byte)1 : (byte)0;
+            byte* native_created_from_snap = &native_created_from_snap_val;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                {
+                    byte ret = ImNodesNative.imnodes_IsLinkCreatedBoolPtr(native_started_at_attribute_id, native_ended_at_attribute_id, native_created_from_snap);
+                    created_from_snap = native_created_from_snap_val != 0;
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_node_id, ref int started_at_attribute_id, ref int ended_at_node_id, ref int ended_at_attribute_id)
+        {
+            byte* created_from_snap = null;
+            fixed (int* native_started_at_node_id = &started_at_node_id)
+            {
+                fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+                {
+                    fixed (int* native_ended_at_node_id = &ended_at_node_id)
+                    {
+                        fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                        {
+                            byte ret = ImNodesNative.imnodes_IsLinkCreatedIntPtr(native_started_at_node_id, native_started_at_attribute_id, native_ended_at_node_id, native_ended_at_attribute_id, created_from_snap);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_node_id, ref int started_at_attribute_id, ref int ended_at_node_id, ref int ended_at_attribute_id, ref bool created_from_snap)
+        {
+            byte native_created_from_snap_val = created_from_snap ? (byte)1 : (byte)0;
+            byte* native_created_from_snap = &native_created_from_snap_val;
+            fixed (int* native_started_at_node_id = &started_at_node_id)
+            {
+                fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+                {
+                    fixed (int* native_ended_at_node_id = &ended_at_node_id)
+                    {
+                        fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                        {
+                            byte ret = ImNodesNative.imnodes_IsLinkCreatedIntPtr(native_started_at_node_id, native_started_at_attribute_id, native_ended_at_node_id, native_ended_at_attribute_id, native_created_from_snap);
+                            created_from_snap = native_created_from_snap_val != 0;
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool IsLinkDestroyed(ref int link_id)
+        {
+            fixed (int* native_link_id = &link_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsLinkDestroyed(native_link_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkDropped()
+        {
+            int* started_at_attribute_id = null;
+            byte including_detached_links = 1;
+            byte ret = ImNodesNative.imnodes_IsLinkDropped(started_at_attribute_id, including_detached_links);
+            return ret != 0;
+        }
+        public static bool IsLinkDropped(ref int started_at_attribute_id)
+        {
+            byte including_detached_links = 1;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsLinkDropped(native_started_at_attribute_id, including_detached_links);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkDropped(ref int started_at_attribute_id, bool including_detached_links)
+        {
+            byte native_including_detached_links = including_detached_links ? (byte)1 : (byte)0;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsLinkDropped(native_started_at_attribute_id, native_including_detached_links);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkHovered(ref int link_id)
+        {
+            fixed (int* native_link_id = &link_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsLinkHovered(native_link_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkStarted(ref int started_at_attribute_id)
+        {
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsLinkStarted(native_started_at_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsNodeHovered(ref int node_id)
+        {
+            fixed (int* native_node_id = &node_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsNodeHovered(native_node_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsPinHovered(ref int attribute_id)
+        {
+            fixed (int* native_attribute_id = &attribute_id)
+            {
+                byte ret = ImNodesNative.imnodes_IsPinHovered(native_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static void Link(int id, int start_attribute_id, int end_attribute_id)
+        {
+            ImNodesNative.imnodes_Link(id, start_attribute_id, end_attribute_id);
+        }
+        public static void LoadCurrentEditorStateFromIniFile(string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            ImNodesNative.imnodes_LoadCurrentEditorStateFromIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static void LoadCurrentEditorStateFromIniString(string data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            ImNodesNative.imnodes_LoadCurrentEditorStateFromIniString(native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+        public static void LoadEditorStateFromIniFile(IntPtr editor, string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            ImNodesNative.imnodes_LoadEditorStateFromIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static void LoadEditorStateFromIniString(IntPtr editor, string data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            ImNodesNative.imnodes_LoadEditorStateFromIniString(editor, native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+        public static int NumSelectedLinks()
+        {
+            int ret = ImNodesNative.imnodes_NumSelectedLinks();
+            return ret;
+        }
+        public static int NumSelectedNodes()
+        {
+            int ret = ImNodesNative.imnodes_NumSelectedNodes();
+            return ret;
+        }
+        public static void PopAttributeFlag()
+        {
+            ImNodesNative.imnodes_PopAttributeFlag();
+        }
+        public static void PopColorStyle()
+        {
+            ImNodesNative.imnodes_PopColorStyle();
+        }
+        public static void PopStyleVar()
+        {
+            ImNodesNative.imnodes_PopStyleVar();
+        }
+        public static void PushAttributeFlag(AttributeFlags flag)
+        {
+            ImNodesNative.imnodes_PushAttributeFlag(flag);
+        }
+        public static void PushColorStyle(ColorStyle item, uint color)
+        {
+            ImNodesNative.imnodes_PushColorStyle(item, color);
+        }
+        public static void PushStyleVar(StyleVar style_item, float value)
+        {
+            ImNodesNative.imnodes_PushStyleVar(style_item, value);
+        }
+        public static void SaveCurrentEditorStateToIniFile(string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            ImNodesNative.imnodes_SaveCurrentEditorStateToIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static string SaveCurrentEditorStateToIniString()
+        {
+            uint* data_size = null;
+            byte* ret = ImNodesNative.imnodes_SaveCurrentEditorStateToIniString(data_size);
+            return Util.StringFromPtr(ret);
+        }
+        public static string SaveCurrentEditorStateToIniString(ref uint data_size)
+        {
+            fixed (uint* native_data_size = &data_size)
+            {
+                byte* ret = ImNodesNative.imnodes_SaveCurrentEditorStateToIniString(native_data_size);
+                return Util.StringFromPtr(ret);
+            }
+        }
+        public static void SaveEditorStateToIniFile(IntPtr editor, string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            ImNodesNative.imnodes_SaveEditorStateToIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static string SaveEditorStateToIniString(IntPtr editor)
+        {
+            uint* data_size = null;
+            byte* ret = ImNodesNative.imnodes_SaveEditorStateToIniString(editor, data_size);
+            return Util.StringFromPtr(ret);
+        }
+        public static string SaveEditorStateToIniString(IntPtr editor, ref uint data_size)
+        {
+            fixed (uint* native_data_size = &data_size)
+            {
+                byte* ret = ImNodesNative.imnodes_SaveEditorStateToIniString(editor, native_data_size);
+                return Util.StringFromPtr(ret);
+            }
+        }
+        public static void SetNodeDraggable(int node_id, bool draggable)
+        {
+            byte native_draggable = draggable ? (byte)1 : (byte)0;
+            ImNodesNative.imnodes_SetNodeDraggable(node_id, native_draggable);
+        }
+        public static void SetNodeEditorSpacePos(int node_id, Vector2 editor_space_pos)
+        {
+            ImNodesNative.imnodes_SetNodeEditorSpacePos(node_id, editor_space_pos);
+        }
+        public static void SetNodeGridSpacePos(int node_id, Vector2 grid_pos)
+        {
+            ImNodesNative.imnodes_SetNodeGridSpacePos(node_id, grid_pos);
+        }
+        public static void SetNodeScreenSpacePos(int node_id, Vector2 screen_space_pos)
+        {
+            ImNodesNative.imnodes_SetNodeScreenSpacePos(node_id, screen_space_pos);
+        }
+        public static void Shutdown()
+        {
+            ImNodesNative.imnodes_Shutdown();
+        }
+        public static void StyleColorsClassic()
+        {
+            ImNodesNative.imnodes_StyleColorsClassic();
+        }
+        public static void StyleColorsDark()
+        {
+            ImNodesNative.imnodes_StyleColorsDark();
+        }
+        public static void StyleColorsLight()
+        {
+            ImNodesNative.imnodes_StyleColorsLight();
+        }
+    }
+}

src/ImNodes.NET/Generated/ImNodesNative.gen.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImNodesNative
+    {
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void EmulateThreeButtonMouse_destroy(EmulateThreeButtonMouse* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern EmulateThreeButtonMouse* EmulateThreeButtonMouse_EmulateThreeButtonMouse();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginInputAttribute(int id, PinShape shape);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNode(int id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNodeEditor();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNodeTitleBar();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginOutputAttribute(int id, PinShape shape);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginStaticAttribute(int id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_ClearLinkSelection();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_ClearNodeSelection();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr imnodes_EditorContextCreate();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextFree(IntPtr noname1);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextGetPanning(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextMoveToNode(int node_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextResetPanning(Vector2 pos);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextSet(IntPtr noname1);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndInputAttribute();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNode();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNodeEditor();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNodeTitleBar();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndOutputAttribute();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndStaticAttribute();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IO* imnodes_GetIO();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeDimensions(Vector2* pOut, int id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeEditorSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeGridSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeScreenSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetSelectedLinks(int* link_ids);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetSelectedNodes(int* node_ids);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern Style* imnodes_GetStyle();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Initialize();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsAnyAttributeActive(int* attribute_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsAttributeActive();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsEditorHovered();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkCreatedBoolPtr(int* started_at_attribute_id, int* ended_at_attribute_id, byte* created_from_snap);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkCreatedIntPtr(int* started_at_node_id, int* started_at_attribute_id, int* ended_at_node_id, int* ended_at_attribute_id, byte* created_from_snap);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkDestroyed(int* link_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkDropped(int* started_at_attribute_id, byte including_detached_links);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkHovered(int* link_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkStarted(int* started_at_attribute_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsNodeHovered(int* node_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsPinHovered(int* attribute_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Link(int id, int start_attribute_id, int end_attribute_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadCurrentEditorStateFromIniFile(byte* file_name);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadCurrentEditorStateFromIniString(byte* data, uint data_size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadEditorStateFromIniFile(IntPtr editor, byte* file_name);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadEditorStateFromIniString(IntPtr editor, byte* data, uint data_size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int imnodes_NumSelectedLinks();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int imnodes_NumSelectedNodes();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopAttributeFlag();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopColorStyle();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopStyleVar();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushAttributeFlag(AttributeFlags flag);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushColorStyle(ColorStyle item, uint color);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushStyleVar(StyleVar style_item, float value);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SaveCurrentEditorStateToIniFile(byte* file_name);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* imnodes_SaveCurrentEditorStateToIniString(uint* data_size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SaveEditorStateToIniFile(IntPtr editor, byte* file_name);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* imnodes_SaveEditorStateToIniString(IntPtr editor, uint* data_size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeDraggable(int node_id, byte draggable);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeEditorSpacePos(int node_id, Vector2 editor_space_pos);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeGridSpacePos(int node_id, Vector2 grid_pos);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeScreenSpacePos(int node_id, Vector2 screen_space_pos);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Shutdown();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsClassic();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsDark();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsLight();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void IO_destroy(IO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IO* IO_IO();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void LinkDetachWithModifierClick_destroy(LinkDetachWithModifierClick* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern LinkDetachWithModifierClick* LinkDetachWithModifierClick_LinkDetachWithModifierClick();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void Style_destroy(Style* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern Style* Style_Style();
+    }
+}

src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct LinkDetachWithModifierClick
+    {
+        public byte* modifier;
+    }
+    public unsafe partial struct LinkDetachWithModifierClickPtr
+    {
+        public LinkDetachWithModifierClick* NativePtr { get; }
+        public LinkDetachWithModifierClickPtr(LinkDetachWithModifierClick* nativePtr) => NativePtr = nativePtr;
+        public LinkDetachWithModifierClickPtr(IntPtr nativePtr) => NativePtr = (LinkDetachWithModifierClick*)nativePtr;
+        public static implicit operator LinkDetachWithModifierClickPtr(LinkDetachWithModifierClick* nativePtr) => new LinkDetachWithModifierClickPtr(nativePtr);
+        public static implicit operator LinkDetachWithModifierClick* (LinkDetachWithModifierClickPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator LinkDetachWithModifierClickPtr(IntPtr nativePtr) => new LinkDetachWithModifierClickPtr(nativePtr);
+        public IntPtr modifier { get => (IntPtr)NativePtr->modifier; set => NativePtr->modifier = (byte*)value; }
+        public void Destroy()
+        {
+            ImNodesNative.LinkDetachWithModifierClick_destroy((LinkDetachWithModifierClick*)(NativePtr));
+        }
+    }
+}

src/ImNodes.NET/Generated/PinShape.gen.cs

@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    public enum PinShape
+    {
+        _Circle = 0,
+        _CircleFilled = 1,
+        _Triangle = 2,
+        _TriangleFilled = 3,
+        _Quad = 4,
+        _QuadFilled = 5,
+    }
+}

src/ImNodes.NET/Generated/Style.gen.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct Style
+    {
+        public float grid_spacing;
+        public float node_corner_rounding;
+        public float node_padding_horizontal;
+        public float node_padding_vertical;
+        public float node_border_thickness;
+        public float link_thickness;
+        public float link_line_segments_per_length;
+        public float link_hover_distance;
+        public float pin_circle_radius;
+        public float pin_quad_side_length;
+        public float pin_triangle_side_length;
+        public float pin_line_thickness;
+        public float pin_hover_radius;
+        public float pin_offset;
+        public StyleFlags flags;
+        public fixed uint colors[16];
+    }
+    public unsafe partial struct StylePtr
+    {
+        public Style* NativePtr { get; }
+        public StylePtr(Style* nativePtr) => NativePtr = nativePtr;
+        public StylePtr(IntPtr nativePtr) => NativePtr = (Style*)nativePtr;
+        public static implicit operator StylePtr(Style* nativePtr) => new StylePtr(nativePtr);
+        public static implicit operator Style* (StylePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator StylePtr(IntPtr nativePtr) => new StylePtr(nativePtr);
+        public ref float grid_spacing => ref Unsafe.AsRef<float>(&NativePtr->grid_spacing);
+        public ref float node_corner_rounding => ref Unsafe.AsRef<float>(&NativePtr->node_corner_rounding);
+        public ref float node_padding_horizontal => ref Unsafe.AsRef<float>(&NativePtr->node_padding_horizontal);
+        public ref float node_padding_vertical => ref Unsafe.AsRef<float>(&NativePtr->node_padding_vertical);
+        public ref float node_border_thickness => ref Unsafe.AsRef<float>(&NativePtr->node_border_thickness);
+        public ref float link_thickness => ref Unsafe.AsRef<float>(&NativePtr->link_thickness);
+        public ref float link_line_segments_per_length => ref Unsafe.AsRef<float>(&NativePtr->link_line_segments_per_length);
+        public ref float link_hover_distance => ref Unsafe.AsRef<float>(&NativePtr->link_hover_distance);
+        public ref float pin_circle_radius => ref Unsafe.AsRef<float>(&NativePtr->pin_circle_radius);
+        public ref float pin_quad_side_length => ref Unsafe.AsRef<float>(&NativePtr->pin_quad_side_length);
+        public ref float pin_triangle_side_length => ref Unsafe.AsRef<float>(&NativePtr->pin_triangle_side_length);
+        public ref float pin_line_thickness => ref Unsafe.AsRef<float>(&NativePtr->pin_line_thickness);
+        public ref float pin_hover_radius => ref Unsafe.AsRef<float>(&NativePtr->pin_hover_radius);
+        public ref float pin_offset => ref Unsafe.AsRef<float>(&NativePtr->pin_offset);
+        public ref StyleFlags flags => ref Unsafe.AsRef<StyleFlags>(&NativePtr->flags);
+        public RangeAccessor<uint> colors => new RangeAccessor<uint>(NativePtr->colors, 16);
+        public void Destroy()
+        {
+            ImNodesNative.Style_destroy((Style*)(NativePtr));
+        }
+    }
+}

src/ImNodes.NET/Generated/StyleFlags.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum StyleFlags
+    {
+        _None = 0,
+        _NodeOutline = 1 << 0,
+        _GridLines = 1 << 2,
+    }
+}

src/ImNodes.NET/Generated/StyleVar.gen.cs

@@ -0,0 +1,20 @@
+namespace ImGuiNET
+{
+    public enum StyleVar
+    {
+        _GridSpacing = 0,
+        _NodeCornerRounding = 1,
+        _NodePaddingHorizontal = 2,
+        _NodePaddingVertical = 3,
+        _NodeBorderThickness = 4,
+        _LinkThickness = 5,
+        _LinkLineSegmentsPerLength = 6,
+        _LinkHoverDistance = 7,
+        _PinCircleRadius = 8,
+        _PinQuadSideLength = 9,
+        _PinTriangleSideLength = 10,
+        _PinLineThickness = 11,
+        _PinHoverRadius = 12,
+        _PinOffset = 13,
+    }
+}

src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs

@@ -0,0 +1,18 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImPlotAxisFlags
+    {
+        None = 0,
+        NoGridLines = 1 << 0,
+        NoTickMarks = 1 << 1,
+        NoTickLabels = 1 << 2,
+        LogScale = 1 << 3,
+        Time = 1 << 4,
+        Invert = 1 << 5,
+        LockMin = 1 << 6,
+        LockMax = 1 << 7,
+        Lock = LockMin | LockMax,
+        NoDecorations = NoGridLines | NoTickMarks | NoTickLabels,
+    }
+}

src/ImPlot.NET/Generated/ImPlotCol.gen.cs

@@ -0,0 +1,31 @@
+namespace ImGuiNET
+{
+    public enum ImPlotCol
+    {
+        Line = 0,
+        Fill = 1,
+        MarkerOutline = 2,
+        MarkerFill = 3,
+        ErrorBar = 4,
+        FrameBg = 5,
+        PlotBg = 6,
+        PlotBorder = 7,
+        LegendBg = 8,
+        LegendBorder = 9,
+        LegendText = 10,
+        TitleText = 11,
+        InlayText = 12,
+        XAxis = 13,
+        XAxisGrid = 14,
+        YAxis = 15,
+        YAxisGrid = 16,
+        YAxis2 = 17,
+        YAxisGrid2 = 18,
+        YAxis3 = 19,
+        YAxisGrid3 = 20,
+        Selection = 21,
+        Query = 22,
+        Crosshairs = 23,
+        COUNT = 24,
+    }
+}

src/ImPlot.NET/Generated/ImPlotColormap.gen.cs

@@ -0,0 +1,18 @@
+namespace ImGuiNET
+{
+    public enum ImPlotColormap
+    {
+        Default = 0,
+        Deep = 1,
+        Dark = 2,
+        Pastel = 3,
+        Paired = 4,
+        Viridis = 5,
+        Plasma = 6,
+        Hot = 7,
+        Cool = 8,
+        Pink = 9,
+        Jet = 10,
+        COUNT = 11,
+    }
+}

src/ImPlot.NET/Generated/ImPlotFlags.gen.cs

@@ -0,0 +1,20 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImPlotFlags
+    {
+        None = 0,
+        NoLegend = 1 << 0,
+        NoMenus = 1 << 1,
+        NoBoxSelect = 1 << 2,
+        NoMousePos = 1 << 3,
+        NoHighlight = 1 << 4,
+        NoChild = 1 << 5,
+        YAxis2 = 1 << 6,
+        YAxis3 = 1 << 7,
+        Query = 1 << 8,
+        Crosshairs = 1 << 9,
+        AntiAliased = 1 << 10,
+        CanvasOnly = NoLegend | NoMenus | NoBoxSelect | NoMousePos,
+    }
+}

src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImPlotInputMap
+    {
+        public ImGuiMouseButton PanButton;
+        public ImGuiKeyModFlags PanMod;
+        public ImGuiMouseButton FitButton;
+        public ImGuiMouseButton ContextMenuButton;
+        public ImGuiMouseButton BoxSelectButton;
+        public ImGuiKeyModFlags BoxSelectMod;
+        public ImGuiMouseButton BoxSelectCancelButton;
+        public ImGuiMouseButton QueryButton;
+        public ImGuiKeyModFlags QueryMod;
+        public ImGuiKeyModFlags QueryToggleMod;
+        public ImGuiKeyModFlags HorizontalMod;
+        public ImGuiKeyModFlags VerticalMod;
+    }
+    public unsafe partial struct ImPlotInputMapPtr
+    {
+        public ImPlotInputMap* NativePtr { get; }
+        public ImPlotInputMapPtr(ImPlotInputMap* nativePtr) => NativePtr = nativePtr;
+        public ImPlotInputMapPtr(IntPtr nativePtr) => NativePtr = (ImPlotInputMap*)nativePtr;
+        public static implicit operator ImPlotInputMapPtr(ImPlotInputMap* nativePtr) => new ImPlotInputMapPtr(nativePtr);
+        public static implicit operator ImPlotInputMap* (ImPlotInputMapPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotInputMapPtr(IntPtr nativePtr) => new ImPlotInputMapPtr(nativePtr);
+        public ref ImGuiMouseButton PanButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->PanButton);
+        public ref ImGuiKeyModFlags PanMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->PanMod);
+        public ref ImGuiMouseButton FitButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->FitButton);
+        public ref ImGuiMouseButton ContextMenuButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->ContextMenuButton);
+        public ref ImGuiMouseButton BoxSelectButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->BoxSelectButton);
+        public ref ImGuiKeyModFlags BoxSelectMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->BoxSelectMod);
+        public ref ImGuiMouseButton BoxSelectCancelButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->BoxSelectCancelButton);
+        public ref ImGuiMouseButton QueryButton => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->QueryButton);
+        public ref ImGuiKeyModFlags QueryMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->QueryMod);
+        public ref ImGuiKeyModFlags QueryToggleMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->QueryToggleMod);
+        public ref ImGuiKeyModFlags HorizontalMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->HorizontalMod);
+        public ref ImGuiKeyModFlags VerticalMod => ref Unsafe.AsRef<ImGuiKeyModFlags>(&NativePtr->VerticalMod);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotInputMap_destroy((ImPlotInputMap*)(NativePtr));
+        }
+    }
+}

src/ImPlot.NET/Generated/ImPlotLimits.gen.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImPlotLimits
+    {
+        public ImPlotRange X;
+        public ImPlotRange Y;
+    }
+    public unsafe partial struct ImPlotLimitsPtr
+    {
+        public ImPlotLimits* NativePtr { get; }
+        public ImPlotLimitsPtr(ImPlotLimits* nativePtr) => NativePtr = nativePtr;
+        public ImPlotLimitsPtr(IntPtr nativePtr) => NativePtr = (ImPlotLimits*)nativePtr;
+        public static implicit operator ImPlotLimitsPtr(ImPlotLimits* nativePtr) => new ImPlotLimitsPtr(nativePtr);
+        public static implicit operator ImPlotLimits* (ImPlotLimitsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotLimitsPtr(IntPtr nativePtr) => new ImPlotLimitsPtr(nativePtr);
+        public ref ImPlotRange X => ref Unsafe.AsRef<ImPlotRange>(&NativePtr->X);
+        public ref ImPlotRange Y => ref Unsafe.AsRef<ImPlotRange>(&NativePtr->Y);
+        public bool Contains(ImPlotPoint p)
+        {
+            byte ret = ImPlotNative.ImPlotLimits_ContainsPlotPoInt((ImPlotLimits*)(NativePtr), p);
+            return ret != 0;
+        }
+        public bool Contains(double x, double y)
+        {
+            byte ret = ImPlotNative.ImPlotLimits_Containsdouble((ImPlotLimits*)(NativePtr), x, y);
+            return ret != 0;
+        }
+    }
+}

src/ImPlot.NET/Generated/ImPlotLocation.gen.cs

@@ -0,0 +1,15 @@
+namespace ImGuiNET
+{
+    public enum ImPlotLocation
+    {
+        Center = 0,
+        North = 1 << 0,
+        South = 1 << 1,
+        West = 1 << 2,
+        East = 1 << 3,
+        NorthWest = North | West,
+        NorthEast = North | East,
+        SouthWest = South | West,
+        SouthEast = South | East,
+    }
+}

src/ImPlot.NET/Generated/ImPlotMarker.gen.cs

@@ -0,0 +1,18 @@
+namespace ImGuiNET
+{
+    public enum ImPlotMarker
+    {
+        None = -1,
+        Circle = 0,
+        Square = 1,
+        Diamond = 2,
+        Up = 3,
+        Down = 4,
+        Left = 5,
+        Right = 6,
+        Cross = 7,
+        Plus = 8,
+        Asterisk = 9,
+        COUNT = 10,
+    }
+}

src/ImPlot.NET/Generated/ImPlotNative.gen.cs

@@ -0,0 +1,656 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImPlotNative
+    {
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_AnnotateStr(double x, double y, Vector2 pix_offset, byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_AnnotateVec4(double x, double y, Vector2 pix_offset, Vector4 color, byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_AnnotateClampedStr(double x, double y, Vector2 pix_offset, byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_AnnotateClampedVec4(double x, double y, Vector2 pix_offset, Vector4 color, byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginLegendDragDropSource(byte* label_id, ImGuiDragDropFlags flags);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginLegendPopup(byte* label_id, ImGuiMouseButton mouse_button);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginPlot(byte* title_id, byte* x_label, byte* y_label, Vector2 size, ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags, ImPlotAxisFlags y2_flags, ImPlotAxisFlags y3_flags);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ImPlot_CreateContext();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_DestroyContext(IntPtr ctx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragLineX(byte* id, double* x_value, byte show_label, Vector4 col, float thickness);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragLineY(byte* id, double* y_value, byte show_label, Vector4 col, float thickness);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragPoint(byte* id, double* x, double* y, byte show_label, Vector4 col, float radius);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndLegendDragDropSource();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndLegendPopup();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndPlot();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_FitNextPlotAxes(byte x, byte y, byte y2, byte y3);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetColormapColor(Vector4* pOut, int index);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetColormapName(ImPlotColormap colormap);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ImPlot_GetColormapSize();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ImPlot_GetCurrentContext();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotInputMap* ImPlot_GetInputMap();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetLastItemColor(Vector4* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetMarkerName(ImPlotMarker idx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawList* ImPlot_GetPlotDrawList();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotLimits(ImPlotLimits* pOut, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotMousePos(ImPlotPoint* pOut, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotPos(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotQuery(ImPlotLimits* pOut, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotSize(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotStyle* ImPlot_GetStyle();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetStyleColorName(ImPlotCol idx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_HideNextItem(byte hidden, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsLegendEntryHovered(byte* label_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotHovered();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotQueried();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotXAxisHovered();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotYAxisHovered(ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_LerpColormap(Vector4* pOut, float t);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_LinkNextPlotLimits(double* xmin, double* xmax, double* ymin, double* ymax, double* ymin2, double* ymax2, double* ymin3, double* ymax3);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_NextColormapColor(Vector4* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PixelsToPlotVec2(ImPlotPoint* pOut, Vector2 pix, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PixelsToPlotFloat(ImPlotPoint* pOut, float x, float y, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsFloatPtrInt(byte* label_id, float* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsdoublePtrInt(byte* label_id, double* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS8PtrInt(byte* label_id, sbyte* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU8PtrInt(byte* label_id, byte* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS16PtrInt(byte* label_id, short* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU16PtrInt(byte* label_id, ushort* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS32PtrInt(byte* label_id, int* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU32PtrInt(byte* label_id, uint* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS64PtrInt(byte* label_id, long* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU64PtrInt(byte* label_id, ulong* values, int count, double width, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, double width, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHFloatPtrInt(byte* label_id, float* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHdoublePtrInt(byte* label_id, double* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS8PtrInt(byte* label_id, sbyte* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU8PtrInt(byte* label_id, byte* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS16PtrInt(byte* label_id, short* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU16PtrInt(byte* label_id, ushort* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS32PtrInt(byte* label_id, int* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU32PtrInt(byte* label_id, uint* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS64PtrInt(byte* label_id, long* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU64PtrInt(byte* label_id, ulong* values, int count, double height, double shift, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsHU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, double height, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalFloatPtr(byte* label_id, float* xs, float* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitaldoublePtr(byte* label_id, double* xs, double* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalU8Ptr(byte* label_id, byte* xs, byte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalS16Ptr(byte* label_id, short* xs, short* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalS32Ptr(byte* label_id, int* xs, int* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalU32Ptr(byte* label_id, uint* xs, uint* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalS64Ptr(byte* label_id, long* xs, long* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDummy(byte* label_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(byte* label_id, float* xs, float* ys, float* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(byte* label_id, double* xs, double* ys, double* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrInt(byte* label_id, sbyte* xs, sbyte* ys, sbyte* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrInt(byte* label_id, byte* xs, byte* ys, byte* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrInt(byte* label_id, short* xs, short* ys, short* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrInt(byte* label_id, ushort* xs, ushort* ys, ushort* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrInt(byte* label_id, int* xs, int* ys, int* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrInt(byte* label_id, uint* xs, uint* ys, uint* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrInt(byte* label_id, long* xs, long* ys, long* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrInt(byte* label_id, ulong* xs, ulong* ys, ulong* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, float* neg, float* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, double* neg, double* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, sbyte* neg, sbyte* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, byte* neg, byte* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrS16Ptr(byte* label_id, short* xs, short* ys, short* neg, short* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, ushort* neg, ushort* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int* neg, int* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, uint* neg, uint* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrS64Ptr(byte* label_id, long* xs, long* ys, long* neg, long* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, ulong* neg, ulong* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(byte* label_id, float* xs, float* ys, float* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(byte* label_id, double* xs, double* ys, double* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrInt(byte* label_id, sbyte* xs, sbyte* ys, sbyte* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrInt(byte* label_id, byte* xs, byte* ys, byte* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrInt(byte* label_id, short* xs, short* ys, short* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrInt(byte* label_id, ushort* xs, ushort* ys, ushort* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrInt(byte* label_id, int* xs, int* ys, int* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrInt(byte* label_id, uint* xs, uint* ys, uint* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrInt(byte* label_id, long* xs, long* ys, long* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrInt(byte* label_id, ulong* xs, ulong* ys, ulong* err, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, float* neg, float* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, double* neg, double* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, sbyte* neg, sbyte* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, byte* neg, byte* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrS16Ptr(byte* label_id, short* xs, short* ys, short* neg, short* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, ushort* neg, ushort* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int* neg, int* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, uint* neg, uint* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrS64Ptr(byte* label_id, long* xs, long* ys, long* neg, long* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, ulong* neg, ulong* pos, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapFloatPtr(byte* label_id, float* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapdoublePtr(byte* label_id, double* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapS8Ptr(byte* label_id, sbyte* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapU8Ptr(byte* label_id, byte* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapS16Ptr(byte* label_id, short* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapU16Ptr(byte* label_id, ushort* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapS32Ptr(byte* label_id, int* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapU32Ptr(byte* label_id, uint* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapS64Ptr(byte* label_id, long* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmapU64Ptr(byte* label_id, ulong* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotImage(byte* label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineFloatPtrInt(byte* label_id, float* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLinedoublePtrInt(byte* label_id, double* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU8PtrInt(byte* label_id, byte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS16PtrInt(byte* label_id, short* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU16PtrInt(byte* label_id, ushort* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS32PtrInt(byte* label_id, int* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU32PtrInt(byte* label_id, uint* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS64PtrInt(byte* label_id, long* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU64PtrInt(byte* label_id, ulong* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLinedoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartFloatPtr(byte** label_ids, float* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartdoublePtr(byte** label_ids, double* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartS8Ptr(byte** label_ids, sbyte* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartU8Ptr(byte** label_ids, byte* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartS16Ptr(byte** label_ids, short* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartU16Ptr(byte** label_ids, ushort* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartS32Ptr(byte** label_ids, int* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartU32Ptr(byte** label_ids, uint* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartS64Ptr(byte** label_ids, long* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChartU64Ptr(byte** label_ids, ulong* values, int count, double x, double y, double radius, byte normalize, byte* label_fmt, double angle0);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterFloatPtrInt(byte* label_id, float* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterdoublePtrInt(byte* label_id, double* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU8PtrInt(byte* label_id, byte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS16PtrInt(byte* label_id, short* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU16PtrInt(byte* label_id, ushort* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS32PtrInt(byte* label_id, int* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU32PtrInt(byte* label_id, uint* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS64PtrInt(byte* label_id, long* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU64PtrInt(byte* label_id, ulong* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(byte* label_id, float* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(byte* label_id, double* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS8PtrIntdoubledoubleInt(byte* label_id, sbyte* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU8PtrIntdoubledoubleInt(byte* label_id, byte* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS16PtrIntdoubledoubleInt(byte* label_id, short* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU16PtrIntdoubledoubleInt(byte* label_id, ushort* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS32PtrIntdoubledoubleInt(byte* label_id, int* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU32PtrIntdoubledoubleInt(byte* label_id, uint* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS64PtrIntdoubledoubleInt(byte* label_id, long* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU64PtrIntdoubledoubleInt(byte* label_id, ulong* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedFloatPtrFloatPtrIntInt(byte* label_id, float* xs, float* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadeddoublePtrdoublePtrIntInt(byte* label_id, double* xs, double* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS8PtrS8PtrIntInt(byte* label_id, sbyte* xs, sbyte* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU8PtrU8PtrIntInt(byte* label_id, byte* xs, byte* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS16PtrS16PtrIntInt(byte* label_id, short* xs, short* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU16PtrU16PtrIntInt(byte* label_id, ushort* xs, ushort* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS32PtrS32PtrIntInt(byte* label_id, int* xs, int* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU32PtrU32PtrIntInt(byte* label_id, uint* xs, uint* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS64PtrS64PtrIntInt(byte* label_id, long* xs, long* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU64PtrU64PtrIntInt(byte* label_id, ulong* xs, ulong* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(byte* label_id, float* xs, float* ys1, float* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(byte* label_id, double* xs, double* ys1, double* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS8PtrS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys1, sbyte* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU8PtrU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys1, byte* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS16PtrS16PtrS16Ptr(byte* label_id, short* xs, short* ys1, short* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU16PtrU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys1, ushort* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS32PtrS32PtrS32Ptr(byte* label_id, int* xs, int* ys1, int* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU32PtrU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys1, uint* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedS64PtrS64PtrS64Ptr(byte* label_id, long* xs, long* ys1, long* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedU64PtrU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys1, ulong* ys2, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsFloatPtrInt(byte* label_id, float* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsdoublePtrInt(byte* label_id, double* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU8PtrInt(byte* label_id, byte* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS16PtrInt(byte* label_id, short* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU16PtrInt(byte* label_id, ushort* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS32PtrInt(byte* label_id, int* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU32PtrInt(byte* label_id, uint* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS64PtrInt(byte* label_id, long* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU64PtrInt(byte* label_id, ulong* values, int count, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsFloatPtrInt(byte* label_id, float* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsdoublePtrInt(byte* label_id, double* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS8PtrInt(byte* label_id, sbyte* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU8PtrInt(byte* label_id, byte* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS16PtrInt(byte* label_id, short* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU16PtrInt(byte* label_id, ushort* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS32PtrInt(byte* label_id, int* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU32PtrInt(byte* label_id, uint* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS64PtrInt(byte* label_id, long* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU64PtrInt(byte* label_id, ulong* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsS64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStemsU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, double y_ref, int offset, int stride);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotText(byte* text, double x, double y, byte vertical, Vector2 pix_offset);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotToPixelsPlotPoInt(Vector2* pOut, ImPlotPoint plt, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotToPixelsdouble(Vector2* pOut, double x, double y, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopColormap(int count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopPlotClipRect();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopStyleColor(int count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopStyleVar(int count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushColormapPlotColormap(ImPlotColormap colormap);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushColormapVec4Ptr(Vector4* colormap, int size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushPlotClipRect();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleColorU32(ImPlotCol idx, uint col);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleColorVec4(ImPlotCol idx, Vector4 col);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVarFloat(ImPlotStyleVar idx, float val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVarInt(ImPlotStyleVar idx, int val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVarVec2(ImPlotStyleVar idx, Vector2 val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetColormapVec4Ptr(Vector4* colormap, int size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetColormapPlotColormap(ImPlotColormap colormap, int samples);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetCurrentContext(IntPtr ctx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetImGuiContext(IntPtr ctx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation, byte outside);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetMousePosLocation(ImPlotLocation location);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextErrorBarStyle(Vector4 col, float size, float weight);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextFillStyle(Vector4 col, float alpha_mod);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextLineStyle(Vector4 col, float weight);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight, Vector4 outline);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotLimitsX(double xmin, double xmax, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotTicksXdoublePtr(double* values, int n_ticks, byte** labels, byte show_default);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotTicksXdouble(double x_min, double x_max, int n_ticks, byte** labels, byte show_default);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotTicksYdoublePtr(double* values, int n_ticks, byte** labels, byte show_default, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextPlotTicksYdouble(double y_min, double y_max, int n_ticks, byte** labels, byte show_default, ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetPlotYAxis(ImPlotYAxis y_axis);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowColormapScale(double scale_min, double scale_max, float height);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ShowColormapSelector(byte* label);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowDemoWindow(byte* p_open);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowMetricsWindow(byte* p_popen);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowStyleEditor(ImPlotStyle* @ref);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ShowStyleSelector(byte* label);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowUserGuide();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsAuto(ImPlotStyle* dst);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsClassic(ImPlotStyle* dst);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsDark(ImPlotStyle* dst);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsLight(ImPlotStyle* dst);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotInputMap_destroy(ImPlotInputMap* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotInputMap* ImPlotInputMap_ImPlotInputMap();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotLimits_ContainsPlotPoInt(ImPlotLimits* self, ImPlotPoint p);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotLimits_Containsdouble(ImPlotLimits* self, double x, double y);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotPoint_destroy(ImPlotPoint* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPointNil();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPointdouble(double _x, double _y);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPointVec2(Vector2 p);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotRange_Contains(ImPlotRange* self, double value);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRange_destroy(ImPlotRange* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRange* ImPlotRange_ImPlotRangeNil();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRange* ImPlotRange_ImPlotRangedouble(double _min, double _max);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlotRange_Size(ImPlotRange* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotStyle_destroy(ImPlotStyle* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotStyle* ImPlotStyle_ImPlotStyle();
+    }
+}

src/ImPlot.NET/Generated/ImPlotOrientation.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    public enum ImPlotOrientation
+    {
+        Horizontal = 0,
+        Vertical = 1,
+    }
+}

src/ImPlot.NET/Generated/ImPlotPoint.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImPlotPoint
+    {
+        public double x;
+        public double y;
+    }
+    public unsafe partial struct ImPlotPointPtr
+    {
+        public ImPlotPoint* NativePtr { get; }
+        public ImPlotPointPtr(ImPlotPoint* nativePtr) => NativePtr = nativePtr;
+        public ImPlotPointPtr(IntPtr nativePtr) => NativePtr = (ImPlotPoint*)nativePtr;
+        public static implicit operator ImPlotPointPtr(ImPlotPoint* nativePtr) => new ImPlotPointPtr(nativePtr);
+        public static implicit operator ImPlotPoint* (ImPlotPointPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotPointPtr(IntPtr nativePtr) => new ImPlotPointPtr(nativePtr);
+        public ref double x => ref Unsafe.AsRef<double>(&NativePtr->x);
+        public ref double y => ref Unsafe.AsRef<double>(&NativePtr->y);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotPoint_destroy((ImPlotPoint*)(NativePtr));
+        }
+    }
+}

src/ImPlot.NET/Generated/ImPlotRange.gen.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImPlotRange
+    {
+        public double Min;
+        public double Max;
+    }
+    public unsafe partial struct ImPlotRangePtr
+    {
+        public ImPlotRange* NativePtr { get; }
+        public ImPlotRangePtr(ImPlotRange* nativePtr) => NativePtr = nativePtr;
+        public ImPlotRangePtr(IntPtr nativePtr) => NativePtr = (ImPlotRange*)nativePtr;
+        public static implicit operator ImPlotRangePtr(ImPlotRange* nativePtr) => new ImPlotRangePtr(nativePtr);
+        public static implicit operator ImPlotRange* (ImPlotRangePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotRangePtr(IntPtr nativePtr) => new ImPlotRangePtr(nativePtr);
+        public ref double Min => ref Unsafe.AsRef<double>(&NativePtr->Min);
+        public ref double Max => ref Unsafe.AsRef<double>(&NativePtr->Max);
+        public bool Contains(double value)
+        {
+            byte ret = ImPlotNative.ImPlotRange_Contains((ImPlotRange*)(NativePtr), value);
+            return ret != 0;
+        }
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotRange_destroy((ImPlotRange*)(NativePtr));
+        }
+        public double Size()
+        {
+            double ret = ImPlotNative.ImPlotRange_Size((ImPlotRange*)(NativePtr));
+            return ret;
+        }
+    }
+}

src/ImPlot.NET/Generated/ImPlotStyle.gen.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImPlotStyle
+    {
+        public float LineWeight;
+        public int Marker;
+        public float MarkerSize;
+        public float MarkerWeight;
+        public float FillAlpha;
+        public float ErrorBarSize;
+        public float ErrorBarWeight;
+        public float DigitalBitHeight;
+        public float DigitalBitGap;
+        public float PlotBorderSize;
+        public float MinorAlpha;
+        public Vector2 MajorTickLen;
+        public Vector2 MinorTickLen;
+        public Vector2 MajorTickSize;
+        public Vector2 MinorTickSize;
+        public Vector2 MajorGridSize;
+        public Vector2 MinorGridSize;
+        public Vector2 PlotPadding;
+        public Vector2 LabelPadding;
+        public Vector2 LegendPadding;
+        public Vector2 LegendInnerPadding;
+        public Vector2 LegendSpacing;
+        public Vector2 MousePosPadding;
+        public Vector2 AnnotationPadding;
+        public Vector2 PlotDefaultSize;
+        public Vector2 PlotMinSize;
+        public Vector4 Colors_0;
+        public Vector4 Colors_1;
+        public Vector4 Colors_2;
+        public Vector4 Colors_3;
+        public Vector4 Colors_4;
+        public Vector4 Colors_5;
+        public Vector4 Colors_6;
+        public Vector4 Colors_7;
+        public Vector4 Colors_8;
+        public Vector4 Colors_9;
+        public Vector4 Colors_10;
+        public Vector4 Colors_11;
+        public Vector4 Colors_12;
+        public Vector4 Colors_13;
+        public Vector4 Colors_14;
+        public Vector4 Colors_15;
+        public Vector4 Colors_16;
+        public Vector4 Colors_17;
+        public Vector4 Colors_18;
+        public Vector4 Colors_19;
+        public Vector4 Colors_20;
+        public Vector4 Colors_21;
+        public Vector4 Colors_22;
+        public Vector4 Colors_23;
+        public byte AntiAliasedLines;
+        public byte UseLocalTime;
+        public byte UseISO8601;
+        public byte Use24HourClock;
+    }
+    public unsafe partial struct ImPlotStylePtr
+    {
+        public ImPlotStyle* NativePtr { get; }
+        public ImPlotStylePtr(ImPlotStyle* nativePtr) => NativePtr = nativePtr;
+        public ImPlotStylePtr(IntPtr nativePtr) => NativePtr = (ImPlotStyle*)nativePtr;
+        public static implicit operator ImPlotStylePtr(ImPlotStyle* nativePtr) => new ImPlotStylePtr(nativePtr);
+        public static implicit operator ImPlotStyle* (ImPlotStylePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotStylePtr(IntPtr nativePtr) => new ImPlotStylePtr(nativePtr);
+        public ref float LineWeight => ref Unsafe.AsRef<float>(&NativePtr->LineWeight);
+        public ref int Marker => ref Unsafe.AsRef<int>(&NativePtr->Marker);
+        public ref float MarkerSize => ref Unsafe.AsRef<float>(&NativePtr->MarkerSize);
+        public ref float MarkerWeight => ref Unsafe.AsRef<float>(&NativePtr->MarkerWeight);
+        public ref float FillAlpha => ref Unsafe.AsRef<float>(&NativePtr->FillAlpha);
+        public ref float ErrorBarSize => ref Unsafe.AsRef<float>(&NativePtr->ErrorBarSize);
+        public ref float ErrorBarWeight => ref Unsafe.AsRef<float>(&NativePtr->ErrorBarWeight);
+        public ref float DigitalBitHeight => ref Unsafe.AsRef<float>(&NativePtr->DigitalBitHeight);
+        public ref float DigitalBitGap => ref Unsafe.AsRef<float>(&NativePtr->DigitalBitGap);
+        public ref float PlotBorderSize => ref Unsafe.AsRef<float>(&NativePtr->PlotBorderSize);
+        public ref float MinorAlpha => ref Unsafe.AsRef<float>(&NativePtr->MinorAlpha);
+        public ref Vector2 MajorTickLen => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorTickLen);
+        public ref Vector2 MinorTickLen => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorTickLen);
+        public ref Vector2 MajorTickSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorTickSize);
+        public ref Vector2 MinorTickSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorTickSize);
+        public ref Vector2 MajorGridSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorGridSize);
+        public ref Vector2 MinorGridSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorGridSize);
+        public ref Vector2 PlotPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotPadding);
+        public ref Vector2 LabelPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LabelPadding);
+        public ref Vector2 LegendPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendPadding);
+        public ref Vector2 LegendInnerPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendInnerPadding);
+        public ref Vector2 LegendSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendSpacing);
+        public ref Vector2 MousePosPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePosPadding);
+        public ref Vector2 AnnotationPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->AnnotationPadding);
+        public ref Vector2 PlotDefaultSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotDefaultSize);
+        public ref Vector2 PlotMinSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotMinSize);
+        public RangeAccessor<Vector4> Colors => new RangeAccessor<Vector4>(&NativePtr->Colors_0, 24);
+        public ref bool AntiAliasedLines => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedLines);
+        public ref bool UseLocalTime => ref Unsafe.AsRef<bool>(&NativePtr->UseLocalTime);
+        public ref bool UseISO8601 => ref Unsafe.AsRef<bool>(&NativePtr->UseISO8601);
+        public ref bool Use24HourClock => ref Unsafe.AsRef<bool>(&NativePtr->Use24HourClock);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotStyle_destroy((ImPlotStyle*)(NativePtr));
+        }
+    }
+}

src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs

@@ -0,0 +1,33 @@
+namespace ImGuiNET
+{
+    public enum ImPlotStyleVar
+    {
+        LineWeight = 0,
+        Marker = 1,
+        MarkerSize = 2,
+        MarkerWeight = 3,
+        FillAlpha = 4,
+        ErrorBarSize = 5,
+        ErrorBarWeight = 6,
+        DigitalBitHeight = 7,
+        DigitalBitGap = 8,
+        PlotBorderSize = 9,
+        MinorAlpha = 10,
+        MajorTickLen = 11,
+        MinorTickLen = 12,
+        MajorTickSize = 13,
+        MinorTickSize = 14,
+        MajorGridSize = 15,
+        MinorGridSize = 16,
+        PlotPadding = 17,
+        LabelPadding = 18,
+        LegendPadding = 19,
+        LegendInnerPadding = 20,
+        LegendSpacing = 21,
+        MousePosPadding = 22,
+        AnnotationPadding = 23,
+        PlotDefaultSize = 24,
+        PlotMinSize = 25,
+        COUNT = 26,
+    }
+}

src/ImPlot.NET/Generated/ImPlotYAxis.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImPlotYAxis
+    {
+        _1 = 0,
+        _2 = 1,
+        _3 = 2,
+    }
+}