Dalamud/imgui/Dalamud.Bindings.ImGui/Generated/Functions/Functions.089.cs

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using HexaGen.Runtime;
using System.Numerics;

namespace Dalamud.Bindings.ImGui
{
	public unsafe partial class ImGui
	{

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int sizeNative(ImGuiTextBuffer* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, int>)funcTable[449])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[449])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int size(ImGuiTextBufferPtr self)
		{
			int ret = sizeNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int size(ref ImGuiTextBuffer self)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				int ret = sizeNative((ImGuiTextBuffer*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte emptyNative(ImGuiTextBuffer* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, byte>)funcTable[450])(self);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, byte>)funcTable[450])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool empty(ImGuiTextBufferPtr self)
		{
			byte ret = emptyNative(self);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool empty(ref ImGuiTextBuffer self)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte ret = emptyNative((ImGuiTextBuffer*)pself);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void clearNative(ImGuiTextBuffer* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, void>)funcTable[451])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[451])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void clear(ImGuiTextBufferPtr self)
		{
			clearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void clear(ref ImGuiTextBuffer self)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				clearNative((ImGuiTextBuffer*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void reserveNative(ImGuiTextBuffer* self, int capacity)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, int, void>)funcTable[452])(self, capacity);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[452])((nint)self, capacity);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void reserve(ImGuiTextBufferPtr self, int capacity)
		{
			reserveNative(self, capacity);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void reserve(ref ImGuiTextBuffer self, int capacity)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				reserveNative((ImGuiTextBuffer*)pself, capacity);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte* c_strNative(ImGuiTextBuffer* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, byte*>)funcTable[453])(self);
			#else
			return (byte*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[453])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte* c_str(ImGuiTextBufferPtr self)
		{
			byte* ret = c_strNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static string c_strS(ImGuiTextBufferPtr self)
		{
			string ret = Utils.DecodeStringUTF8(c_strNative(self));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte* c_str(ref ImGuiTextBuffer self)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* ret = c_strNative((ImGuiTextBuffer*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static string c_strS(ref ImGuiTextBuffer self)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				string ret = Utils.DecodeStringUTF8(c_strNative((ImGuiTextBuffer*)pself));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void appendNative(ImGuiTextBuffer* self, byte* str, byte* strEnd)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, byte*, byte*, void>)funcTable[454])(self, str, strEnd);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, void>)funcTable[454])((nint)self, (nint)str, (nint)strEnd);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, byte* str, byte* strEnd)
		{
			appendNative(self, str, strEnd);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, byte* str)
		{
			appendNative(self, str, (byte*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, byte* str, byte* strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				appendNative((ImGuiTextBuffer*)pself, str, strEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, byte* str)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				appendNative((ImGuiTextBuffer*)pself, str, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ref byte str, byte* strEnd)
		{
			fixed (byte* pstr = &str)
			{
				appendNative(self, (byte*)pstr, strEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ref byte str)
		{
			fixed (byte* pstr = &str)
			{
				appendNative(self, (byte*)pstr, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ReadOnlySpan<byte> str, byte* strEnd)
		{
			fixed (byte* pstr = str)
			{
				appendNative(self, (byte*)pstr, strEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ReadOnlySpan<byte> str)
		{
			fixed (byte* pstr = str)
			{
				appendNative(self, (byte*)pstr, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, string str, byte* strEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (str != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(str);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			appendNative(self, pStr0, strEnd);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, string str)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (str != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(str);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			appendNative(self, pStr0, (byte*)(default));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ref byte str, byte* strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = &str)
				{
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, strEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ref byte str)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = &str)
				{
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)(default));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ReadOnlySpan<byte> str, byte* strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = str)
				{
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, strEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ReadOnlySpan<byte> str)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = str)
				{
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)(default));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, string str, byte* strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (str != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(str);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendNative((ImGuiTextBuffer*)pself, pStr0, strEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, string str)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (str != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(str);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendNative((ImGuiTextBuffer*)pself, pStr0, (byte*)(default));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, byte* str, ref byte strEnd)
		{
			fixed (byte* pstrEnd = &strEnd)
			{
				appendNative(self, str, (byte*)pstrEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, byte* str, ReadOnlySpan<byte> strEnd)
		{
			fixed (byte* pstrEnd = strEnd)
			{
				appendNative(self, str, (byte*)pstrEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, byte* str, string strEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (strEnd != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(strEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			appendNative(self, str, pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, byte* str, ref byte strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstrEnd = &strEnd)
				{
					appendNative((ImGuiTextBuffer*)pself, str, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, byte* str, ReadOnlySpan<byte> strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstrEnd = strEnd)
				{
					appendNative((ImGuiTextBuffer*)pself, str, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, byte* str, string strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (strEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(strEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendNative((ImGuiTextBuffer*)pself, str, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ref byte str, ref byte strEnd)
		{
			fixed (byte* pstr = &str)
			{
				fixed (byte* pstrEnd = &strEnd)
				{
					appendNative(self, (byte*)pstr, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ReadOnlySpan<byte> str, ReadOnlySpan<byte> strEnd)
		{
			fixed (byte* pstr = str)
			{
				fixed (byte* pstrEnd = strEnd)
				{
					appendNative(self, (byte*)pstr, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, string str, string strEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (str != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(str);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (strEnd != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(strEnd);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			appendNative(self, pStr0, pStr1);
			if (pStrSize1 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr1);
			}
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ref byte str, ReadOnlySpan<byte> strEnd)
		{
			fixed (byte* pstr = &str)
			{
				fixed (byte* pstrEnd = strEnd)
				{
					appendNative(self, (byte*)pstr, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ref byte str, string strEnd)
		{
			fixed (byte* pstr = &str)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (strEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(strEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendNative(self, (byte*)pstr, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ReadOnlySpan<byte> str, ref byte strEnd)
		{
			fixed (byte* pstr = str)
			{
				fixed (byte* pstrEnd = &strEnd)
				{
					appendNative(self, (byte*)pstr, (byte*)pstrEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, ReadOnlySpan<byte> str, string strEnd)
		{
			fixed (byte* pstr = str)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (strEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(strEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendNative(self, (byte*)pstr, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, string str, ref byte strEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (str != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(str);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pstrEnd = &strEnd)
			{
				appendNative(self, pStr0, (byte*)pstrEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ImGuiTextBufferPtr self, string str, ReadOnlySpan<byte> strEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (str != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(str);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pstrEnd = strEnd)
			{
				appendNative(self, pStr0, (byte*)pstrEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ref byte str, ref byte strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = &str)
				{
					fixed (byte* pstrEnd = &strEnd)
					{
						appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)pstrEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ReadOnlySpan<byte> str, ReadOnlySpan<byte> strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = str)
				{
					fixed (byte* pstrEnd = strEnd)
					{
						appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)pstrEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, string str, string strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (str != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(str);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				byte* pStr1 = null;
				int pStrSize1 = 0;
				if (strEnd != null)
				{
					pStrSize1 = Utils.GetByteCountUTF8(strEnd);
					if (pStrSize1 >= Utils.MaxStackallocSize)
					{
						pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
					}
					else
					{
						byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
						pStr1 = pStrStack1;
					}
					int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
					pStr1[pStrOffset1] = 0;
				}
				appendNative((ImGuiTextBuffer*)pself, pStr0, pStr1);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr1);
				}
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ref byte str, ReadOnlySpan<byte> strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = &str)
				{
					fixed (byte* pstrEnd = strEnd)
					{
						appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)pstrEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ref byte str, string strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = &str)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (strEnd != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(strEnd);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, pStr0);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ReadOnlySpan<byte> str, ref byte strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = str)
				{
					fixed (byte* pstrEnd = &strEnd)
					{
						appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, (byte*)pstrEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, ReadOnlySpan<byte> str, string strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pstr = str)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (strEnd != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(strEnd);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					appendNative((ImGuiTextBuffer*)pself, (byte*)pstr, pStr0);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, string str, ref byte strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (str != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(str);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (byte* pstrEnd = &strEnd)
				{
					appendNative((ImGuiTextBuffer*)pself, pStr0, (byte*)pstrEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void append(ref ImGuiTextBuffer self, string str, ReadOnlySpan<byte> strEnd)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (str != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(str);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (byte* pstrEnd = strEnd)
				{
					appendNative((ImGuiTextBuffer*)pself, pStr0, (byte*)pstrEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void appendfvNative(ImGuiTextBuffer* self, byte* fmt, nuint args)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTextBuffer*, byte*, nuint, void>)funcTable[455])(self, fmt, args);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nuint, void>)funcTable[455])((nint)self, (nint)fmt, args);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ImGuiTextBufferPtr self, byte* fmt, nuint args)
		{
			appendfvNative(self, fmt, args);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ref ImGuiTextBuffer self, byte* fmt, nuint args)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				appendfvNative((ImGuiTextBuffer*)pself, fmt, args);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ImGuiTextBufferPtr self, ref byte fmt, nuint args)
		{
			fixed (byte* pfmt = &fmt)
			{
				appendfvNative(self, (byte*)pfmt, args);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ImGuiTextBufferPtr self, ReadOnlySpan<byte> fmt, nuint args)
		{
			fixed (byte* pfmt = fmt)
			{
				appendfvNative(self, (byte*)pfmt, args);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ImGuiTextBufferPtr self, string fmt, nuint args)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (fmt != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(fmt);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			appendfvNative(self, pStr0, args);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ref ImGuiTextBuffer self, ref byte fmt, nuint args)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pfmt = &fmt)
				{
					appendfvNative((ImGuiTextBuffer*)pself, (byte*)pfmt, args);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ref ImGuiTextBuffer self, ReadOnlySpan<byte> fmt, nuint args)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				fixed (byte* pfmt = fmt)
				{
					appendfvNative((ImGuiTextBuffer*)pself, (byte*)pfmt, args);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void appendfv(ref ImGuiTextBuffer self, string fmt, nuint args)
		{
			fixed (ImGuiTextBuffer* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (fmt != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(fmt);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				appendfvNative((ImGuiTextBuffer*)pself, pStr0, args);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStoragePair* ImGuiStoragePairNative(uint key, int valI)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, int, ImGuiStoragePair*>)funcTable[456])(key, valI);
			#else
			return (ImGuiStoragePair*)((delegate* unmanaged[Cdecl]<uint, int, nint>)funcTable[456])(key, valI);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStoragePairPtr ImGuiStoragePair(uint key, int valI)
		{
			ImGuiStoragePairPtr ret = ImGuiStoragePairNative(key, valI);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImGuiStoragePair* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStoragePair*, void>)funcTable[457])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[457])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImGuiStoragePairPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImGuiStoragePair self)
		{
			fixed (ImGuiStoragePair* pself = &self)
			{
				DestroyNative((ImGuiStoragePair*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStoragePair* ImGuiStoragePairNative(uint key, float valF)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, float, ImGuiStoragePair*>)funcTable[458])(key, valF);
			#else
			return (ImGuiStoragePair*)((delegate* unmanaged[Cdecl]<uint, float, nint>)funcTable[458])(key, valF);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStoragePairPtr ImGuiStoragePair(uint key, float valF)
		{
			ImGuiStoragePairPtr ret = ImGuiStoragePairNative(key, valF);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStoragePair* ImGuiStoragePairNative(uint key, void* valP)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, void*, ImGuiStoragePair*>)funcTable[459])(key, valP);
			#else
			return (ImGuiStoragePair*)((delegate* unmanaged[Cdecl]<uint, nint, nint>)funcTable[459])(key, (nint)valP);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStoragePairPtr ImGuiStoragePair(uint key, void* valP)
		{
			ImGuiStoragePairPtr ret = ImGuiStoragePairNative(key, valP);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearNative(ImGuiStorage* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, void>)funcTable[460])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[460])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ImGuiStoragePtr self)
		{
			ClearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ref ImGuiStorage self)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				ClearNative((ImGuiStorage*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetIntNative(ImGuiStorage* self, uint key, int defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, int, int>)funcTable[461])(self, key, defaultVal);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, uint, int, int>)funcTable[461])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetInt(ImGuiStoragePtr self, uint key, int defaultVal)
		{
			int ret = GetIntNative(self, key, defaultVal);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetInt(ImGuiStoragePtr self, uint key)
		{
			int ret = GetIntNative(self, key, (int)(0));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetInt(ref ImGuiStorage self, uint key, int defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				int ret = GetIntNative((ImGuiStorage*)pself, key, defaultVal);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetInt(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				int ret = GetIntNative((ImGuiStorage*)pself, key, (int)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetIntNative(ImGuiStorage* self, uint key, int val)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, int, void>)funcTable[462])(self, key, val);
			#else
			((delegate* unmanaged[Cdecl]<nint, uint, int, void>)funcTable[462])((nint)self, key, val);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetInt(ImGuiStoragePtr self, uint key, int val)
		{
			SetIntNative(self, key, val);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetInt(ref ImGuiStorage self, uint key, int val)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				SetIntNative((ImGuiStorage*)pself, key, val);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte GetBoolNative(ImGuiStorage* self, uint key, byte defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, byte, byte>)funcTable[463])(self, key, defaultVal);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, uint, byte, byte>)funcTable[463])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool GetBool(ImGuiStoragePtr self, uint key, bool defaultVal)
		{
			byte ret = GetBoolNative(self, key, defaultVal ? (byte)1 : (byte)0);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool GetBool(ImGuiStoragePtr self, uint key)
		{
			byte ret = GetBoolNative(self, key, (byte)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool GetBool(ref ImGuiStorage self, uint key, bool defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				byte ret = GetBoolNative((ImGuiStorage*)pself, key, defaultVal ? (byte)1 : (byte)0);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool GetBool(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				byte ret = GetBoolNative((ImGuiStorage*)pself, key, (byte)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetBoolNative(ImGuiStorage* self, uint key, byte val)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, byte, void>)funcTable[464])(self, key, val);
			#else
			((delegate* unmanaged[Cdecl]<nint, uint, byte, void>)funcTable[464])((nint)self, key, val);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetBool(ImGuiStoragePtr self, uint key, bool val)
		{
			SetBoolNative(self, key, val ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetBool(ref ImGuiStorage self, uint key, bool val)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				SetBoolNative((ImGuiStorage*)pself, key, val ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetFloatNative(ImGuiStorage* self, uint key, float defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, float, float>)funcTable[465])(self, key, defaultVal);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, uint, float, float>)funcTable[465])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetFloat(ImGuiStoragePtr self, uint key, float defaultVal)
		{
			float ret = GetFloatNative(self, key, defaultVal);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetFloat(ImGuiStoragePtr self, uint key)
		{
			float ret = GetFloatNative(self, key, (float)(0.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetFloat(ref ImGuiStorage self, uint key, float defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				float ret = GetFloatNative((ImGuiStorage*)pself, key, defaultVal);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetFloat(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				float ret = GetFloatNative((ImGuiStorage*)pself, key, (float)(0.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetFloatNative(ImGuiStorage* self, uint key, float val)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, float, void>)funcTable[466])(self, key, val);
			#else
			((delegate* unmanaged[Cdecl]<nint, uint, float, void>)funcTable[466])((nint)self, key, val);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetFloat(ImGuiStoragePtr self, uint key, float val)
		{
			SetFloatNative(self, key, val);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetFloat(ref ImGuiStorage self, uint key, float val)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				SetFloatNative((ImGuiStorage*)pself, key, val);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void* GetVoidPtrNative(ImGuiStorage* self, uint key)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, void*>)funcTable[467])(self, key);
			#else
			return (void*)((delegate* unmanaged[Cdecl]<nint, uint, nint>)funcTable[467])((nint)self, key);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* GetVoidPtr(ImGuiStoragePtr self, uint key)
		{
			void* ret = GetVoidPtrNative(self, key);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* GetVoidPtr(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				void* ret = GetVoidPtrNative((ImGuiStorage*)pself, key);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetVoidPtrNative(ImGuiStorage* self, uint key, void* val)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, void*, void>)funcTable[468])(self, key, val);
			#else
			((delegate* unmanaged[Cdecl]<nint, uint, nint, void>)funcTable[468])((nint)self, key, (nint)val);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetVoidPtr(ImGuiStoragePtr self, uint key, void* val)
		{
			SetVoidPtrNative(self, key, val);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetVoidPtr(ref ImGuiStorage self, uint key, void* val)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				SetVoidPtrNative((ImGuiStorage*)pself, key, val);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int* GetIntRefNative(ImGuiStorage* self, uint key, int defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, int, int*>)funcTable[469])(self, key, defaultVal);
			#else
			return (int*)((delegate* unmanaged[Cdecl]<nint, uint, int, nint>)funcTable[469])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int* GetIntRef(ImGuiStoragePtr self, uint key, int defaultVal)
		{
			int* ret = GetIntRefNative(self, key, defaultVal);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int* GetIntRef(ImGuiStoragePtr self, uint key)
		{
			int* ret = GetIntRefNative(self, key, (int)(0));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int* GetIntRef(ref ImGuiStorage self, uint key, int defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				int* ret = GetIntRefNative((ImGuiStorage*)pself, key, defaultVal);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int* GetIntRef(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				int* ret = GetIntRefNative((ImGuiStorage*)pself, key, (int)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool* GetBoolRefNative(ImGuiStorage* self, uint key, byte defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, byte, bool*>)funcTable[470])(self, key, defaultVal);
			#else
			return (bool*)((delegate* unmanaged[Cdecl]<nint, uint, byte, nint>)funcTable[470])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool* GetBoolRef(ImGuiStoragePtr self, uint key, bool defaultVal)
		{
			bool* ret = GetBoolRefNative(self, key, defaultVal ? (byte)1 : (byte)0);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool* GetBoolRef(ImGuiStoragePtr self, uint key)
		{
			bool* ret = GetBoolRefNative(self, key, (byte)(0));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool* GetBoolRef(ref ImGuiStorage self, uint key, bool defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				bool* ret = GetBoolRefNative((ImGuiStorage*)pself, key, defaultVal ? (byte)1 : (byte)0);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool* GetBoolRef(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				bool* ret = GetBoolRefNative((ImGuiStorage*)pself, key, (byte)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float* GetFloatRefNative(ImGuiStorage* self, uint key, float defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, float, float*>)funcTable[471])(self, key, defaultVal);
			#else
			return (float*)((delegate* unmanaged[Cdecl]<nint, uint, float, nint>)funcTable[471])((nint)self, key, defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float* GetFloatRef(ImGuiStoragePtr self, uint key, float defaultVal)
		{
			float* ret = GetFloatRefNative(self, key, defaultVal);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float* GetFloatRef(ImGuiStoragePtr self, uint key)
		{
			float* ret = GetFloatRefNative(self, key, (float)(0.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float* GetFloatRef(ref ImGuiStorage self, uint key, float defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				float* ret = GetFloatRefNative((ImGuiStorage*)pself, key, defaultVal);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float* GetFloatRef(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				float* ret = GetFloatRefNative((ImGuiStorage*)pself, key, (float)(0.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void** GetVoidPtrRefNative(ImGuiStorage* self, uint key, void* defaultVal)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*, uint, void*, void**>)funcTable[472])(self, key, defaultVal);
			#else
			return (void**)((delegate* unmanaged[Cdecl]<nint, uint, nint, nint>)funcTable[472])((nint)self, key, (nint)defaultVal);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void** GetVoidPtrRef(ImGuiStoragePtr self, uint key, void* defaultVal)
		{
			void** ret = GetVoidPtrRefNative(self, key, defaultVal);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void** GetVoidPtrRef(ImGuiStoragePtr self, uint key)
		{
			void** ret = GetVoidPtrRefNative(self, key, (void*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void** GetVoidPtrRef(ref ImGuiStorage self, uint key, void* defaultVal)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				void** ret = GetVoidPtrRefNative((ImGuiStorage*)pself, key, defaultVal);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void** GetVoidPtrRef(ref ImGuiStorage self, uint key)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				void** ret = GetVoidPtrRefNative((ImGuiStorage*)pself, key, (void*)(default));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetAllIntNative(ImGuiStorage* self, int val)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, int, void>)funcTable[473])(self, val);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[473])((nint)self, val);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetAllInt(ImGuiStoragePtr self, int val)
		{
			SetAllIntNative(self, val);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetAllInt(ref ImGuiStorage self, int val)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				SetAllIntNative((ImGuiStorage*)pself, val);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void BuildSortByKeyNative(ImGuiStorage* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, void>)funcTable[474])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[474])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BuildSortByKey(ImGuiStoragePtr self)
		{
			BuildSortByKeyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BuildSortByKey(ref ImGuiStorage self)
		{
			fixed (ImGuiStorage* pself = &self)
			{
				BuildSortByKeyNative((ImGuiStorage*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiListClipper* ImGuiListClipperNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiListClipper*>)funcTable[475])();
			#else
			return (ImGuiListClipper*)((delegate* unmanaged[Cdecl]<nint>)funcTable[475])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiListClipperPtr ImGuiListClipper()
		{
			ImGuiListClipperPtr ret = ImGuiListClipperNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImGuiListClipper* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiListClipper*, void>)funcTable[476])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[476])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImGuiListClipperPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImGuiListClipper self)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				DestroyNative((ImGuiListClipper*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void BeginNative(ImGuiListClipper* self, int itemsCount, float itemsHeight)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiListClipper*, int, float, void>)funcTable[477])(self, itemsCount, itemsHeight);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, float, void>)funcTable[477])((nint)self, itemsCount, itemsHeight);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Begin(ImGuiListClipperPtr self, int itemsCount, float itemsHeight)
		{
			BeginNative(self, itemsCount, itemsHeight);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Begin(ImGuiListClipperPtr self, int itemsCount)
		{
			BeginNative(self, itemsCount, (float)(-1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Begin(ref ImGuiListClipper self, int itemsCount, float itemsHeight)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				BeginNative((ImGuiListClipper*)pself, itemsCount, itemsHeight);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Begin(ref ImGuiListClipper self, int itemsCount)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				BeginNative((ImGuiListClipper*)pself, itemsCount, (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndNative(ImGuiListClipper* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiListClipper*, void>)funcTable[478])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[478])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void End(ImGuiListClipperPtr self)
		{
			EndNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void End(ref ImGuiListClipper self)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				EndNative((ImGuiListClipper*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte StepNative(ImGuiListClipper* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiListClipper*, byte>)funcTable[479])(self);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, byte>)funcTable[479])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Step(ImGuiListClipperPtr self)
		{
			byte ret = StepNative(self);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Step(ref ImGuiListClipper self)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				byte ret = StepNative((ImGuiListClipper*)pself);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ForceDisplayRangeByIndicesNative(ImGuiListClipper* self, int itemMin, int itemMax)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiListClipper*, int, int, void>)funcTable[480])(self, itemMin, itemMax);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, int, void>)funcTable[480])((nint)self, itemMin, itemMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ForceDisplayRangeByIndices(ImGuiListClipperPtr self, int itemMin, int itemMax)
		{
			ForceDisplayRangeByIndicesNative(self, itemMin, itemMax);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ForceDisplayRangeByIndices(ref ImGuiListClipper self, int itemMin, int itemMax)
		{
			fixed (ImGuiListClipper* pself = &self)
			{
				ForceDisplayRangeByIndicesNative((ImGuiListClipper*)pself, itemMin, itemMax);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImColor* ImColorNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImColor*>)funcTable[481])();
			#else
			return (ImColor*)((delegate* unmanaged[Cdecl]<nint>)funcTable[481])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor()
		{
			ImColorPtr ret = ImColorNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImColor* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImColor*, void>)funcTable[482])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[482])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImColorPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImColor self)
		{
			fixed (ImColor* pself = &self)
			{
				DestroyNative((ImColor*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImColor* ImColorNative(float r, float g, float b, float a)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, float, float, ImColor*>)funcTable[483])(r, g, b, a);
			#else
			return (ImColor*)((delegate* unmanaged[Cdecl]<float, float, float, float, nint>)funcTable[483])(r, g, b, a);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(float r, float g, float b, float a)
		{
			ImColorPtr ret = ImColorNative(r, g, b, a);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(float r, float g, float b)
		{
			ImColorPtr ret = ImColorNative(r, g, b, (float)(1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImColor* ImColorNative(Vector4 col)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector4, ImColor*>)funcTable[484])(col);
			#else
			return (ImColor*)((delegate* unmanaged[Cdecl]<Vector4, nint>)funcTable[484])(col);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(Vector4 col)
		{
			ImColorPtr ret = ImColorNative(col);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImColor* ImColorNative(int r, int g, int b, int a)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, int, int, int, ImColor*>)funcTable[485])(r, g, b, a);
			#else
			return (ImColor*)((delegate* unmanaged[Cdecl]<int, int, int, int, nint>)funcTable[485])(r, g, b, a);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(int r, int g, int b, int a)
		{
			ImColorPtr ret = ImColorNative(r, g, b, a);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(int r, int g, int b)
		{
			ImColorPtr ret = ImColorNative(r, g, b, (int)(255));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImColor* ImColorNative(uint rgba)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, ImColor*>)funcTable[486])(rgba);
			#else
			return (ImColor*)((delegate* unmanaged[Cdecl]<uint, nint>)funcTable[486])(rgba);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColorPtr ImColor(uint rgba)
		{
			ImColorPtr ret = ImColorNative(rgba);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetHSVNative(ImColor* self, float h, float s, float v, float a)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImColor*, float, float, float, float, void>)funcTable[487])(self, h, s, v, a);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, float, float, float, void>)funcTable[487])((nint)self, h, s, v, a);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetHSV(ImColorPtr self, float h, float s, float v, float a)
		{
			SetHSVNative(self, h, s, v, a);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetHSV(ImColorPtr self, float h, float s, float v)
		{
			SetHSVNative(self, h, s, v, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetHSV(ref ImColor self, float h, float s, float v, float a)
		{
			fixed (ImColor* pself = &self)
			{
				SetHSVNative((ImColor*)pself, h, s, v, a);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetHSV(ref ImColor self, float h, float s, float v)
		{
			fixed (ImColor* pself = &self)
			{
				SetHSVNative((ImColor*)pself, h, s, v, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void HSVNative(ImColor* pOut, float h, float s, float v, float a)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImColor*, float, float, float, float, void>)funcTable[488])(pOut, h, s, v, a);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, float, float, float, void>)funcTable[488])((nint)pOut, h, s, v, a);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColor HSV(float h, float s, float v)
		{
			ImColor ret;
			HSVNative(&ret, h, s, v, (float)(1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImColor HSV(float h, float s, float v, float a)
		{
			ImColor ret;
			HSVNative(&ret, h, s, v, a);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void HSV(ImColorPtr pOut, float h, float s, float v, float a)
		{
			HSVNative(pOut, h, s, v, a);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void HSV(ImColorPtr pOut, float h, float s, float v)
		{
			HSVNative(pOut, h, s, v, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void HSV(ref ImColor pOut, float h, float s, float v, float a)
		{
			fixed (ImColor* ppOut = &pOut)
			{
				HSVNative((ImColor*)ppOut, h, s, v, a);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void HSV(ref ImColor pOut, float h, float s, float v)
		{
			fixed (ImColor* ppOut = &pOut)
			{
				HSVNative((ImColor*)ppOut, h, s, v, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawCmd* ImDrawCmdNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawCmd*>)funcTable[489])();
			#else
			return (ImDrawCmd*)((delegate* unmanaged[Cdecl]<nint>)funcTable[489])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawCmdPtr ImDrawCmd()
		{
			ImDrawCmdPtr ret = ImDrawCmdNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImDrawCmd* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawCmd*, void>)funcTable[490])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[490])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImDrawCmdPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImDrawCmd self)
		{
			fixed (ImDrawCmd* pself = &self)
			{
				DestroyNative((ImDrawCmd*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImTextureID GetTexIDNative(ImDrawCmd* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawCmd*, ImTextureID>)funcTable[491])(self);
			#else
			return (ImTextureID)((delegate* unmanaged[Cdecl]<nint, ImTextureID>)funcTable[491])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImTextureID GetTexID(ImDrawCmdPtr self)
		{
			ImTextureID ret = GetTexIDNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImTextureID GetTexID(ref ImDrawCmd self)
		{
			fixed (ImDrawCmd* pself = &self)
			{
				ImTextureID ret = GetTexIDNative((ImDrawCmd*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawListSplitter* ImDrawListSplitterNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawListSplitter*>)funcTable[492])();
			#else
			return (ImDrawListSplitter*)((delegate* unmanaged[Cdecl]<nint>)funcTable[492])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListSplitterPtr ImDrawListSplitter()
		{
			ImDrawListSplitterPtr ret = ImDrawListSplitterNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImDrawListSplitter* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, void>)funcTable[493])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[493])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImDrawListSplitterPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImDrawListSplitter self)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				DestroyNative((ImDrawListSplitter*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearNative(ImDrawListSplitter* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, void>)funcTable[494])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[494])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ImDrawListSplitterPtr self)
		{
			ClearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ref ImDrawListSplitter self)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				ClearNative((ImDrawListSplitter*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearFreeMemoryNative(ImDrawListSplitter* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, void>)funcTable[495])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[495])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ImDrawListSplitterPtr self)
		{
			ClearFreeMemoryNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ref ImDrawListSplitter self)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				ClearFreeMemoryNative((ImDrawListSplitter*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SplitNative(ImDrawListSplitter* self, ImDrawList* drawList, int count)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, ImDrawList*, int, void>)funcTable[496])(self, drawList, count);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, int, void>)funcTable[496])((nint)self, (nint)drawList, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Split(ImDrawListSplitterPtr self, ImDrawListPtr drawList, int count)
		{
			SplitNative(self, drawList, count);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Split(ref ImDrawListSplitter self, ImDrawListPtr drawList, int count)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				SplitNative((ImDrawListSplitter*)pself, drawList, count);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Split(ImDrawListSplitterPtr self, ref ImDrawList drawList, int count)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				SplitNative(self, (ImDrawList*)pdrawList, count);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Split(ref ImDrawListSplitter self, ref ImDrawList drawList, int count)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				fixed (ImDrawList* pdrawList = &drawList)
				{
					SplitNative((ImDrawListSplitter*)pself, (ImDrawList*)pdrawList, count);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void MergeNative(ImDrawListSplitter* self, ImDrawList* drawList)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, ImDrawList*, void>)funcTable[497])(self, drawList);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[497])((nint)self, (nint)drawList);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Merge(ImDrawListSplitterPtr self, ImDrawListPtr drawList)
		{
			MergeNative(self, drawList);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Merge(ref ImDrawListSplitter self, ImDrawListPtr drawList)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				MergeNative((ImDrawListSplitter*)pself, drawList);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Merge(ImDrawListSplitterPtr self, ref ImDrawList drawList)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				MergeNative(self, (ImDrawList*)pdrawList);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Merge(ref ImDrawListSplitter self, ref ImDrawList drawList)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				fixed (ImDrawList* pdrawList = &drawList)
				{
					MergeNative((ImDrawListSplitter*)pself, (ImDrawList*)pdrawList);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetCurrentChannelNative(ImDrawListSplitter* self, ImDrawList* drawList, int channelIdx)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSplitter*, ImDrawList*, int, void>)funcTable[498])(self, drawList, channelIdx);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, int, void>)funcTable[498])((nint)self, (nint)drawList, channelIdx);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentChannel(ImDrawListSplitterPtr self, ImDrawListPtr drawList, int channelIdx)
		{
			SetCurrentChannelNative(self, drawList, channelIdx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentChannel(ref ImDrawListSplitter self, ImDrawListPtr drawList, int channelIdx)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				SetCurrentChannelNative((ImDrawListSplitter*)pself, drawList, channelIdx);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentChannel(ImDrawListSplitterPtr self, ref ImDrawList drawList, int channelIdx)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				SetCurrentChannelNative(self, (ImDrawList*)pdrawList, channelIdx);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentChannel(ref ImDrawListSplitter self, ref ImDrawList drawList, int channelIdx)
		{
			fixed (ImDrawListSplitter* pself = &self)
			{
				fixed (ImDrawList* pdrawList = &drawList)
				{
					SetCurrentChannelNative((ImDrawListSplitter*)pself, (ImDrawList*)pdrawList, channelIdx);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawList* ImDrawListNative(ImDrawListSharedData* sharedData)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawListSharedData*, ImDrawList*>)funcTable[499])(sharedData);
			#else
			return (ImDrawList*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[499])((nint)sharedData);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr ImDrawList(ImDrawListSharedDataPtr sharedData)
		{
			ImDrawListPtr ret = ImDrawListNative(sharedData);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr ImDrawList(ref ImDrawListSharedData sharedData)
		{
			fixed (ImDrawListSharedData* psharedData = &sharedData)
			{
				ImDrawListPtr ret = ImDrawListNative((ImDrawListSharedData*)psharedData);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DestroyNative(ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[500])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[500])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImDrawListPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				DestroyNative((ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PushClipRectNative(ImDrawList* self, Vector2 clipRectMin, Vector2 clipRectMax, byte intersectWithCurrentClipRect)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, byte, void>)funcTable[501])(self, clipRectMin, clipRectMax, intersectWithCurrentClipRect);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, byte, void>)funcTable[501])((nint)self, clipRectMin, clipRectMax, intersectWithCurrentClipRect);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRect(ImDrawListPtr self, Vector2 clipRectMin, Vector2 clipRectMax, bool intersectWithCurrentClipRect)
		{
			PushClipRectNative(self, clipRectMin, clipRectMax, intersectWithCurrentClipRect ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRect(ImDrawListPtr self, Vector2 clipRectMin, Vector2 clipRectMax)
		{
			PushClipRectNative(self, clipRectMin, clipRectMax, (byte)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRect(ref ImDrawList self, Vector2 clipRectMin, Vector2 clipRectMax, bool intersectWithCurrentClipRect)
		{
			fixed (ImDrawList* pself = &self)
			{
				PushClipRectNative((ImDrawList*)pself, clipRectMin, clipRectMax, intersectWithCurrentClipRect ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRect(ref ImDrawList self, Vector2 clipRectMin, Vector2 clipRectMax)
		{
			fixed (ImDrawList* pself = &self)
			{
				PushClipRectNative((ImDrawList*)pself, clipRectMin, clipRectMax, (byte)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PushClipRectFullScreenNative(ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[502])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[502])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRectFullScreen(ImDrawListPtr self)
		{
			PushClipRectFullScreenNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRectFullScreen(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				PushClipRectFullScreenNative((ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PopClipRectNative(ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[503])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[503])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopClipRect(ImDrawListPtr self)
		{
			PopClipRectNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopClipRect(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				PopClipRectNative((ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PushTextureIDNative(ImDrawList* self, ImTextureID textureId)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, ImTextureID, void>)funcTable[504])(self, textureId);
			#else
			((delegate* unmanaged[Cdecl]<nint, ImTextureID, void>)funcTable[504])((nint)self, textureId);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushTextureID(ImDrawListPtr self, ImTextureID textureId)
		{
			PushTextureIDNative(self, textureId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushTextureID(ref ImDrawList self, ImTextureID textureId)
		{
			fixed (ImDrawList* pself = &self)
			{
				PushTextureIDNative((ImDrawList*)pself, textureId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PopTextureIDNative(ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[505])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[505])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopTextureID(ImDrawListPtr self)
		{
			PopTextureIDNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopTextureID(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				PopTextureIDNative((ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetClipRectMinNative(Vector2* pOut, ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImDrawList*, void>)funcTable[506])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[506])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetClipRectMin(ImDrawListPtr self)
		{
			Vector2 ret;
			GetClipRectMinNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMin(Vector2* pOut, ImDrawListPtr self)
		{
			GetClipRectMinNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMin(ref Vector2 pOut, ImDrawListPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetClipRectMinNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetClipRectMin(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				Vector2 ret;
				GetClipRectMinNative(&ret, (ImDrawList*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMin(Vector2* pOut, ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				GetClipRectMinNative(pOut, (ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMin(ref Vector2 pOut, ref ImDrawList self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImDrawList* pself = &self)
				{
					GetClipRectMinNative((Vector2*)ppOut, (ImDrawList*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetClipRectMaxNative(Vector2* pOut, ImDrawList* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImDrawList*, void>)funcTable[507])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[507])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetClipRectMax(ImDrawListPtr self)
		{
			Vector2 ret;
			GetClipRectMaxNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMax(Vector2* pOut, ImDrawListPtr self)
		{
			GetClipRectMaxNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMax(ref Vector2 pOut, ImDrawListPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetClipRectMaxNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetClipRectMax(ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				Vector2 ret;
				GetClipRectMaxNative(&ret, (ImDrawList*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMax(Vector2* pOut, ref ImDrawList self)
		{
			fixed (ImDrawList* pself = &self)
			{
				GetClipRectMaxNative(pOut, (ImDrawList*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetClipRectMax(ref Vector2 pOut, ref ImDrawList self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImDrawList* pself = &self)
				{
					GetClipRectMaxNative((Vector2*)ppOut, (ImDrawList*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddLineNative(ImDrawList* self, Vector2 p1, Vector2 p2, uint col, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, uint, float, void>)funcTable[508])(self, p1, p2, col, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, uint, float, void>)funcTable[508])((nint)self, p1, p2, col, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddLine(ImDrawListPtr self, Vector2 p1, Vector2 p2, uint col, float thickness)
		{
			AddLineNative(self, p1, p2, col, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddLine(ImDrawListPtr self, Vector2 p1, Vector2 p2, uint col)
		{
			AddLineNative(self, p1, p2, col, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddLine(ref ImDrawList self, Vector2 p1, Vector2 p2, uint col, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddLineNative((ImDrawList*)pself, p1, p2, col, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddLine(ref ImDrawList self, Vector2 p1, Vector2 p2, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddLineNative((ImDrawList*)pself, p1, p2, col, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddRectNative(ImDrawList* self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, uint, float, ImDrawFlags, float, void>)funcTable[509])(self, pMin, pMax, col, rounding, flags, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, uint, float, ImDrawFlags, float, void>)funcTable[509])((nint)self, pMin, pMax, col, rounding, flags, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags, float thickness)
		{
			AddRectNative(self, pMin, pMax, col, rounding, flags, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags)
		{
			AddRectNative(self, pMin, pMax, col, rounding, flags, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding)
		{
			AddRectNative(self, pMin, pMax, col, rounding, (ImDrawFlags)(0), (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col)
		{
			AddRectNative(self, pMin, pMax, col, (float)(0.0f), (ImDrawFlags)(0), (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags)
		{
			AddRectNative(self, pMin, pMax, col, (float)(0.0f), flags, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding, float thickness)
		{
			AddRectNative(self, pMin, pMax, col, rounding, (ImDrawFlags)(0), thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags, float thickness)
		{
			AddRectNative(self, pMin, pMax, col, (float)(0.0f), flags, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, rounding, flags, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, rounding, flags, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, rounding, (ImDrawFlags)(0), (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, (float)(0.0f), (ImDrawFlags)(0), (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, (float)(0.0f), flags, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, rounding, (ImDrawFlags)(0), thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRect(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectNative((ImDrawList*)pself, pMin, pMax, col, (float)(0.0f), flags, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddRectFilledNative(ImDrawList* self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, uint, float, ImDrawFlags, void>)funcTable[510])(self, pMin, pMax, col, rounding, flags);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, uint, float, ImDrawFlags, void>)funcTable[510])((nint)self, pMin, pMax, col, rounding, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags)
		{
			AddRectFilledNative(self, pMin, pMax, col, rounding, flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, float rounding)
		{
			AddRectFilledNative(self, pMin, pMax, col, rounding, (ImDrawFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col)
		{
			AddRectFilledNative(self, pMin, pMax, col, (float)(0.0f), (ImDrawFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags)
		{
			AddRectFilledNative(self, pMin, pMax, col, (float)(0.0f), flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding, ImDrawFlags flags)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectFilledNative((ImDrawList*)pself, pMin, pMax, col, rounding, flags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, float rounding)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectFilledNative((ImDrawList*)pself, pMin, pMax, col, rounding, (ImDrawFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectFilledNative((ImDrawList*)pself, pMin, pMax, col, (float)(0.0f), (ImDrawFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilled(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint col, ImDrawFlags flags)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectFilledNative((ImDrawList*)pself, pMin, pMax, col, (float)(0.0f), flags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddRectFilledMultiColorNative(ImDrawList* self, Vector2 pMin, Vector2 pMax, uint colUprLeft, uint colUprRight, uint colBotRight, uint colBotLeft)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, uint, uint, uint, uint, void>)funcTable[511])(self, pMin, pMax, colUprLeft, colUprRight, colBotRight, colBotLeft);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, uint, uint, uint, uint, void>)funcTable[511])((nint)self, pMin, pMax, colUprLeft, colUprRight, colBotRight, colBotLeft);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilledMultiColor(ImDrawListPtr self, Vector2 pMin, Vector2 pMax, uint colUprLeft, uint colUprRight, uint colBotRight, uint colBotLeft)
		{
			AddRectFilledMultiColorNative(self, pMin, pMax, colUprLeft, colUprRight, colBotRight, colBotLeft);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddRectFilledMultiColor(ref ImDrawList self, Vector2 pMin, Vector2 pMax, uint colUprLeft, uint colUprRight, uint colBotRight, uint colBotLeft)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddRectFilledMultiColorNative((ImDrawList*)pself, pMin, pMax, colUprLeft, colUprRight, colBotRight, colBotLeft);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddQuadNative(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, Vector2, Vector2, uint, float, void>)funcTable[512])(self, p1, p2, p3, p4, col, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, uint, float, void>)funcTable[512])((nint)self, p1, p2, p3, p4, col, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuad(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
		{
			AddQuadNative(self, p1, p2, p3, p4, col, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuad(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			AddQuadNative(self, p1, p2, p3, p4, col, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuad(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddQuadNative((ImDrawList*)pself, p1, p2, p3, p4, col, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuad(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddQuadNative((ImDrawList*)pself, p1, p2, p3, p4, col, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddQuadFilledNative(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, Vector2, Vector2, uint, void>)funcTable[513])(self, p1, p2, p3, p4, col);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, uint, void>)funcTable[513])((nint)self, p1, p2, p3, p4, col);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuadFilled(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			AddQuadFilledNative(self, p1, p2, p3, p4, col);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddQuadFilled(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddQuadFilledNative((ImDrawList*)pself, p1, p2, p3, p4, col);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddTriangleNative(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, Vector2, uint, float, void>)funcTable[514])(self, p1, p2, p3, col, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, uint, float, void>)funcTable[514])((nint)self, p1, p2, p3, col, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangle(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
		{
			AddTriangleNative(self, p1, p2, p3, col, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangle(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			AddTriangleNative(self, p1, p2, p3, col, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangle(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTriangleNative((ImDrawList*)pself, p1, p2, p3, col, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangle(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTriangleNative((ImDrawList*)pself, p1, p2, p3, col, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddTriangleFilledNative(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, Vector2, Vector2, uint, void>)funcTable[515])(self, p1, p2, p3, col);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, uint, void>)funcTable[515])((nint)self, p1, p2, p3, col);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangleFilled(ImDrawListPtr self, Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			AddTriangleFilledNative(self, p1, p2, p3, col);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddTriangleFilled(ref ImDrawList self, Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTriangleFilledNative((ImDrawList*)pself, p1, p2, p3, col);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddCircleNative(ImDrawList* self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, float, uint, int, float, void>)funcTable[516])(self, center, radius, col, numSegments, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, float, uint, int, float, void>)funcTable[516])((nint)self, center, radius, col, numSegments, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			AddCircleNative(self, center, radius, col, numSegments, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments)
		{
			AddCircleNative(self, center, radius, col, numSegments, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ImDrawListPtr self, Vector2 center, float radius, uint col)
		{
			AddCircleNative(self, center, radius, col, (int)(0), (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ImDrawListPtr self, Vector2 center, float radius, uint col, float thickness)
		{
			AddCircleNative(self, center, radius, col, (int)(0), thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleNative((ImDrawList*)pself, center, radius, col, numSegments, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleNative((ImDrawList*)pself, center, radius, col, numSegments, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ref ImDrawList self, Vector2 center, float radius, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleNative((ImDrawList*)pself, center, radius, col, (int)(0), (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircle(ref ImDrawList self, Vector2 center, float radius, uint col, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleNative((ImDrawList*)pself, center, radius, col, (int)(0), thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddCircleFilledNative(ImDrawList* self, Vector2 center, float radius, uint col, int numSegments)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, float, uint, int, void>)funcTable[517])(self, center, radius, col, numSegments);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, float, uint, int, void>)funcTable[517])((nint)self, center, radius, col, numSegments);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircleFilled(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments)
		{
			AddCircleFilledNative(self, center, radius, col, numSegments);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircleFilled(ImDrawListPtr self, Vector2 center, float radius, uint col)
		{
			AddCircleFilledNative(self, center, radius, col, (int)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircleFilled(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleFilledNative((ImDrawList*)pself, center, radius, col, numSegments);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddCircleFilled(ref ImDrawList self, Vector2 center, float radius, uint col)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddCircleFilledNative((ImDrawList*)pself, center, radius, col, (int)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddNgonNative(ImDrawList* self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, float, uint, int, float, void>)funcTable[518])(self, center, radius, col, numSegments, thickness);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, float, uint, int, float, void>)funcTable[518])((nint)self, center, radius, col, numSegments, thickness);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgon(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			AddNgonNative(self, center, radius, col, numSegments, thickness);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgon(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments)
		{
			AddNgonNative(self, center, radius, col, numSegments, (float)(1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgon(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments, float thickness)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddNgonNative((ImDrawList*)pself, center, radius, col, numSegments, thickness);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgon(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddNgonNative((ImDrawList*)pself, center, radius, col, numSegments, (float)(1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddNgonFilledNative(ImDrawList* self, Vector2 center, float radius, uint col, int numSegments)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, float, uint, int, void>)funcTable[519])(self, center, radius, col, numSegments);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, float, uint, int, void>)funcTable[519])((nint)self, center, radius, col, numSegments);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgonFilled(ImDrawListPtr self, Vector2 center, float radius, uint col, int numSegments)
		{
			AddNgonFilledNative(self, center, radius, col, numSegments);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddNgonFilled(ref ImDrawList self, Vector2 center, float radius, uint col, int numSegments)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddNgonFilledNative((ImDrawList*)pself, center, radius, col, numSegments);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddTextNative(ImDrawList* self, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, Vector2, uint, byte*, byte*, void>)funcTable[520])(self, pos, col, textBegin, textEnd);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, uint, nint, nint, void>)funcTable[520])((nint)self, pos, col, (nint)textBegin, (nint)textEnd);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			AddTextNative(self, pos, col, textBegin, textEnd);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, byte* textBegin)
		{
			AddTextNative(self, pos, col, textBegin, (byte*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, pos, col, textBegin, textEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, byte* textBegin)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, pos, col, textBegin, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ref byte textBegin, byte* textEnd)
		{
			fixed (byte* ptextBegin = &textBegin)
			{
				AddTextNative(self, pos, col, (byte*)ptextBegin, textEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ref byte textBegin)
		{
			fixed (byte* ptextBegin = &textBegin)
			{
				AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, byte* textEnd)
		{
			fixed (byte* ptextBegin = textBegin)
			{
				AddTextNative(self, pos, col, (byte*)ptextBegin, textEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin)
		{
			fixed (byte* ptextBegin = textBegin)
			{
				AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, string textBegin, byte* textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textBegin != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textBegin);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			AddTextNative(self, pos, col, pStr0, textEnd);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, string textBegin)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textBegin != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textBegin);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			AddTextNative(self, pos, col, pStr0, (byte*)(default));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ref byte textBegin, byte* textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = &textBegin)
				{
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, textEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ref byte textBegin)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = &textBegin)
				{
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)(default));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, byte* textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = textBegin)
				{
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, textEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = textBegin)
				{
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)(default));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, string textBegin, byte* textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textBegin != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textBegin);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				AddTextNative((ImDrawList*)pself, pos, col, pStr0, textEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, string textBegin)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textBegin != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textBegin);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				AddTextNative((ImDrawList*)pself, pos, col, pStr0, (byte*)(default));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, byte* textBegin, ref byte textEnd)
		{
			fixed (byte* ptextEnd = &textEnd)
			{
				AddTextNative(self, pos, col, textBegin, (byte*)ptextEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, byte* textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (byte* ptextEnd = textEnd)
			{
				AddTextNative(self, pos, col, textBegin, (byte*)ptextEnd);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, byte* textBegin, string textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textEnd != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			AddTextNative(self, pos, col, textBegin, pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, byte* textBegin, ref byte textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextEnd = &textEnd)
				{
					AddTextNative((ImDrawList*)pself, pos, col, textBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, byte* textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextEnd = textEnd)
				{
					AddTextNative((ImDrawList*)pself, pos, col, textBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, byte* textBegin, string textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				AddTextNative((ImDrawList*)pself, pos, col, textBegin, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ref byte textBegin, ref byte textEnd)
		{
			fixed (byte* ptextBegin = &textBegin)
			{
				fixed (byte* ptextEnd = &textEnd)
				{
					AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (byte* ptextBegin = textBegin)
			{
				fixed (byte* ptextEnd = textEnd)
				{
					AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, string textBegin, string textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textBegin != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textBegin);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, 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<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			AddTextNative(self, pos, col, pStr0, pStr1);
			if (pStrSize1 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr1);
			}
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ref byte textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (byte* ptextBegin = &textBegin)
			{
				fixed (byte* ptextEnd = textEnd)
				{
					AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ref byte textBegin, string textEnd)
		{
			fixed (byte* ptextBegin = &textBegin)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				AddTextNative(self, pos, col, (byte*)ptextBegin, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, ref byte textEnd)
		{
			fixed (byte* ptextBegin = textBegin)
			{
				fixed (byte* ptextEnd = &textEnd)
				{
					AddTextNative(self, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, string textEnd)
		{
			fixed (byte* ptextBegin = textBegin)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textEnd != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				AddTextNative(self, pos, col, (byte*)ptextBegin, pStr0);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, string textBegin, ref byte textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textBegin != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textBegin);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* ptextEnd = &textEnd)
			{
				AddTextNative(self, pos, col, pStr0, (byte*)ptextEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, Vector2 pos, uint col, string textBegin, ReadOnlySpan<byte> textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (textBegin != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(textBegin);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* ptextEnd = textEnd)
			{
				AddTextNative(self, pos, col, pStr0, (byte*)ptextEnd);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ref byte textBegin, ref byte textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = &textBegin)
				{
					fixed (byte* ptextEnd = &textEnd)
					{
						AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = textBegin)
				{
					fixed (byte* ptextEnd = textEnd)
					{
						AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, string textBegin, string textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textBegin != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textBegin);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, 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<byte>(pStrSize1 + 1);
					}
					else
					{
						byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
						pStr1 = pStrStack1;
					}
					int pStrOffset1 = Utils.EncodeStringUTF8(textEnd, pStr1, pStrSize1);
					pStr1[pStrOffset1] = 0;
				}
				AddTextNative((ImDrawList*)pself, pos, col, pStr0, pStr1);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr1);
				}
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ref byte textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = &textBegin)
				{
					fixed (byte* ptextEnd = textEnd)
					{
						AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ref byte textBegin, string textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = &textBegin)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (textEnd != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(textEnd);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, pStr0);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, ref byte textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = textBegin)
				{
					fixed (byte* ptextEnd = &textEnd)
					{
						AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, (byte*)ptextEnd);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, ReadOnlySpan<byte> textBegin, string textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				fixed (byte* ptextBegin = textBegin)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (textEnd != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(textEnd);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(textEnd, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					AddTextNative((ImDrawList*)pself, pos, col, (byte*)ptextBegin, pStr0);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, string textBegin, ref byte textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textBegin != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textBegin);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (byte* ptextEnd = &textEnd)
				{
					AddTextNative((ImDrawList*)pself, pos, col, pStr0, (byte*)ptextEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, Vector2 pos, uint col, string textBegin, ReadOnlySpan<byte> textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (textBegin != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(textBegin);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(textBegin, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (byte* ptextEnd = textEnd)
				{
					AddTextNative((ImDrawList*)pself, pos, col, pStr0, (byte*)ptextEnd);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddTextNative(ImDrawList* self, ImFont* font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth, Vector4* cpuFineClipRect)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, ImFont*, float, Vector2, uint, byte*, byte*, float, Vector4*, void>)funcTable[521])(self, font, fontSize, pos, col, textBegin, textEnd, wrapWidth, cpuFineClipRect);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, float, Vector2, uint, nint, nint, float, nint, void>)funcTable[521])((nint)self, (nint)font, fontSize, pos, col, (nint)textBegin, (nint)textEnd, wrapWidth, (nint)cpuFineClipRect);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth, Vector4* cpuFineClipRect)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, textEnd, wrapWidth, cpuFineClipRect);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, textEnd, wrapWidth, (Vector4*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, textEnd, (float)(0.0f), (Vector4*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, (byte*)(default), (float)(0.0f), (Vector4*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, float wrapWidth)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, (byte*)(default), wrapWidth, (Vector4*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, Vector4* cpuFineClipRect)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, textEnd, (float)(0.0f), cpuFineClipRect);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, Vector4* cpuFineClipRect)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, (byte*)(default), (float)(0.0f), cpuFineClipRect);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, float wrapWidth, Vector4* cpuFineClipRect)
		{
			AddTextNative(self, font, fontSize, pos, col, textBegin, (byte*)(default), wrapWidth, cpuFineClipRect);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth, Vector4* cpuFineClipRect)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, textEnd, wrapWidth, cpuFineClipRect);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, textEnd, wrapWidth, (Vector4*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, textEnd, (float)(0.0f), (Vector4*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, (byte*)(default), (float)(0.0f), (Vector4*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, float wrapWidth)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, (byte*)(default), wrapWidth, (Vector4*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, Vector4* cpuFineClipRect)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, textEnd, (float)(0.0f), cpuFineClipRect);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, Vector4* cpuFineClipRect)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, (byte*)(default), (float)(0.0f), cpuFineClipRect);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ref ImDrawList self, ImFontPtr font, float fontSize, Vector2 pos, uint col, byte* textBegin, float wrapWidth, Vector4* cpuFineClipRect)
		{
			fixed (ImDrawList* pself = &self)
			{
				AddTextNative((ImDrawList*)pself, font, fontSize, pos, col, textBegin, (byte*)(default), wrapWidth, cpuFineClipRect);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ref ImFont font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth, Vector4* cpuFineClipRect)
		{
			fixed (ImFont* pfont = &font)
			{
				AddTextNative(self, (ImFont*)pfont, fontSize, pos, col, textBegin, textEnd, wrapWidth, cpuFineClipRect);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ref ImFont font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd, float wrapWidth)
		{
			fixed (ImFont* pfont = &font)
			{
				AddTextNative(self, (ImFont*)pfont, fontSize, pos, col, textBegin, textEnd, wrapWidth, (Vector4*)(default));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void AddText(ImDrawListPtr self, ref ImFont font, float fontSize, Vector2 pos, uint col, byte* textBegin, byte* textEnd)
		{
			fixed (ImFont* pfont = &font)
			{
				AddTextNative(self, (ImFont*)pfont, fontSize, pos, col, textBegin, textEnd, (float)(0.0f), (Vector4*)(default));
			}
		}
	}
}