mirror of
https://github.com/goatcorp/Dalamud.git
synced 2025-12-15 05:04:15 +01:00
5042 lines
134 KiB
C#
5042 lines
134 KiB
C#
// ------------------------------------------------------------------------------
|
|
// <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 PlotDigital(string labelId, ulong* xs, ulong* ys, 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;
|
|
}
|
|
PlotDigitalNative(pStr0, xs, ys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count, int offset)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ulong* ys, int count, int offset, int stride)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ulong* ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ulong* ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, flags, offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, flags, offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ulong* ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, ys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ulong* xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ulong* xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ulong* xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, flags, offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ulong* xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, xs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(byte* labelId, ref ulong xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative(labelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ref byte labelId, ref ulong xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, stride);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count, int offset)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(ReadOnlySpan<byte> labelId, ref ulong xs, ref ulong ys, int count, int offset, int stride)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
fixed (ulong* pxs = &xs)
|
|
{
|
|
fixed (ulong* pys = &ys)
|
|
{
|
|
PlotDigitalNative((byte*)plabelId, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, flags, offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, flags, offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, flags, (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), (int)(0), (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, (int)(sizeof(ulong)));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDigital(string labelId, ref ulong xs, ref ulong ys, 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)
|
|
{
|
|
PlotDigitalNative(pStr0, (ulong*)pxs, (ulong*)pys, count, (ImPlotDigitalFlags)(0), offset, stride);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PlotImageNative(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte*, ImTextureID, ImPlotPoint, ImPlotPoint, Vector2, Vector2, Vector4, ImPlotImageFlags, void>)funcTable[253])(labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, ImTextureID, ImPlotPoint, ImPlotPoint, Vector2, Vector2, Vector4, ImPlotImageFlags, void>)funcTable[253])((nint)labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(byte* labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
PlotImageNative(labelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ref byte labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(ReadOnlySpan<byte> labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol, ImPlotImageFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotImageNative((byte*)plabelId, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, Vector4 tintCol)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, uv1, tintCol, (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol)
|
|
{
|
|
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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, (ImPlotImageFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector2 uv1, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, uv1, (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), (Vector4)(new Vector4(1,1,1,1)), flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector2 uv0, Vector4 tintCol, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, uv0, (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotImage(string labelId, ImTextureID userTextureId, ImPlotPoint boundsMin, ImPlotPoint boundsMax, Vector4 tintCol, ImPlotImageFlags 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;
|
|
}
|
|
PlotImageNative(pStr0, userTextureId, boundsMin, boundsMax, (Vector2)(new Vector2(0,0)), (Vector2)(new Vector2(1,1)), tintCol, flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PlotTextNative(byte* text, double x, double y, Vector2 pixOffset, ImPlotTextFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte*, double, double, Vector2, ImPlotTextFlags, void>)funcTable[254])(text, x, y, pixOffset, flags);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, double, double, Vector2, ImPlotTextFlags, void>)funcTable[254])((nint)text, x, y, pixOffset, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(byte* text, double x, double y, Vector2 pixOffset, ImPlotTextFlags flags)
|
|
{
|
|
PlotTextNative(text, x, y, pixOffset, flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(byte* text, double x, double y, Vector2 pixOffset)
|
|
{
|
|
PlotTextNative(text, x, y, pixOffset, (ImPlotTextFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(byte* text, double x, double y)
|
|
{
|
|
PlotTextNative(text, x, y, (Vector2)(new Vector2(0,0)), (ImPlotTextFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(byte* text, double x, double y, ImPlotTextFlags flags)
|
|
{
|
|
PlotTextNative(text, x, y, (Vector2)(new Vector2(0,0)), flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ref byte text, double x, double y, Vector2 pixOffset, ImPlotTextFlags flags)
|
|
{
|
|
fixed (byte* ptext = &text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, pixOffset, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ref byte text, double x, double y, Vector2 pixOffset)
|
|
{
|
|
fixed (byte* ptext = &text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, pixOffset, (ImPlotTextFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ref byte text, double x, double y)
|
|
{
|
|
fixed (byte* ptext = &text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, (Vector2)(new Vector2(0,0)), (ImPlotTextFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ref byte text, double x, double y, ImPlotTextFlags flags)
|
|
{
|
|
fixed (byte* ptext = &text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, (Vector2)(new Vector2(0,0)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ReadOnlySpan<byte> text, double x, double y, Vector2 pixOffset, ImPlotTextFlags flags)
|
|
{
|
|
fixed (byte* ptext = text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, pixOffset, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ReadOnlySpan<byte> text, double x, double y, Vector2 pixOffset)
|
|
{
|
|
fixed (byte* ptext = text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, pixOffset, (ImPlotTextFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ReadOnlySpan<byte> text, double x, double y)
|
|
{
|
|
fixed (byte* ptext = text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, (Vector2)(new Vector2(0,0)), (ImPlotTextFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(ReadOnlySpan<byte> text, double x, double y, ImPlotTextFlags flags)
|
|
{
|
|
fixed (byte* ptext = text)
|
|
{
|
|
PlotTextNative((byte*)ptext, x, y, (Vector2)(new Vector2(0,0)), flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(string text, double x, double y, Vector2 pixOffset, ImPlotTextFlags flags)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (text != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(text);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
PlotTextNative(pStr0, x, y, pixOffset, flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(string text, double x, double y, Vector2 pixOffset)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (text != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(text);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
PlotTextNative(pStr0, x, y, pixOffset, (ImPlotTextFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(string text, double x, double y)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (text != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(text);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
PlotTextNative(pStr0, x, y, (Vector2)(new Vector2(0,0)), (ImPlotTextFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotText(string text, double x, double y, ImPlotTextFlags flags)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (text != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(text);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
PlotTextNative(pStr0, x, y, (Vector2)(new Vector2(0,0)), flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PlotDummyNative(byte* labelId, ImPlotDummyFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte*, ImPlotDummyFlags, void>)funcTable[255])(labelId, flags);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, ImPlotDummyFlags, void>)funcTable[255])((nint)labelId, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(byte* labelId, ImPlotDummyFlags flags)
|
|
{
|
|
PlotDummyNative(labelId, flags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(byte* labelId)
|
|
{
|
|
PlotDummyNative(labelId, (ImPlotDummyFlags)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(ref byte labelId, ImPlotDummyFlags flags)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotDummyNative((byte*)plabelId, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(ref byte labelId)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
PlotDummyNative((byte*)plabelId, (ImPlotDummyFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(ReadOnlySpan<byte> labelId, ImPlotDummyFlags flags)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotDummyNative((byte*)plabelId, flags);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(ReadOnlySpan<byte> labelId)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
PlotDummyNative((byte*)plabelId, (ImPlotDummyFlags)(0));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(string labelId, ImPlotDummyFlags 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;
|
|
}
|
|
PlotDummyNative(pStr0, flags);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotDummy(string labelId)
|
|
{
|
|
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;
|
|
}
|
|
PlotDummyNative(pStr0, (ImPlotDummyFlags)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte DragPointNative(int id, double* x, double* y, Vector4 col, float size, ImPlotDragToolFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, double*, double*, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[256])(id, x, y, col, size, flags);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<int, nint, nint, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[256])(id, (nint)x, (nint)y, col, size, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, double* y, Vector4 col, float size, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragPointNative(id, x, y, col, size, flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, double* y, Vector4 col, float size)
|
|
{
|
|
byte ret = DragPointNative(id, x, y, col, size, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, double* y, Vector4 col)
|
|
{
|
|
byte ret = DragPointNative(id, x, y, col, (float)(4), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, double* y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragPointNative(id, x, y, col, (float)(4), flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, double* y, Vector4 col, float size, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, y, col, size, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, double* y, Vector4 col, float size)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, y, col, size, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, double* y, Vector4 col)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, y, col, (float)(4), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, double* y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, y, col, (float)(4), flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, ref double y, Vector4 col, float size, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, x, (double*)py, col, size, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, ref double y, Vector4 col, float size)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, x, (double*)py, col, size, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, ref double y, Vector4 col)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, x, (double*)py, col, (float)(4), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, double* x, ref double y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, x, (double*)py, col, (float)(4), flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, ref double y, Vector4 col, float size, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, (double*)py, col, size, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, ref double y, Vector4 col, float size)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, (double*)py, col, size, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, ref double y, Vector4 col)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, (double*)py, col, (float)(4), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragPoint(int id, ref double x, ref double y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragPointNative(id, (double*)px, (double*)py, col, (float)(4), flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte DragLineXNative(int id, double* x, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, double*, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[257])(id, x, col, thickness, flags);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<int, nint, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[257])(id, (nint)x, col, thickness, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, double* x, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragLineXNative(id, x, col, thickness, flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, double* x, Vector4 col, float thickness)
|
|
{
|
|
byte ret = DragLineXNative(id, x, col, thickness, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, double* x, Vector4 col)
|
|
{
|
|
byte ret = DragLineXNative(id, x, col, (float)(1), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, double* x, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragLineXNative(id, x, col, (float)(1), flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, ref double x, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragLineXNative(id, (double*)px, col, thickness, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, ref double x, Vector4 col, float thickness)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragLineXNative(id, (double*)px, col, thickness, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, ref double x, Vector4 col)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragLineXNative(id, (double*)px, col, (float)(1), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineX(int id, ref double x, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px = &x)
|
|
{
|
|
byte ret = DragLineXNative(id, (double*)px, col, (float)(1), flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte DragLineYNative(int id, double* y, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, double*, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[258])(id, y, col, thickness, flags);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<int, nint, Vector4, float, ImPlotDragToolFlags, byte>)funcTable[258])(id, (nint)y, col, thickness, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, double* y, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragLineYNative(id, y, col, thickness, flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, double* y, Vector4 col, float thickness)
|
|
{
|
|
byte ret = DragLineYNative(id, y, col, thickness, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, double* y, Vector4 col)
|
|
{
|
|
byte ret = DragLineYNative(id, y, col, (float)(1), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, double* y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragLineYNative(id, y, col, (float)(1), flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, ref double y, Vector4 col, float thickness, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragLineYNative(id, (double*)py, col, thickness, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, ref double y, Vector4 col, float thickness)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragLineYNative(id, (double*)py, col, thickness, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, ref double y, Vector4 col)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragLineYNative(id, (double*)py, col, (float)(1), (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragLineY(int id, ref double y, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py = &y)
|
|
{
|
|
byte ret = DragLineYNative(id, (double*)py, col, (float)(1), flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte DragRectNative(int id, double* x1, double* y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, double*, double*, double*, double*, Vector4, ImPlotDragToolFlags, byte>)funcTable[259])(id, x1, y1, x2, y2, col, flags);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<int, nint, nint, nint, nint, Vector4, ImPlotDragToolFlags, byte>)funcTable[259])(id, (nint)x1, (nint)y1, (nint)x2, (nint)y2, col, flags);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, x2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, double* x2, double* y2, Vector4 col)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, x2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, x2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, double* x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, x2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, x2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, double* x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, x2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, x2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, double* x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, x2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, ref double x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, (double*)px2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, ref double x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, (double*)px2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, ref double x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, (double*)px2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, ref double x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, (double*)px2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, ref double x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, (double*)px2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, ref double x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, (double*)px2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, double* y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, (double*)px2, y2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, double* y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, (double*)px2, y2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, double* x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, x2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, double* x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, x2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, double* x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, x2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, double* x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, x2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, double* x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, x2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, double* x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, x2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, double* x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, x2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, double* x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, x2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, ref double x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, (double*)px2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, double* y1, ref double x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, y1, (double*)px2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, ref double x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, (double*)px2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, double* y1, ref double x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, y1, (double*)px2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, ref double x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, (double*)px2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, double* x1, ref double y1, ref double x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, x1, (double*)py1, (double*)px2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, (double*)px2, (double*)py2, col, flags);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, ref double y2, Vector4 col)
|
|
{
|
|
fixed (double* px1 = &x1)
|
|
{
|
|
fixed (double* py1 = &y1)
|
|
{
|
|
fixed (double* px2 = &x2)
|
|
{
|
|
fixed (double* py2 = &y2)
|
|
{
|
|
byte ret = DragRectNative(id, (double*)px1, (double*)py1, (double*)px2, (double*)py2, col, (ImPlotDragToolFlags)(0));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void AnnotationNative(double x, double y, Vector4 col, Vector2 pixOffset, byte clamp, byte round)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, byte, void>)funcTable[260])(x, y, col, pixOffset, clamp, round);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, byte, void>)funcTable[260])(x, y, col, pixOffset, clamp, round);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, bool round)
|
|
{
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, round ? (byte)1 : (byte)0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp)
|
|
{
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, (byte)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void AnnotationNative(double x, double y, Vector4 col, Vector2 pixOffset, byte clamp, byte* fmt)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, byte*, void>)funcTable[261])(x, y, col, pixOffset, clamp, fmt);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, nint, void>)funcTable[261])(x, y, col, pixOffset, clamp, (nint)fmt);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, byte* fmt)
|
|
{
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, fmt);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, ref byte fmt)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, ReadOnlySpan<byte> fmt)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Annotation(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, string fmt)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
AnnotationNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void AnnotationVNative(double x, double y, Vector4 col, Vector2 pixOffset, byte clamp, byte* fmt, nuint args)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, byte*, nuint, void>)funcTable[262])(x, y, col, pixOffset, clamp, fmt, args);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, double, Vector4, Vector2, byte, nint, nuint, void>)funcTable[262])(x, y, col, pixOffset, clamp, (nint)fmt, args);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void AnnotationV(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, byte* fmt, nuint args)
|
|
{
|
|
AnnotationVNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, fmt, args);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void AnnotationV(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, ref byte fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
AnnotationVNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void AnnotationV(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, ReadOnlySpan<byte> fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
AnnotationVNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void AnnotationV(double x, double y, Vector4 col, Vector2 pixOffset, bool clamp, string fmt, nuint args)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
AnnotationVNative(x, y, col, pixOffset, clamp ? (byte)1 : (byte)0, pStr0, args);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagXNative(double x, Vector4 col, byte round)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte, void>)funcTable[263])(x, col, round);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte, void>)funcTable[263])(x, col, round);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col, bool round)
|
|
{
|
|
TagXNative(x, col, round ? (byte)1 : (byte)0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col)
|
|
{
|
|
TagXNative(x, col, (byte)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagXNative(double x, Vector4 col, byte* fmt)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte*, void>)funcTable[264])(x, col, fmt);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, nint, void>)funcTable[264])(x, col, (nint)fmt);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col, byte* fmt)
|
|
{
|
|
TagXNative(x, col, fmt);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col, ref byte fmt)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
TagXNative(x, col, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col, ReadOnlySpan<byte> fmt)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
TagXNative(x, col, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagX(double x, Vector4 col, string fmt)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
TagXNative(x, col, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagXVNative(double x, Vector4 col, byte* fmt, nuint args)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte*, nuint, void>)funcTable[265])(x, col, fmt, args);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, nint, nuint, void>)funcTable[265])(x, col, (nint)fmt, args);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagXV(double x, Vector4 col, byte* fmt, nuint args)
|
|
{
|
|
TagXVNative(x, col, fmt, args);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagXV(double x, Vector4 col, ref byte fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
TagXVNative(x, col, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagXV(double x, Vector4 col, ReadOnlySpan<byte> fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
TagXVNative(x, col, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagXV(double x, Vector4 col, string fmt, nuint args)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
TagXVNative(x, col, pStr0, args);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagYNative(double y, Vector4 col, byte round)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte, void>)funcTable[266])(y, col, round);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte, void>)funcTable[266])(y, col, round);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col, bool round)
|
|
{
|
|
TagYNative(y, col, round ? (byte)1 : (byte)0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col)
|
|
{
|
|
TagYNative(y, col, (byte)(0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagYNative(double y, Vector4 col, byte* fmt)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte*, void>)funcTable[267])(y, col, fmt);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, nint, void>)funcTable[267])(y, col, (nint)fmt);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col, byte* fmt)
|
|
{
|
|
TagYNative(y, col, fmt);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col, ref byte fmt)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
TagYNative(y, col, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col, ReadOnlySpan<byte> fmt)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
TagYNative(y, col, (byte*)pfmt);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagY(double y, Vector4 col, string fmt)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
TagYNative(y, col, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void TagYVNative(double y, Vector4 col, byte* fmt, nuint args)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, byte*, nuint, void>)funcTable[268])(y, col, fmt, args);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<double, Vector4, nint, nuint, void>)funcTable[268])(y, col, (nint)fmt, args);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagYV(double y, Vector4 col, byte* fmt, nuint args)
|
|
{
|
|
TagYVNative(y, col, fmt, args);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagYV(double y, Vector4 col, ref byte fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = &fmt)
|
|
{
|
|
TagYVNative(y, col, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagYV(double y, Vector4 col, ReadOnlySpan<byte> fmt, nuint args)
|
|
{
|
|
fixed (byte* pfmt = fmt)
|
|
{
|
|
TagYVNative(y, col, (byte*)pfmt, args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void TagYV(double y, Vector4 col, string fmt, nuint args)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (fmt != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(fmt);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
TagYVNative(y, col, pStr0, args);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetAxisNative(ImAxis axis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImAxis, void>)funcTable[269])(axis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<ImAxis, void>)funcTable[269])(axis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetAxis(ImAxis axis)
|
|
{
|
|
SetAxisNative(axis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetAxesNative(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, void>)funcTable[270])(xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, void>)funcTable[270])(xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetAxes(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
SetAxesNative(xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PixelsToPlotNative(ImPlotPoint* pOut, Vector2 pix, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImPlotPoint*, Vector2, ImAxis, ImAxis, void>)funcTable[271])(pOut, pix, xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, Vector2, ImAxis, ImAxis, void>)funcTable[271])((nint)pOut, pix, xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(Vector2 pix)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, pix, (ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(Vector2 pix, ImAxis xAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, pix, xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, Vector2 pix)
|
|
{
|
|
PixelsToPlotNative(pOut, pix, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(Vector2 pix, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, pix, xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, Vector2 pix, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
PixelsToPlotNative(pOut, pix, xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, Vector2 pix, ImAxis xAxis)
|
|
{
|
|
PixelsToPlotNative(pOut, pix, xAxis, (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, Vector2 pix, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, pix, xAxis, yAxis);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, Vector2 pix, ImAxis xAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, pix, xAxis, (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, Vector2 pix)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, pix, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PixelsToPlotNative(ImPlotPoint* pOut, float x, float y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImPlotPoint*, float, float, ImAxis, ImAxis, void>)funcTable[272])(pOut, x, y, xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, float, float, ImAxis, ImAxis, void>)funcTable[272])((nint)pOut, x, y, xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(float x, float y)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(float x, float y, ImAxis xAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, x, y, xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, float x, float y)
|
|
{
|
|
PixelsToPlotNative(pOut, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint PixelsToPlot(float x, float y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
PixelsToPlotNative(&ret, x, y, xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, float x, float y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
PixelsToPlotNative(pOut, x, y, xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ImPlotPointPtr pOut, float x, float y, ImAxis xAxis)
|
|
{
|
|
PixelsToPlotNative(pOut, x, y, xAxis, (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, float x, float y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, x, y, xAxis, yAxis);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, float x, float y, ImAxis xAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, x, y, xAxis, (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PixelsToPlot(ref ImPlotPoint pOut, float x, float y)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
PixelsToPlotNative((ImPlotPoint*)ppOut, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PlotToPixelsNative(Vector2* pOut, ImPlotPoint plt, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<Vector2*, ImPlotPoint, ImAxis, ImAxis, void>)funcTable[273])(pOut, plt, xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, ImPlotPoint, ImAxis, ImAxis, void>)funcTable[273])((nint)pOut, plt, xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(ImPlotPoint plt)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, plt, (ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(ImPlotPoint plt, ImAxis xAxis)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, plt, xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, ImPlotPoint plt)
|
|
{
|
|
PlotToPixelsNative(pOut, plt, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(ImPlotPoint plt, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, plt, xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, ImPlotPoint plt, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
PlotToPixelsNative(pOut, plt, xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, ImPlotPoint plt, ImAxis xAxis)
|
|
{
|
|
PlotToPixelsNative(pOut, plt, xAxis, (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, ImPlotPoint plt, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, plt, xAxis, yAxis);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, ImPlotPoint plt, ImAxis xAxis)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, plt, xAxis, (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, ImPlotPoint plt)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, plt, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void PlotToPixelsNative(Vector2* pOut, double x, double y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<Vector2*, double, double, ImAxis, ImAxis, void>)funcTable[274])(pOut, x, y, xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, double, double, ImAxis, ImAxis, void>)funcTable[274])((nint)pOut, x, y, xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(double x, double y)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(double x, double y, ImAxis xAxis)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, x, y, xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, double x, double y)
|
|
{
|
|
PlotToPixelsNative(pOut, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 PlotToPixels(double x, double y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
Vector2 ret;
|
|
PlotToPixelsNative(&ret, x, y, xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, double x, double y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
PlotToPixelsNative(pOut, x, y, xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(Vector2* pOut, double x, double y, ImAxis xAxis)
|
|
{
|
|
PlotToPixelsNative(pOut, x, y, xAxis, (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, double x, double y, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, x, y, xAxis, yAxis);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, double x, double y, ImAxis xAxis)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, x, y, xAxis, (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void PlotToPixels(ref Vector2 pOut, double x, double y)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
PlotToPixelsNative((Vector2*)ppOut, x, y, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void GetPlotPosNative(Vector2* pOut)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<Vector2*, void>)funcTable[275])(pOut);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, void>)funcTable[275])((nint)pOut);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 GetPlotPos()
|
|
{
|
|
Vector2 ret;
|
|
GetPlotPosNative(&ret);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotPos(Vector2* pOut)
|
|
{
|
|
GetPlotPosNative(pOut);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotPos(ref Vector2 pOut)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
GetPlotPosNative((Vector2*)ppOut);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void GetPlotSizeNative(Vector2* pOut)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<Vector2*, void>)funcTable[276])(pOut);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, void>)funcTable[276])((nint)pOut);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static Vector2 GetPlotSize()
|
|
{
|
|
Vector2 ret;
|
|
GetPlotSizeNative(&ret);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotSize(Vector2* pOut)
|
|
{
|
|
GetPlotSizeNative(pOut);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotSize(ref Vector2 pOut)
|
|
{
|
|
fixed (Vector2* ppOut = &pOut)
|
|
{
|
|
GetPlotSizeNative((Vector2*)ppOut);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void GetPlotMousePosNative(ImPlotPoint* pOut, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImPlotPoint*, ImAxis, ImAxis, void>)funcTable[277])(pOut, xAxis, yAxis);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, ImAxis, ImAxis, void>)funcTable[277])((nint)pOut, xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint GetPlotMousePos()
|
|
{
|
|
ImPlotPoint ret;
|
|
GetPlotMousePosNative(&ret, (ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint GetPlotMousePos(ImAxis xAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
GetPlotMousePosNative(&ret, xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ImPlotPointPtr pOut)
|
|
{
|
|
GetPlotMousePosNative(pOut, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotPoint GetPlotMousePos(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
ImPlotPoint ret;
|
|
GetPlotMousePosNative(&ret, xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ImPlotPointPtr pOut, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
GetPlotMousePosNative(pOut, xAxis, yAxis);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ImPlotPointPtr pOut, ImAxis xAxis)
|
|
{
|
|
GetPlotMousePosNative(pOut, xAxis, (ImAxis)(-1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ref ImPlotPoint pOut, ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
GetPlotMousePosNative((ImPlotPoint*)ppOut, xAxis, yAxis);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ref ImPlotPoint pOut, ImAxis xAxis)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
GetPlotMousePosNative((ImPlotPoint*)ppOut, xAxis, (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void GetPlotMousePos(ref ImPlotPoint pOut)
|
|
{
|
|
fixed (ImPlotPoint* ppOut = &pOut)
|
|
{
|
|
GetPlotMousePosNative((ImPlotPoint*)ppOut, (ImAxis)(-1), (ImAxis)(-1));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static ImPlotRect GetPlotLimitsNative(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, ImPlotRect>)funcTable[278])(xAxis, yAxis);
|
|
#else
|
|
return (ImPlotRect)((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, ImPlotRect>)funcTable[278])(xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotLimits(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
ImPlotRect ret = GetPlotLimitsNative(xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotLimits(ImAxis xAxis)
|
|
{
|
|
ImPlotRect ret = GetPlotLimitsNative(xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotLimits()
|
|
{
|
|
ImPlotRect ret = GetPlotLimitsNative((ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsPlotHoveredNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte>)funcTable[279])();
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[279])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsPlotHovered()
|
|
{
|
|
byte ret = IsPlotHoveredNative();
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsAxisHoveredNative(ImAxis axis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<ImAxis, byte>)funcTable[280])(axis);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<ImAxis, byte>)funcTable[280])(axis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsAxisHovered(ImAxis axis)
|
|
{
|
|
byte ret = IsAxisHoveredNative(axis);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsSubplotsHoveredNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte>)funcTable[281])();
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[281])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsSubplotsHovered()
|
|
{
|
|
byte ret = IsSubplotsHoveredNative();
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsPlotSelectedNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte>)funcTable[282])();
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[282])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsPlotSelected()
|
|
{
|
|
byte ret = IsPlotSelectedNative();
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static ImPlotRect GetPlotSelectionNative(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, ImPlotRect>)funcTable[283])(xAxis, yAxis);
|
|
#else
|
|
return (ImPlotRect)((delegate* unmanaged[Cdecl]<ImAxis, ImAxis, ImPlotRect>)funcTable[283])(xAxis, yAxis);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotSelection(ImAxis xAxis, ImAxis yAxis)
|
|
{
|
|
ImPlotRect ret = GetPlotSelectionNative(xAxis, yAxis);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotSelection(ImAxis xAxis)
|
|
{
|
|
ImPlotRect ret = GetPlotSelectionNative(xAxis, (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static ImPlotRect GetPlotSelection()
|
|
{
|
|
ImPlotRect ret = GetPlotSelectionNative((ImAxis)(-1), (ImAxis)(-1));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void CancelPlotSelectionNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[284])();
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[284])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void CancelPlotSelection()
|
|
{
|
|
CancelPlotSelectionNative();
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void HideNextItemNative(byte hidden, ImPlotCond cond)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte, ImPlotCond, void>)funcTable[285])(hidden, cond);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<byte, ImPlotCond, void>)funcTable[285])(hidden, cond);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void HideNextItem(bool hidden, ImPlotCond cond)
|
|
{
|
|
HideNextItemNative(hidden ? (byte)1 : (byte)0, cond);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void HideNextItem(bool hidden)
|
|
{
|
|
HideNextItemNative(hidden ? (byte)1 : (byte)0, (ImPlotCond)(ImPlotCond.Once));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void HideNextItem()
|
|
{
|
|
HideNextItemNative((byte)(1), (ImPlotCond)(ImPlotCond.Once));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void HideNextItem(ImPlotCond cond)
|
|
{
|
|
HideNextItemNative((byte)(1), cond);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte BeginAlignedPlotsNative(byte* groupId, byte vertical)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte, byte>)funcTable[286])(groupId, vertical);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<nint, byte, byte>)funcTable[286])((nint)groupId, vertical);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(byte* groupId, bool vertical)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative(groupId, vertical ? (byte)1 : (byte)0);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(byte* groupId)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative(groupId, (byte)(1));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(ref byte groupId, bool vertical)
|
|
{
|
|
fixed (byte* pgroupId = &groupId)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative((byte*)pgroupId, vertical ? (byte)1 : (byte)0);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(ref byte groupId)
|
|
{
|
|
fixed (byte* pgroupId = &groupId)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative((byte*)pgroupId, (byte)(1));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(ReadOnlySpan<byte> groupId, bool vertical)
|
|
{
|
|
fixed (byte* pgroupId = groupId)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative((byte*)pgroupId, vertical ? (byte)1 : (byte)0);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(ReadOnlySpan<byte> groupId)
|
|
{
|
|
fixed (byte* pgroupId = groupId)
|
|
{
|
|
byte ret = BeginAlignedPlotsNative((byte*)pgroupId, (byte)(1));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(string groupId, bool vertical)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (groupId != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(groupId);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(groupId, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte ret = BeginAlignedPlotsNative(pStr0, vertical ? (byte)1 : (byte)0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginAlignedPlots(string groupId)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (groupId != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(groupId);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(groupId, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte ret = BeginAlignedPlotsNative(pStr0, (byte)(1));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void EndAlignedPlotsNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[287])();
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[287])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void EndAlignedPlots()
|
|
{
|
|
EndAlignedPlotsNative();
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte BeginLegendPopupNative(byte* labelId, ImGuiMouseButton mouseButton)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, ImGuiMouseButton, byte>)funcTable[288])(labelId, mouseButton);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<nint, ImGuiMouseButton, byte>)funcTable[288])((nint)labelId, mouseButton);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(byte* labelId, ImGuiMouseButton mouseButton)
|
|
{
|
|
byte ret = BeginLegendPopupNative(labelId, mouseButton);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(byte* labelId)
|
|
{
|
|
byte ret = BeginLegendPopupNative(labelId, (ImGuiMouseButton)(1));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(ref byte labelId, ImGuiMouseButton mouseButton)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
byte ret = BeginLegendPopupNative((byte*)plabelId, mouseButton);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(ref byte labelId)
|
|
{
|
|
fixed (byte* plabelId = &labelId)
|
|
{
|
|
byte ret = BeginLegendPopupNative((byte*)plabelId, (ImGuiMouseButton)(1));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(ReadOnlySpan<byte> labelId, ImGuiMouseButton mouseButton)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
byte ret = BeginLegendPopupNative((byte*)plabelId, mouseButton);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(ReadOnlySpan<byte> labelId)
|
|
{
|
|
fixed (byte* plabelId = labelId)
|
|
{
|
|
byte ret = BeginLegendPopupNative((byte*)plabelId, (ImGuiMouseButton)(1));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool BeginLegendPopup(string labelId, ImGuiMouseButton mouseButton)
|
|
{
|
|
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;
|
|
}
|
|
byte ret = BeginLegendPopupNative(pStr0, mouseButton);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|