diff --git a/src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs b/src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs new file mode 100644 index 0000000..c15b483 --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs b/src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs new file mode 100644 index 0000000..7cd7ea9 --- /dev/null +++ b/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); + } +} diff --git a/src/ImGuizmo.NET/Generated/MODE.gen.cs b/src/ImGuizmo.NET/Generated/MODE.gen.cs new file mode 100644 index 0000000..8ec5ca8 --- /dev/null +++ b/src/ImGuizmo.NET/Generated/MODE.gen.cs @@ -0,0 +1,8 @@ +namespace ImGuiNET +{ + public enum MODE + { + LOCAL = 0, + WORLD = 1, + } +} diff --git a/src/ImGuizmo.NET/Generated/OPERATION.gen.cs b/src/ImGuizmo.NET/Generated/OPERATION.gen.cs new file mode 100644 index 0000000..62604a4 --- /dev/null +++ b/src/ImGuizmo.NET/Generated/OPERATION.gen.cs @@ -0,0 +1,10 @@ +namespace ImGuiNET +{ + public enum OPERATION + { + TRANSLATE = 0, + ROTATE = 1, + SCALE = 2, + BOUNDS = 3, + } +} diff --git a/src/ImNodes.NET/Generated/AttributeFlags.gen.cs b/src/ImNodes.NET/Generated/AttributeFlags.gen.cs new file mode 100644 index 0000000..5bcd422 --- /dev/null +++ b/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, + } +} diff --git a/src/ImNodes.NET/Generated/ColorStyle.gen.cs b/src/ImNodes.NET/Generated/ColorStyle.gen.cs new file mode 100644 index 0000000..23d52d6 --- /dev/null +++ b/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, + } +} diff --git a/src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs b/src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs new file mode 100644 index 0000000..d790cd9 --- /dev/null +++ b/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(&NativePtr->enabled); + public IntPtr modifier { get => (IntPtr)NativePtr->modifier; set => NativePtr->modifier = (byte*)value; } + public void Destroy() + { + ImNodesNative.EmulateThreeButtonMouse_destroy((EmulateThreeButtonMouse*)(NativePtr)); + } + } +} diff --git a/src/ImNodes.NET/Generated/IO.gen.cs b/src/ImNodes.NET/Generated/IO.gen.cs new file mode 100644 index 0000000..ef51b80 --- /dev/null +++ b/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(&NativePtr->emulate_three_button_mouse); + public ref LinkDetachWithModifierClick link_detach_with_modifier_click => ref Unsafe.AsRef(&NativePtr->link_detach_with_modifier_click); + public void Destroy() + { + ImNodesNative.IO_destroy((IO*)(NativePtr)); + } + } +} diff --git a/src/ImNodes.NET/Generated/ImNodes.gen.cs b/src/ImNodes.NET/Generated/ImNodes.gen.cs new file mode 100644 index 0000000..4235519 --- /dev/null +++ b/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(); + } + } +} diff --git a/src/ImNodes.NET/Generated/ImNodesNative.gen.cs b/src/ImNodes.NET/Generated/ImNodesNative.gen.cs new file mode 100644 index 0000000..8c04d6e --- /dev/null +++ b/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(); + } +} diff --git a/src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs b/src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs new file mode 100644 index 0000000..d2fdf4c --- /dev/null +++ b/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)); + } + } +} diff --git a/src/ImNodes.NET/Generated/PinShape.gen.cs b/src/ImNodes.NET/Generated/PinShape.gen.cs new file mode 100644 index 0000000..3f99ad5 --- /dev/null +++ b/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, + } +} diff --git a/src/ImNodes.NET/Generated/Style.gen.cs b/src/ImNodes.NET/Generated/Style.gen.cs new file mode 100644 index 0000000..ece743a --- /dev/null +++ b/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(&NativePtr->grid_spacing); + public ref float node_corner_rounding => ref Unsafe.AsRef(&NativePtr->node_corner_rounding); + public ref float node_padding_horizontal => ref Unsafe.AsRef(&NativePtr->node_padding_horizontal); + public ref float node_padding_vertical => ref Unsafe.AsRef(&NativePtr->node_padding_vertical); + public ref float node_border_thickness => ref Unsafe.AsRef(&NativePtr->node_border_thickness); + public ref float link_thickness => ref Unsafe.AsRef(&NativePtr->link_thickness); + public ref float link_line_segments_per_length => ref Unsafe.AsRef(&NativePtr->link_line_segments_per_length); + public ref float link_hover_distance => ref Unsafe.AsRef(&NativePtr->link_hover_distance); + public ref float pin_circle_radius => ref Unsafe.AsRef(&NativePtr->pin_circle_radius); + public ref float pin_quad_side_length => ref Unsafe.AsRef(&NativePtr->pin_quad_side_length); + public ref float pin_triangle_side_length => ref Unsafe.AsRef(&NativePtr->pin_triangle_side_length); + public ref float pin_line_thickness => ref Unsafe.AsRef(&NativePtr->pin_line_thickness); + public ref float pin_hover_radius => ref Unsafe.AsRef(&NativePtr->pin_hover_radius); + public ref float pin_offset => ref Unsafe.AsRef(&NativePtr->pin_offset); + public ref StyleFlags flags => ref Unsafe.AsRef(&NativePtr->flags); + public RangeAccessor colors => new RangeAccessor(NativePtr->colors, 16); + public void Destroy() + { + ImNodesNative.Style_destroy((Style*)(NativePtr)); + } + } +} diff --git a/src/ImNodes.NET/Generated/StyleFlags.gen.cs b/src/ImNodes.NET/Generated/StyleFlags.gen.cs new file mode 100644 index 0000000..b97f76a --- /dev/null +++ b/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, + } +} diff --git a/src/ImNodes.NET/Generated/StyleVar.gen.cs b/src/ImNodes.NET/Generated/StyleVar.gen.cs new file mode 100644 index 0000000..cc21b8e --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlot.gen.cs b/src/ImPlot.NET/Generated/ImPlot.gen.cs new file mode 100644 index 0000000..20226cf --- /dev/null +++ b/src/ImPlot.NET/Generated/ImPlot.gen.cs @@ -0,0 +1,32630 @@ +using System; +using System.Numerics; +using System.Runtime.InteropServices; +using System.Text; + +namespace ImGuiNET +{ + public static unsafe partial class ImPlot + { + public static void Annotate(double x, double y, Vector2 pix_offset, string fmt) + { + byte* native_fmt; + int fmt_byteCount = 0; + if (fmt != null) + { + fmt_byteCount = Encoding.UTF8.GetByteCount(fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_fmt = Util.Allocate(fmt_byteCount + 1); + } + else + { + byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1]; + native_fmt = native_fmt_stackBytes; + } + int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount); + native_fmt[native_fmt_offset] = 0; + } + else { native_fmt = null; } + ImPlotNative.ImPlot_AnnotateStr(x, y, pix_offset, native_fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_fmt); + } + } + public static void Annotate(double x, double y, Vector2 pix_offset, Vector4 color, string fmt) + { + byte* native_fmt; + int fmt_byteCount = 0; + if (fmt != null) + { + fmt_byteCount = Encoding.UTF8.GetByteCount(fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_fmt = Util.Allocate(fmt_byteCount + 1); + } + else + { + byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1]; + native_fmt = native_fmt_stackBytes; + } + int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount); + native_fmt[native_fmt_offset] = 0; + } + else { native_fmt = null; } + ImPlotNative.ImPlot_AnnotateVec4(x, y, pix_offset, color, native_fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_fmt); + } + } + public static void AnnotateClamped(double x, double y, Vector2 pix_offset, string fmt) + { + byte* native_fmt; + int fmt_byteCount = 0; + if (fmt != null) + { + fmt_byteCount = Encoding.UTF8.GetByteCount(fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_fmt = Util.Allocate(fmt_byteCount + 1); + } + else + { + byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1]; + native_fmt = native_fmt_stackBytes; + } + int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount); + native_fmt[native_fmt_offset] = 0; + } + else { native_fmt = null; } + ImPlotNative.ImPlot_AnnotateClampedStr(x, y, pix_offset, native_fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_fmt); + } + } + public static void AnnotateClamped(double x, double y, Vector2 pix_offset, Vector4 color, string fmt) + { + byte* native_fmt; + int fmt_byteCount = 0; + if (fmt != null) + { + fmt_byteCount = Encoding.UTF8.GetByteCount(fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_fmt = Util.Allocate(fmt_byteCount + 1); + } + else + { + byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1]; + native_fmt = native_fmt_stackBytes; + } + int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount); + native_fmt[native_fmt_offset] = 0; + } + else { native_fmt = null; } + ImPlotNative.ImPlot_AnnotateClampedVec4(x, y, pix_offset, color, native_fmt); + if (fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_fmt); + } + } + public static bool BeginLegendDragDropSource(string label_id) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + ImGuiDragDropFlags flags = 0; + byte ret = ImPlotNative.ImPlot_BeginLegendDragDropSource(native_label_id, flags); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + return ret != 0; + } + public static bool BeginLegendDragDropSource(string label_id, ImGuiDragDropFlags flags) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte ret = ImPlotNative.ImPlot_BeginLegendDragDropSource(native_label_id, flags); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + return ret != 0; + } + public static bool BeginLegendPopup(string label_id) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + ImGuiMouseButton mouse_button = (ImGuiMouseButton)1; + byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + return ret != 0; + } + public static bool BeginLegendPopup(string label_id, ImGuiMouseButton mouse_button) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + return ret != 0; + } + public static bool BeginPlot(string title_id) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label = null; + byte* native_y_label = null; + Vector2 size = new Vector2(-1, 0); + ImPlotFlags flags = ImPlotFlags.None; + ImPlotAxisFlags x_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label = null; + Vector2 size = new Vector2(-1, 0); + ImPlotFlags flags = ImPlotFlags.None; + ImPlotAxisFlags x_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + Vector2 size = new Vector2(-1, 0); + ImPlotFlags flags = ImPlotFlags.None; + ImPlotAxisFlags x_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + ImPlotFlags flags = ImPlotFlags.None; + ImPlotAxisFlags x_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size, ImPlotFlags flags) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + ImPlotAxisFlags x_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size, ImPlotFlags flags, ImPlotAxisFlags x_flags) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + ImPlotAxisFlags y_flags = ImPlotAxisFlags.None; + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size, ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + ImPlotAxisFlags y2_flags = ImPlotAxisFlags.NoGridLines; + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size, ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags, ImPlotAxisFlags y2_flags) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + ImPlotAxisFlags y3_flags = ImPlotAxisFlags.NoGridLines; + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static bool BeginPlot(string title_id, string x_label, string y_label, Vector2 size, ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags, ImPlotAxisFlags y2_flags, ImPlotAxisFlags y3_flags) + { + byte* native_title_id; + int title_id_byteCount = 0; + if (title_id != null) + { + title_id_byteCount = Encoding.UTF8.GetByteCount(title_id); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + native_title_id = Util.Allocate(title_id_byteCount + 1); + } + else + { + byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1]; + native_title_id = native_title_id_stackBytes; + } + int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount); + native_title_id[native_title_id_offset] = 0; + } + else { native_title_id = null; } + byte* native_x_label; + int x_label_byteCount = 0; + if (x_label != null) + { + x_label_byteCount = Encoding.UTF8.GetByteCount(x_label); + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + native_x_label = Util.Allocate(x_label_byteCount + 1); + } + else + { + byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1]; + native_x_label = native_x_label_stackBytes; + } + int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount); + native_x_label[native_x_label_offset] = 0; + } + else { native_x_label = null; } + byte* native_y_label; + int y_label_byteCount = 0; + if (y_label != null) + { + y_label_byteCount = Encoding.UTF8.GetByteCount(y_label); + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + native_y_label = Util.Allocate(y_label_byteCount + 1); + } + else + { + byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1]; + native_y_label = native_y_label_stackBytes; + } + int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount); + native_y_label[native_y_label_offset] = 0; + } + else { native_y_label = null; } + byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, native_x_label, native_y_label, size, flags, x_flags, y_flags, y2_flags, y3_flags); + if (title_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_title_id); + } + if (x_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_x_label); + } + if (y_label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_y_label); + } + return ret != 0; + } + public static IntPtr CreateContext() + { + IntPtr ret = ImPlotNative.ImPlot_CreateContext(); + return ret; + } + public static void DestroyContext() + { + IntPtr ctx = IntPtr.Zero; + ImPlotNative.ImPlot_DestroyContext(ctx); + } + public static void DestroyContext(IntPtr ctx) + { + ImPlotNative.ImPlot_DestroyContext(ctx); + } + public static bool DragLineX(string id, ref double x_value) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte show_label = 1; + Vector4 col = new Vector4(0, 0, 0, -1); + float thickness = 1; + fixed (double* native_x_value = &x_value) + { + byte ret = ImPlotNative.ImPlot_DragLineX(native_id, native_x_value, show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineX(string id, ref double x_value, bool show_label) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + Vector4 col = new Vector4(0, 0, 0, -1); + float thickness = 1; + fixed (double* native_x_value = &x_value) + { + byte ret = ImPlotNative.ImPlot_DragLineX(native_id, native_x_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineX(string id, ref double x_value, bool show_label, Vector4 col) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + float thickness = 1; + fixed (double* native_x_value = &x_value) + { + byte ret = ImPlotNative.ImPlot_DragLineX(native_id, native_x_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineX(string id, ref double x_value, bool show_label, Vector4 col, float thickness) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + fixed (double* native_x_value = &x_value) + { + byte ret = ImPlotNative.ImPlot_DragLineX(native_id, native_x_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineY(string id, ref double y_value) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte show_label = 1; + Vector4 col = new Vector4(0, 0, 0, -1); + float thickness = 1; + fixed (double* native_y_value = &y_value) + { + byte ret = ImPlotNative.ImPlot_DragLineY(native_id, native_y_value, show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineY(string id, ref double y_value, bool show_label) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + Vector4 col = new Vector4(0, 0, 0, -1); + float thickness = 1; + fixed (double* native_y_value = &y_value) + { + byte ret = ImPlotNative.ImPlot_DragLineY(native_id, native_y_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineY(string id, ref double y_value, bool show_label, Vector4 col) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + float thickness = 1; + fixed (double* native_y_value = &y_value) + { + byte ret = ImPlotNative.ImPlot_DragLineY(native_id, native_y_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragLineY(string id, ref double y_value, bool show_label, Vector4 col, float thickness) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + fixed (double* native_y_value = &y_value) + { + byte ret = ImPlotNative.ImPlot_DragLineY(native_id, native_y_value, native_show_label, col, thickness); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + public static bool DragPoint(string id, ref double x, ref double y) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte show_label = 1; + Vector4 col = new Vector4(0, 0, 0, -1); + float radius = 4; + fixed (double* native_x = &x) + { + fixed (double* native_y = &y) + { + byte ret = ImPlotNative.ImPlot_DragPoint(native_id, native_x, native_y, show_label, col, radius); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + } + public static bool DragPoint(string id, ref double x, ref double y, bool show_label) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + Vector4 col = new Vector4(0, 0, 0, -1); + float radius = 4; + fixed (double* native_x = &x) + { + fixed (double* native_y = &y) + { + byte ret = ImPlotNative.ImPlot_DragPoint(native_id, native_x, native_y, native_show_label, col, radius); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + } + public static bool DragPoint(string id, ref double x, ref double y, bool show_label, Vector4 col) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + float radius = 4; + fixed (double* native_x = &x) + { + fixed (double* native_y = &y) + { + byte ret = ImPlotNative.ImPlot_DragPoint(native_id, native_x, native_y, native_show_label, col, radius); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + } + public static bool DragPoint(string id, ref double x, ref double y, bool show_label, Vector4 col, float radius) + { + byte* native_id; + int id_byteCount = 0; + if (id != null) + { + id_byteCount = Encoding.UTF8.GetByteCount(id); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + native_id = Util.Allocate(id_byteCount + 1); + } + else + { + byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1]; + native_id = native_id_stackBytes; + } + int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount); + native_id[native_id_offset] = 0; + } + else { native_id = null; } + byte native_show_label = show_label ? (byte)1 : (byte)0; + fixed (double* native_x = &x) + { + fixed (double* native_y = &y) + { + byte ret = ImPlotNative.ImPlot_DragPoint(native_id, native_x, native_y, native_show_label, col, radius); + if (id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_id); + } + return ret != 0; + } + } + } + public static void EndLegendDragDropSource() + { + ImPlotNative.ImPlot_EndLegendDragDropSource(); + } + public static void EndLegendPopup() + { + ImPlotNative.ImPlot_EndLegendPopup(); + } + public static void EndPlot() + { + ImPlotNative.ImPlot_EndPlot(); + } + public static void FitNextPlotAxes() + { + byte x = 1; + byte y = 1; + byte y2 = 1; + byte y3 = 1; + ImPlotNative.ImPlot_FitNextPlotAxes(x, y, y2, y3); + } + public static void FitNextPlotAxes(bool x) + { + byte native_x = x ? (byte)1 : (byte)0; + byte y = 1; + byte y2 = 1; + byte y3 = 1; + ImPlotNative.ImPlot_FitNextPlotAxes(native_x, y, y2, y3); + } + public static void FitNextPlotAxes(bool x, bool y) + { + byte native_x = x ? (byte)1 : (byte)0; + byte native_y = y ? (byte)1 : (byte)0; + byte y2 = 1; + byte y3 = 1; + ImPlotNative.ImPlot_FitNextPlotAxes(native_x, native_y, y2, y3); + } + public static void FitNextPlotAxes(bool x, bool y, bool y2) + { + byte native_x = x ? (byte)1 : (byte)0; + byte native_y = y ? (byte)1 : (byte)0; + byte native_y2 = y2 ? (byte)1 : (byte)0; + byte y3 = 1; + ImPlotNative.ImPlot_FitNextPlotAxes(native_x, native_y, native_y2, y3); + } + public static void FitNextPlotAxes(bool x, bool y, bool y2, bool y3) + { + byte native_x = x ? (byte)1 : (byte)0; + byte native_y = y ? (byte)1 : (byte)0; + byte native_y2 = y2 ? (byte)1 : (byte)0; + byte native_y3 = y3 ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_FitNextPlotAxes(native_x, native_y, native_y2, native_y3); + } + public static Vector4 GetColormapColor(int index) + { + Vector4 __retval; + ImPlotNative.ImPlot_GetColormapColor(&__retval, index); + return __retval; + } + public static string GetColormapName(ImPlotColormap colormap) + { + byte* ret = ImPlotNative.ImPlot_GetColormapName(colormap); + return Util.StringFromPtr(ret); + } + public static int GetColormapSize() + { + int ret = ImPlotNative.ImPlot_GetColormapSize(); + return ret; + } + public static IntPtr GetCurrentContext() + { + IntPtr ret = ImPlotNative.ImPlot_GetCurrentContext(); + return ret; + } + public static ImPlotInputMapPtr GetInputMap() + { + ImPlotInputMap* ret = ImPlotNative.ImPlot_GetInputMap(); + return new ImPlotInputMapPtr(ret); + } + public static Vector4 GetLastItemColor() + { + Vector4 __retval; + ImPlotNative.ImPlot_GetLastItemColor(&__retval); + return __retval; + } + public static string GetMarkerName(ImPlotMarker idx) + { + byte* ret = ImPlotNative.ImPlot_GetMarkerName(idx); + return Util.StringFromPtr(ret); + } + public static ImDrawListPtr GetPlotDrawList() + { + ImDrawList* ret = ImPlotNative.ImPlot_GetPlotDrawList(); + return new ImDrawListPtr(ret); + } + public static ImPlotLimits GetPlotLimits() + { + ImPlotLimits __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_GetPlotLimits(&__retval, y_axis); + return __retval; + } + public static ImPlotLimits GetPlotLimits(ImPlotYAxis y_axis) + { + ImPlotLimits __retval; + ImPlotNative.ImPlot_GetPlotLimits(&__retval, y_axis); + return __retval; + } + public static ImPlotPoint GetPlotMousePos() + { + ImPlotPoint __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_GetPlotMousePos(&__retval, y_axis); + return __retval; + } + public static ImPlotPoint GetPlotMousePos(ImPlotYAxis y_axis) + { + ImPlotPoint __retval; + ImPlotNative.ImPlot_GetPlotMousePos(&__retval, y_axis); + return __retval; + } + public static Vector2 GetPlotPos() + { + Vector2 __retval; + ImPlotNative.ImPlot_GetPlotPos(&__retval); + return __retval; + } + public static ImPlotLimits GetPlotQuery() + { + ImPlotLimits __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_GetPlotQuery(&__retval, y_axis); + return __retval; + } + public static ImPlotLimits GetPlotQuery(ImPlotYAxis y_axis) + { + ImPlotLimits __retval; + ImPlotNative.ImPlot_GetPlotQuery(&__retval, y_axis); + return __retval; + } + public static Vector2 GetPlotSize() + { + Vector2 __retval; + ImPlotNative.ImPlot_GetPlotSize(&__retval); + return __retval; + } + public static ImPlotStylePtr GetStyle() + { + ImPlotStyle* ret = ImPlotNative.ImPlot_GetStyle(); + return new ImPlotStylePtr(ret); + } + public static string GetStyleColorName(ImPlotCol idx) + { + byte* ret = ImPlotNative.ImPlot_GetStyleColorName(idx); + return Util.StringFromPtr(ret); + } + public static void HideNextItem() + { + byte hidden = 1; + ImGuiCond cond = ImGuiCond.Once; + ImPlotNative.ImPlot_HideNextItem(hidden, cond); + } + public static void HideNextItem(bool hidden) + { + byte native_hidden = hidden ? (byte)1 : (byte)0; + ImGuiCond cond = ImGuiCond.Once; + ImPlotNative.ImPlot_HideNextItem(native_hidden, cond); + } + public static void HideNextItem(bool hidden, ImGuiCond cond) + { + byte native_hidden = hidden ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_HideNextItem(native_hidden, cond); + } + public static bool IsLegendEntryHovered(string label_id) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte ret = ImPlotNative.ImPlot_IsLegendEntryHovered(native_label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + return ret != 0; + } + public static bool IsPlotHovered() + { + byte ret = ImPlotNative.ImPlot_IsPlotHovered(); + return ret != 0; + } + public static bool IsPlotQueried() + { + byte ret = ImPlotNative.ImPlot_IsPlotQueried(); + return ret != 0; + } + public static bool IsPlotXAxisHovered() + { + byte ret = ImPlotNative.ImPlot_IsPlotXAxisHovered(); + return ret != 0; + } + public static bool IsPlotYAxisHovered() + { + ImPlotYAxis y_axis = (ImPlotYAxis)0; + byte ret = ImPlotNative.ImPlot_IsPlotYAxisHovered(y_axis); + return ret != 0; + } + public static bool IsPlotYAxisHovered(ImPlotYAxis y_axis) + { + byte ret = ImPlotNative.ImPlot_IsPlotYAxisHovered(y_axis); + return ret != 0; + } + public static Vector4 LerpColormap(float t) + { + Vector4 __retval; + ImPlotNative.ImPlot_LerpColormap(&__retval, t); + return __retval; + } + public static void LinkNextPlotLimits(ref double xmin, ref double xmax, ref double ymin, ref double ymax) + { + double* ymin2 = null; + double* ymax2 = null; + double* ymin3 = null; + double* ymax3 = null; + fixed (double* native_xmin = &xmin) + { + fixed (double* native_xmax = &xmax) + { + fixed (double* native_ymin = &ymin) + { + fixed (double* native_ymax = &ymax) + { + ImPlotNative.ImPlot_LinkNextPlotLimits(native_xmin, native_xmax, native_ymin, native_ymax, ymin2, ymax2, ymin3, ymax3); + } + } + } + } + } + public static void LinkNextPlotLimits(ref double xmin, ref double xmax, ref double ymin, ref double ymax, ref double ymin2) + { + double* ymax2 = null; + double* ymin3 = null; + double* ymax3 = null; + fixed (double* native_xmin = &xmin) + { + fixed (double* native_xmax = &xmax) + { + fixed (double* native_ymin = &ymin) + { + fixed (double* native_ymax = &ymax) + { + fixed (double* native_ymin2 = &ymin2) + { + ImPlotNative.ImPlot_LinkNextPlotLimits(native_xmin, native_xmax, native_ymin, native_ymax, native_ymin2, ymax2, ymin3, ymax3); + } + } + } + } + } + } + public static void LinkNextPlotLimits(ref double xmin, ref double xmax, ref double ymin, ref double ymax, ref double ymin2, ref double ymax2) + { + double* ymin3 = null; + double* ymax3 = null; + fixed (double* native_xmin = &xmin) + { + fixed (double* native_xmax = &xmax) + { + fixed (double* native_ymin = &ymin) + { + fixed (double* native_ymax = &ymax) + { + fixed (double* native_ymin2 = &ymin2) + { + fixed (double* native_ymax2 = &ymax2) + { + ImPlotNative.ImPlot_LinkNextPlotLimits(native_xmin, native_xmax, native_ymin, native_ymax, native_ymin2, native_ymax2, ymin3, ymax3); + } + } + } + } + } + } + } + public static void LinkNextPlotLimits(ref double xmin, ref double xmax, ref double ymin, ref double ymax, ref double ymin2, ref double ymax2, ref double ymin3) + { + double* ymax3 = null; + fixed (double* native_xmin = &xmin) + { + fixed (double* native_xmax = &xmax) + { + fixed (double* native_ymin = &ymin) + { + fixed (double* native_ymax = &ymax) + { + fixed (double* native_ymin2 = &ymin2) + { + fixed (double* native_ymax2 = &ymax2) + { + fixed (double* native_ymin3 = &ymin3) + { + ImPlotNative.ImPlot_LinkNextPlotLimits(native_xmin, native_xmax, native_ymin, native_ymax, native_ymin2, native_ymax2, native_ymin3, ymax3); + } + } + } + } + } + } + } + } + public static void LinkNextPlotLimits(ref double xmin, ref double xmax, ref double ymin, ref double ymax, ref double ymin2, ref double ymax2, ref double ymin3, ref double ymax3) + { + fixed (double* native_xmin = &xmin) + { + fixed (double* native_xmax = &xmax) + { + fixed (double* native_ymin = &ymin) + { + fixed (double* native_ymax = &ymax) + { + fixed (double* native_ymin2 = &ymin2) + { + fixed (double* native_ymax2 = &ymax2) + { + fixed (double* native_ymin3 = &ymin3) + { + fixed (double* native_ymax3 = &ymax3) + { + ImPlotNative.ImPlot_LinkNextPlotLimits(native_xmin, native_xmax, native_ymin, native_ymax, native_ymin2, native_ymax2, native_ymin3, native_ymax3); + } + } + } + } + } + } + } + } + } + public static Vector4 NextColormapColor() + { + Vector4 __retval; + ImPlotNative.ImPlot_NextColormapColor(&__retval); + return __retval; + } + public static ImPlotPoint PixelsToPlot(Vector2 pix) + { + ImPlotPoint __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_PixelsToPlotVec2(&__retval, pix, y_axis); + return __retval; + } + public static ImPlotPoint PixelsToPlot(Vector2 pix, ImPlotYAxis y_axis) + { + ImPlotPoint __retval; + ImPlotNative.ImPlot_PixelsToPlotVec2(&__retval, pix, y_axis); + return __retval; + } + public static ImPlotPoint PixelsToPlot(float x, float y) + { + ImPlotPoint __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_PixelsToPlotFloat(&__retval, x, y, y_axis); + return __retval; + } + public static ImPlotPoint PixelsToPlot(float x, float y, ImPlotYAxis y_axis) + { + ImPlotPoint __retval; + ImPlotNative.ImPlot_PixelsToPlotFloat(&__retval, x, y, y_axis); + return __retval; + } + public static void PlotBars(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref float values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref float values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref float values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref float values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref double values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref double values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref double values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref double values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref sbyte values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref sbyte values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref sbyte values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref sbyte values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref byte values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref byte values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref byte values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref byte values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU8PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref short values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref short values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref short values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref short values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ushort values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ushort values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ushort values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ushort values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU16PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref int values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref int values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref int values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref int values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref uint values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref uint values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref uint values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref uint values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU32PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref long values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref long values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref long values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref long values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsS64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double width = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ulong values, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ulong values, int count, double width, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ulong values, int count, double width, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref ulong values, int count, double width, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsU64PtrInt(native_label_id, native_values, count, width, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double width) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double width, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double width, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, width, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref float values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref float values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref float values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref float values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref double values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref double values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref double values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref double values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref sbyte values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref sbyte values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref sbyte values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref sbyte values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref byte values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref byte values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref byte values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref byte values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref short values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref short values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref short values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref short values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ushort values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ushort values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ushort values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ushort values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref int values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref int values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref int values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref int values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref uint values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref uint values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref uint values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref uint values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref long values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref long values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref long values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref long values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double height = 0.67; + double shift = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ulong values, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double shift = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ulong values, int count, double height, double shift) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ulong values, int count, double height, double shift, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref ulong values, int count, double height, double shift, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrInt(native_label_id, native_values, count, height, shift, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotBarsH(string label_id, ref float xs, ref float ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref float xs, ref float ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref float xs, ref float ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref double xs, ref double ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref double xs, ref double ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref double xs, ref double ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref sbyte xs, ref sbyte ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref sbyte xs, ref sbyte ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref sbyte xs, ref sbyte ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref byte xs, ref byte ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref byte xs, ref byte ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref byte xs, ref byte ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref short xs, ref short ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref short xs, ref short ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref short xs, ref short ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ushort xs, ref ushort ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ushort xs, ref ushort ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ushort xs, ref ushort ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref int xs, ref int ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref int xs, ref int ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref int xs, ref int ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref uint xs, ref uint ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref uint xs, ref uint ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref uint xs, ref uint ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref long xs, ref long ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref long xs, ref long ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref long xs, ref long ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ulong xs, ref ulong ys, int count, double height) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ulong xs, ref ulong ys, int count, double height, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotBarsH(string label_id, ref ulong xs, ref ulong ys, int count, double height, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotBarsHU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, height, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref float xs, ref float ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref float xs, ref float ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitaldoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref double xs, ref double ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitaldoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref double xs, ref double ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitaldoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref short xs, ref short ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref short xs, ref short ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref int xs, ref int ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref int xs, ref int ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref long xs, ref long ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref long xs, ref long ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotDigitalU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotDummy(string label_id) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + ImPlotNative.ImPlot_PlotDummy(native_label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_err = &err) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + fixed (float* native_neg = &neg) + { + fixed (float* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + fixed (double* native_neg = &neg) + { + fixed (double* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + fixed (sbyte* native_neg = &neg) + { + fixed (sbyte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + fixed (byte* native_neg = &neg) + { + fixed (byte* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + fixed (short* native_neg = &neg) + { + fixed (short* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + fixed (ushort* native_neg = &neg) + { + fixed (ushort* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + fixed (int* native_neg = &neg) + { + fixed (int* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + fixed (uint* native_neg = &neg) + { + fixed (uint* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + fixed (long* native_neg = &neg) + { + fixed (long* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHS64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotErrorBarsH(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + fixed (ulong* native_neg = &neg) + { + fixed (ulong* native_pos = &pos) + { + ImPlotNative.ImPlot_PlotErrorBarsHU64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + } + public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapFloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapFloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapFloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapFloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapdoublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapdoublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapdoublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapdoublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapS64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 }; + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 }; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotHeatmapU64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + Vector2 uv0 = new Vector2(); + Vector2 uv1 = new Vector2(1, 1); + Vector4 tint_col = new Vector4(1, 1, 1, 1); + ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + Vector2 uv1 = new Vector2(1, 1); + Vector4 tint_col = new Vector4(1, 1, 1, 1); + ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + Vector4 tint_col = new Vector4(1, 1, 1, 1); + ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + public static void PlotLine(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref float values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref float values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref float values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref float values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotLinedoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref double values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotLinedoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref double values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotLinedoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref double values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotLinedoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref double values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotLinedoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref sbyte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref byte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref byte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref byte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref byte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref short values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref short values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref short values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref short values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ushort values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref int values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref int values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref int values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref int values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref uint values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref uint values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref uint values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref uint values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref long values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref long values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref long values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref long values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ulong values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotLineU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotLine(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref float xs, ref float ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref float xs, ref float ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLinedoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref double xs, ref double ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLinedoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref double xs, ref double ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLinedoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref short xs, ref short ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref short xs, ref short ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref int xs, ref int ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref int xs, ref int ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref long xs, ref long ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref long xs, ref long ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotLineU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartFloatPtr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartFloatPtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartFloatPtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartFloatPtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartdoublePtr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartdoublePtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartdoublePtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartdoublePtr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS8Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU8Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU8Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS16Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU16Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU16Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS32Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU32Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU32Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS64Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartS64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte normalize = 0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU64Ptr(native_label_ids, native_values, count, x, y, radius, normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, bool normalize) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f"); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + double angle0 = 90; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, bool normalize, string label_fmt) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + double angle0 = 90; + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, bool normalize, string label_fmt, double angle0) + { + int* label_ids_byteCounts = stackalloc int[label_ids.Length]; + int label_ids_byteCount = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + label_ids_byteCount += label_ids_byteCounts[i] + 1; + } + byte* native_label_ids_data = stackalloc byte[label_ids_byteCount]; + int offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + string s = label_ids[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_label_ids_data + offset, label_ids_byteCounts[i]); + native_label_ids_data[offset] = 0; + offset += 1; + } + } + byte** native_label_ids = stackalloc byte*[label_ids.Length]; + offset = 0; + for (int i = 0; i < label_ids.Length; i++) + { + native_label_ids[i] = &native_label_ids_data[offset]; + offset += label_ids_byteCounts[i] + 1; + } + byte native_normalize = normalize ? (byte)1 : (byte)0; + byte* native_label_fmt; + int label_fmt_byteCount = 0; + if (label_fmt != null) + { + label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + native_label_fmt = Util.Allocate(label_fmt_byteCount + 1); + } + else + { + byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1]; + native_label_fmt = native_label_fmt_stackBytes; + } + int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount); + native_label_fmt[native_label_fmt_offset] = 0; + } + else { native_label_fmt = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotPieChartU64Ptr(native_label_ids, native_values, count, x, y, radius, native_normalize, native_label_fmt, angle0); + if (label_fmt_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_fmt); + } + } + } + public static void PlotScatter(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref float values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref float values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref float values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref float values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref double values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref double values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref double values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref double values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref byte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref short values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref short values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref short values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref short values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ushort values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref int values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref int values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref int values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref int values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref uint values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref long values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref long values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref long values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref long values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ulong values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotScatterU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotScatter(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref float xs, ref float ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref float xs, ref float ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref double xs, ref double ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref double xs, ref double ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref short xs, ref short ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref short xs, ref short ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref int xs, ref int ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref int xs, ref int ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref long xs, ref long ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref long xs, ref long ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotScatterU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref double values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref byte values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU8PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref short values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU16PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref int values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref uint values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU32PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref long values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedS64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotShadedU64PtrIntdoubledoubleInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrIntInt(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys1 = &ys1) + { + fixed (float* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys1 = &ys1) + { + fixed (float* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys1 = &ys1) + { + fixed (float* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys1 = &ys1) + { + fixed (double* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys1 = &ys1) + { + fixed (double* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys1 = &ys1) + { + fixed (double* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys1 = &ys1) + { + fixed (sbyte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys1 = &ys1) + { + fixed (sbyte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys1 = &ys1) + { + fixed (sbyte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys1 = &ys1) + { + fixed (byte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys1 = &ys1) + { + fixed (byte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys1 = &ys1) + { + fixed (byte* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys1 = &ys1) + { + fixed (short* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys1 = &ys1) + { + fixed (short* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys1 = &ys1) + { + fixed (short* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys1 = &ys1) + { + fixed (ushort* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys1 = &ys1) + { + fixed (ushort* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys1 = &ys1) + { + fixed (ushort* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys1 = &ys1) + { + fixed (int* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys1 = &ys1) + { + fixed (int* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys1 = &ys1) + { + fixed (int* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys1 = &ys1) + { + fixed (uint* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys1 = &ys1) + { + fixed (uint* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys1 = &ys1) + { + fixed (uint* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys1 = &ys1) + { + fixed (long* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys1 = &ys1) + { + fixed (long* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys1 = &ys1) + { + fixed (long* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys1 = &ys1) + { + fixed (ulong* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys1 = &ys1) + { + fixed (ulong* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys1 = &ys1) + { + fixed (ulong* native_ys2 = &ys2) + { + ImPlotNative.ImPlot_PlotShadedU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + } + public static void PlotStairs(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref float values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref float values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref float values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref float values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref double values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref double values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref double values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref double values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref byte values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU8PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref short values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref short values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref short values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref short values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ushort values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU16PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref int values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref int values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref int values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref int values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref uint values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU32PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref long values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref long values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref long values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref long values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsS64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ulong values, int count, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStairsU64PtrInt(native_label_id, native_values, count, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStairs(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref float xs, ref float ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref float xs, ref float ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref double xs, ref double ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref double xs, ref double ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref short xs, ref short ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref short xs, ref short ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref int xs, ref int ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref int xs, ref int ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref long xs, ref long ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref long xs, ref long ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStairsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref float values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref double values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref sbyte values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref byte values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU8PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref short values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ushort values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU16PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref int values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref uint values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU32PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref long values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsS64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double xscale = 1; + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count, double y_ref, double xscale) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double x0 = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref ulong values, int count, double y_ref, double xscale, double x0, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_values = &values) + { + ImPlotNative.ImPlot_PlotStemsU64PtrInt(native_label_id, native_values, count, y_ref, xscale, x0, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + public static void PlotStems(string label_id, ref float xs, ref float ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(float); + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (float* native_xs = &xs) + { + fixed (float* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsFloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref double xs, ref double ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(double); + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (double* native_xs = &xs) + { + fixed (double* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsdoublePtrdoublePtr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(sbyte); + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (sbyte* native_xs = &xs) + { + fixed (sbyte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS8PtrS8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(byte); + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (byte* native_xs = &xs) + { + fixed (byte* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU8PtrU8Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref short xs, ref short ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(short); + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (short* native_xs = &xs) + { + fixed (short* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS16PtrS16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ushort); + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ushort* native_xs = &xs) + { + fixed (ushort* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU16PtrU16Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref int xs, ref int ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(int); + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (int* native_xs = &xs) + { + fixed (int* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS32PtrS32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(uint); + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (uint* native_xs = &xs) + { + fixed (uint* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU32PtrU32Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref long xs, ref long ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(long); + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (long* native_xs = &xs) + { + fixed (long* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsS64PtrS64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + double y_ref = 0; + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int offset = 0; + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref, int offset) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + int stride = sizeof(ulong); + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double y_ref, int offset, int stride) + { + byte* native_label_id; + int label_id_byteCount = 0; + if (label_id != null) + { + label_id_byteCount = Encoding.UTF8.GetByteCount(label_id); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + native_label_id = Util.Allocate(label_id_byteCount + 1); + } + else + { + byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1]; + native_label_id = native_label_id_stackBytes; + } + int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount); + native_label_id[native_label_id_offset] = 0; + } + else { native_label_id = null; } + fixed (ulong* native_xs = &xs) + { + fixed (ulong* native_ys = &ys) + { + ImPlotNative.ImPlot_PlotStemsU64PtrU64Ptr(native_label_id, native_xs, native_ys, count, y_ref, offset, stride); + if (label_id_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label_id); + } + } + } + } + public static void PlotText(string text, double x, double y) + { + byte* native_text; + int text_byteCount = 0; + if (text != null) + { + text_byteCount = Encoding.UTF8.GetByteCount(text); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + native_text = Util.Allocate(text_byteCount + 1); + } + else + { + byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1]; + native_text = native_text_stackBytes; + } + int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount); + native_text[native_text_offset] = 0; + } + else { native_text = null; } + byte vertical = 0; + Vector2 pix_offset = new Vector2(); + ImPlotNative.ImPlot_PlotText(native_text, x, y, vertical, pix_offset); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_text); + } + } + public static void PlotText(string text, double x, double y, bool vertical) + { + byte* native_text; + int text_byteCount = 0; + if (text != null) + { + text_byteCount = Encoding.UTF8.GetByteCount(text); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + native_text = Util.Allocate(text_byteCount + 1); + } + else + { + byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1]; + native_text = native_text_stackBytes; + } + int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount); + native_text[native_text_offset] = 0; + } + else { native_text = null; } + byte native_vertical = vertical ? (byte)1 : (byte)0; + Vector2 pix_offset = new Vector2(); + ImPlotNative.ImPlot_PlotText(native_text, x, y, native_vertical, pix_offset); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_text); + } + } + public static void PlotText(string text, double x, double y, bool vertical, Vector2 pix_offset) + { + byte* native_text; + int text_byteCount = 0; + if (text != null) + { + text_byteCount = Encoding.UTF8.GetByteCount(text); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + native_text = Util.Allocate(text_byteCount + 1); + } + else + { + byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1]; + native_text = native_text_stackBytes; + } + int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount); + native_text[native_text_offset] = 0; + } + else { native_text = null; } + byte native_vertical = vertical ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_PlotText(native_text, x, y, native_vertical, pix_offset); + if (text_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_text); + } + } + public static Vector2 PlotToPixels(ImPlotPoint plt) + { + Vector2 __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_PlotToPixelsPlotPoInt(&__retval, plt, y_axis); + return __retval; + } + public static Vector2 PlotToPixels(ImPlotPoint plt, ImPlotYAxis y_axis) + { + Vector2 __retval; + ImPlotNative.ImPlot_PlotToPixelsPlotPoInt(&__retval, plt, y_axis); + return __retval; + } + public static Vector2 PlotToPixels(double x, double y) + { + Vector2 __retval; + ImPlotYAxis y_axis = (ImPlotYAxis)(-1); + ImPlotNative.ImPlot_PlotToPixelsdouble(&__retval, x, y, y_axis); + return __retval; + } + public static Vector2 PlotToPixels(double x, double y, ImPlotYAxis y_axis) + { + Vector2 __retval; + ImPlotNative.ImPlot_PlotToPixelsdouble(&__retval, x, y, y_axis); + return __retval; + } + public static void PopColormap() + { + int count = 1; + ImPlotNative.ImPlot_PopColormap(count); + } + public static void PopColormap(int count) + { + ImPlotNative.ImPlot_PopColormap(count); + } + public static void PopPlotClipRect() + { + ImPlotNative.ImPlot_PopPlotClipRect(); + } + public static void PopStyleColor() + { + int count = 1; + ImPlotNative.ImPlot_PopStyleColor(count); + } + public static void PopStyleColor(int count) + { + ImPlotNative.ImPlot_PopStyleColor(count); + } + public static void PopStyleVar() + { + int count = 1; + ImPlotNative.ImPlot_PopStyleVar(count); + } + public static void PopStyleVar(int count) + { + ImPlotNative.ImPlot_PopStyleVar(count); + } + public static void PushColormap(ImPlotColormap colormap) + { + ImPlotNative.ImPlot_PushColormapPlotColormap(colormap); + } + public static void PushColormap(ref Vector4 colormap, int size) + { + fixed (Vector4* native_colormap = &colormap) + { + ImPlotNative.ImPlot_PushColormapVec4Ptr(native_colormap, size); + } + } + public static void PushPlotClipRect() + { + ImPlotNative.ImPlot_PushPlotClipRect(); + } + public static void PushStyleColor(ImPlotCol idx, uint col) + { + ImPlotNative.ImPlot_PushStyleColorU32(idx, col); + } + public static void PushStyleColor(ImPlotCol idx, Vector4 col) + { + ImPlotNative.ImPlot_PushStyleColorVec4(idx, col); + } + public static void PushStyleVar(ImPlotStyleVar idx, float val) + { + ImPlotNative.ImPlot_PushStyleVarFloat(idx, val); + } + public static void PushStyleVar(ImPlotStyleVar idx, int val) + { + ImPlotNative.ImPlot_PushStyleVarInt(idx, val); + } + public static void PushStyleVar(ImPlotStyleVar idx, Vector2 val) + { + ImPlotNative.ImPlot_PushStyleVarVec2(idx, val); + } + public static void SetColormap(ref Vector4 colormap, int size) + { + fixed (Vector4* native_colormap = &colormap) + { + ImPlotNative.ImPlot_SetColormapVec4Ptr(native_colormap, size); + } + } + public static void SetColormap(ImPlotColormap colormap) + { + int samples = 0; + ImPlotNative.ImPlot_SetColormapPlotColormap(colormap, samples); + } + public static void SetColormap(ImPlotColormap colormap, int samples) + { + ImPlotNative.ImPlot_SetColormapPlotColormap(colormap, samples); + } + public static void SetCurrentContext(IntPtr ctx) + { + ImPlotNative.ImPlot_SetCurrentContext(ctx); + } + public static void SetImGuiContext(IntPtr ctx) + { + ImPlotNative.ImPlot_SetImGuiContext(ctx); + } + public static void SetLegendLocation(ImPlotLocation location) + { + ImPlotOrientation orientation = ImPlotOrientation.Vertical; + byte outside = 0; + ImPlotNative.ImPlot_SetLegendLocation(location, orientation, outside); + } + public static void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation) + { + byte outside = 0; + ImPlotNative.ImPlot_SetLegendLocation(location, orientation, outside); + } + public static void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation, bool outside) + { + byte native_outside = outside ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_SetLegendLocation(location, orientation, native_outside); + } + public static void SetMousePosLocation(ImPlotLocation location) + { + ImPlotNative.ImPlot_SetMousePosLocation(location); + } + public static void SetNextErrorBarStyle() + { + Vector4 col = new Vector4(0, 0, 0, -1); + float size = -1; + float weight = -1; + ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight); + } + public static void SetNextErrorBarStyle(Vector4 col) + { + float size = -1; + float weight = -1; + ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight); + } + public static void SetNextErrorBarStyle(Vector4 col, float size) + { + float weight = -1; + ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight); + } + public static void SetNextErrorBarStyle(Vector4 col, float size, float weight) + { + ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight); + } + public static void SetNextFillStyle() + { + Vector4 col = new Vector4(0, 0, 0, -1); + float alpha_mod = -1; + ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod); + } + public static void SetNextFillStyle(Vector4 col) + { + float alpha_mod = -1; + ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod); + } + public static void SetNextFillStyle(Vector4 col, float alpha_mod) + { + ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod); + } + public static void SetNextLineStyle() + { + Vector4 col = new Vector4(0, 0, 0, -1); + float weight = -1; + ImPlotNative.ImPlot_SetNextLineStyle(col, weight); + } + public static void SetNextLineStyle(Vector4 col) + { + float weight = -1; + ImPlotNative.ImPlot_SetNextLineStyle(col, weight); + } + public static void SetNextLineStyle(Vector4 col, float weight) + { + ImPlotNative.ImPlot_SetNextLineStyle(col, weight); + } + public static void SetNextMarkerStyle() + { + ImPlotMarker marker = (ImPlotMarker)(-1); + float size = -1; + Vector4 fill = new Vector4(0, 0, 0, -1); + float weight = -1; + Vector4 outline = new Vector4(0, 0, 0, -1); + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextMarkerStyle(ImPlotMarker marker) + { + float size = -1; + Vector4 fill = new Vector4(0, 0, 0, -1); + float weight = -1; + Vector4 outline = new Vector4(0, 0, 0, -1); + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextMarkerStyle(ImPlotMarker marker, float size) + { + Vector4 fill = new Vector4(0, 0, 0, -1); + float weight = -1; + Vector4 outline = new Vector4(0, 0, 0, -1); + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill) + { + float weight = -1; + Vector4 outline = new Vector4(0, 0, 0, -1); + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight) + { + Vector4 outline = new Vector4(0, 0, 0, -1); + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight, Vector4 outline) + { + ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline); + } + public static void SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax) + { + ImGuiCond cond = ImGuiCond.Once; + ImPlotNative.ImPlot_SetNextPlotLimits(xmin, xmax, ymin, ymax, cond); + } + public static void SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax, ImGuiCond cond) + { + ImPlotNative.ImPlot_SetNextPlotLimits(xmin, xmax, ymin, ymax, cond); + } + public static void SetNextPlotLimitsX(double xmin, double xmax) + { + ImGuiCond cond = ImGuiCond.Once; + ImPlotNative.ImPlot_SetNextPlotLimitsX(xmin, xmax, cond); + } + public static void SetNextPlotLimitsX(double xmin, double xmax, ImGuiCond cond) + { + ImPlotNative.ImPlot_SetNextPlotLimitsX(xmin, xmax, cond); + } + public static void SetNextPlotLimitsY(double ymin, double ymax) + { + ImGuiCond cond = ImGuiCond.Once; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + ImPlotNative.ImPlot_SetNextPlotLimitsY(ymin, ymax, cond, y_axis); + } + public static void SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond) + { + ImPlotYAxis y_axis = (ImPlotYAxis)0; + ImPlotNative.ImPlot_SetNextPlotLimitsY(ymin, ymax, cond, y_axis); + } + public static void SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond, ImPlotYAxis y_axis) + { + ImPlotNative.ImPlot_SetNextPlotLimitsY(ymin, ymax, cond, y_axis); + } + public static void SetNextPlotTicksX(ref double values, int n_ticks) + { + byte** labels = null; + byte show_default = 0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksXdoublePtr(native_values, n_ticks, labels, show_default); + } + } + public static void SetNextPlotTicksX(ref double values, int n_ticks, string[] labels) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte show_default = 0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksXdoublePtr(native_values, n_ticks, native_labels, show_default); + } + } + public static void SetNextPlotTicksX(ref double values, int n_ticks, string[] labels, bool show_default) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksXdoublePtr(native_values, n_ticks, native_labels, native_show_default); + } + } + public static void SetNextPlotTicksX(double x_min, double x_max, int n_ticks) + { + byte** labels = null; + byte show_default = 0; + ImPlotNative.ImPlot_SetNextPlotTicksXdouble(x_min, x_max, n_ticks, labels, show_default); + } + public static void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, string[] labels) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte show_default = 0; + ImPlotNative.ImPlot_SetNextPlotTicksXdouble(x_min, x_max, n_ticks, native_labels, show_default); + } + public static void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, string[] labels, bool show_default) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_SetNextPlotTicksXdouble(x_min, x_max, n_ticks, native_labels, native_show_default); + } + public static void SetNextPlotTicksY(ref double values, int n_ticks) + { + byte** labels = null; + byte show_default = 0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksYdoublePtr(native_values, n_ticks, labels, show_default, y_axis); + } + } + public static void SetNextPlotTicksY(ref double values, int n_ticks, string[] labels) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte show_default = 0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksYdoublePtr(native_values, n_ticks, native_labels, show_default, y_axis); + } + } + public static void SetNextPlotTicksY(ref double values, int n_ticks, string[] labels, bool show_default) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksYdoublePtr(native_values, n_ticks, native_labels, native_show_default, y_axis); + } + } + public static void SetNextPlotTicksY(ref double values, int n_ticks, string[] labels, bool show_default, ImPlotYAxis y_axis) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + fixed (double* native_values = &values) + { + ImPlotNative.ImPlot_SetNextPlotTicksYdoublePtr(native_values, n_ticks, native_labels, native_show_default, y_axis); + } + } + public static void SetNextPlotTicksY(double y_min, double y_max, int n_ticks) + { + byte** labels = null; + byte show_default = 0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + ImPlotNative.ImPlot_SetNextPlotTicksYdouble(y_min, y_max, n_ticks, labels, show_default, y_axis); + } + public static void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, string[] labels) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte show_default = 0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + ImPlotNative.ImPlot_SetNextPlotTicksYdouble(y_min, y_max, n_ticks, native_labels, show_default, y_axis); + } + public static void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, string[] labels, bool show_default) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + ImPlotYAxis y_axis = (ImPlotYAxis)0; + ImPlotNative.ImPlot_SetNextPlotTicksYdouble(y_min, y_max, n_ticks, native_labels, native_show_default, y_axis); + } + public static void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, string[] labels, bool show_default, ImPlotYAxis y_axis) + { + int* labels_byteCounts = stackalloc int[labels.Length]; + int labels_byteCount = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s); + labels_byteCount += labels_byteCounts[i] + 1; + } + byte* native_labels_data = stackalloc byte[labels_byteCount]; + int offset = 0; + for (int i = 0; i < labels.Length; i++) + { + string s = labels[i]; + fixed (char* sPtr = s) + { + offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_labels_data + offset, labels_byteCounts[i]); + native_labels_data[offset] = 0; + offset += 1; + } + } + byte** native_labels = stackalloc byte*[labels.Length]; + offset = 0; + for (int i = 0; i < labels.Length; i++) + { + native_labels[i] = &native_labels_data[offset]; + offset += labels_byteCounts[i] + 1; + } + byte native_show_default = show_default ? (byte)1 : (byte)0; + ImPlotNative.ImPlot_SetNextPlotTicksYdouble(y_min, y_max, n_ticks, native_labels, native_show_default, y_axis); + } + public static void SetPlotYAxis(ImPlotYAxis y_axis) + { + ImPlotNative.ImPlot_SetPlotYAxis(y_axis); + } + public static void ShowColormapScale(double scale_min, double scale_max, float height) + { + ImPlotNative.ImPlot_ShowColormapScale(scale_min, scale_max, height); + } + public static bool ShowColormapSelector(string label) + { + byte* native_label; + int label_byteCount = 0; + if (label != null) + { + label_byteCount = Encoding.UTF8.GetByteCount(label); + if (label_byteCount > Util.StackAllocationSizeLimit) + { + native_label = Util.Allocate(label_byteCount + 1); + } + else + { + byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1]; + native_label = native_label_stackBytes; + } + int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount); + native_label[native_label_offset] = 0; + } + else { native_label = null; } + byte ret = ImPlotNative.ImPlot_ShowColormapSelector(native_label); + if (label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label); + } + return ret != 0; + } + public static void ShowDemoWindow() + { + byte* p_open = null; + ImPlotNative.ImPlot_ShowDemoWindow(p_open); + } + public static void ShowDemoWindow(ref bool p_open) + { + byte native_p_open_val = p_open ? (byte)1 : (byte)0; + byte* native_p_open = &native_p_open_val; + ImPlotNative.ImPlot_ShowDemoWindow(native_p_open); + p_open = native_p_open_val != 0; + } + public static void ShowMetricsWindow() + { + byte* p_popen = null; + ImPlotNative.ImPlot_ShowMetricsWindow(p_popen); + } + public static void ShowMetricsWindow(ref bool p_popen) + { + byte native_p_popen_val = p_popen ? (byte)1 : (byte)0; + byte* native_p_popen = &native_p_popen_val; + ImPlotNative.ImPlot_ShowMetricsWindow(native_p_popen); + p_popen = native_p_popen_val != 0; + } + public static void ShowStyleEditor() + { + ImPlotStyle* @ref = null; + ImPlotNative.ImPlot_ShowStyleEditor(@ref); + } + public static void ShowStyleEditor(ImPlotStylePtr @ref) + { + ImPlotStyle* native_ref = @ref.NativePtr; + ImPlotNative.ImPlot_ShowStyleEditor(native_ref); + } + public static bool ShowStyleSelector(string label) + { + byte* native_label; + int label_byteCount = 0; + if (label != null) + { + label_byteCount = Encoding.UTF8.GetByteCount(label); + if (label_byteCount > Util.StackAllocationSizeLimit) + { + native_label = Util.Allocate(label_byteCount + 1); + } + else + { + byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1]; + native_label = native_label_stackBytes; + } + int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount); + native_label[native_label_offset] = 0; + } + else { native_label = null; } + byte ret = ImPlotNative.ImPlot_ShowStyleSelector(native_label); + if (label_byteCount > Util.StackAllocationSizeLimit) + { + Util.Free(native_label); + } + return ret != 0; + } + public static void ShowUserGuide() + { + ImPlotNative.ImPlot_ShowUserGuide(); + } + public static void StyleColorsAuto() + { + ImPlotStyle* dst = null; + ImPlotNative.ImPlot_StyleColorsAuto(dst); + } + public static void StyleColorsAuto(ImPlotStylePtr dst) + { + ImPlotStyle* native_dst = dst.NativePtr; + ImPlotNative.ImPlot_StyleColorsAuto(native_dst); + } + public static void StyleColorsClassic() + { + ImPlotStyle* dst = null; + ImPlotNative.ImPlot_StyleColorsClassic(dst); + } + public static void StyleColorsClassic(ImPlotStylePtr dst) + { + ImPlotStyle* native_dst = dst.NativePtr; + ImPlotNative.ImPlot_StyleColorsClassic(native_dst); + } + public static void StyleColorsDark() + { + ImPlotStyle* dst = null; + ImPlotNative.ImPlot_StyleColorsDark(dst); + } + public static void StyleColorsDark(ImPlotStylePtr dst) + { + ImPlotStyle* native_dst = dst.NativePtr; + ImPlotNative.ImPlot_StyleColorsDark(native_dst); + } + public static void StyleColorsLight() + { + ImPlotStyle* dst = null; + ImPlotNative.ImPlot_StyleColorsLight(dst); + } + public static void StyleColorsLight(ImPlotStylePtr dst) + { + ImPlotStyle* native_dst = dst.NativePtr; + ImPlotNative.ImPlot_StyleColorsLight(native_dst); + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs new file mode 100644 index 0000000..7da9bd3 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotCol.gen.cs b/src/ImPlot.NET/Generated/ImPlotCol.gen.cs new file mode 100644 index 0000000..4272f15 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotColormap.gen.cs b/src/ImPlot.NET/Generated/ImPlotColormap.gen.cs new file mode 100644 index 0000000..d6f3384 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotFlags.gen.cs new file mode 100644 index 0000000..f865161 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs b/src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs new file mode 100644 index 0000000..5317c53 --- /dev/null +++ b/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(&NativePtr->PanButton); + public ref ImGuiKeyModFlags PanMod => ref Unsafe.AsRef(&NativePtr->PanMod); + public ref ImGuiMouseButton FitButton => ref Unsafe.AsRef(&NativePtr->FitButton); + public ref ImGuiMouseButton ContextMenuButton => ref Unsafe.AsRef(&NativePtr->ContextMenuButton); + public ref ImGuiMouseButton BoxSelectButton => ref Unsafe.AsRef(&NativePtr->BoxSelectButton); + public ref ImGuiKeyModFlags BoxSelectMod => ref Unsafe.AsRef(&NativePtr->BoxSelectMod); + public ref ImGuiMouseButton BoxSelectCancelButton => ref Unsafe.AsRef(&NativePtr->BoxSelectCancelButton); + public ref ImGuiMouseButton QueryButton => ref Unsafe.AsRef(&NativePtr->QueryButton); + public ref ImGuiKeyModFlags QueryMod => ref Unsafe.AsRef(&NativePtr->QueryMod); + public ref ImGuiKeyModFlags QueryToggleMod => ref Unsafe.AsRef(&NativePtr->QueryToggleMod); + public ref ImGuiKeyModFlags HorizontalMod => ref Unsafe.AsRef(&NativePtr->HorizontalMod); + public ref ImGuiKeyModFlags VerticalMod => ref Unsafe.AsRef(&NativePtr->VerticalMod); + public void Destroy() + { + ImPlotNative.ImPlotInputMap_destroy((ImPlotInputMap*)(NativePtr)); + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotLimits.gen.cs b/src/ImPlot.NET/Generated/ImPlotLimits.gen.cs new file mode 100644 index 0000000..78ddb38 --- /dev/null +++ b/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(&NativePtr->X); + public ref ImPlotRange Y => ref Unsafe.AsRef(&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; + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotLocation.gen.cs b/src/ImPlot.NET/Generated/ImPlotLocation.gen.cs new file mode 100644 index 0000000..8d29854 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotMarker.gen.cs b/src/ImPlot.NET/Generated/ImPlotMarker.gen.cs new file mode 100644 index 0000000..b97b1a7 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotNative.gen.cs b/src/ImPlot.NET/Generated/ImPlotNative.gen.cs new file mode 100644 index 0000000..82699e4 --- /dev/null +++ b/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(); + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotOrientation.gen.cs b/src/ImPlot.NET/Generated/ImPlotOrientation.gen.cs new file mode 100644 index 0000000..61cf545 --- /dev/null +++ b/src/ImPlot.NET/Generated/ImPlotOrientation.gen.cs @@ -0,0 +1,8 @@ +namespace ImGuiNET +{ + public enum ImPlotOrientation + { + Horizontal = 0, + Vertical = 1, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotPoint.gen.cs b/src/ImPlot.NET/Generated/ImPlotPoint.gen.cs new file mode 100644 index 0000000..030f4e5 --- /dev/null +++ b/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(&NativePtr->x); + public ref double y => ref Unsafe.AsRef(&NativePtr->y); + public void Destroy() + { + ImPlotNative.ImPlotPoint_destroy((ImPlotPoint*)(NativePtr)); + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotRange.gen.cs b/src/ImPlot.NET/Generated/ImPlotRange.gen.cs new file mode 100644 index 0000000..30d837e --- /dev/null +++ b/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(&NativePtr->Min); + public ref double Max => ref Unsafe.AsRef(&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; + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotStyle.gen.cs b/src/ImPlot.NET/Generated/ImPlotStyle.gen.cs new file mode 100644 index 0000000..c7c5044 --- /dev/null +++ b/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(&NativePtr->LineWeight); + public ref int Marker => ref Unsafe.AsRef(&NativePtr->Marker); + public ref float MarkerSize => ref Unsafe.AsRef(&NativePtr->MarkerSize); + public ref float MarkerWeight => ref Unsafe.AsRef(&NativePtr->MarkerWeight); + public ref float FillAlpha => ref Unsafe.AsRef(&NativePtr->FillAlpha); + public ref float ErrorBarSize => ref Unsafe.AsRef(&NativePtr->ErrorBarSize); + public ref float ErrorBarWeight => ref Unsafe.AsRef(&NativePtr->ErrorBarWeight); + public ref float DigitalBitHeight => ref Unsafe.AsRef(&NativePtr->DigitalBitHeight); + public ref float DigitalBitGap => ref Unsafe.AsRef(&NativePtr->DigitalBitGap); + public ref float PlotBorderSize => ref Unsafe.AsRef(&NativePtr->PlotBorderSize); + public ref float MinorAlpha => ref Unsafe.AsRef(&NativePtr->MinorAlpha); + public ref Vector2 MajorTickLen => ref Unsafe.AsRef(&NativePtr->MajorTickLen); + public ref Vector2 MinorTickLen => ref Unsafe.AsRef(&NativePtr->MinorTickLen); + public ref Vector2 MajorTickSize => ref Unsafe.AsRef(&NativePtr->MajorTickSize); + public ref Vector2 MinorTickSize => ref Unsafe.AsRef(&NativePtr->MinorTickSize); + public ref Vector2 MajorGridSize => ref Unsafe.AsRef(&NativePtr->MajorGridSize); + public ref Vector2 MinorGridSize => ref Unsafe.AsRef(&NativePtr->MinorGridSize); + public ref Vector2 PlotPadding => ref Unsafe.AsRef(&NativePtr->PlotPadding); + public ref Vector2 LabelPadding => ref Unsafe.AsRef(&NativePtr->LabelPadding); + public ref Vector2 LegendPadding => ref Unsafe.AsRef(&NativePtr->LegendPadding); + public ref Vector2 LegendInnerPadding => ref Unsafe.AsRef(&NativePtr->LegendInnerPadding); + public ref Vector2 LegendSpacing => ref Unsafe.AsRef(&NativePtr->LegendSpacing); + public ref Vector2 MousePosPadding => ref Unsafe.AsRef(&NativePtr->MousePosPadding); + public ref Vector2 AnnotationPadding => ref Unsafe.AsRef(&NativePtr->AnnotationPadding); + public ref Vector2 PlotDefaultSize => ref Unsafe.AsRef(&NativePtr->PlotDefaultSize); + public ref Vector2 PlotMinSize => ref Unsafe.AsRef(&NativePtr->PlotMinSize); + public RangeAccessor Colors => new RangeAccessor(&NativePtr->Colors_0, 24); + public ref bool AntiAliasedLines => ref Unsafe.AsRef(&NativePtr->AntiAliasedLines); + public ref bool UseLocalTime => ref Unsafe.AsRef(&NativePtr->UseLocalTime); + public ref bool UseISO8601 => ref Unsafe.AsRef(&NativePtr->UseISO8601); + public ref bool Use24HourClock => ref Unsafe.AsRef(&NativePtr->Use24HourClock); + public void Destroy() + { + ImPlotNative.ImPlotStyle_destroy((ImPlotStyle*)(NativePtr)); + } + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs b/src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs new file mode 100644 index 0000000..2e8a881 --- /dev/null +++ b/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, + } +} diff --git a/src/ImPlot.NET/Generated/ImPlotYAxis.gen.cs b/src/ImPlot.NET/Generated/ImPlotYAxis.gen.cs new file mode 100644 index 0000000..fdd5797 --- /dev/null +++ b/src/ImPlot.NET/Generated/ImPlotYAxis.gen.cs @@ -0,0 +1,9 @@ +namespace ImGuiNET +{ + public enum ImPlotYAxis + { + _1 = 0, + _2 = 1, + _3 = 2, + } +}