// ------------------------------------------------------------------------------
//
// 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;
namespace Dalamud.Bindings.ImGui
{
public unsafe partial class ImGuiP
{
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, ref byte textEnd, Vector2* textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, textSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, string textEnd, Vector2* textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, pStr0, textSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ref byte textEnd, Vector2* textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, textSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ReadOnlySpan textEnd, Vector2* textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, textSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = &text)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = text)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, textEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = &text)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, textEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, byte* textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, textEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, string textEnd, ref Vector2 textSizeIfKnown)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, text, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, string textEnd, ref Vector2 textSizeIfKnown)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, pStr1, (Vector2*)ptextSizeIfKnown);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ImDrawListPtr drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative(drawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, pStr1, (Vector2*)ptextSizeIfKnown);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ref byte text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, ReadOnlySpan text, string textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, (byte*)ptext, pStr0, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ref byte textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
///
/// To be documented.
///
public static void RenderTextEllipsis(ref ImDrawList drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, string text, ReadOnlySpan textEnd, ref Vector2 textSizeIfKnown)
{
fixed (ImDrawList* pdrawList = &drawList)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
fixed (Vector2* ptextSizeIfKnown = &textSizeIfKnown)
{
RenderTextEllipsisNative((ImDrawList*)pdrawList, posMin, posMax, clipMaxX, ellipsisMaxX, pStr0, (byte*)ptextEnd, (Vector2*)ptextSizeIfKnown);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderFrameNative(Vector2 pMin, Vector2 pMax, uint fillCol, byte border, float rounding)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1178])(pMin, pMax, fillCol, border, rounding);
#else
((delegate* unmanaged[Cdecl])funcTable[1178])(pMin, pMax, fillCol, border, rounding);
#endif
}
///
/// To be documented.
///
public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, bool border, float rounding)
{
RenderFrameNative(pMin, pMax, fillCol, border ? (byte)1 : (byte)0, rounding);
}
///
/// To be documented.
///
public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, bool border)
{
RenderFrameNative(pMin, pMax, fillCol, border ? (byte)1 : (byte)0, (float)(0.0f));
}
///
/// To be documented.
///
public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol)
{
RenderFrameNative(pMin, pMax, fillCol, (byte)(1), (float)(0.0f));
}
///
/// To be documented.
///
public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, float rounding)
{
RenderFrameNative(pMin, pMax, fillCol, (byte)(1), rounding);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderFrameBorderNative(Vector2 pMin, Vector2 pMax, float rounding)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1179])(pMin, pMax, rounding);
#else
((delegate* unmanaged[Cdecl])funcTable[1179])(pMin, pMax, rounding);
#endif
}
///
/// To be documented.
///
public static void RenderFrameBorder(Vector2 pMin, Vector2 pMax, float rounding)
{
RenderFrameBorderNative(pMin, pMax, rounding);
}
///
/// To be documented.
///
public static void RenderFrameBorder(Vector2 pMin, Vector2 pMax)
{
RenderFrameBorderNative(pMin, pMax, (float)(0.0f));
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderColorRectWithAlphaCheckerboardNative(ImDrawList* drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding, ImDrawFlags flags)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1180])(drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
#else
((delegate* unmanaged[Cdecl])funcTable[1180])((nint)drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
#endif
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding, ImDrawFlags flags)
{
RenderColorRectWithAlphaCheckerboardNative(drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding)
{
RenderColorRectWithAlphaCheckerboardNative(drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, (ImDrawFlags)(0));
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff)
{
RenderColorRectWithAlphaCheckerboardNative(drawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), (ImDrawFlags)(0));
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, ImDrawFlags flags)
{
RenderColorRectWithAlphaCheckerboardNative(drawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), flags);
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding, ImDrawFlags flags)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderColorRectWithAlphaCheckerboardNative((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
}
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderColorRectWithAlphaCheckerboardNative((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, (ImDrawFlags)(0));
}
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderColorRectWithAlphaCheckerboardNative((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), (ImDrawFlags)(0));
}
}
///
/// To be documented.
///
public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, ImDrawFlags flags)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderColorRectWithAlphaCheckerboardNative((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), flags);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderNavHighlightNative(ImRect bb, uint id, ImGuiNavHighlightFlags flags)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1181])(bb, id, flags);
#else
((delegate* unmanaged[Cdecl])funcTable[1181])(bb, id, flags);
#endif
}
///
/// To be documented.
///
public static void RenderNavHighlight(ImRect bb, uint id, ImGuiNavHighlightFlags flags)
{
RenderNavHighlightNative(bb, id, flags);
}
///
/// To be documented.
///
public static void RenderNavHighlight(ImRect bb, uint id)
{
RenderNavHighlightNative(bb, id, (ImGuiNavHighlightFlags)(ImGuiNavHighlightFlags.TypeDefault));
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte* FindRenderedTextEndNative(byte* text, byte* textEnd)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1182])(text, textEnd);
#else
return (byte*)((delegate* unmanaged[Cdecl])funcTable[1182])((nint)text, (nint)textEnd);
#endif
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(byte* text, byte* textEnd)
{
byte* ret = FindRenderedTextEndNative(text, textEnd);
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(byte* text)
{
byte* ret = FindRenderedTextEndNative(text, (byte*)(default));
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(byte* text)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(text, (byte*)(default)));
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(byte* text, byte* textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(text, textEnd));
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ref byte text, byte* textEnd)
{
fixed (byte* ptext = &text)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, textEnd);
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ref byte text)
{
fixed (byte* ptext = &text)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)(default));
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ref byte text)
{
fixed (byte* ptext = &text)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)(default)));
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ref byte text, byte* textEnd)
{
fixed (byte* ptext = &text)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, textEnd));
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ReadOnlySpan text, byte* textEnd)
{
fixed (byte* ptext = text)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, textEnd);
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ReadOnlySpan text)
{
fixed (byte* ptext = text)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)(default));
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ReadOnlySpan text)
{
fixed (byte* ptext = text)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)(default)));
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ReadOnlySpan text, byte* textEnd)
{
fixed (byte* ptext = text)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, textEnd));
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(string text, byte* textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* ret = FindRenderedTextEndNative(pStr0, textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(string text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* ret = FindRenderedTextEndNative(pStr0, (byte*)(default));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(string text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(pStr0, (byte*)(default)));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(string text, byte* textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(pStr0, textEnd));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(byte* text, ref byte textEnd)
{
fixed (byte* ptextEnd = &textEnd)
{
byte* ret = FindRenderedTextEndNative(text, (byte*)ptextEnd);
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(byte* text, ref byte textEnd)
{
fixed (byte* ptextEnd = &textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(text, (byte*)ptextEnd));
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(byte* text, ReadOnlySpan textEnd)
{
fixed (byte* ptextEnd = textEnd)
{
byte* ret = FindRenderedTextEndNative(text, (byte*)ptextEnd);
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(byte* text, ReadOnlySpan textEnd)
{
fixed (byte* ptextEnd = textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(text, (byte*)ptextEnd));
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(byte* text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* ret = FindRenderedTextEndNative(text, pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(byte* text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(text, pStr0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ref byte text, ref byte textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd);
return ret;
}
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ref byte text, ref byte textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd));
return ret;
}
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ReadOnlySpan text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd);
return ret;
}
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ReadOnlySpan text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd));
return ret;
}
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(string text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
byte* ret = FindRenderedTextEndNative(pStr0, pStr1);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(string text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(pStr0, pStr1));
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ref byte text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd);
return ret;
}
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ref byte text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd));
return ret;
}
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ref byte text, string textEnd)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* ret = FindRenderedTextEndNative((byte*)ptext, pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ref byte text, string textEnd)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, pStr0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ReadOnlySpan text, ref byte textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
byte* ret = FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd);
return ret;
}
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ReadOnlySpan text, ref byte textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, (byte*)ptextEnd));
return ret;
}
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(ReadOnlySpan text, string textEnd)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* ret = FindRenderedTextEndNative((byte*)ptext, pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(ReadOnlySpan text, string textEnd)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative((byte*)ptext, pStr0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(string text, ref byte textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
byte* ret = FindRenderedTextEndNative(pStr0, (byte*)ptextEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(string text, ref byte textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(pStr0, (byte*)ptextEnd));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static byte* FindRenderedTextEnd(string text, ReadOnlySpan textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
byte* ret = FindRenderedTextEndNative(pStr0, (byte*)ptextEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
public static string FindRenderedTextEndS(string text, ReadOnlySpan textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
string ret = Utils.DecodeStringUTF8(FindRenderedTextEndNative(pStr0, (byte*)ptextEnd));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderMouseCursorNative(Vector2 pos, float scale, ImGuiMouseCursor mouseCursor, uint colFill, uint colBorder, uint colShadow)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1183])(pos, scale, mouseCursor, colFill, colBorder, colShadow);
#else
((delegate* unmanaged[Cdecl])funcTable[1183])(pos, scale, mouseCursor, colFill, colBorder, colShadow);
#endif
}
///
/// To be documented.
///
public static void RenderMouseCursor(Vector2 pos, float scale, ImGuiMouseCursor mouseCursor, uint colFill, uint colBorder, uint colShadow)
{
RenderMouseCursorNative(pos, scale, mouseCursor, colFill, colBorder, colShadow);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderArrowNative(ImDrawList* drawList, Vector2 pos, uint col, ImGuiDir dir, float scale)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1184])(drawList, pos, col, dir, scale);
#else
((delegate* unmanaged[Cdecl])funcTable[1184])((nint)drawList, pos, col, dir, scale);
#endif
}
///
/// To be documented.
///
public static void RenderArrow(ImDrawListPtr drawList, Vector2 pos, uint col, ImGuiDir dir, float scale)
{
RenderArrowNative(drawList, pos, col, dir, scale);
}
///
/// To be documented.
///
public static void RenderArrow(ImDrawListPtr drawList, Vector2 pos, uint col, ImGuiDir dir)
{
RenderArrowNative(drawList, pos, col, dir, (float)(1.0f));
}
///
/// To be documented.
///
public static void RenderArrow(ref ImDrawList drawList, Vector2 pos, uint col, ImGuiDir dir, float scale)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderArrowNative((ImDrawList*)pdrawList, pos, col, dir, scale);
}
}
///
/// To be documented.
///
public static void RenderArrow(ref ImDrawList drawList, Vector2 pos, uint col, ImGuiDir dir)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderArrowNative((ImDrawList*)pdrawList, pos, col, dir, (float)(1.0f));
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderBulletNative(ImDrawList* drawList, Vector2 pos, uint col)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1185])(drawList, pos, col);
#else
((delegate* unmanaged[Cdecl])funcTable[1185])((nint)drawList, pos, col);
#endif
}
///
/// To be documented.
///
public static void RenderBullet(ImDrawListPtr drawList, Vector2 pos, uint col)
{
RenderBulletNative(drawList, pos, col);
}
///
/// To be documented.
///
public static void RenderBullet(ref ImDrawList drawList, Vector2 pos, uint col)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderBulletNative((ImDrawList*)pdrawList, pos, col);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderCheckMarkNative(ImDrawList* drawList, Vector2 pos, uint col, float sz)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1186])(drawList, pos, col, sz);
#else
((delegate* unmanaged[Cdecl])funcTable[1186])((nint)drawList, pos, col, sz);
#endif
}
///
/// To be documented.
///
public static void RenderCheckMark(ImDrawListPtr drawList, Vector2 pos, uint col, float sz)
{
RenderCheckMarkNative(drawList, pos, col, sz);
}
///
/// To be documented.
///
public static void RenderCheckMark(ref ImDrawList drawList, Vector2 pos, uint col, float sz)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderCheckMarkNative((ImDrawList*)pdrawList, pos, col, sz);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderArrowPointingAtNative(ImDrawList* drawList, Vector2 pos, Vector2 halfSz, ImGuiDir direction, uint col)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1187])(drawList, pos, halfSz, direction, col);
#else
((delegate* unmanaged[Cdecl])funcTable[1187])((nint)drawList, pos, halfSz, direction, col);
#endif
}
///
/// To be documented.
///
public static void RenderArrowPointingAt(ImDrawListPtr drawList, Vector2 pos, Vector2 halfSz, ImGuiDir direction, uint col)
{
RenderArrowPointingAtNative(drawList, pos, halfSz, direction, col);
}
///
/// To be documented.
///
public static void RenderArrowPointingAt(ref ImDrawList drawList, Vector2 pos, Vector2 halfSz, ImGuiDir direction, uint col)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderArrowPointingAtNative((ImDrawList*)pdrawList, pos, halfSz, direction, col);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderArrowDockMenuNative(ImDrawList* drawList, Vector2 pMin, float sz, uint col)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1188])(drawList, pMin, sz, col);
#else
((delegate* unmanaged[Cdecl])funcTable[1188])((nint)drawList, pMin, sz, col);
#endif
}
///
/// To be documented.
///
public static void RenderArrowDockMenu(ImDrawListPtr drawList, Vector2 pMin, float sz, uint col)
{
RenderArrowDockMenuNative(drawList, pMin, sz, col);
}
///
/// To be documented.
///
public static void RenderArrowDockMenu(ref ImDrawList drawList, Vector2 pMin, float sz, uint col)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderArrowDockMenuNative((ImDrawList*)pdrawList, pMin, sz, col);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderRectFilledRangeHNative(ImDrawList* drawList, ImRect rect, uint col, float xStartNorm, float xEndNorm, float rounding)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1189])(drawList, rect, col, xStartNorm, xEndNorm, rounding);
#else
((delegate* unmanaged[Cdecl])funcTable[1189])((nint)drawList, rect, col, xStartNorm, xEndNorm, rounding);
#endif
}
///
/// To be documented.
///
public static void RenderRectFilledRangeH(ImDrawListPtr drawList, ImRect rect, uint col, float xStartNorm, float xEndNorm, float rounding)
{
RenderRectFilledRangeHNative(drawList, rect, col, xStartNorm, xEndNorm, rounding);
}
///
/// To be documented.
///
public static void RenderRectFilledRangeH(ref ImDrawList drawList, ImRect rect, uint col, float xStartNorm, float xEndNorm, float rounding)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderRectFilledRangeHNative((ImDrawList*)pdrawList, rect, col, xStartNorm, xEndNorm, rounding);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RenderRectFilledWithHoleNative(ImDrawList* drawList, ImRect outer, ImRect inner, uint col, float rounding)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1190])(drawList, outer, inner, col, rounding);
#else
((delegate* unmanaged[Cdecl])funcTable[1190])((nint)drawList, outer, inner, col, rounding);
#endif
}
///
/// To be documented.
///
public static void RenderRectFilledWithHole(ImDrawListPtr drawList, ImRect outer, ImRect inner, uint col, float rounding)
{
RenderRectFilledWithHoleNative(drawList, outer, inner, col, rounding);
}
///
/// To be documented.
///
public static void RenderRectFilledWithHole(ref ImDrawList drawList, ImRect outer, ImRect inner, uint col, float rounding)
{
fixed (ImDrawList* pdrawList = &drawList)
{
RenderRectFilledWithHoleNative((ImDrawList*)pdrawList, outer, inner, col, rounding);
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static ImDrawFlags CalcRoundingFlagsForRectInRectNative(ImRect rIn, ImRect rOuter, float threshold)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1191])(rIn, rOuter, threshold);
#else
return (ImDrawFlags)((delegate* unmanaged[Cdecl])funcTable[1191])(rIn, rOuter, threshold);
#endif
}
///
/// To be documented.
///
public static ImDrawFlags CalcRoundingFlagsForRectInRect(ImRect rIn, ImRect rOuter, float threshold)
{
ImDrawFlags ret = CalcRoundingFlagsForRectInRectNative(rIn, rOuter, threshold);
return ret;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void TextExNative(byte* text, byte* textEnd, ImGuiTextFlags flags)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1192])(text, textEnd, flags);
#else
((delegate* unmanaged[Cdecl])funcTable[1192])((nint)text, (nint)textEnd, flags);
#endif
}
///
/// To be documented.
///
public static void TextEx(byte* text, byte* textEnd, ImGuiTextFlags flags)
{
TextExNative(text, textEnd, flags);
}
///
/// To be documented.
///
public static void TextEx(byte* text, byte* textEnd)
{
TextExNative(text, textEnd, (ImGuiTextFlags)(0));
}
///
/// To be documented.
///
public static void TextEx(byte* text)
{
TextExNative(text, (byte*)(default), (ImGuiTextFlags)(0));
}
///
/// To be documented.
///
public static void TextEx(byte* text, ImGuiTextFlags flags)
{
TextExNative(text, (byte*)(default), flags);
}
///
/// To be documented.
///
public static void TextEx(ref byte text, byte* textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = &text)
{
TextExNative((byte*)ptext, textEnd, flags);
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, byte* textEnd)
{
fixed (byte* ptext = &text)
{
TextExNative((byte*)ptext, textEnd, (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text)
{
fixed (byte* ptext = &text)
{
TextExNative((byte*)ptext, (byte*)(default), (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, ImGuiTextFlags flags)
{
fixed (byte* ptext = &text)
{
TextExNative((byte*)ptext, (byte*)(default), flags);
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, byte* textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = text)
{
TextExNative((byte*)ptext, textEnd, flags);
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, byte* textEnd)
{
fixed (byte* ptext = text)
{
TextExNative((byte*)ptext, textEnd, (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text)
{
fixed (byte* ptext = text)
{
TextExNative((byte*)ptext, (byte*)(default), (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, ImGuiTextFlags flags)
{
fixed (byte* ptext = text)
{
TextExNative((byte*)ptext, (byte*)(default), flags);
}
}
///
/// To be documented.
///
public static void TextEx(string text, byte* textEnd, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(pStr0, textEnd, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(string text, byte* textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(pStr0, textEnd, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(string text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(pStr0, (byte*)(default), (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(string text, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(pStr0, (byte*)(default), flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, ref byte textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative(text, (byte*)ptextEnd, flags);
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, ref byte textEnd)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative(text, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, ReadOnlySpan textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative(text, (byte*)ptextEnd, flags);
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, ReadOnlySpan textEnd)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative(text, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, string textEnd, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(text, pStr0, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(byte* text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative(text, pStr0, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, ref byte textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, flags);
}
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, ref byte textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, ReadOnlySpan textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, flags);
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
}
///
/// To be documented.
///
public static void TextEx(string text, string textEnd, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
TextExNative(pStr0, pStr1, flags);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(string text, string textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte* pStr1 = null;
int pStrSize1 = 0;
if (textEnd != null)
{
pStrSize1 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize1 >= Utils.MaxStackallocSize)
{
pStr1 = Utils.Alloc(pStrSize1 + 1);
}
else
{
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
pStr1 = pStrStack1;
}
int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
pStr1[pStrOffset1] = 0;
}
TextExNative(pStr0, pStr1, (ImGuiTextFlags)(0));
if (pStrSize1 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr1);
}
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, ReadOnlySpan textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, flags);
}
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, ReadOnlySpan textEnd)
{
fixed (byte* ptext = &text)
{
fixed (byte* ptextEnd = textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, string textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative((byte*)ptext, pStr0, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(ref byte text, string textEnd)
{
fixed (byte* ptext = &text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative((byte*)ptext, pStr0, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, ref byte textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, flags);
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, ref byte textEnd)
{
fixed (byte* ptext = text)
{
fixed (byte* ptextEnd = &textEnd)
{
TextExNative((byte*)ptext, (byte*)ptextEnd, (ImGuiTextFlags)(0));
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, string textEnd, ImGuiTextFlags flags)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative((byte*)ptext, pStr0, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(ReadOnlySpan text, string textEnd)
{
fixed (byte* ptext = text)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (textEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(textEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
TextExNative((byte*)ptext, pStr0, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(string text, ref byte textEnd, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
TextExNative(pStr0, (byte*)ptextEnd, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(string text, ref byte textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = &textEnd)
{
TextExNative(pStr0, (byte*)ptextEnd, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(string text, ReadOnlySpan textEnd, ImGuiTextFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
TextExNative(pStr0, (byte*)ptextEnd, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
public static void TextEx(string text, ReadOnlySpan textEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (text != null)
{
pStrSize0 = Utils.GetByteCountUTF8(text);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
fixed (byte* ptextEnd = textEnd)
{
TextExNative(pStr0, (byte*)ptextEnd, (ImGuiTextFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ButtonExNative(byte* label, Vector2 sizeArg, ImGuiButtonFlags flags)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1193])(label, sizeArg, flags);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1193])((nint)label, sizeArg, flags);
#endif
}
///
/// To be documented.
///
public static bool ButtonEx(byte* label, Vector2 sizeArg, ImGuiButtonFlags flags)
{
byte ret = ButtonExNative(label, sizeArg, flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(byte* label, Vector2 sizeArg)
{
byte ret = ButtonExNative(label, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(byte* label)
{
byte ret = ButtonExNative(label, (Vector2)(new Vector2(0,0)), (ImGuiButtonFlags)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(byte* label, ImGuiButtonFlags flags)
{
byte ret = ButtonExNative(label, (Vector2)(new Vector2(0,0)), flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(ref byte label, Vector2 sizeArg, ImGuiButtonFlags flags)
{
fixed (byte* plabel = &label)
{
byte ret = ButtonExNative((byte*)plabel, sizeArg, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ref byte label, Vector2 sizeArg)
{
fixed (byte* plabel = &label)
{
byte ret = ButtonExNative((byte*)plabel, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = ButtonExNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ref byte label, ImGuiButtonFlags flags)
{
fixed (byte* plabel = &label)
{
byte ret = ButtonExNative((byte*)plabel, (Vector2)(new Vector2(0,0)), flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ReadOnlySpan label, Vector2 sizeArg, ImGuiButtonFlags flags)
{
fixed (byte* plabel = label)
{
byte ret = ButtonExNative((byte*)plabel, sizeArg, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ReadOnlySpan label, Vector2 sizeArg)
{
fixed (byte* plabel = label)
{
byte ret = ButtonExNative((byte*)plabel, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = ButtonExNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(ReadOnlySpan label, ImGuiButtonFlags flags)
{
fixed (byte* plabel = label)
{
byte ret = ButtonExNative((byte*)plabel, (Vector2)(new Vector2(0,0)), flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonEx(string label, Vector2 sizeArg, ImGuiButtonFlags flags)
{
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 = ButtonExNative(pStr0, sizeArg, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(string label, Vector2 sizeArg)
{
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 = ButtonExNative(pStr0, sizeArg, (ImGuiButtonFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(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 = ButtonExNative(pStr0, (Vector2)(new Vector2(0,0)), (ImGuiButtonFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonEx(string label, ImGuiButtonFlags flags)
{
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 = ButtonExNative(pStr0, (Vector2)(new Vector2(0,0)), flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte CloseButtonNative(uint id, Vector2 pos)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1194])(id, pos);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1194])(id, pos);
#endif
}
///
/// To be documented.
///
public static bool CloseButton(uint id, Vector2 pos)
{
byte ret = CloseButtonNative(id, pos);
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte CollapseButtonNative(uint id, Vector2 pos, ImGuiDockNode* dockNode)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1195])(id, pos, dockNode);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1195])(id, pos, (nint)dockNode);
#endif
}
///
/// To be documented.
///
public static bool CollapseButton(uint id, Vector2 pos, ImGuiDockNodePtr dockNode)
{
byte ret = CollapseButtonNative(id, pos, dockNode);
return ret != 0;
}
///
/// To be documented.
///
public static bool CollapseButton(uint id, Vector2 pos, ref ImGuiDockNode dockNode)
{
fixed (ImGuiDockNode* pdockNode = &dockNode)
{
byte ret = CollapseButtonNative(id, pos, (ImGuiDockNode*)pdockNode);
return ret != 0;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ArrowButtonExNative(byte* strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1196])(strId, dir, sizeArg, flags);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1196])((nint)strId, dir, sizeArg, flags);
#endif
}
///
/// To be documented.
///
public static bool ArrowButtonEx(byte* strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
{
byte ret = ArrowButtonExNative(strId, dir, sizeArg, flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool ArrowButtonEx(byte* strId, ImGuiDir dir, Vector2 sizeArg)
{
byte ret = ArrowButtonExNative(strId, dir, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool ArrowButtonEx(ref byte strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
{
fixed (byte* pstrId = &strId)
{
byte ret = ArrowButtonExNative((byte*)pstrId, dir, sizeArg, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ArrowButtonEx(ref byte strId, ImGuiDir dir, Vector2 sizeArg)
{
fixed (byte* pstrId = &strId)
{
byte ret = ArrowButtonExNative((byte*)pstrId, dir, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ArrowButtonEx(ReadOnlySpan strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
{
fixed (byte* pstrId = strId)
{
byte ret = ArrowButtonExNative((byte*)pstrId, dir, sizeArg, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ArrowButtonEx(ReadOnlySpan strId, ImGuiDir dir, Vector2 sizeArg)
{
fixed (byte* pstrId = strId)
{
byte ret = ArrowButtonExNative((byte*)pstrId, dir, sizeArg, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ArrowButtonEx(string strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (strId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(strId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(strId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ArrowButtonExNative(pStr0, dir, sizeArg, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool ArrowButtonEx(string strId, ImGuiDir dir, Vector2 sizeArg)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (strId != null)
{
pStrSize0 = Utils.GetByteCountUTF8(strId);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(strId, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = ArrowButtonExNative(pStr0, dir, sizeArg, (ImGuiButtonFlags)(0));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void ScrollbarNative(ImGuiAxis axis)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1197])(axis);
#else
((delegate* unmanaged[Cdecl])funcTable[1197])(axis);
#endif
}
///
/// To be documented.
///
public static void Scrollbar(ImGuiAxis axis)
{
ScrollbarNative(axis);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ScrollbarExNative(ImRect bb, uint id, ImGuiAxis axis, long* pScrollV, long availV, long contentsV, ImDrawFlags flags)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1198])(bb, id, axis, pScrollV, availV, contentsV, flags);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1198])(bb, id, axis, (nint)pScrollV, availV, contentsV, flags);
#endif
}
///
/// To be documented.
///
public static bool ScrollbarEx(ImRect bb, uint id, ImGuiAxis axis, long* pScrollV, long availV, long contentsV, ImDrawFlags flags)
{
byte ret = ScrollbarExNative(bb, id, axis, pScrollV, availV, contentsV, flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool ScrollbarEx(ImRect bb, uint id, ImGuiAxis axis, ref long pScrollV, long availV, long contentsV, ImDrawFlags flags)
{
fixed (long* ppScrollV = &pScrollV)
{
byte ret = ScrollbarExNative(bb, id, axis, (long*)ppScrollV, availV, contentsV, flags);
return ret != 0;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ImageButtonExNative(uint id, ImTextureID textureId, Vector2 size, Vector2 uv0, Vector2 uv1, Vector2 padding, Vector4 bgCol, Vector4 tintCol)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1199])(id, textureId, size, uv0, uv1, padding, bgCol, tintCol);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1199])(id, textureId, size, uv0, uv1, padding, bgCol, tintCol);
#endif
}
///
/// To be documented.
///
public static bool ImageButtonEx(uint id, ImTextureID textureId, Vector2 size, Vector2 uv0, Vector2 uv1, Vector2 padding, Vector4 bgCol, Vector4 tintCol)
{
byte ret = ImageButtonExNative(id, textureId, size, uv0, uv1, padding, bgCol, tintCol);
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void GetWindowScrollbarRectNative(ImRect* pOut, ImGuiWindow* window, ImGuiAxis axis)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1200])(pOut, window, axis);
#else
((delegate* unmanaged[Cdecl])funcTable[1200])((nint)pOut, (nint)window, axis);
#endif
}
///
/// To be documented.
///
public static ImRect GetWindowScrollbarRect(ImGuiWindowPtr window, ImGuiAxis axis)
{
ImRect ret;
GetWindowScrollbarRectNative(&ret, window, axis);
return ret;
}
///
/// To be documented.
///
public static void GetWindowScrollbarRect(ImRectPtr pOut, ImGuiWindowPtr window, ImGuiAxis axis)
{
GetWindowScrollbarRectNative(pOut, window, axis);
}
///
/// To be documented.
///
public static void GetWindowScrollbarRect(ref ImRect pOut, ImGuiWindowPtr window, ImGuiAxis axis)
{
fixed (ImRect* ppOut = &pOut)
{
GetWindowScrollbarRectNative((ImRect*)ppOut, window, axis);
}
}
///
/// To be documented.
///
public static ImRect GetWindowScrollbarRect(ref ImGuiWindow window, ImGuiAxis axis)
{
fixed (ImGuiWindow* pwindow = &window)
{
ImRect ret;
GetWindowScrollbarRectNative(&ret, (ImGuiWindow*)pwindow, axis);
return ret;
}
}
///
/// To be documented.
///
public static void GetWindowScrollbarRect(ImRectPtr pOut, ref ImGuiWindow window, ImGuiAxis axis)
{
fixed (ImGuiWindow* pwindow = &window)
{
GetWindowScrollbarRectNative(pOut, (ImGuiWindow*)pwindow, axis);
}
}
///
/// To be documented.
///
public static void GetWindowScrollbarRect(ref ImRect pOut, ref ImGuiWindow window, ImGuiAxis axis)
{
fixed (ImRect* ppOut = &pOut)
{
fixed (ImGuiWindow* pwindow = &window)
{
GetWindowScrollbarRectNative((ImRect*)ppOut, (ImGuiWindow*)pwindow, axis);
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint GetWindowScrollbarIDNative(ImGuiWindow* window, ImGuiAxis axis)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1201])(window, axis);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[1201])((nint)window, axis);
#endif
}
///
/// To be documented.
///
public static uint GetWindowScrollbarID(ImGuiWindowPtr window, ImGuiAxis axis)
{
uint ret = GetWindowScrollbarIDNative(window, axis);
return ret;
}
///
/// To be documented.
///
public static uint GetWindowScrollbarID(ref ImGuiWindow window, ImGuiAxis axis)
{
fixed (ImGuiWindow* pwindow = &window)
{
uint ret = GetWindowScrollbarIDNative((ImGuiWindow*)pwindow, axis);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint GetWindowResizeCornerIDNative(ImGuiWindow* window, int n)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1202])(window, n);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[1202])((nint)window, n);
#endif
}
///
/// To be documented.
///
public static uint GetWindowResizeCornerID(ImGuiWindowPtr window, int n)
{
uint ret = GetWindowResizeCornerIDNative(window, n);
return ret;
}
///
/// To be documented.
///
public static uint GetWindowResizeCornerID(ref ImGuiWindow window, int n)
{
fixed (ImGuiWindow* pwindow = &window)
{
uint ret = GetWindowResizeCornerIDNative((ImGuiWindow*)pwindow, n);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static uint GetWindowResizeBorderIDNative(ImGuiWindow* window, ImGuiDir dir)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1203])(window, dir);
#else
return (uint)((delegate* unmanaged[Cdecl])funcTable[1203])((nint)window, dir);
#endif
}
///
/// To be documented.
///
public static uint GetWindowResizeBorderID(ImGuiWindowPtr window, ImGuiDir dir)
{
uint ret = GetWindowResizeBorderIDNative(window, dir);
return ret;
}
///
/// To be documented.
///
public static uint GetWindowResizeBorderID(ref ImGuiWindow window, ImGuiDir dir)
{
fixed (ImGuiWindow* pwindow = &window)
{
uint ret = GetWindowResizeBorderIDNative((ImGuiWindow*)pwindow, dir);
return ret;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void SeparatorExNative(ImGuiSeparatorFlags flags)
{
#if NET5_0_OR_GREATER
((delegate* unmanaged[Cdecl])funcTable[1204])(flags);
#else
((delegate* unmanaged[Cdecl])funcTable[1204])(flags);
#endif
}
///
/// To be documented.
///
public static void SeparatorEx(ImGuiSeparatorFlags flags)
{
SeparatorExNative(flags);
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte CheckboxFlagsNative(byte* label, long* flags, long flagsValue)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1205])(label, flags, flagsValue);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1205])((nint)label, (nint)flags, flagsValue);
#endif
}
///
/// To be documented.
///
public static bool CheckboxFlags(byte* label, long* flags, long flagsValue)
{
byte ret = CheckboxFlagsNative(label, flags, flagsValue);
return ret != 0;
}
///
/// To be documented.
///
public static bool CheckboxFlags(ref byte label, long* flags, long flagsValue)
{
fixed (byte* plabel = &label)
{
byte ret = CheckboxFlagsNative((byte*)plabel, flags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ReadOnlySpan label, long* flags, long flagsValue)
{
fixed (byte* plabel = label)
{
byte ret = CheckboxFlagsNative((byte*)plabel, flags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(string label, long* flags, long flagsValue)
{
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 = CheckboxFlagsNative(pStr0, flags, flagsValue);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool CheckboxFlags(byte* label, ref long flags, long flagsValue)
{
fixed (long* pflags = &flags)
{
byte ret = CheckboxFlagsNative(label, (long*)pflags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ref byte label, ref long flags, long flagsValue)
{
fixed (byte* plabel = &label)
{
fixed (long* pflags = &flags)
{
byte ret = CheckboxFlagsNative((byte*)plabel, (long*)pflags, flagsValue);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ReadOnlySpan label, ref long flags, long flagsValue)
{
fixed (byte* plabel = label)
{
fixed (long* pflags = &flags)
{
byte ret = CheckboxFlagsNative((byte*)plabel, (long*)pflags, flagsValue);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(string label, ref long flags, long flagsValue)
{
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 (long* pflags = &flags)
{
byte ret = CheckboxFlagsNative(pStr0, (long*)pflags, flagsValue);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte CheckboxFlagsNative(byte* label, ulong* flags, ulong flagsValue)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1206])(label, flags, flagsValue);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1206])((nint)label, (nint)flags, flagsValue);
#endif
}
///
/// To be documented.
///
public static bool CheckboxFlags(byte* label, ulong* flags, ulong flagsValue)
{
byte ret = CheckboxFlagsNative(label, flags, flagsValue);
return ret != 0;
}
///
/// To be documented.
///
public static bool CheckboxFlags(ref byte label, ulong* flags, ulong flagsValue)
{
fixed (byte* plabel = &label)
{
byte ret = CheckboxFlagsNative((byte*)plabel, flags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ReadOnlySpan label, ulong* flags, ulong flagsValue)
{
fixed (byte* plabel = label)
{
byte ret = CheckboxFlagsNative((byte*)plabel, flags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(string label, ulong* flags, ulong flagsValue)
{
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 = CheckboxFlagsNative(pStr0, flags, flagsValue);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool CheckboxFlags(byte* label, ref ulong flags, ulong flagsValue)
{
fixed (ulong* pflags = &flags)
{
byte ret = CheckboxFlagsNative(label, (ulong*)pflags, flagsValue);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ref byte label, ref ulong flags, ulong flagsValue)
{
fixed (byte* plabel = &label)
{
fixed (ulong* pflags = &flags)
{
byte ret = CheckboxFlagsNative((byte*)plabel, (ulong*)pflags, flagsValue);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(ReadOnlySpan label, ref ulong flags, ulong flagsValue)
{
fixed (byte* plabel = label)
{
fixed (ulong* pflags = &flags)
{
byte ret = CheckboxFlagsNative((byte*)plabel, (ulong*)pflags, flagsValue);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool CheckboxFlags(string label, ref ulong flags, ulong flagsValue)
{
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 (ulong* pflags = &flags)
{
byte ret = CheckboxFlagsNative(pStr0, (ulong*)pflags, flagsValue);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte ButtonBehaviorNative(ImRect bb, uint id, bool* outHovered, bool* outHeld, ImGuiButtonFlags flags)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1207])(bb, id, outHovered, outHeld, flags);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1207])(bb, id, (nint)outHovered, (nint)outHeld, flags);
#endif
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, bool* outHeld, ImGuiButtonFlags flags)
{
byte ret = ButtonBehaviorNative(bb, id, outHovered, outHeld, flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, bool* outHeld)
{
byte ret = ButtonBehaviorNative(bb, id, outHovered, outHeld, (ImGuiButtonFlags)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, bool* outHeld, ImGuiButtonFlags flags)
{
fixed (bool* poutHovered = &outHovered)
{
byte ret = ButtonBehaviorNative(bb, id, (bool*)poutHovered, outHeld, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, bool* outHeld)
{
fixed (bool* poutHovered = &outHovered)
{
byte ret = ButtonBehaviorNative(bb, id, (bool*)poutHovered, outHeld, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, ref bool outHeld, ImGuiButtonFlags flags)
{
fixed (bool* poutHeld = &outHeld)
{
byte ret = ButtonBehaviorNative(bb, id, outHovered, (bool*)poutHeld, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, ref bool outHeld)
{
fixed (bool* poutHeld = &outHeld)
{
byte ret = ButtonBehaviorNative(bb, id, outHovered, (bool*)poutHeld, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, ref bool outHeld, ImGuiButtonFlags flags)
{
fixed (bool* poutHovered = &outHovered)
{
fixed (bool* poutHeld = &outHeld)
{
byte ret = ButtonBehaviorNative(bb, id, (bool*)poutHovered, (bool*)poutHeld, flags);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, ref bool outHeld)
{
fixed (bool* poutHovered = &outHovered)
{
fixed (bool* poutHeld = &outHeld)
{
byte ret = ButtonBehaviorNative(bb, id, (bool*)poutHovered, (bool*)poutHeld, (ImGuiButtonFlags)(0));
return ret != 0;
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte DragBehaviorNative(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1208])(id, dataType, pV, vSpeed, pMin, pMax, format, flags);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1208])(id, dataType, (nint)pV, vSpeed, (nint)pMin, (nint)pMax, (nint)format, flags);
#endif
}
///
/// To be documented.
///
public static bool DragBehavior(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags)
{
byte ret = DragBehaviorNative(id, dataType, pV, vSpeed, pMin, pMax, format, flags);
return ret != 0;
}
///
/// To be documented.
///
public static bool DragBehavior(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, ref byte format, ImGuiSliderFlags flags)
{
fixed (byte* pformat = &format)
{
byte ret = DragBehaviorNative(id, dataType, pV, vSpeed, pMin, pMax, (byte*)pformat, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool DragBehavior(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, ReadOnlySpan format, ImGuiSliderFlags flags)
{
fixed (byte* pformat = format)
{
byte ret = DragBehaviorNative(id, dataType, pV, vSpeed, pMin, pMax, (byte*)pformat, flags);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool DragBehavior(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, string format, ImGuiSliderFlags flags)
{
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 = DragBehaviorNative(id, dataType, pV, vSpeed, pMin, pMax, pStr0, flags);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte SliderBehaviorNative(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags, ImRect* outGrabBb)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1209])(bb, id, dataType, pV, pMin, pMax, format, flags, outGrabBb);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1209])(bb, id, dataType, (nint)pV, (nint)pMin, (nint)pMax, (nint)format, flags, (nint)outGrabBb);
#endif
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags, ImRectPtr outGrabBb)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, format, flags, outGrabBb);
return ret != 0;
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, ref byte format, ImGuiSliderFlags flags, ImRectPtr outGrabBb)
{
fixed (byte* pformat = &format)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, (byte*)pformat, flags, outGrabBb);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, ReadOnlySpan format, ImGuiSliderFlags flags, ImRectPtr outGrabBb)
{
fixed (byte* pformat = format)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, (byte*)pformat, flags, outGrabBb);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, string format, ImGuiSliderFlags flags, ImRectPtr outGrabBb)
{
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 = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, pStr0, flags, outGrabBb);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags, ref ImRect outGrabBb)
{
fixed (ImRect* poutGrabBb = &outGrabBb)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, format, flags, (ImRect*)poutGrabBb);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, ref byte format, ImGuiSliderFlags flags, ref ImRect outGrabBb)
{
fixed (byte* pformat = &format)
{
fixed (ImRect* poutGrabBb = &outGrabBb)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, (byte*)pformat, flags, (ImRect*)poutGrabBb);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, ReadOnlySpan format, ImGuiSliderFlags flags, ref ImRect outGrabBb)
{
fixed (byte* pformat = format)
{
fixed (ImRect* poutGrabBb = &outGrabBb)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, (byte*)pformat, flags, (ImRect*)poutGrabBb);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SliderBehavior(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, string format, ImGuiSliderFlags flags, ref ImRect outGrabBb)
{
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;
}
fixed (ImRect* poutGrabBb = &outGrabBb)
{
byte ret = SliderBehaviorNative(bb, id, dataType, pV, pMin, pMax, pStr0, flags, (ImRect*)poutGrabBb);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte SplitterBehaviorNative(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1210])(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1210])(bb, id, axis, (nint)size1, (nint)size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
#endif
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, uint bgCol)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
return ret != 0;
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, uint bgCol)
{
fixed (float* psize1 = &size1)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, uint bgCol)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, uint bgCol)
{
fixed (float* psize1 = &size1)
{
fixed (float* psize2 = &size2)
{
byte ret = SplitterBehaviorNative(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
return ret != 0;
}
}
}
///
/// To be documented.
///
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static byte TreeNodeBehaviorNative(uint id, ImGuiTreeNodeFlags flags, byte* label, byte* labelEnd)
{
#if NET5_0_OR_GREATER
return ((delegate* unmanaged[Cdecl])funcTable[1211])(id, flags, label, labelEnd);
#else
return (byte)((delegate* unmanaged[Cdecl])funcTable[1211])(id, flags, (nint)label, (nint)labelEnd);
#endif
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, byte* label, byte* labelEnd)
{
byte ret = TreeNodeBehaviorNative(id, flags, label, labelEnd);
return ret != 0;
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, byte* label)
{
byte ret = TreeNodeBehaviorNative(id, flags, label, (byte*)(default));
return ret != 0;
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ref byte label, byte* labelEnd)
{
fixed (byte* plabel = &label)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, labelEnd);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ref byte label)
{
fixed (byte* plabel = &label)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, (byte*)(default));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ReadOnlySpan label, byte* labelEnd)
{
fixed (byte* plabel = label)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, labelEnd);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ReadOnlySpan label)
{
fixed (byte* plabel = label)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, (byte*)(default));
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, string label, byte* labelEnd)
{
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 = TreeNodeBehaviorNative(id, flags, pStr0, labelEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, 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 = TreeNodeBehaviorNative(id, flags, pStr0, (byte*)(default));
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, byte* label, ref byte labelEnd)
{
fixed (byte* plabelEnd = &labelEnd)
{
byte ret = TreeNodeBehaviorNative(id, flags, label, (byte*)plabelEnd);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, byte* label, ReadOnlySpan labelEnd)
{
fixed (byte* plabelEnd = labelEnd)
{
byte ret = TreeNodeBehaviorNative(id, flags, label, (byte*)plabelEnd);
return ret != 0;
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, byte* label, string labelEnd)
{
byte* pStr0 = null;
int pStrSize0 = 0;
if (labelEnd != null)
{
pStrSize0 = Utils.GetByteCountUTF8(labelEnd);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
pStr0 = Utils.Alloc(pStrSize0 + 1);
}
else
{
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
pStr0 = pStrStack0;
}
int pStrOffset0 = Utils.EncodeStringUTF8(labelEnd, pStr0, pStrSize0);
pStr0[pStrOffset0] = 0;
}
byte ret = TreeNodeBehaviorNative(id, flags, label, pStr0);
if (pStrSize0 >= Utils.MaxStackallocSize)
{
Utils.Free(pStr0);
}
return ret != 0;
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ref byte label, ref byte labelEnd)
{
fixed (byte* plabel = &label)
{
fixed (byte* plabelEnd = &labelEnd)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, (byte*)plabelEnd);
return ret != 0;
}
}
}
///
/// To be documented.
///
public static bool TreeNodeBehavior(uint id, ImGuiTreeNodeFlags flags, ReadOnlySpan label, ReadOnlySpan labelEnd)
{
fixed (byte* plabel = label)
{
fixed (byte* plabelEnd = labelEnd)
{
byte ret = TreeNodeBehaviorNative(id, flags, (byte*)plabel, (byte*)plabelEnd);
return ret != 0;
}
}
}
}
}