ToxicMushroom/Dalamud
1
0
Fork 0
mirror of https://github.com/goatcorp/Dalamud.git synced 2025-12-12 18:27:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
Dalamud/imgui/Dalamud.Bindings.ImPlot/Generated/Functions/Functions.070.cs
goaaats b5a8bfe399 move bindings around
2025-04-06 21:08:34 +02:00

5034 lines
141 KiB
C#
Raw Blame History

// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using HexaGen.Runtime;
using System.Numerics;
using Dalamud.Bindings.ImGui;
namespace Dalamud.Bindings.ImPlot
{
public unsafe partial class ImPlot
{
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ulong* neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, neg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ulong* ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, ys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ulong* xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, xs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(byte* labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(labelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ref byte labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, flags, (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), (int)(0), (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, (int)(sizeof(ulong)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotErrorBars(string labelId, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (ulong* pxs = &xs)
{
fixed (ulong* pys = &ys)
{
fixed (ulong* pneg = &neg)
{
fixed (ulong* ppos = &pos)
{
PlotErrorBarsNative(pStr0, (ulong*)pxs, (ulong*)pys, (ulong*)pneg, (ulong*)ppos, count, (ImPlotErrorBarsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
}
/// <summary>
/// To be documented.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void PlotStemsNative(byte* labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl]<byte*, float*, int, double, double, double, ImPlotStemsFlags, int, int, void>)funcTable[181])(labelId, values, count, reference, scale, start, flags, offset, stride);
#else
((delegate* unmanaged[Cdecl]<nint, nint, int, double, double, double, ImPlotStemsFlags, int, int, void>)funcTable[181])((nint)labelId, (nint)values, count, reference, scale, start, flags, offset, stride);
#endif
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, scale, start, flags, offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
PlotStemsNative(labelId, values, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
PlotStemsNative(labelId, values, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start)
{
PlotStemsNative(labelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, ImPlotStemsFlags flags)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, ImPlotStemsFlags flags)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start, int offset)
{
PlotStemsNative(labelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, int offset)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, int offset)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, int offset)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, ImPlotStemsFlags flags, int offset)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, double start, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, int offset, int stride)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, scale, (double)(0), flags, offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
PlotStemsNative(labelId, values, count, reference, (double)(1), (double)(0), flags, offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, float* values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
PlotStemsNative(labelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, double start, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, float* values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, double start, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, scale, (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, reference, (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, float* values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
PlotStemsNative((byte*)plabelId, values, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, ImPlotStemsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, ImPlotStemsFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, ImPlotStemsFlags flags, int offset)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, double start, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, scale, (double)(0), flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, reference, (double)(1), (double)(0), flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(string labelId, float* values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
PlotStemsNative(pStr0, values, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, ImPlotStemsFlags flags)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, ImPlotStemsFlags flags)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, ImPlotStemsFlags flags, int offset)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, double start, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, scale, (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(byte* labelId, ref float values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (float* pvalues = &values)
{
PlotStemsNative(labelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), flags, offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, double start, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, double scale, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, double reference, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ref byte labelId, ref float values, int count, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = &labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, offset, stride);
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags, int offset)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, offset, (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference, double scale, double start, ImPlotStemsFlags flags)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, flags, (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference, double scale, double start)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, start, (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference, double scale)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, scale, (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count, double reference)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, reference, (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
/// <summary>
/// To be documented.
/// </summary>
public static void PlotStems(ReadOnlySpan<byte> labelId, ref float values, int count)
{
fixed (byte* plabelId = labelId)
{
fixed (float* pvalues = &values)
{
PlotStemsNative((byte*)plabelId, (float*)pvalues, count, (double)(0), (double)(1), (double)(0), (ImPlotStemsFlags)(0), (int)(0), (int)(sizeof(float)));
}
}
}
}
}
Reference in a new issue View git blame Copy permalink