using System;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: InternalsVisibleTo("ImPlot.NET")]
[assembly: InternalsVisibleTo("ImNodes.NET")]
[assembly: AssemblyCompany("Eric Mellino")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A .NET wrapper for the Dear ImGui library.")]
[assembly: AssemblyFileVersion("1.90.1.1")]
[assembly: AssemblyInformationalVersion("1.0.0+94d483978526a3cf3ae9161d5029f1ee00412879")]
[assembly: AssemblyProduct("ImGui.NET")]
[assembly: AssemblyTitle("ImGui.NET")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.90.1.1")]
[module: UnverifiableCode]
namespace ImGuiNET;

public delegate void Platform_CreateWindow(ImGuiViewportPtr vp);
public delegate void Platform_DestroyWindow(ImGuiViewportPtr vp);
public delegate void Platform_ShowWindow(ImGuiViewportPtr vp);
public delegate void Platform_SetWindowPos(ImGuiViewportPtr vp, Vector2 pos);
public unsafe delegate void Platform_GetWindowPos(ImGuiViewportPtr vp, Vector2* outPos);
public delegate void Platform_SetWindowSize(ImGuiViewportPtr vp, Vector2 size);
public unsafe delegate void Platform_GetWindowSize(ImGuiViewportPtr vp, Vector2* outSize);
public delegate void Platform_SetWindowFocus(ImGuiViewportPtr vp);
public delegate byte Platform_GetWindowFocus(ImGuiViewportPtr vp);
public delegate byte Platform_GetWindowMinimized(ImGuiViewportPtr vp);
public delegate void Platform_SetWindowTitle(ImGuiViewportPtr vp, IntPtr title);
public struct ImColor
{
	public Vector4 Value;
}
public struct ImColorPtr
{
	public unsafe ImColor* NativePtr { get; }

	public unsafe ref Vector4 Value => ref Unsafe.AsRef<Vector4>(&NativePtr->Value);

	public unsafe ImColorPtr(ImColor* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImColorPtr(IntPtr nativePtr)
	{
		NativePtr = (ImColor*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImColorPtr(ImColor* nativePtr)
	{
		return new ImColorPtr(nativePtr);
	}

	public unsafe static implicit operator ImColor*(ImColorPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImColorPtr(IntPtr nativePtr)
	{
		return new ImColorPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImColor_destroy(NativePtr);
	}

	public unsafe ImColor HSV(float h, float s, float v)
	{
		float a = 1f;
		ImColor result = default(ImColor);
		ImGuiNative.ImColor_HSV(&result, h, s, v, a);
		return result;
	}

	public unsafe ImColor HSV(float h, float s, float v, float a)
	{
		ImColor result = default(ImColor);
		ImGuiNative.ImColor_HSV(&result, h, s, v, a);
		return result;
	}

	public unsafe void SetHSV(float h, float s, float v)
	{
		float a = 1f;
		ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
	}

	public unsafe void SetHSV(float h, float s, float v, float a)
	{
		ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
	}
}
public struct ImDrawChannel
{
	public ImVector _CmdBuffer;

	public ImVector _IdxBuffer;
}
public struct ImDrawChannelPtr
{
	public unsafe ImDrawChannel* NativePtr { get; }

	public unsafe ImPtrVector<ImDrawCmdPtr> _CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->_CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());

	public unsafe ImVector<ushort> _IdxBuffer => new ImVector<ushort>(NativePtr->_IdxBuffer);

	public unsafe ImDrawChannelPtr(ImDrawChannel* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawChannelPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawChannel*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawChannelPtr(ImDrawChannel* nativePtr)
	{
		return new ImDrawChannelPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawChannel*(ImDrawChannelPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawChannelPtr(IntPtr nativePtr)
	{
		return new ImDrawChannelPtr(nativePtr);
	}
}
public struct ImDrawCmd
{
	public Vector4 ClipRect;

	public IntPtr TextureId;

	public uint VtxOffset;

	public uint IdxOffset;

	public uint ElemCount;

	public IntPtr UserCallback;

	public unsafe void* UserCallbackData;
}
public struct ImDrawCmdPtr
{
	public unsafe ImDrawCmd* NativePtr { get; }

	public unsafe ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);

	public unsafe ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);

	public unsafe ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);

	public unsafe ref uint IdxOffset => ref Unsafe.AsRef<uint>(&NativePtr->IdxOffset);

	public unsafe ref uint ElemCount => ref Unsafe.AsRef<uint>(&NativePtr->ElemCount);

	public unsafe ref IntPtr UserCallback => ref Unsafe.AsRef<IntPtr>(&NativePtr->UserCallback);

	public unsafe IntPtr UserCallbackData
	{
		get
		{
			return (IntPtr)NativePtr->UserCallbackData;
		}
		set
		{
			NativePtr->UserCallbackData = (void*)value;
		}
	}

	public unsafe ImDrawCmdPtr(ImDrawCmd* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawCmdPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawCmd*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawCmdPtr(ImDrawCmd* nativePtr)
	{
		return new ImDrawCmdPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawCmd*(ImDrawCmdPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawCmdPtr(IntPtr nativePtr)
	{
		return new ImDrawCmdPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawCmd_destroy(NativePtr);
	}

	public unsafe IntPtr GetTexID()
	{
		return ImGuiNative.ImDrawCmd_GetTexID(NativePtr);
	}
}
public struct ImDrawCmdHeader
{
	public Vector4 ClipRect;

	public IntPtr TextureId;

	public uint VtxOffset;
}
public struct ImDrawCmdHeaderPtr
{
	public unsafe ImDrawCmdHeader* NativePtr { get; }

	public unsafe ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);

	public unsafe ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);

	public unsafe ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);

	public unsafe ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawCmdHeaderPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawCmdHeader*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr)
	{
		return new ImDrawCmdHeaderPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawCmdHeader*(ImDrawCmdHeaderPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawCmdHeaderPtr(IntPtr nativePtr)
	{
		return new ImDrawCmdHeaderPtr(nativePtr);
	}
}
public struct ImDrawData
{
	public byte Valid;

	public int CmdListsCount;

	public int TotalIdxCount;

	public int TotalVtxCount;

	public ImVector CmdLists;

	public Vector2 DisplayPos;

	public Vector2 DisplaySize;

	public Vector2 FramebufferScale;

	public unsafe ImGuiViewport* OwnerViewport;
}
public struct ImDrawDataPtr
{
	public unsafe ImDrawData* NativePtr { get; }

	public unsafe ref bool Valid => ref Unsafe.AsRef<bool>(&NativePtr->Valid);

	public unsafe ref int CmdListsCount => ref Unsafe.AsRef<int>(&NativePtr->CmdListsCount);

	public unsafe ref int TotalIdxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalIdxCount);

	public unsafe ref int TotalVtxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalVtxCount);

	public unsafe ImVector<ImDrawListPtr> CmdLists => new ImVector<ImDrawListPtr>(NativePtr->CmdLists);

	public unsafe ref Vector2 DisplayPos => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayPos);

	public unsafe ref Vector2 DisplaySize => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySize);

	public unsafe ref Vector2 FramebufferScale => ref Unsafe.AsRef<Vector2>(&NativePtr->FramebufferScale);

	public unsafe ImGuiViewportPtr OwnerViewport => new ImGuiViewportPtr(NativePtr->OwnerViewport);

	public unsafe ImDrawDataPtr(ImDrawData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawDataPtr(ImDrawData* nativePtr)
	{
		return new ImDrawDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawData*(ImDrawDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawDataPtr(IntPtr nativePtr)
	{
		return new ImDrawDataPtr(nativePtr);
	}

	public unsafe void AddDrawList(ImDrawListPtr draw_list)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawData_AddDrawList(NativePtr, nativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImDrawData_Clear(NativePtr);
	}

	public unsafe void DeIndexAllBuffers()
	{
		ImGuiNative.ImDrawData_DeIndexAllBuffers(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawData_destroy(NativePtr);
	}

	public unsafe void ScaleClipRects(Vector2 fb_scale)
	{
		ImGuiNative.ImDrawData_ScaleClipRects(NativePtr, fb_scale);
	}
}
[Flags]
public enum ImDrawFlags
{
	None = 0,
	Closed = 1,
	RoundCornersTopLeft = 0x10,
	RoundCornersTopRight = 0x20,
	RoundCornersBottomLeft = 0x40,
	RoundCornersBottomRight = 0x80,
	RoundCornersNone = 0x100,
	RoundCornersTop = 0x30,
	RoundCornersBottom = 0xC0,
	RoundCornersLeft = 0x50,
	RoundCornersRight = 0xA0,
	RoundCornersAll = 0xF0,
	RoundCornersDefault = 0xF0,
	RoundCornersMask = 0x1F0
}
public struct ImDrawList
{
	public ImVector CmdBuffer;

	public ImVector IdxBuffer;

	public ImVector VtxBuffer;

	public ImDrawListFlags Flags;

	public uint _VtxCurrentIdx;

	public IntPtr _Data;

	public unsafe byte* _OwnerName;

	public unsafe ImDrawVert* _VtxWritePtr;

	public unsafe ushort* _IdxWritePtr;

	public ImVector _ClipRectStack;

	public ImVector _TextureIdStack;

	public ImVector _Path;

	public ImDrawCmdHeader _CmdHeader;

	public ImDrawListSplitter _Splitter;

	public float _FringeScale;
}
public struct ImDrawListPtr
{
	public unsafe ImDrawList* NativePtr { get; }

	public unsafe ImPtrVector<ImDrawCmdPtr> CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());

	public unsafe ImVector<ushort> IdxBuffer => new ImVector<ushort>(NativePtr->IdxBuffer);

	public unsafe ImPtrVector<ImDrawVertPtr> VtxBuffer => new ImPtrVector<ImDrawVertPtr>(NativePtr->VtxBuffer, Unsafe.SizeOf<ImDrawVert>());

	public unsafe ref ImDrawListFlags Flags => ref Unsafe.AsRef<ImDrawListFlags>(&NativePtr->Flags);

	public unsafe ref uint _VtxCurrentIdx => ref Unsafe.AsRef<uint>(&NativePtr->_VtxCurrentIdx);

	public unsafe ref IntPtr _Data => ref Unsafe.AsRef<IntPtr>(&NativePtr->_Data);

	public unsafe NullTerminatedString _OwnerName => new NullTerminatedString(NativePtr->_OwnerName);

	public unsafe ImDrawVertPtr _VtxWritePtr => new ImDrawVertPtr(NativePtr->_VtxWritePtr);

	public unsafe IntPtr _IdxWritePtr
	{
		get
		{
			return (IntPtr)NativePtr->_IdxWritePtr;
		}
		set
		{
			NativePtr->_IdxWritePtr = (ushort*)(void*)value;
		}
	}

	public unsafe ImVector<Vector4> _ClipRectStack => new ImVector<Vector4>(NativePtr->_ClipRectStack);

	public unsafe ImVector<IntPtr> _TextureIdStack => new ImVector<IntPtr>(NativePtr->_TextureIdStack);

	public unsafe ImVector<Vector2> _Path => new ImVector<Vector2>(NativePtr->_Path);

	public unsafe ref ImDrawCmdHeader _CmdHeader => ref Unsafe.AsRef<ImDrawCmdHeader>(&NativePtr->_CmdHeader);

	public unsafe ref ImDrawListSplitter _Splitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->_Splitter);

	public unsafe ref float _FringeScale => ref Unsafe.AsRef<float>(&NativePtr->_FringeScale);

	public unsafe ImDrawListPtr(ImDrawList* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawListPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawList*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawListPtr(ImDrawList* nativePtr)
	{
		return new ImDrawListPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawList*(ImDrawListPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawListPtr(IntPtr nativePtr)
	{
		return new ImDrawListPtr(nativePtr);
	}

	public unsafe int _CalcCircleAutoSegmentCount(float radius)
	{
		return ImGuiNative.ImDrawList__CalcCircleAutoSegmentCount(NativePtr, radius);
	}

	public unsafe void _ClearFreeMemory()
	{
		ImGuiNative.ImDrawList__ClearFreeMemory(NativePtr);
	}

	public unsafe void _OnChangedClipRect()
	{
		ImGuiNative.ImDrawList__OnChangedClipRect(NativePtr);
	}

	public unsafe void _OnChangedTextureID()
	{
		ImGuiNative.ImDrawList__OnChangedTextureID(NativePtr);
	}

	public unsafe void _OnChangedVtxOffset()
	{
		ImGuiNative.ImDrawList__OnChangedVtxOffset(NativePtr);
	}

	public unsafe void _PathArcToFastEx(Vector2 center, float radius, int a_min_sample, int a_max_sample, int a_step)
	{
		ImGuiNative.ImDrawList__PathArcToFastEx(NativePtr, center, radius, a_min_sample, a_max_sample, a_step);
	}

	public unsafe void _PathArcToN(Vector2 center, float radius, float a_min, float a_max, int num_segments)
	{
		ImGuiNative.ImDrawList__PathArcToN(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void _PopUnusedDrawCmd()
	{
		ImGuiNative.ImDrawList__PopUnusedDrawCmd(NativePtr);
	}

	public unsafe void _ResetForNewFrame()
	{
		ImGuiNative.ImDrawList__ResetForNewFrame(NativePtr);
	}

	public unsafe void _TryMergeDrawCmds()
	{
		ImGuiNative.ImDrawList__TryMergeDrawCmds(NativePtr);
	}

	public unsafe void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddBezierCubic(NativePtr, p1, p2, p3, p4, col, thickness, num_segments);
	}

	public unsafe void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness, int num_segments)
	{
		ImGuiNative.ImDrawList_AddBezierCubic(NativePtr, p1, p2, p3, p4, col, thickness, num_segments);
	}

	public unsafe void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddBezierQuadratic(NativePtr, p1, p2, p3, col, thickness, num_segments);
	}

	public unsafe void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness, int num_segments)
	{
		ImGuiNative.ImDrawList_AddBezierQuadratic(NativePtr, p1, p2, p3, col, thickness, num_segments);
	}

	public unsafe void AddCallback(IntPtr callback, IntPtr callback_data)
	{
		void* callback_data2 = callback_data.ToPointer();
		ImGuiNative.ImDrawList_AddCallback(NativePtr, callback, callback_data2);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col)
	{
		int num_segments = 0;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col, int num_segments)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col, int num_segments, float thickness)
	{
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircleFilled(Vector2 center, float radius, uint col)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddCircleFilled(Vector2 center, float radius, uint col, int num_segments)
	{
		ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddConvexPolyFilled(ref Vector2 points, int num_points, uint col)
	{
		fixed (Vector2* points2 = &points)
		{
			ImGuiNative.ImDrawList_AddConvexPolyFilled(NativePtr, points2, num_points, col);
		}
	}

	public unsafe void AddDrawCmd()
	{
		ImGuiNative.ImDrawList_AddDrawCmd(NativePtr);
	}

	public unsafe void AddEllipse(Vector2 center, float radius_x, float radius_y, uint col)
	{
		float rot = 0f;
		int num_segments = 0;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius_x, radius_y, col, rot, num_segments, thickness);
	}

	public unsafe void AddEllipse(Vector2 center, float radius_x, float radius_y, uint col, float rot)
	{
		int num_segments = 0;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius_x, radius_y, col, rot, num_segments, thickness);
	}

	public unsafe void AddEllipse(Vector2 center, float radius_x, float radius_y, uint col, float rot, int num_segments)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius_x, radius_y, col, rot, num_segments, thickness);
	}

	public unsafe void AddEllipse(Vector2 center, float radius_x, float radius_y, uint col, float rot, int num_segments, float thickness)
	{
		ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius_x, radius_y, col, rot, num_segments, thickness);
	}

	public unsafe void AddEllipseFilled(Vector2 center, float radius_x, float radius_y, uint col)
	{
		float rot = 0f;
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius_x, radius_y, col, rot, num_segments);
	}

	public unsafe void AddEllipseFilled(Vector2 center, float radius_x, float radius_y, uint col, float rot)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius_x, radius_y, col, rot, num_segments);
	}

	public unsafe void AddEllipseFilled(Vector2 center, float radius_x, float radius_y, uint col, float rot, int num_segments)
	{
		ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius_x, radius_y, col, rot, num_segments);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max)
	{
		Vector2 uv_min = default(Vector2);
		Vector2 uv_max = new Vector2(1f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min)
	{
		Vector2 uv_max = new Vector2(1f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max)
	{
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col)
	{
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4)
	{
		Vector2 uv = default(Vector2);
		Vector2 uv2 = new Vector2(1f, 0f);
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1)
	{
		Vector2 uv2 = new Vector2(1f, 0f);
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2)
	{
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3)
	{
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4)
	{
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4, uint col)
	{
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
	}

	public unsafe void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
	}

	public unsafe void AddLine(Vector2 p1, Vector2 p2, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
	}

	public unsafe void AddLine(Vector2 p1, Vector2 p2, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
	}

	public unsafe void AddNgon(Vector2 center, float radius, uint col, int num_segments)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddNgon(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddNgon(Vector2 center, float radius, uint col, int num_segments, float thickness)
	{
		ImGuiNative.ImDrawList_AddNgon(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddNgonFilled(Vector2 center, float radius, uint col, int num_segments)
	{
		ImGuiNative.ImDrawList_AddNgonFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddPolyline(ref Vector2 points, int num_points, uint col, ImDrawFlags flags, float thickness)
	{
		fixed (Vector2* points2 = &points)
		{
			ImGuiNative.ImDrawList_AddPolyline(NativePtr, points2, num_points, col, flags, thickness);
		}
	}

	public unsafe void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddQuad(NativePtr, p1, p2, p3, p4, col, thickness);
	}

	public unsafe void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddQuad(NativePtr, p1, p2, p3, p4, col, thickness);
	}

	public unsafe void AddQuadFilled(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
	{
		ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, p1, p2, p3, p4, col);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags, float thickness)
	{
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilledMultiColor(Vector2 p_min, Vector2 p_max, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
	{
		ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
	}

	public unsafe void AddText(Vector2 pos, uint col, string text_begin)
	{
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		ImGuiNative.ImDrawList_AddText_Vec2(NativePtr, pos, col, ptr, ptr + num);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin)
	{
		ImFont* nativePtr = font.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		float wrap_width = 0f;
		Vector4* cpu_fine_clip_rect = null;
		ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width)
	{
		ImFont* nativePtr = font.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		Vector4* cpu_fine_clip_rect = null;
		ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width, ref Vector4 cpu_fine_clip_rect)
	{
		ImFont* nativePtr = font.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		fixed (Vector4* cpu_fine_clip_rect2 = &cpu_fine_clip_rect)
		{
			ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect2);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}
	}

	public unsafe void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddTriangle(NativePtr, p1, p2, p3, col, thickness);
	}

	public unsafe void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddTriangle(NativePtr, p1, p2, p3, col, thickness);
	}

	public unsafe void AddTriangleFilled(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
	{
		ImGuiNative.ImDrawList_AddTriangleFilled(NativePtr, p1, p2, p3, col);
	}

	public unsafe void ChannelsMerge()
	{
		ImGuiNative.ImDrawList_ChannelsMerge(NativePtr);
	}

	public unsafe void ChannelsSetCurrent(int n)
	{
		ImGuiNative.ImDrawList_ChannelsSetCurrent(NativePtr, n);
	}

	public unsafe void ChannelsSplit(int count)
	{
		ImGuiNative.ImDrawList_ChannelsSplit(NativePtr, count);
	}

	public unsafe ImDrawListPtr CloneOutput()
	{
		return new ImDrawListPtr(ImGuiNative.ImDrawList_CloneOutput(NativePtr));
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawList_destroy(NativePtr);
	}

	public unsafe Vector2 GetClipRectMax()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImDrawList_GetClipRectMax(&result, NativePtr);
		return result;
	}

	public unsafe Vector2 GetClipRectMin()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImDrawList_GetClipRectMin(&result, NativePtr);
		return result;
	}

	public unsafe void PathArcTo(Vector2 center, float radius, float a_min, float a_max)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathArcTo(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void PathArcTo(Vector2 center, float radius, float a_min, float a_max, int num_segments)
	{
		ImGuiNative.ImDrawList_PathArcTo(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void PathArcToFast(Vector2 center, float radius, int a_min_of_12, int a_max_of_12)
	{
		ImGuiNative.ImDrawList_PathArcToFast(NativePtr, center, radius, a_min_of_12, a_max_of_12);
	}

	public unsafe void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathBezierCubicCurveTo(NativePtr, p2, p3, p4, num_segments);
	}

	public unsafe void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4, int num_segments)
	{
		ImGuiNative.ImDrawList_PathBezierCubicCurveTo(NativePtr, p2, p3, p4, num_segments);
	}

	public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
	}

	public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3, int num_segments)
	{
		ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
	}

	public unsafe void PathClear()
	{
		ImGuiNative.ImDrawList_PathClear(NativePtr);
	}

	public unsafe void PathEllipticalArcTo(Vector2 center, float radius_x, float radius_y, float rot, float a_min, float a_max)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathEllipticalArcTo(NativePtr, center, radius_x, radius_y, rot, a_min, a_max, num_segments);
	}

	public unsafe void PathEllipticalArcTo(Vector2 center, float radius_x, float radius_y, float rot, float a_min, float a_max, int num_segments)
	{
		ImGuiNative.ImDrawList_PathEllipticalArcTo(NativePtr, center, radius_x, radius_y, rot, a_min, a_max, num_segments);
	}

	public unsafe void PathFillConvex(uint col)
	{
		ImGuiNative.ImDrawList_PathFillConvex(NativePtr, col);
	}

	public unsafe void PathLineTo(Vector2 pos)
	{
		ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
	}

	public unsafe void PathLineToMergeDuplicate(Vector2 pos)
	{
		ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathStroke(uint col)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PathStroke(uint col, ImDrawFlags flags)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PathStroke(uint col, ImDrawFlags flags, float thickness)
	{
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PopClipRect()
	{
		ImGuiNative.ImDrawList_PopClipRect(NativePtr);
	}

	public unsafe void PopTextureID()
	{
		ImGuiNative.ImDrawList_PopTextureID(NativePtr);
	}

	public unsafe void PrimQuadUV(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
	{
		ImGuiNative.ImDrawList_PrimQuadUV(NativePtr, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
	}

	public unsafe void PrimRect(Vector2 a, Vector2 b, uint col)
	{
		ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
	}

	public unsafe void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
	{
		ImGuiNative.ImDrawList_PrimRectUV(NativePtr, a, b, uv_a, uv_b, col);
	}

	public unsafe void PrimReserve(int idx_count, int vtx_count)
	{
		ImGuiNative.ImDrawList_PrimReserve(NativePtr, idx_count, vtx_count);
	}

	public unsafe void PrimUnreserve(int idx_count, int vtx_count)
	{
		ImGuiNative.ImDrawList_PrimUnreserve(NativePtr, idx_count, vtx_count);
	}

	public unsafe void PrimVtx(Vector2 pos, Vector2 uv, uint col)
	{
		ImGuiNative.ImDrawList_PrimVtx(NativePtr, pos, uv, col);
	}

	public unsafe void PrimWriteIdx(ushort idx)
	{
		ImGuiNative.ImDrawList_PrimWriteIdx(NativePtr, idx);
	}

	public unsafe void PrimWriteVtx(Vector2 pos, Vector2 uv, uint col)
	{
		ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
	}

	public unsafe void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
	{
		byte intersect_with_current_clip_rect = 0;
		ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
	}

	public unsafe void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
	{
		byte intersect_with_current_clip_rect2 = (intersect_with_current_clip_rect ? ((byte)1) : ((byte)0));
		ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect2);
	}

	public unsafe void PushClipRectFullScreen()
	{
		ImGuiNative.ImDrawList_PushClipRectFullScreen(NativePtr);
	}

	public unsafe void PushTextureID(IntPtr texture_id)
	{
		ImGuiNative.ImDrawList_PushTextureID(NativePtr, texture_id);
	}
}
[Flags]
public enum ImDrawListFlags
{
	None = 0,
	AntiAliasedLines = 1,
	AntiAliasedLinesUseTex = 2,
	AntiAliasedFill = 4,
	AllowVtxOffset = 8
}
public struct ImDrawListSplitter
{
	public int _Current;

	public int _Count;

	public ImVector _Channels;
}
public struct ImDrawListSplitterPtr
{
	public unsafe ImDrawListSplitter* NativePtr { get; }

	public unsafe ref int _Current => ref Unsafe.AsRef<int>(&NativePtr->_Current);

	public unsafe ref int _Count => ref Unsafe.AsRef<int>(&NativePtr->_Count);

	public unsafe ImPtrVector<ImDrawChannelPtr> _Channels => new ImPtrVector<ImDrawChannelPtr>(NativePtr->_Channels, Unsafe.SizeOf<ImDrawChannel>());

	public unsafe ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawListSplitterPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawListSplitter*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr)
	{
		return new ImDrawListSplitterPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawListSplitter*(ImDrawListSplitterPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawListSplitterPtr(IntPtr nativePtr)
	{
		return new ImDrawListSplitterPtr(nativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImDrawListSplitter_Clear(NativePtr);
	}

	public unsafe void ClearFreeMemory()
	{
		ImGuiNative.ImDrawListSplitter_ClearFreeMemory(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawListSplitter_destroy(NativePtr);
	}

	public unsafe void Merge(ImDrawListPtr draw_list)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_Merge(NativePtr, nativePtr);
	}

	public unsafe void SetCurrentChannel(ImDrawListPtr draw_list, int channel_idx)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_SetCurrentChannel(NativePtr, nativePtr, channel_idx);
	}

	public unsafe void Split(ImDrawListPtr draw_list, int count)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_Split(NativePtr, nativePtr, count);
	}
}
public struct ImDrawVert
{
	public Vector2 pos;

	public Vector2 uv;

	public uint col;
}
public struct ImDrawVertPtr
{
	public unsafe ImDrawVert* NativePtr { get; }

	public unsafe ref Vector2 pos => ref Unsafe.AsRef<Vector2>(&NativePtr->pos);

	public unsafe ref Vector2 uv => ref Unsafe.AsRef<Vector2>(&NativePtr->uv);

	public unsafe ref uint col => ref Unsafe.AsRef<uint>(&NativePtr->col);

	public unsafe ImDrawVertPtr(ImDrawVert* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawVertPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawVert*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawVertPtr(ImDrawVert* nativePtr)
	{
		return new ImDrawVertPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawVert*(ImDrawVertPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawVertPtr(IntPtr nativePtr)
	{
		return new ImDrawVertPtr(nativePtr);
	}
}
public struct ImFont
{
	public ImVector IndexAdvanceX;

	public float FallbackAdvanceX;

	public float FontSize;

	public ImVector IndexLookup;

	public ImVector Glyphs;

	public unsafe ImFontGlyph* FallbackGlyph;

	public unsafe ImFontAtlas* ContainerAtlas;

	public unsafe ImFontConfig* ConfigData;

	public short ConfigDataCount;

	public ushort FallbackChar;

	public ushort EllipsisChar;

	public short EllipsisCharCount;

	public float EllipsisWidth;

	public float EllipsisCharStep;

	public byte DirtyLookupTables;

	public float Scale;

	public float Ascent;

	public float Descent;

	public int MetricsTotalSurface;

	public unsafe fixed byte Used4kPagesMap[2];
}
public struct ImFontPtr
{
	public unsafe ImFont* NativePtr { get; }

	public unsafe ImVector<float> IndexAdvanceX => new ImVector<float>(NativePtr->IndexAdvanceX);

	public unsafe ref float FallbackAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->FallbackAdvanceX);

	public unsafe ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);

	public unsafe ImVector<ushort> IndexLookup => new ImVector<ushort>(NativePtr->IndexLookup);

	public unsafe ImPtrVector<ImFontGlyphPtr> Glyphs => new ImPtrVector<ImFontGlyphPtr>(NativePtr->Glyphs, Unsafe.SizeOf<ImFontGlyph>());

	public unsafe ImFontGlyphPtr FallbackGlyph => new ImFontGlyphPtr(NativePtr->FallbackGlyph);

	public unsafe ImFontAtlasPtr ContainerAtlas => new ImFontAtlasPtr(NativePtr->ContainerAtlas);

	public unsafe ImFontConfigPtr ConfigData => new ImFontConfigPtr(NativePtr->ConfigData);

	public unsafe ref short ConfigDataCount => ref Unsafe.AsRef<short>(&NativePtr->ConfigDataCount);

	public unsafe ref ushort FallbackChar => ref Unsafe.AsRef<ushort>(&NativePtr->FallbackChar);

	public unsafe ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);

	public unsafe ref short EllipsisCharCount => ref Unsafe.AsRef<short>(&NativePtr->EllipsisCharCount);

	public unsafe ref float EllipsisWidth => ref Unsafe.AsRef<float>(&NativePtr->EllipsisWidth);

	public unsafe ref float EllipsisCharStep => ref Unsafe.AsRef<float>(&NativePtr->EllipsisCharStep);

	public unsafe ref bool DirtyLookupTables => ref Unsafe.AsRef<bool>(&NativePtr->DirtyLookupTables);

	public unsafe ref float Scale => ref Unsafe.AsRef<float>(&NativePtr->Scale);

	public unsafe ref float Ascent => ref Unsafe.AsRef<float>(&NativePtr->Ascent);

	public unsafe ref float Descent => ref Unsafe.AsRef<float>(&NativePtr->Descent);

	public unsafe ref int MetricsTotalSurface => ref Unsafe.AsRef<int>(&NativePtr->MetricsTotalSurface);

	public unsafe RangeAccessor<byte> Used4kPagesMap => new RangeAccessor<byte>(NativePtr->Used4kPagesMap, 2);

	public unsafe ImFontPtr(ImFont* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFont*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontPtr(ImFont* nativePtr)
	{
		return new ImFontPtr(nativePtr);
	}

	public unsafe static implicit operator ImFont*(ImFontPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontPtr(IntPtr nativePtr)
	{
		return new ImFontPtr(nativePtr);
	}

	public unsafe void AddGlyph(ImFontConfigPtr src_cfg, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
	{
		ImFontConfig* nativePtr = src_cfg.NativePtr;
		ImGuiNative.ImFont_AddGlyph(NativePtr, nativePtr, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
	}

	public unsafe void AddRemapChar(ushort dst, ushort src)
	{
		byte overwrite_dst = 1;
		ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, overwrite_dst);
	}

	public unsafe void AddRemapChar(ushort dst, ushort src, bool overwrite_dst)
	{
		byte overwrite_dst2 = (overwrite_dst ? ((byte)1) : ((byte)0));
		ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, overwrite_dst2);
	}

	public unsafe void BuildLookupTable()
	{
		ImGuiNative.ImFont_BuildLookupTable(NativePtr);
	}

	public unsafe Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin)
	{
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		byte** remaining = null;
		Vector2 result = default(Vector2);
		ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return result;
	}

	public unsafe Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin, ref byte* remaining)
	{
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		fixed (byte** remaining2 = &remaining)
		{
			Vector2 result = default(Vector2);
			ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining2);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}
	}

	public unsafe string CalcWordWrapPositionA(float scale, string text, float wrap_width)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* ptr2 = ImGuiNative.ImFont_CalcWordWrapPositionA(NativePtr, scale, ptr, ptr + num, wrap_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return Util.StringFromPtr(ptr2);
	}

	public unsafe void ClearOutputData()
	{
		ImGuiNative.ImFont_ClearOutputData(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFont_destroy(NativePtr);
	}

	public unsafe ImFontGlyphPtr FindGlyph(ushort c)
	{
		return new ImFontGlyphPtr(ImGuiNative.ImFont_FindGlyph(NativePtr, c));
	}

	public unsafe ImFontGlyphPtr FindGlyphNoFallback(ushort c)
	{
		return new ImFontGlyphPtr(ImGuiNative.ImFont_FindGlyphNoFallback(NativePtr, c));
	}

	public unsafe float GetCharAdvance(ushort c)
	{
		return ImGuiNative.ImFont_GetCharAdvance(NativePtr, c);
	}

	public unsafe string GetDebugName()
	{
		return Util.StringFromPtr(ImGuiNative.ImFont_GetDebugName(NativePtr));
	}

	public unsafe void GrowIndex(int new_size)
	{
		ImGuiNative.ImFont_GrowIndex(NativePtr, new_size);
	}

	public unsafe bool IsLoaded()
	{
		return ImGuiNative.ImFont_IsLoaded(NativePtr) != 0;
	}

	public unsafe void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImFont_RenderChar(NativePtr, nativePtr, size, pos, col, c);
	}

	public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		float wrap_width = 0f;
		byte cpu_fine_clip = 0;
		ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		byte cpu_fine_clip = 0;
		ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width, bool cpu_fine_clip)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		int num = 0;
		num = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8(text_begin, ptr, num);
		ptr[utf] = 0;
		byte cpu_fine_clip2 = (cpu_fine_clip ? ((byte)1) : ((byte)0));
		ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void SetGlyphVisible(ushort c, bool visible)
	{
		byte visible2 = (visible ? ((byte)1) : ((byte)0));
		ImGuiNative.ImFont_SetGlyphVisible(NativePtr, c, visible2);
	}
}
public struct ImFontAtlas
{
	public ImFontAtlasFlags Flags;

	public IntPtr TexID;

	public int TexDesiredWidth;

	public int TexGlyphPadding;

	public byte Locked;

	public unsafe void* UserData;

	public byte TexReady;

	public byte TexPixelsUseColors;

	public unsafe byte* TexPixelsAlpha8;

	public unsafe uint* TexPixelsRGBA32;

	public int TexWidth;

	public int TexHeight;

	public Vector2 TexUvScale;

	public Vector2 TexUvWhitePixel;

	public ImVector Fonts;

	public ImVector CustomRects;

	public ImVector ConfigData;

	public Vector4 TexUvLines_0;

	public Vector4 TexUvLines_1;

	public Vector4 TexUvLines_2;

	public Vector4 TexUvLines_3;

	public Vector4 TexUvLines_4;

	public Vector4 TexUvLines_5;

	public Vector4 TexUvLines_6;

	public Vector4 TexUvLines_7;

	public Vector4 TexUvLines_8;

	public Vector4 TexUvLines_9;

	public Vector4 TexUvLines_10;

	public Vector4 TexUvLines_11;

	public Vector4 TexUvLines_12;

	public Vector4 TexUvLines_13;

	public Vector4 TexUvLines_14;

	public Vector4 TexUvLines_15;

	public Vector4 TexUvLines_16;

	public Vector4 TexUvLines_17;

	public Vector4 TexUvLines_18;

	public Vector4 TexUvLines_19;

	public Vector4 TexUvLines_20;

	public Vector4 TexUvLines_21;

	public Vector4 TexUvLines_22;

	public Vector4 TexUvLines_23;

	public Vector4 TexUvLines_24;

	public Vector4 TexUvLines_25;

	public Vector4 TexUvLines_26;

	public Vector4 TexUvLines_27;

	public Vector4 TexUvLines_28;

	public Vector4 TexUvLines_29;

	public Vector4 TexUvLines_30;

	public Vector4 TexUvLines_31;

	public Vector4 TexUvLines_32;

	public Vector4 TexUvLines_33;

	public Vector4 TexUvLines_34;

	public Vector4 TexUvLines_35;

	public Vector4 TexUvLines_36;

	public Vector4 TexUvLines_37;

	public Vector4 TexUvLines_38;

	public Vector4 TexUvLines_39;

	public Vector4 TexUvLines_40;

	public Vector4 TexUvLines_41;

	public Vector4 TexUvLines_42;

	public Vector4 TexUvLines_43;

	public Vector4 TexUvLines_44;

	public Vector4 TexUvLines_45;

	public Vector4 TexUvLines_46;

	public Vector4 TexUvLines_47;

	public Vector4 TexUvLines_48;

	public Vector4 TexUvLines_49;

	public Vector4 TexUvLines_50;

	public Vector4 TexUvLines_51;

	public Vector4 TexUvLines_52;

	public Vector4 TexUvLines_53;

	public Vector4 TexUvLines_54;

	public Vector4 TexUvLines_55;

	public Vector4 TexUvLines_56;

	public Vector4 TexUvLines_57;

	public Vector4 TexUvLines_58;

	public Vector4 TexUvLines_59;

	public Vector4 TexUvLines_60;

	public Vector4 TexUvLines_61;

	public Vector4 TexUvLines_62;

	public Vector4 TexUvLines_63;

	public unsafe IntPtr* FontBuilderIO;

	public uint FontBuilderFlags;

	public int PackIdMouseCursors;

	public int PackIdLines;
}
public struct ImFontAtlasPtr
{
	public unsafe ImFontAtlas* NativePtr { get; }

	public unsafe ref ImFontAtlasFlags Flags => ref Unsafe.AsRef<ImFontAtlasFlags>(&NativePtr->Flags);

	public unsafe ref IntPtr TexID => ref Unsafe.AsRef<IntPtr>(&NativePtr->TexID);

	public unsafe ref int TexDesiredWidth => ref Unsafe.AsRef<int>(&NativePtr->TexDesiredWidth);

	public unsafe ref int TexGlyphPadding => ref Unsafe.AsRef<int>(&NativePtr->TexGlyphPadding);

	public unsafe ref bool Locked => ref Unsafe.AsRef<bool>(&NativePtr->Locked);

	public unsafe IntPtr UserData
	{
		get
		{
			return (IntPtr)NativePtr->UserData;
		}
		set
		{
			NativePtr->UserData = (void*)value;
		}
	}

	public unsafe ref bool TexReady => ref Unsafe.AsRef<bool>(&NativePtr->TexReady);

	public unsafe ref bool TexPixelsUseColors => ref Unsafe.AsRef<bool>(&NativePtr->TexPixelsUseColors);

	public unsafe IntPtr TexPixelsAlpha8
	{
		get
		{
			return (IntPtr)NativePtr->TexPixelsAlpha8;
		}
		set
		{
			NativePtr->TexPixelsAlpha8 = (byte*)(void*)value;
		}
	}

	public unsafe IntPtr TexPixelsRGBA32
	{
		get
		{
			return (IntPtr)NativePtr->TexPixelsRGBA32;
		}
		set
		{
			NativePtr->TexPixelsRGBA32 = (uint*)(void*)value;
		}
	}

	public unsafe ref int TexWidth => ref Unsafe.AsRef<int>(&NativePtr->TexWidth);

	public unsafe ref int TexHeight => ref Unsafe.AsRef<int>(&NativePtr->TexHeight);

	public unsafe ref Vector2 TexUvScale => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvScale);

	public unsafe ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvWhitePixel);

	public unsafe ImVector<ImFontPtr> Fonts => new ImVector<ImFontPtr>(NativePtr->Fonts);

	public unsafe ImPtrVector<ImFontAtlasCustomRectPtr> CustomRects => new ImPtrVector<ImFontAtlasCustomRectPtr>(NativePtr->CustomRects, Unsafe.SizeOf<ImFontAtlasCustomRect>());

	public unsafe ImPtrVector<ImFontConfigPtr> ConfigData => new ImPtrVector<ImFontConfigPtr>(NativePtr->ConfigData, Unsafe.SizeOf<ImFontConfig>());

	public unsafe RangeAccessor<Vector4> TexUvLines => new RangeAccessor<Vector4>(&NativePtr->TexUvLines_0, 64);

	public unsafe IntPtr FontBuilderIO
	{
		get
		{
			return (IntPtr)NativePtr->FontBuilderIO;
		}
		set
		{
			NativePtr->FontBuilderIO = (IntPtr*)(void*)value;
		}
	}

	public unsafe ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);

	public unsafe ref int PackIdMouseCursors => ref Unsafe.AsRef<int>(&NativePtr->PackIdMouseCursors);

	public unsafe ref int PackIdLines => ref Unsafe.AsRef<int>(&NativePtr->PackIdLines);

	public unsafe ImFontAtlasPtr(ImFontAtlas* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontAtlasPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontAtlas*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontAtlasPtr(ImFontAtlas* nativePtr)
	{
		return new ImFontAtlasPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontAtlas*(ImFontAtlasPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontAtlasPtr(IntPtr nativePtr)
	{
		return new ImFontAtlasPtr(nativePtr);
	}

	public unsafe int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x)
	{
		ImFont* nativePtr = font.NativePtr;
		return ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, nativePtr, id, width, height, advance_x, default(Vector2));
	}

	public unsafe int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x, Vector2 offset)
	{
		ImFont* nativePtr = font.NativePtr;
		return ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, nativePtr, id, width, height, advance_x, offset);
	}

	public unsafe int AddCustomRectRegular(int width, int height)
	{
		return ImGuiNative.ImFontAtlas_AddCustomRectRegular(NativePtr, width, height);
	}

	public unsafe ImFontPtr AddFont(ImFontConfigPtr font_cfg)
	{
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFont(NativePtr, nativePtr));
	}

	public unsafe ImFontPtr AddFontDefault()
	{
		ImFontConfig* font_cfg = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, font_cfg));
	}

	public unsafe ImFontPtr AddFontDefault(ImFontConfigPtr font_cfg)
	{
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, nativePtr));
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		ImFont* nativePtr = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, font_cfg, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr);
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		ImFont* nativePtr = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, font_cfg, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_data_size, size_pixels, font_cfg, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels, ImFontConfigPtr font_cfg)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_data_size, size_pixels, nativePtr, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_data_size, size_pixels, nativePtr, glyph_ranges2));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_data_size, size_pixels, font_cfg, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels, ImFontConfigPtr font_cfg)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_data_size, size_pixels, nativePtr, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_data_size, size_pixels, nativePtr, glyph_ranges2));
	}

	public unsafe bool Build()
	{
		return ImGuiNative.ImFontAtlas_Build(NativePtr) != 0;
	}

	public unsafe void CalcCustomRectUV(ImFontAtlasCustomRectPtr rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
	{
		ImFontAtlasCustomRect* nativePtr = rect.NativePtr;
		fixed (Vector2* out_uv_min2 = &out_uv_min)
		{
			fixed (Vector2* out_uv_max2 = &out_uv_max)
			{
				ImGuiNative.ImFontAtlas_CalcCustomRectUV(NativePtr, nativePtr, out_uv_min2, out_uv_max2);
			}
		}
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImFontAtlas_Clear(NativePtr);
	}

	public unsafe void ClearFonts()
	{
		ImGuiNative.ImFontAtlas_ClearFonts(NativePtr);
	}

	public unsafe void ClearInputData()
	{
		ImGuiNative.ImFontAtlas_ClearInputData(NativePtr);
	}

	public unsafe void ClearTexData()
	{
		ImGuiNative.ImFontAtlas_ClearTexData(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontAtlas_destroy(NativePtr);
	}

	public unsafe ImFontAtlasCustomRectPtr GetCustomRectByIndex(int index)
	{
		return new ImFontAtlasCustomRectPtr(ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index));
	}

	public unsafe IntPtr GetGlyphRangesChineseFull()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesChineseSimplifiedCommon()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesCyrillic()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesDefault()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesGreek()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesGreek(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesJapanese()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesKorean()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesThai()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesVietnamese()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesVietnamese(NativePtr);
	}

	public unsafe bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offset, out Vector2 out_size, out Vector2 out_uv_border, out Vector2 out_uv_fill)
	{
		fixed (Vector2* out_offset2 = &out_offset)
		{
			fixed (Vector2* out_size2 = &out_size)
			{
				fixed (Vector2* out_uv_border2 = &out_uv_border)
				{
					fixed (Vector2* out_uv_fill2 = &out_uv_fill)
					{
						return ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, out_offset2, out_size2, out_uv_border2, out_uv_fill2) != 0;
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe bool IsBuilt()
	{
		return ImGuiNative.ImFontAtlas_IsBuilt(NativePtr) != 0;
	}

	public unsafe void SetTexID(IntPtr id)
	{
		ImGuiNative.ImFontAtlas_SetTexID(NativePtr, id);
	}
}
public struct ImFontAtlasCustomRect
{
	public ushort Width;

	public ushort Height;

	public ushort X;

	public ushort Y;

	public uint GlyphID;

	public float GlyphAdvanceX;

	public Vector2 GlyphOffset;

	public unsafe ImFont* Font;
}
public struct ImFontAtlasCustomRectPtr
{
	public unsafe ImFontAtlasCustomRect* NativePtr { get; }

	public unsafe ref ushort Width => ref Unsafe.AsRef<ushort>(&NativePtr->Width);

	public unsafe ref ushort Height => ref Unsafe.AsRef<ushort>(&NativePtr->Height);

	public unsafe ref ushort X => ref Unsafe.AsRef<ushort>(&NativePtr->X);

	public unsafe ref ushort Y => ref Unsafe.AsRef<ushort>(&NativePtr->Y);

	public unsafe ref uint GlyphID => ref Unsafe.AsRef<uint>(&NativePtr->GlyphID);

	public unsafe ref float GlyphAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphAdvanceX);

	public unsafe ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);

	public unsafe ImFontPtr Font => new ImFontPtr(NativePtr->Font);

	public unsafe ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontAtlasCustomRectPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontAtlasCustomRect*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr)
	{
		return new ImFontAtlasCustomRectPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontAtlasCustomRect*(ImFontAtlasCustomRectPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontAtlasCustomRectPtr(IntPtr nativePtr)
	{
		return new ImFontAtlasCustomRectPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontAtlasCustomRect_destroy(NativePtr);
	}

	public unsafe bool IsPacked()
	{
		return ImGuiNative.ImFontAtlasCustomRect_IsPacked(NativePtr) != 0;
	}
}
[Flags]
public enum ImFontAtlasFlags
{
	None = 0,
	NoPowerOfTwoHeight = 1,
	NoMouseCursors = 2,
	NoBakedLines = 4
}
public struct ImFontConfig
{
	public unsafe void* FontData;

	public int FontDataSize;

	public byte FontDataOwnedByAtlas;

	public int FontNo;

	public float SizePixels;

	public int OversampleH;

	public int OversampleV;

	public byte PixelSnapH;

	public Vector2 GlyphExtraSpacing;

	public Vector2 GlyphOffset;

	public unsafe ushort* GlyphRanges;

	public float GlyphMinAdvanceX;

	public float GlyphMaxAdvanceX;

	public byte MergeMode;

	public uint FontBuilderFlags;

	public float RasterizerMultiply;

	public float RasterizerDensity;

	public ushort EllipsisChar;

	public unsafe fixed byte Name[40];

	public unsafe ImFont* DstFont;
}
public struct ImFontConfigPtr
{
	public unsafe ImFontConfig* NativePtr { get; }

	public unsafe IntPtr FontData
	{
		get
		{
			return (IntPtr)NativePtr->FontData;
		}
		set
		{
			NativePtr->FontData = (void*)value;
		}
	}

	public unsafe ref int FontDataSize => ref Unsafe.AsRef<int>(&NativePtr->FontDataSize);

	public unsafe ref bool FontDataOwnedByAtlas => ref Unsafe.AsRef<bool>(&NativePtr->FontDataOwnedByAtlas);

	public unsafe ref int FontNo => ref Unsafe.AsRef<int>(&NativePtr->FontNo);

	public unsafe ref float SizePixels => ref Unsafe.AsRef<float>(&NativePtr->SizePixels);

	public unsafe ref int OversampleH => ref Unsafe.AsRef<int>(&NativePtr->OversampleH);

	public unsafe ref int OversampleV => ref Unsafe.AsRef<int>(&NativePtr->OversampleV);

	public unsafe ref bool PixelSnapH => ref Unsafe.AsRef<bool>(&NativePtr->PixelSnapH);

	public unsafe ref Vector2 GlyphExtraSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphExtraSpacing);

	public unsafe ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);

	public unsafe IntPtr GlyphRanges
	{
		get
		{
			return (IntPtr)NativePtr->GlyphRanges;
		}
		set
		{
			NativePtr->GlyphRanges = (ushort*)(void*)value;
		}
	}

	public unsafe ref float GlyphMinAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMinAdvanceX);

	public unsafe ref float GlyphMaxAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMaxAdvanceX);

	public unsafe ref bool MergeMode => ref Unsafe.AsRef<bool>(&NativePtr->MergeMode);

	public unsafe ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);

	public unsafe ref float RasterizerMultiply => ref Unsafe.AsRef<float>(&NativePtr->RasterizerMultiply);

	public unsafe ref float RasterizerDensity => ref Unsafe.AsRef<float>(&NativePtr->RasterizerDensity);

	public unsafe ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);

	public unsafe RangeAccessor<byte> Name => new RangeAccessor<byte>(NativePtr->Name, 40);

	public unsafe ImFontPtr DstFont => new ImFontPtr(NativePtr->DstFont);

	public unsafe ImFontConfigPtr(ImFontConfig* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontConfigPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontConfig*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontConfigPtr(ImFontConfig* nativePtr)
	{
		return new ImFontConfigPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontConfig*(ImFontConfigPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontConfigPtr(IntPtr nativePtr)
	{
		return new ImFontConfigPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontConfig_destroy(NativePtr);
	}
}
public struct ImFontGlyph
{
	public uint Colored;

	public uint Visible;

	public uint Codepoint;

	public float AdvanceX;

	public float X0;

	public float Y0;

	public float X1;

	public float Y1;

	public float U0;

	public float V0;

	public float U1;

	public float V1;
}
public struct ImFontGlyphPtr
{
	public unsafe ImFontGlyph* NativePtr { get; }

	public unsafe ref uint Colored => ref Unsafe.AsRef<uint>(&NativePtr->Colored);

	public unsafe ref uint Visible => ref Unsafe.AsRef<uint>(&NativePtr->Visible);

	public unsafe ref uint Codepoint => ref Unsafe.AsRef<uint>(&NativePtr->Codepoint);

	public unsafe ref float AdvanceX => ref Unsafe.AsRef<float>(&NativePtr->AdvanceX);

	public unsafe ref float X0 => ref Unsafe.AsRef<float>(&NativePtr->X0);

	public unsafe ref float Y0 => ref Unsafe.AsRef<float>(&NativePtr->Y0);

	public unsafe ref float X1 => ref Unsafe.AsRef<float>(&NativePtr->X1);

	public unsafe ref float Y1 => ref Unsafe.AsRef<float>(&NativePtr->Y1);

	public unsafe ref float U0 => ref Unsafe.AsRef<float>(&NativePtr->U0);

	public unsafe ref float V0 => ref Unsafe.AsRef<float>(&NativePtr->V0);

	public unsafe ref float U1 => ref Unsafe.AsRef<float>(&NativePtr->U1);

	public unsafe ref float V1 => ref Unsafe.AsRef<float>(&NativePtr->V1);

	public unsafe ImFontGlyphPtr(ImFontGlyph* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontGlyphPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontGlyph*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontGlyphPtr(ImFontGlyph* nativePtr)
	{
		return new ImFontGlyphPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontGlyph*(ImFontGlyphPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontGlyphPtr(IntPtr nativePtr)
	{
		return new ImFontGlyphPtr(nativePtr);
	}
}
public struct ImFontGlyphRangesBuilder
{
	public ImVector UsedChars;
}
public struct ImFontGlyphRangesBuilderPtr
{
	public unsafe ImFontGlyphRangesBuilder* NativePtr { get; }

	public unsafe ImVector<uint> UsedChars => new ImVector<uint>(NativePtr->UsedChars);

	public unsafe ImFontGlyphRangesBuilderPtr(ImFontGlyphRangesBuilder* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontGlyphRangesBuilderPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontGlyphRangesBuilder*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontGlyphRangesBuilderPtr(ImFontGlyphRangesBuilder* nativePtr)
	{
		return new ImFontGlyphRangesBuilderPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontGlyphRangesBuilder*(ImFontGlyphRangesBuilderPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontGlyphRangesBuilderPtr(IntPtr nativePtr)
	{
		return new ImFontGlyphRangesBuilderPtr(nativePtr);
	}

	public unsafe void AddChar(ushort c)
	{
		ImGuiNative.ImFontGlyphRangesBuilder_AddChar(NativePtr, c);
	}

	public unsafe void AddRanges(IntPtr ranges)
	{
		ushort* ranges2 = (ushort*)ranges.ToPointer();
		ImGuiNative.ImFontGlyphRangesBuilder_AddRanges(NativePtr, ranges2);
	}

	public unsafe void AddText(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.ImFontGlyphRangesBuilder_AddText(NativePtr, ptr, ptr + num);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void BuildRanges(out ImVector out_ranges)
	{
		fixed (ImVector* out_ranges2 = &out_ranges)
		{
			ImGuiNative.ImFontGlyphRangesBuilder_BuildRanges(NativePtr, out_ranges2);
		}
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImFontGlyphRangesBuilder_Clear(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontGlyphRangesBuilder_destroy(NativePtr);
	}

	public unsafe bool GetBit(uint n)
	{
		return ImGuiNative.ImFontGlyphRangesBuilder_GetBit(NativePtr, n) != 0;
	}

	public unsafe void SetBit(uint n)
	{
		ImGuiNative.ImFontGlyphRangesBuilder_SetBit(NativePtr, n);
	}
}
public static class ImGui
{
	public unsafe static ImGuiPayloadPtr AcceptDragDropPayload(string type)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiDragDropFlags flags = ImGuiDragDropFlags.None;
		ImGuiPayload* nativePtr = ImGuiNative.igAcceptDragDropPayload(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImGuiPayloadPtr(nativePtr);
	}

	public unsafe static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPayload* nativePtr = ImGuiNative.igAcceptDragDropPayload(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImGuiPayloadPtr(nativePtr);
	}

	public static void AlignTextToFramePadding()
	{
		ImGuiNative.igAlignTextToFramePadding();
	}

	public unsafe static bool ArrowButton(string str_id, ImGuiDir dir)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igArrowButton(ptr, dir);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Begin(string name)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBegin(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Begin(string name, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBegin(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool Begin(string name, ref bool p_open, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBegin(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 size = default(Vector2);
		ImGuiChildFlags child_flags = ImGuiChildFlags.None;
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiChildFlags child_flags = ImGuiChildFlags.None;
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginChild(uint id)
	{
		Vector2 size = default(Vector2);
		ImGuiChildFlags child_flags = ImGuiChildFlags.None;
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size)
	{
		ImGuiChildFlags child_flags = ImGuiChildFlags.None;
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags)
	{
		ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
	{
		return ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags) != 0;
	}

	public unsafe static bool BeginCombo(string label, string preview_value)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (preview_value != null)
		{
			num2 = Encoding.UTF8.GetByteCount(preview_value);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(preview_value, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiComboFlags flags = ImGuiComboFlags.None;
		byte num3 = ImGuiNative.igBeginCombo(ptr, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool BeginCombo(string label, string preview_value, ImGuiComboFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (preview_value != null)
		{
			num2 = Encoding.UTF8.GetByteCount(preview_value);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(preview_value, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igBeginCombo(ptr, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public static void BeginDisabled()
	{
		ImGuiNative.igBeginDisabled(1);
	}

	public static void BeginDisabled(bool disabled)
	{
		ImGuiNative.igBeginDisabled(disabled ? ((byte)1) : ((byte)0));
	}

	public static bool BeginDragDropSource()
	{
		return ImGuiNative.igBeginDragDropSource(ImGuiDragDropFlags.None) != 0;
	}

	public static bool BeginDragDropSource(ImGuiDragDropFlags flags)
	{
		return ImGuiNative.igBeginDragDropSource(flags) != 0;
	}

	public static bool BeginDragDropTarget()
	{
		return ImGuiNative.igBeginDragDropTarget() != 0;
	}

	public static void BeginGroup()
	{
		ImGuiNative.igBeginGroup();
	}

	public static bool BeginItemTooltip()
	{
		return ImGuiNative.igBeginItemTooltip() != 0;
	}

	public unsafe static bool BeginListBox(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginListBox(ptr, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginListBox(string label, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginListBox(ptr, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginMainMenuBar()
	{
		return ImGuiNative.igBeginMainMenuBar() != 0;
	}

	public unsafe static bool BeginMenu(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte enabled = 1;
		byte num2 = ImGuiNative.igBeginMenu(ptr, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginMenu(string label, bool enabled)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte enabled2 = (enabled ? ((byte)1) : ((byte)0));
		byte num2 = ImGuiNative.igBeginMenu(ptr, enabled2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginMenuBar()
	{
		return ImGuiNative.igBeginMenuBar() != 0;
	}

	public unsafe static bool BeginPopup(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopup(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopup(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextItem()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextItem(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextItem(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextItem(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextVoid()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextVoid(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextVoid(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextVoid(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextWindow()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextWindow(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextWindow(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextWindow(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name, ref bool p_open, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTabBar(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTabBarFlags flags = ImGuiTabBarFlags.None;
		byte num2 = ImGuiNative.igBeginTabBar(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabBar(string str_id, ImGuiTabBarFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginTabBar(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label, ref bool p_open, ImGuiTabItemFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (p_open ? ((byte)1) : ((byte)0));
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTableFlags flags = ImGuiTableFlags.None;
		Vector2 outer_size = default(Vector2);
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 outer_size = default(Vector2);
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags, Vector2 outer_size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginTooltip()
	{
		return ImGuiNative.igBeginTooltip() != 0;
	}

	public static void Bullet()
	{
		ImGuiNative.igBullet();
	}

	public unsafe static void BulletText(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igBulletText(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static bool Button(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igButton(ptr, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Button(string label, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igButton(ptr, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static float CalcItemWidth()
	{
		return ImGuiNative.igCalcItemWidth();
	}

	public unsafe static Vector2 CalcTextSize(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte hide_text_after_double_hash = 0;
		float wrap_width = -1f;
		Vector2 result = default(Vector2);
		ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash, wrap_wid