// ------------------------------------------------------------------------------
//
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// ------------------------------------------------------------------------------
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
{
///
/// To be documented.
///
public static bool ColormapSlider(string label, float* t, ref Vector4 output, string format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector4* poutput = &output)
{
byte* pStr1 = null;
int pStrSize1 = 0;
if (format != null)
{
pStrSize1 = Utils.GetByteCountUTF8(format);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, pStr1, (ImPlotColormap)(-1));
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, ReadOnlySpan format)
{
fixed (byte* plabel = &label)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, string format, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, string format)
{
fixed (byte* plabel = &label)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, float* t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, float* t, ref Vector4 output, ref byte format)
{
fixed (byte* plabel = label)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, float* t, ref Vector4 output, string format, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, float* t, ref Vector4 output, string format)
{
fixed (byte* plabel = label)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, float* t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, float* t, ref Vector4 output, ref byte format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, float* t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, float* t, ref Vector4 output, ReadOnlySpan format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ref byte format)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ReadOnlySpan format)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, pStr0, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, string format)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ref byte format)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, ReadOnlySpan format)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr1 = null;
int pStrSize1 = 0;
if (format != null)
{
pStrSize1 = Utils.GetByteCountUTF8(format);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, pStr1, cmap);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, string format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr1 = null;
int pStrSize1 = 0;
if (format != null)
{
pStrSize1 = Utils.GetByteCountUTF8(format);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, pStr1, (ImPlotColormap)(-1));
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ReadOnlySpan format)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, string format)
{
fixed (byte* plabel = &label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, ref byte format)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
return ret != 0;
}
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(ReadOnlySpan label, ref float t, ref Vector4 output, string format)
{
fixed (byte* plabel = label)
{
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (format != null)
{
pStrSize0 = Utils.GetByteCountUTF8(format);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ref byte format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = &format)
{
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ReadOnlySpan format, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ReadOnlySpan format)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (float* pt = &t)
{
fixed (Vector4* poutput = &output)
{
fixed (byte* pformat = format)
{
byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ColormapButtonNative(byte* label, Vector2 size, ImPlotColormap cmap)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[332])(label, size, cmap);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[332])((nint)label, size, cmap);
#endif
}
///
/// To be documented.
///
public static bool ColormapButton(byte* label, Vector2 size, ImPlotColormap cmap)
{
byte ret = ColormapButtonNative(label, size, cmap);
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(byte* label, Vector2 size)
{
byte ret = ColormapButtonNative(label, size, (ImPlotColormap)(-1));
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(byte* label)
{
byte ret = ColormapButtonNative(label, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(byte* label, ImPlotColormap cmap)
{
byte ret = ColormapButtonNative(label, (Vector2)(new Vector2(0,0)), cmap);
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(ref byte label, Vector2 size, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
byte ret = ColormapButtonNative((byte*)plabel, size, cmap);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ref byte label, Vector2 size)
{
fixed (byte* plabel = &label)
{
byte ret = ColormapButtonNative((byte*)plabel, size, (ImPlotColormap)(-1));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ref byte label, ImPlotColormap cmap)
{
fixed (byte* plabel = &label)
{
byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), cmap);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ReadOnlySpan label, Vector2 size, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
byte ret = ColormapButtonNative((byte*)plabel, size, cmap);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ReadOnlySpan label, Vector2 size)
{
fixed (byte* plabel = label)
{
byte ret = ColormapButtonNative((byte*)plabel, size, (ImPlotColormap)(-1));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(ReadOnlySpan label, ImPlotColormap cmap)
{
fixed (byte* plabel = label)
{
byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), cmap);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ColormapButton(string label, Vector2 size, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapButtonNative(pStr0, size, cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(string label, Vector2 size)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapButtonNative(pStr0, size, (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(string label)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapButtonNative(pStr0, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ColormapButton(string label, ImPlotColormap cmap)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ColormapButtonNative(pStr0, (Vector2)(new Vector2(0,0)), cmap);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void BustColorCacheNative(byte* plotTitleId)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[333])(plotTitleId);
#else
((delegate* unmanaged[Cdecl])funcTable[333])((nint)plotTitleId);
#endif
}
///
/// To be documented.
///
public static void BustColorCache(byte* plotTitleId)
{
BustColorCacheNative(plotTitleId);
}
///
/// To be documented.
///
public static void BustColorCache()
{
BustColorCacheNative((byte*)(((void*)0)));
}
///
/// To be documented.
///
public static void BustColorCache(ref byte plotTitleId)
{
fixed (byte* pplotTitleId = &plotTitleId)
{
BustColorCacheNative((byte*)pplotTitleId);
}
}
///
/// To be documented.
///
public static void BustColorCache(ReadOnlySpan plotTitleId)
{
fixed (byte* pplotTitleId = plotTitleId)
{
BustColorCacheNative((byte*)pplotTitleId);
}
}
///
/// To be documented.
///
public static void BustColorCache(string plotTitleId)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (plotTitleId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(plotTitleId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(plotTitleId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
BustColorCacheNative(pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ImPlotInputMap* GetInputMapNative()
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[334])();
#else
return (ImPlotInputMap*)((delegate* unmanaged[Cdecl])funcTable[334])();
#endif
}
///
/// To be documented.
///
public static ImPlotInputMapPtr GetInputMap()
{
ImPlotInputMapPtr ret = GetInputMapNative();
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void MapInputDefaultNative(ImPlotInputMap* dst)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[335])(dst);
#else
((delegate* unmanaged[Cdecl])funcTable[335])((nint)dst);
#endif
}
///
/// To be documented.
///
public static void MapInputDefault(ImPlotInputMapPtr dst)
{
MapInputDefaultNative(dst);
}
///
/// To be documented.
///
public static void MapInputDefault()
{
MapInputDefaultNative((ImPlotInputMap*)(((void*)0)));
}
///
/// To be documented.
///
public static void MapInputDefault(ref ImPlotInputMap dst)
{
fixed (ImPlotInputMap* pdst = &dst)
{
MapInputDefaultNative((ImPlotInputMap*)pdst);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void MapInputReverseNative(ImPlotInputMap* dst)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[336])(dst);
#else
((delegate* unmanaged[Cdecl])funcTable[336])((nint)dst);
#endif
}
///
/// To be documented.
///
public static void MapInputReverse(ImPlotInputMapPtr dst)
{
MapInputReverseNative(dst);
}
///
/// To be documented.
///
public static void MapInputReverse()
{
MapInputReverseNative((ImPlotInputMap*)(((void*)0)));
}
///
/// To be documented.
///
public static void MapInputReverse(ref ImPlotInputMap dst)
{
fixed (ImPlotInputMap* pdst = &dst)
{
MapInputReverseNative((ImPlotInputMap*)pdst);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ItemIconNative(Vector4 col)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[337])(col);
#else
((delegate* unmanaged[Cdecl])funcTable[337])(col);
#endif
}
///
/// To be documented.
///
public static void ItemIcon(Vector4 col)
{
ItemIconNative(col);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ItemIconNative(uint col)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[338])(col);
#else
((delegate* unmanaged[Cdecl])funcTable[338])(col);
#endif
}
///
/// To be documented.
///
public static void ItemIcon(uint col)
{
ItemIconNative(col);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ColormapIconNative(ImPlotColormap cmap)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[339])(cmap);
#else
((delegate* unmanaged[Cdecl])funcTable[339])(cmap);
#endif
}
///
/// To be documented.
///
public static void ColormapIcon(ImPlotColormap cmap)
{
ColormapIconNative(cmap);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ImDrawList* GetPlotDrawListNative()
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[340])();
#else
return (ImDrawList*)((delegate* unmanaged[Cdecl])funcTable[340])();
#endif
}
///
/// To be documented.
///
public static ImDrawListPtr GetPlotDrawList()
{
ImDrawListPtr ret = GetPlotDrawListNative();
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void PushPlotClipRectNative(float expand)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[341])(expand);
#else
((delegate* unmanaged[Cdecl])funcTable[341])(expand);
#endif
}
///
/// To be documented.
///
public static void PushPlotClipRect(float expand)
{
PushPlotClipRectNative(expand);
}
///
/// To be documented.
///
public static void PushPlotClipRect()
{
PushPlotClipRectNative((float)(0));
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void PopPlotClipRectNative()
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[342])();
#else
((delegate* unmanaged[Cdecl])funcTable[342])();
#endif
}
///
/// To be documented.
///
public static void PopPlotClipRect()
{
PopPlotClipRectNative();
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ShowStyleSelectorNative(byte* label)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[343])(label);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[343])((nint)label);
#endif
}
///
/// To be documented.
///
public static bool ShowStyleSelector(byte* label)
{
byte ret = ShowStyleSelectorNative(label);
return ret != 0;
}
///
/// To be documented.
///
public static bool ShowStyleSelector(ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = ShowStyleSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowStyleSelector(ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = ShowStyleSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowStyleSelector(string label)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ShowStyleSelectorNative(pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ShowColormapSelectorNative(byte* label)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[344])(label);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[344])((nint)label);
#endif
}
///
/// To be documented.
///
public static bool ShowColormapSelector(byte* label)
{
byte ret = ShowColormapSelectorNative(label);
return ret != 0;
}
///
/// To be documented.
///
public static bool ShowColormapSelector(ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = ShowColormapSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowColormapSelector(ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = ShowColormapSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowColormapSelector(string label)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ShowColormapSelectorNative(pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ShowInputMapSelectorNative(byte* label)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[345])(label);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[345])((nint)label);
#endif
}
///
/// To be documented.
///
public static bool ShowInputMapSelector(byte* label)
{
byte ret = ShowInputMapSelectorNative(label);
return ret != 0;
}
///
/// To be documented.
///
public static bool ShowInputMapSelector(ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = ShowInputMapSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowInputMapSelector(ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = ShowInputMapSelectorNative((byte*)plabel);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ShowInputMapSelector(string label)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (label != null)
{
pStrSize0 = Utils.GetByteCountUTF8(label);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ShowInputMapSelectorNative(pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ShowStyleEditorNative(ImPlotStyle* reference)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[346])(reference);
#else
((delegate* unmanaged[Cdecl])funcTable[346])((nint)reference);
#endif
}
///
/// To be documented.
///
public static void ShowStyleEditor(ImPlotStylePtr reference)
{
ShowStyleEditorNative(reference);
}
///
/// To be documented.
///
public static void ShowStyleEditor()
{
ShowStyleEditorNative((ImPlotStyle*)(((void*)0)));
}
///
/// To be documented.
///
public static void ShowStyleEditor(ref ImPlotStyle reference)
{
fixed (ImPlotStyle* preference = &reference)
{
ShowStyleEditorNative((ImPlotStyle*)preference);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ShowUserGuideNative()
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[347])();
#else
((delegate* unmanaged[Cdecl])funcTable[347])();
#endif
}
///
/// To be documented.
///
public static void ShowUserGuide()
{
ShowUserGuideNative();
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ShowMetricsWindowNative(bool* pPopen)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[348])(pPopen);
#else
((delegate* unmanaged[Cdecl])funcTable[348])((nint)pPopen);
#endif
}
///
/// To be documented.
///
public static void ShowMetricsWindow(bool* pPopen)
{
ShowMetricsWindowNative(pPopen);
}
///
/// To be documented.
///
public static void ShowMetricsWindow()
{
ShowMetricsWindowNative((bool*)(((void*)0)));
}
///
/// To be documented.
///
public static void ShowMetricsWindow(ref bool pPopen)
{
fixed (bool* ppPopen = &pPopen)
{
ShowMetricsWindowNative((bool*)ppPopen);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ShowDemoWindowNative(bool* pOpen)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[349])(pOpen);
#else
((delegate* unmanaged[Cdecl])funcTable[349])((nint)pOpen);
#endif
}
///
/// To be documented.
///
public static void ShowDemoWindow(bool* pOpen)
{
ShowDemoWindowNative(pOpen);
}
///
/// To be documented.
///
public static void ShowDemoWindow()
{
ShowDemoWindowNative((bool*)(((void*)0)));
}
///
/// To be documented.
///
public static void ShowDemoWindow(ref bool pOpen)
{
fixed (bool* ppOpen = &pOpen)
{
ShowDemoWindowNative((bool*)ppOpen);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImLog10Native(float x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[350])(x);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[350])(x);
#endif
}
///
/// To be documented.
///
public static float ImLog10(float x)
{
float ret = ImLog10Native(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImLog10Native(double x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[351])(x);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[351])(x);
#endif
}
///
/// To be documented.
///
public static double ImLog10(double x)
{
double ret = ImLog10Native(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImSinhNative(float x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[352])(x);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[352])(x);
#endif
}
///
/// To be documented.
///
public static float ImSinh(float x)
{
float ret = ImSinhNative(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImSinhNative(double x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[353])(x);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[353])(x);
#endif
}
///
/// To be documented.
///
public static double ImSinh(double x)
{
double ret = ImSinhNative(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImAsinhNative(float x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[354])(x);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[354])(x);
#endif
}
///
/// To be documented.
///
public static float ImAsinh(float x)
{
float ret = ImAsinhNative(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImAsinhNative(double x)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[355])(x);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[355])(x);
#endif
}
///
/// To be documented.
///
public static double ImAsinh(double x)
{
double ret = ImAsinhNative(x);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImRemapNative(float x, float x0, float x1, float y0, float y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[356])(x, x0, x1, y0, y1);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[356])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static float ImRemap(float x, float x0, float x1, float y0, float y1)
{
float ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImRemapNative(double x, double x0, double x1, double y0, double y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[357])(x, x0, x1, y0, y1);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[357])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static double ImRemap(double x, double x0, double x1, double y0, double y1)
{
double ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImRemapNative(byte x, byte x0, byte x1, byte y0, byte y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[358])(x, x0, x1, y0, y1);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[358])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static byte ImRemap(byte x, byte x0, byte x1, byte y0, byte y1)
{
byte ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static short ImRemapNative(short x, short x0, short x1, short y0, short y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[359])(x, x0, x1, y0, y1);
#else
return (short)((delegate* unmanaged[Cdecl])funcTable[359])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static short ImRemap(short x, short x0, short x1, short y0, short y1)
{
short ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ushort ImRemapNative(ushort x, ushort x0, ushort x1, ushort y0, ushort y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[360])(x, x0, x1, y0, y1);
#else
return (ushort)((delegate* unmanaged[Cdecl])funcTable[360])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static ushort ImRemap(ushort x, ushort x0, ushort x1, ushort y0, ushort y1)
{
ushort ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImRemapNative(int x, int x0, int x1, int y0, int y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[361])(x, x0, x1, y0, y1);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[361])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static int ImRemap(int x, int x0, int x1, int y0, int y1)
{
int ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint ImRemapNative(uint x, uint x0, uint x1, uint y0, uint y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[362])(x, x0, x1, y0, y1);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[362])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static uint ImRemap(uint x, uint x0, uint x1, uint y0, uint y1)
{
uint ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ImRemapNative(long x, long x0, long x1, long y0, long y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[363])(x, x0, x1, y0, y1);
#else
return (long)((delegate* unmanaged[Cdecl])funcTable[363])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static long ImRemap(long x, long x0, long x1, long y0, long y1)
{
long ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ulong ImRemapNative(ulong x, ulong x0, ulong x1, ulong y0, ulong y1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[364])(x, x0, x1, y0, y1);
#else
return (ulong)((delegate* unmanaged[Cdecl])funcTable[364])(x, x0, x1, y0, y1);
#endif
}
///
/// To be documented.
///
public static ulong ImRemap(ulong x, ulong x0, ulong x1, ulong y0, ulong y1)
{
ulong ret = ImRemapNative(x, x0, x1, y0, y1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImRemap01Native(float x, float x0, float x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[365])(x, x0, x1);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[365])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static float ImRemap01(float x, float x0, float x1)
{
float ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImRemap01Native(double x, double x0, double x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[366])(x, x0, x1);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[366])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static double ImRemap01(double x, double x0, double x1)
{
double ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImRemap01Native(byte x, byte x0, byte x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[367])(x, x0, x1);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[367])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static byte ImRemap01(byte x, byte x0, byte x1)
{
byte ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static short ImRemap01Native(short x, short x0, short x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[368])(x, x0, x1);
#else
return (short)((delegate* unmanaged[Cdecl])funcTable[368])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static short ImRemap01(short x, short x0, short x1)
{
short ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ushort ImRemap01Native(ushort x, ushort x0, ushort x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[369])(x, x0, x1);
#else
return (ushort)((delegate* unmanaged[Cdecl])funcTable[369])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static ushort ImRemap01(ushort x, ushort x0, ushort x1)
{
ushort ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImRemap01Native(int x, int x0, int x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[370])(x, x0, x1);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[370])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static int ImRemap01(int x, int x0, int x1)
{
int ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint ImRemap01Native(uint x, uint x0, uint x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[371])(x, x0, x1);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[371])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static uint ImRemap01(uint x, uint x0, uint x1)
{
uint ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ImRemap01Native(long x, long x0, long x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[372])(x, x0, x1);
#else
return (long)((delegate* unmanaged[Cdecl])funcTable[372])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static long ImRemap01(long x, long x0, long x1)
{
long ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ulong ImRemap01Native(ulong x, ulong x0, ulong x1)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[373])(x, x0, x1);
#else
return (ulong)((delegate* unmanaged[Cdecl])funcTable[373])(x, x0, x1);
#endif
}
///
/// To be documented.
///
public static ulong ImRemap01(ulong x, ulong x0, ulong x1)
{
ulong ret = ImRemap01Native(x, x0, x1);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImPosModNative(int l, int r)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[374])(l, r);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[374])(l, r);
#endif
}
///
/// To be documented.
///
public static int ImPosMod(int l, int r)
{
int ret = ImPosModNative(l, r);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImNanNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[375])(val);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[375])(val);
#endif
}
///
/// To be documented.
///
public static bool ImNan(double val)
{
byte ret = ImNanNative(val);
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImNanOrInfNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[376])(val);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[376])(val);
#endif
}
///
/// To be documented.
///
public static bool ImNanOrInf(double val)
{
byte ret = ImNanOrInfNative(val);
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImConstrainNanNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[377])(val);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[377])(val);
#endif
}
///
/// To be documented.
///
public static double ImConstrainNan(double val)
{
double ret = ImConstrainNanNative(val);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImConstrainInfNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[378])(val);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[378])(val);
#endif
}
///
/// To be documented.
///
public static double ImConstrainInf(double val)
{
double ret = ImConstrainInfNative(val);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImConstrainLogNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[379])(val);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[379])(val);
#endif
}
///
/// To be documented.
///
public static double ImConstrainLog(double val)
{
double ret = ImConstrainLogNative(val);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImConstrainTimeNative(double val)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[380])(val);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[380])(val);
#endif
}
///
/// To be documented.
///
public static double ImConstrainTime(double val)
{
double ret = ImConstrainTimeNative(val);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImAlmostEqualNative(double v1, double v2, int ulp)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[381])(v1, v2, ulp);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[381])(v1, v2, ulp);
#endif
}
///
/// To be documented.
///
public static bool ImAlmostEqual(double v1, double v2, int ulp)
{
byte ret = ImAlmostEqualNative(v1, v2, ulp);
return ret != 0;
}
///
/// To be documented.
///
public static bool ImAlmostEqual(double v1, double v2)
{
byte ret = ImAlmostEqualNative(v1, v2, (int)(2));
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImMinArrayNative(float* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[382])(values, count);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[382])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static float ImMinArray(float* values, int count)
{
float ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static float ImMinArray(ref float values, int count)
{
fixed (float* pvalues = &values)
{
float ret = ImMinArrayNative((float*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMinArrayNative(double* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[383])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[383])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMinArray(double* values, int count)
{
double ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMinArray(ref double values, int count)
{
fixed (double* pvalues = &values)
{
double ret = ImMinArrayNative((double*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImMinArrayNative(byte* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[384])(values, count);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[384])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static byte ImMinArray(byte* values, int count)
{
byte ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static byte ImMinArray(ref byte values, int count)
{
fixed (byte* pvalues = &values)
{
byte ret = ImMinArrayNative((byte*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static short ImMinArrayNative(short* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[385])(values, count);
#else
return (short)((delegate* unmanaged[Cdecl])funcTable[385])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static short ImMinArray(short* values, int count)
{
short ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static short ImMinArray(ref short values, int count)
{
fixed (short* pvalues = &values)
{
short ret = ImMinArrayNative((short*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ushort ImMinArrayNative(ushort* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[386])(values, count);
#else
return (ushort)((delegate* unmanaged[Cdecl])funcTable[386])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ushort ImMinArray(ushort* values, int count)
{
ushort ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ushort ImMinArray(ref ushort values, int count)
{
fixed (ushort* pvalues = &values)
{
ushort ret = ImMinArrayNative((ushort*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImMinArrayNative(int* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[387])(values, count);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[387])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static int ImMinArray(int* values, int count)
{
int ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static int ImMinArray(ref int values, int count)
{
fixed (int* pvalues = &values)
{
int ret = ImMinArrayNative((int*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint ImMinArrayNative(uint* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[388])(values, count);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[388])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static uint ImMinArray(uint* values, int count)
{
uint ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static uint ImMinArray(ref uint values, int count)
{
fixed (uint* pvalues = &values)
{
uint ret = ImMinArrayNative((uint*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ImMinArrayNative(long* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[389])(values, count);
#else
return (long)((delegate* unmanaged[Cdecl])funcTable[389])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static long ImMinArray(long* values, int count)
{
long ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static long ImMinArray(ref long values, int count)
{
fixed (long* pvalues = &values)
{
long ret = ImMinArrayNative((long*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ulong ImMinArrayNative(ulong* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[390])(values, count);
#else
return (ulong)((delegate* unmanaged[Cdecl])funcTable[390])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ulong ImMinArray(ulong* values, int count)
{
ulong ret = ImMinArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ulong ImMinArray(ref ulong values, int count)
{
fixed (ulong* pvalues = &values)
{
ulong ret = ImMinArrayNative((ulong*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImMaxArrayNative(float* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[391])(values, count);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[391])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static float ImMaxArray(float* values, int count)
{
float ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static float ImMaxArray(ref float values, int count)
{
fixed (float* pvalues = &values)
{
float ret = ImMaxArrayNative((float*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMaxArrayNative(double* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[392])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[392])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMaxArray(double* values, int count)
{
double ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMaxArray(ref double values, int count)
{
fixed (double* pvalues = &values)
{
double ret = ImMaxArrayNative((double*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImMaxArrayNative(byte* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[393])(values, count);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[393])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static byte ImMaxArray(byte* values, int count)
{
byte ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static byte ImMaxArray(ref byte values, int count)
{
fixed (byte* pvalues = &values)
{
byte ret = ImMaxArrayNative((byte*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static short ImMaxArrayNative(short* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[394])(values, count);
#else
return (short)((delegate* unmanaged[Cdecl])funcTable[394])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static short ImMaxArray(short* values, int count)
{
short ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static short ImMaxArray(ref short values, int count)
{
fixed (short* pvalues = &values)
{
short ret = ImMaxArrayNative((short*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ushort ImMaxArrayNative(ushort* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[395])(values, count);
#else
return (ushort)((delegate* unmanaged[Cdecl])funcTable[395])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ushort ImMaxArray(ushort* values, int count)
{
ushort ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ushort ImMaxArray(ref ushort values, int count)
{
fixed (ushort* pvalues = &values)
{
ushort ret = ImMaxArrayNative((ushort*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImMaxArrayNative(int* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[396])(values, count);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[396])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static int ImMaxArray(int* values, int count)
{
int ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static int ImMaxArray(ref int values, int count)
{
fixed (int* pvalues = &values)
{
int ret = ImMaxArrayNative((int*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint ImMaxArrayNative(uint* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[397])(values, count);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[397])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static uint ImMaxArray(uint* values, int count)
{
uint ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static uint ImMaxArray(ref uint values, int count)
{
fixed (uint* pvalues = &values)
{
uint ret = ImMaxArrayNative((uint*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ImMaxArrayNative(long* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[398])(values, count);
#else
return (long)((delegate* unmanaged[Cdecl])funcTable[398])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static long ImMaxArray(long* values, int count)
{
long ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static long ImMaxArray(ref long values, int count)
{
fixed (long* pvalues = &values)
{
long ret = ImMaxArrayNative((long*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ulong ImMaxArrayNative(ulong* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[399])(values, count);
#else
return (ulong)((delegate* unmanaged[Cdecl])funcTable[399])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ulong ImMaxArray(ulong* values, int count)
{
ulong ret = ImMaxArrayNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ulong ImMaxArray(ref ulong values, int count)
{
fixed (ulong* pvalues = &values)
{
ulong ret = ImMaxArrayNative((ulong*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(float* values, int count, float* minOut, float* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[400])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[400])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(float* values, int count, float* minOut, float* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref float values, int count, float* minOut, float* maxOut)
{
fixed (float* pvalues = &values)
{
ImMinMaxArrayNative((float*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(float* values, int count, ref float minOut, float* maxOut)
{
fixed (float* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (float*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref float values, int count, ref float minOut, float* maxOut)
{
fixed (float* pvalues = &values)
{
fixed (float* pminOut = &minOut)
{
ImMinMaxArrayNative((float*)pvalues, count, (float*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(float* values, int count, float* minOut, ref float maxOut)
{
fixed (float* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (float*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref float values, int count, float* minOut, ref float maxOut)
{
fixed (float* pvalues = &values)
{
fixed (float* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((float*)pvalues, count, minOut, (float*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(float* values, int count, ref float minOut, ref float maxOut)
{
fixed (float* pminOut = &minOut)
{
fixed (float* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (float*)pminOut, (float*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref float values, int count, ref float minOut, ref float maxOut)
{
fixed (float* pvalues = &values)
{
fixed (float* pminOut = &minOut)
{
fixed (float* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((float*)pvalues, count, (float*)pminOut, (float*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(double* values, int count, double* minOut, double* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[401])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[401])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(double* values, int count, double* minOut, double* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref double values, int count, double* minOut, double* maxOut)
{
fixed (double* pvalues = &values)
{
ImMinMaxArrayNative((double*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(double* values, int count, ref double minOut, double* maxOut)
{
fixed (double* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (double*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref double values, int count, ref double minOut, double* maxOut)
{
fixed (double* pvalues = &values)
{
fixed (double* pminOut = &minOut)
{
ImMinMaxArrayNative((double*)pvalues, count, (double*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(double* values, int count, double* minOut, ref double maxOut)
{
fixed (double* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (double*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref double values, int count, double* minOut, ref double maxOut)
{
fixed (double* pvalues = &values)
{
fixed (double* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((double*)pvalues, count, minOut, (double*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(double* values, int count, ref double minOut, ref double maxOut)
{
fixed (double* pminOut = &minOut)
{
fixed (double* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (double*)pminOut, (double*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref double values, int count, ref double minOut, ref double maxOut)
{
fixed (double* pvalues = &values)
{
fixed (double* pminOut = &minOut)
{
fixed (double* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((double*)pvalues, count, (double*)pminOut, (double*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(byte* values, int count, byte* minOut, byte* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[402])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[402])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(byte* values, int count, byte* minOut, byte* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref byte values, int count, byte* minOut, byte* maxOut)
{
fixed (byte* pvalues = &values)
{
ImMinMaxArrayNative((byte*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(byte* values, int count, ref byte minOut, byte* maxOut)
{
fixed (byte* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (byte*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref byte values, int count, ref byte minOut, byte* maxOut)
{
fixed (byte* pvalues = &values)
{
fixed (byte* pminOut = &minOut)
{
ImMinMaxArrayNative((byte*)pvalues, count, (byte*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(byte* values, int count, byte* minOut, ref byte maxOut)
{
fixed (byte* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (byte*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref byte values, int count, byte* minOut, ref byte maxOut)
{
fixed (byte* pvalues = &values)
{
fixed (byte* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((byte*)pvalues, count, minOut, (byte*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(byte* values, int count, ref byte minOut, ref byte maxOut)
{
fixed (byte* pminOut = &minOut)
{
fixed (byte* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (byte*)pminOut, (byte*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref byte values, int count, ref byte minOut, ref byte maxOut)
{
fixed (byte* pvalues = &values)
{
fixed (byte* pminOut = &minOut)
{
fixed (byte* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((byte*)pvalues, count, (byte*)pminOut, (byte*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(short* values, int count, short* minOut, short* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[403])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[403])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(short* values, int count, short* minOut, short* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref short values, int count, short* minOut, short* maxOut)
{
fixed (short* pvalues = &values)
{
ImMinMaxArrayNative((short*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(short* values, int count, ref short minOut, short* maxOut)
{
fixed (short* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (short*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref short values, int count, ref short minOut, short* maxOut)
{
fixed (short* pvalues = &values)
{
fixed (short* pminOut = &minOut)
{
ImMinMaxArrayNative((short*)pvalues, count, (short*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(short* values, int count, short* minOut, ref short maxOut)
{
fixed (short* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (short*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref short values, int count, short* minOut, ref short maxOut)
{
fixed (short* pvalues = &values)
{
fixed (short* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((short*)pvalues, count, minOut, (short*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(short* values, int count, ref short minOut, ref short maxOut)
{
fixed (short* pminOut = &minOut)
{
fixed (short* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (short*)pminOut, (short*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref short values, int count, ref short minOut, ref short maxOut)
{
fixed (short* pvalues = &values)
{
fixed (short* pminOut = &minOut)
{
fixed (short* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((short*)pvalues, count, (short*)pminOut, (short*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(ushort* values, int count, ushort* minOut, ushort* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[404])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[404])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(ushort* values, int count, ushort* minOut, ushort* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ushort values, int count, ushort* minOut, ushort* maxOut)
{
fixed (ushort* pvalues = &values)
{
ImMinMaxArrayNative((ushort*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ushort* values, int count, ref ushort minOut, ushort* maxOut)
{
fixed (ushort* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (ushort*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ushort values, int count, ref ushort minOut, ushort* maxOut)
{
fixed (ushort* pvalues = &values)
{
fixed (ushort* pminOut = &minOut)
{
ImMinMaxArrayNative((ushort*)pvalues, count, (ushort*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ushort* values, int count, ushort* minOut, ref ushort maxOut)
{
fixed (ushort* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (ushort*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ushort values, int count, ushort* minOut, ref ushort maxOut)
{
fixed (ushort* pvalues = &values)
{
fixed (ushort* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((ushort*)pvalues, count, minOut, (ushort*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ushort* values, int count, ref ushort minOut, ref ushort maxOut)
{
fixed (ushort* pminOut = &minOut)
{
fixed (ushort* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (ushort*)pminOut, (ushort*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ushort values, int count, ref ushort minOut, ref ushort maxOut)
{
fixed (ushort* pvalues = &values)
{
fixed (ushort* pminOut = &minOut)
{
fixed (ushort* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((ushort*)pvalues, count, (ushort*)pminOut, (ushort*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(int* values, int count, int* minOut, int* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[405])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[405])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(int* values, int count, int* minOut, int* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref int values, int count, int* minOut, int* maxOut)
{
fixed (int* pvalues = &values)
{
ImMinMaxArrayNative((int*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(int* values, int count, ref int minOut, int* maxOut)
{
fixed (int* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (int*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref int values, int count, ref int minOut, int* maxOut)
{
fixed (int* pvalues = &values)
{
fixed (int* pminOut = &minOut)
{
ImMinMaxArrayNative((int*)pvalues, count, (int*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(int* values, int count, int* minOut, ref int maxOut)
{
fixed (int* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (int*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref int values, int count, int* minOut, ref int maxOut)
{
fixed (int* pvalues = &values)
{
fixed (int* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((int*)pvalues, count, minOut, (int*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(int* values, int count, ref int minOut, ref int maxOut)
{
fixed (int* pminOut = &minOut)
{
fixed (int* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (int*)pminOut, (int*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref int values, int count, ref int minOut, ref int maxOut)
{
fixed (int* pvalues = &values)
{
fixed (int* pminOut = &minOut)
{
fixed (int* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((int*)pvalues, count, (int*)pminOut, (int*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(uint* values, int count, uint* minOut, uint* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[406])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[406])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(uint* values, int count, uint* minOut, uint* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref uint values, int count, uint* minOut, uint* maxOut)
{
fixed (uint* pvalues = &values)
{
ImMinMaxArrayNative((uint*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(uint* values, int count, ref uint minOut, uint* maxOut)
{
fixed (uint* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (uint*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref uint values, int count, ref uint minOut, uint* maxOut)
{
fixed (uint* pvalues = &values)
{
fixed (uint* pminOut = &minOut)
{
ImMinMaxArrayNative((uint*)pvalues, count, (uint*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(uint* values, int count, uint* minOut, ref uint maxOut)
{
fixed (uint* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (uint*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref uint values, int count, uint* minOut, ref uint maxOut)
{
fixed (uint* pvalues = &values)
{
fixed (uint* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((uint*)pvalues, count, minOut, (uint*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(uint* values, int count, ref uint minOut, ref uint maxOut)
{
fixed (uint* pminOut = &minOut)
{
fixed (uint* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (uint*)pminOut, (uint*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref uint values, int count, ref uint minOut, ref uint maxOut)
{
fixed (uint* pvalues = &values)
{
fixed (uint* pminOut = &minOut)
{
fixed (uint* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((uint*)pvalues, count, (uint*)pminOut, (uint*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(long* values, int count, long* minOut, long* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[407])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[407])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(long* values, int count, long* minOut, long* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref long values, int count, long* minOut, long* maxOut)
{
fixed (long* pvalues = &values)
{
ImMinMaxArrayNative((long*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(long* values, int count, ref long minOut, long* maxOut)
{
fixed (long* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (long*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref long values, int count, ref long minOut, long* maxOut)
{
fixed (long* pvalues = &values)
{
fixed (long* pminOut = &minOut)
{
ImMinMaxArrayNative((long*)pvalues, count, (long*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(long* values, int count, long* minOut, ref long maxOut)
{
fixed (long* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (long*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref long values, int count, long* minOut, ref long maxOut)
{
fixed (long* pvalues = &values)
{
fixed (long* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((long*)pvalues, count, minOut, (long*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(long* values, int count, ref long minOut, ref long maxOut)
{
fixed (long* pminOut = &minOut)
{
fixed (long* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (long*)pminOut, (long*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref long values, int count, ref long minOut, ref long maxOut)
{
fixed (long* pvalues = &values)
{
fixed (long* pminOut = &minOut)
{
fixed (long* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((long*)pvalues, count, (long*)pminOut, (long*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ImMinMaxArrayNative(ulong* values, int count, ulong* minOut, ulong* maxOut)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[408])(values, count, minOut, maxOut);
#else
((delegate* unmanaged[Cdecl])funcTable[408])((nint)values, count, (nint)minOut, (nint)maxOut);
#endif
}
///
/// To be documented.
///
public static void ImMinMaxArray(ulong* values, int count, ulong* minOut, ulong* maxOut)
{
ImMinMaxArrayNative(values, count, minOut, maxOut);
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ulong values, int count, ulong* minOut, ulong* maxOut)
{
fixed (ulong* pvalues = &values)
{
ImMinMaxArrayNative((ulong*)pvalues, count, minOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ulong* values, int count, ref ulong minOut, ulong* maxOut)
{
fixed (ulong* pminOut = &minOut)
{
ImMinMaxArrayNative(values, count, (ulong*)pminOut, maxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ulong values, int count, ref ulong minOut, ulong* maxOut)
{
fixed (ulong* pvalues = &values)
{
fixed (ulong* pminOut = &minOut)
{
ImMinMaxArrayNative((ulong*)pvalues, count, (ulong*)pminOut, maxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ulong* values, int count, ulong* minOut, ref ulong maxOut)
{
fixed (ulong* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, minOut, (ulong*)pmaxOut);
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ulong values, int count, ulong* minOut, ref ulong maxOut)
{
fixed (ulong* pvalues = &values)
{
fixed (ulong* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((ulong*)pvalues, count, minOut, (ulong*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ulong* values, int count, ref ulong minOut, ref ulong maxOut)
{
fixed (ulong* pminOut = &minOut)
{
fixed (ulong* pmaxOut = &maxOut)
{
ImMinMaxArrayNative(values, count, (ulong*)pminOut, (ulong*)pmaxOut);
}
}
}
///
/// To be documented.
///
public static void ImMinMaxArray(ref ulong values, int count, ref ulong minOut, ref ulong maxOut)
{
fixed (ulong* pvalues = &values)
{
fixed (ulong* pminOut = &minOut)
{
fixed (ulong* pmaxOut = &maxOut)
{
ImMinMaxArrayNative((ulong*)pvalues, count, (ulong*)pminOut, (ulong*)pmaxOut);
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float ImSumNative(float* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[409])(values, count);
#else
return (float)((delegate* unmanaged[Cdecl])funcTable[409])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static float ImSum(float* values, int count)
{
float ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static float ImSum(ref float values, int count)
{
fixed (float* pvalues = &values)
{
float ret = ImSumNative((float*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImSumNative(double* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[410])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[410])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImSum(double* values, int count)
{
double ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImSum(ref double values, int count)
{
fixed (double* pvalues = &values)
{
double ret = ImSumNative((double*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImSumNative(byte* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[411])(values, count);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[411])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static byte ImSum(byte* values, int count)
{
byte ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static byte ImSum(ref byte values, int count)
{
fixed (byte* pvalues = &values)
{
byte ret = ImSumNative((byte*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static short ImSumNative(short* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[412])(values, count);
#else
return (short)((delegate* unmanaged[Cdecl])funcTable[412])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static short ImSum(short* values, int count)
{
short ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static short ImSum(ref short values, int count)
{
fixed (short* pvalues = &values)
{
short ret = ImSumNative((short*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ushort ImSumNative(ushort* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[413])(values, count);
#else
return (ushort)((delegate* unmanaged[Cdecl])funcTable[413])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ushort ImSum(ushort* values, int count)
{
ushort ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ushort ImSum(ref ushort values, int count)
{
fixed (ushort* pvalues = &values)
{
ushort ret = ImSumNative((ushort*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ImSumNative(int* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[414])(values, count);
#else
return (int)((delegate* unmanaged[Cdecl])funcTable[414])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static int ImSum(int* values, int count)
{
int ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static int ImSum(ref int values, int count)
{
fixed (int* pvalues = &values)
{
int ret = ImSumNative((int*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint ImSumNative(uint* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[415])(values, count);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[415])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static uint ImSum(uint* values, int count)
{
uint ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static uint ImSum(ref uint values, int count)
{
fixed (uint* pvalues = &values)
{
uint ret = ImSumNative((uint*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ImSumNative(long* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[416])(values, count);
#else
return (long)((delegate* unmanaged[Cdecl])funcTable[416])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static long ImSum(long* values, int count)
{
long ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static long ImSum(ref long values, int count)
{
fixed (long* pvalues = &values)
{
long ret = ImSumNative((long*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ulong ImSumNative(ulong* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[417])(values, count);
#else
return (ulong)((delegate* unmanaged[Cdecl])funcTable[417])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static ulong ImSum(ulong* values, int count)
{
ulong ret = ImSumNative(values, count);
return ret;
}
///
/// To be documented.
///
public static ulong ImSum(ref ulong values, int count)
{
fixed (ulong* pvalues = &values)
{
ulong ret = ImSumNative((ulong*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(float* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[418])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[418])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(float* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref float values, int count)
{
fixed (float* pvalues = &values)
{
double ret = ImMeanNative((float*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(double* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[419])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[419])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(double* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref double values, int count)
{
fixed (double* pvalues = &values)
{
double ret = ImMeanNative((double*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(byte* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[420])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[420])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(byte* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref byte values, int count)
{
fixed (byte* pvalues = &values)
{
double ret = ImMeanNative((byte*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(short* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[421])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[421])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(short* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref short values, int count)
{
fixed (short* pvalues = &values)
{
double ret = ImMeanNative((short*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(ushort* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[422])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[422])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(ushort* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref ushort values, int count)
{
fixed (ushort* pvalues = &values)
{
double ret = ImMeanNative((ushort*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(int* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[423])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[423])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(int* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref int values, int count)
{
fixed (int* pvalues = &values)
{
double ret = ImMeanNative((int*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(uint* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[424])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[424])((nint)values, count);
#endif
}
///
/// To be documented.
///
public static double ImMean(uint* values, int count)
{
double ret = ImMeanNative(values, count);
return ret;
}
///
/// To be documented.
///
public static double ImMean(ref uint values, int count)
{
fixed (uint* pvalues = &values)
{
double ret = ImMeanNative((uint*)pvalues, count);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double ImMeanNative(long* values, int count)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[425])(values, count);
#else
return (double)((delegate* unmanaged[Cdecl])funcTable[425])((nint)values, count);
#endif
}
}
}