Dalamud/imgui/Dalamud.Bindings.ImGui/Custom/Generated/Internals/Functions/ImGuiP.gen.cs

// <auto-generated/>

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

namespace Dalamud.Bindings.ImGui;

public unsafe partial class ImGuiP
{
		public static void ImQsort(void* baseValue, nuint count, nuint sizeOfElement, delegate*<void*, nuint, nuint, delegate*<void*, void*, int>, int> compareFunc)
		{
			ImGuiPNative.ImQsort(baseValue, count, sizeOfElement, compareFunc);
		}
		public static uint ImAlphaBlendColors(uint colA, uint colB)
		{
			uint ret = ImGuiPNative.ImAlphaBlendColors(colA, colB);
			return ret;
		}
		public static bool ImIsPowerOfTwo(int v)
		{
			byte ret = ImGuiPNative.ImIsPowerOfTwo(v);
			return ret != 0;
		}
		public static bool ImIsPowerOfTwo(ulong v)
		{
			byte ret = ImGuiPNative.ImIsPowerOfTwo(v);
			return ret != 0;
		}
		public static int ImUpperPowerOfTwo(int v)
		{
			int ret = ImGuiPNative.ImUpperPowerOfTwo(v);
			return ret;
		}
		public static ushort* ImStrbolW(ushort* bufMidLine, ushort* bufBegin)
		{
			ushort* ret = ImGuiPNative.ImStrbolW(bufMidLine, bufBegin);
			return ret;
		}
		public static bool ImCharIsBlankA(byte c)
		{
			byte ret = ImGuiPNative.ImCharIsBlankA(c);
			return ret != 0;
		}
		public static bool ImCharIsBlankW(uint c)
		{
			byte ret = ImGuiPNative.ImCharIsBlankW(c);
			return ret != 0;
		}
		public static int ImTextCountUtf8BytesFromStr(ushort* inText, ushort* inTextEnd)
		{
			int ret = ImGuiPNative.ImTextCountUtf8BytesFromStr(inText, inTextEnd);
			return ret;
		}
		public static bool ImFileClose(ImFileHandle file)
		{
			byte ret = ImGuiPNative.ImFileClose(file);
			return ret != 0;
		}
		public static ulong ImFileGetSize(ImFileHandle file)
		{
			ulong ret = ImGuiPNative.ImFileGetSize(file);
			return ret;
		}
		public static ulong ImFileRead(void* data, ulong size, ulong count, ImFileHandle file)
		{
			ulong ret = ImGuiPNative.ImFileRead(data, size, count, file);
			return ret;
		}
		public static ulong ImFileWrite(void* data, ulong size, ulong count, ImFileHandle file)
		{
			ulong ret = ImGuiPNative.ImFileWrite(data, size, count, file);
			return ret;
		}
		public static float ImPow(float x, float y)
		{
			float ret = ImGuiPNative.ImPow(x, y);
			return ret;
		}
		public static double ImPow(double x, double y)
		{
			double ret = ImGuiPNative.ImPow(x, y);
			return ret;
		}
		public static float ImLog(float x)
		{
			float ret = ImGuiPNative.ImLog(x);
			return ret;
		}
		public static double ImLog(double x)
		{
			double ret = ImGuiPNative.ImLog(x);
			return ret;
		}
		public static int ImAbs(int x)
		{
			int ret = ImGuiPNative.ImAbs(x);
			return ret;
		}
		public static float ImAbs(float x)
		{
			float ret = ImGuiPNative.ImAbs(x);
			return ret;
		}
		public static double ImAbs(double x)
		{
			double ret = ImGuiPNative.ImAbs(x);
			return ret;
		}
		public static float ImSign(float x)
		{
			float ret = ImGuiPNative.ImSign(x);
			return ret;
		}
		public static double ImSign(double x)
		{
			double ret = ImGuiPNative.ImSign(x);
			return ret;
		}
		public static float ImRsqrt(float x)
		{
			float ret = ImGuiPNative.ImRsqrt(x);
			return ret;
		}
		public static double ImRsqrt(double x)
		{
			double ret = ImGuiPNative.ImRsqrt(x);
			return ret;
		}
		public static Vector2 ImMin(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImGuiPNative.ImMin(&ret, lhs, rhs);
			return ret;
		}
		public static void ImMin(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImGuiPNative.ImMin(pOut, lhs, rhs);
		}
		public static void ImMin(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImMin((Vector2*)ppOut, lhs, rhs);
			}
		}
		public static Vector2 ImMax(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImGuiPNative.ImMax(&ret, lhs, rhs);
			return ret;
		}
		public static void ImMax(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImGuiPNative.ImMax(pOut, lhs, rhs);
		}
		public static void ImMax(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImMax((Vector2*)ppOut, lhs, rhs);
			}
		}
		public static Vector2 ImClamp(Vector2 v, Vector2 mn, Vector2 mx)
		{
			Vector2 ret;
			ImGuiPNative.ImClamp(&ret, v, mn, mx);
			return ret;
		}
		public static void ImClamp(Vector2* pOut, Vector2 v, Vector2 mn, Vector2 mx)
		{
			ImGuiPNative.ImClamp(pOut, v, mn, mx);
		}
		public static void ImClamp(ref Vector2 pOut, Vector2 v, Vector2 mn, Vector2 mx)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImClamp((Vector2*)ppOut, v, mn, mx);
			}
		}
		public static Vector2 ImLerp(Vector2 a, Vector2 b, float t)
		{
			Vector2 ret;
			ImGuiPNative.ImLerp(&ret, a, b, t);
			return ret;
		}
		public static void ImLerp(Vector2* pOut, Vector2 a, Vector2 b, float t)
		{
			ImGuiPNative.ImLerp(pOut, a, b, t);
		}
		public static void ImLerp(ref Vector2 pOut, Vector2 a, Vector2 b, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImLerp((Vector2*)ppOut, a, b, t);
			}
		}
		public static Vector2 ImLerp(Vector2 a, Vector2 b, Vector2 t)
		{
			Vector2 ret;
			ImGuiPNative.ImLerp(&ret, a, b, t);
			return ret;
		}
		public static void ImLerp(Vector2* pOut, Vector2 a, Vector2 b, Vector2 t)
		{
			ImGuiPNative.ImLerp(pOut, a, b, t);
		}
		public static void ImLerp(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImLerp((Vector2*)ppOut, a, b, t);
			}
		}
		public static Vector4 ImLerp(Vector4 a, Vector4 b, float t)
		{
			Vector4 ret;
			ImGuiPNative.ImLerp(&ret, a, b, t);
			return ret;
		}
		public static void ImLerp(Vector4* pOut, Vector4 a, Vector4 b, float t)
		{
			ImGuiPNative.ImLerp(pOut, a, b, t);
		}
		public static void ImLerp(ref Vector4 pOut, Vector4 a, Vector4 b, float t)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				ImGuiPNative.ImLerp((Vector4*)ppOut, a, b, t);
			}
		}
		public static float ImSaturate(float f)
		{
			float ret = ImGuiPNative.ImSaturate(f);
			return ret;
		}
		public static float ImLengthSqr(Vector2 lhs)
		{
			float ret = ImGuiPNative.ImLengthSqr(lhs);
			return ret;
		}
		public static float ImLengthSqr(Vector4 lhs)
		{
			float ret = ImGuiPNative.ImLengthSqr(lhs);
			return ret;
		}
		public static float ImInvLength(Vector2 lhs, float failValue)
		{
			float ret = ImGuiPNative.ImInvLength(lhs, failValue);
			return ret;
		}
		public static float ImFloor(float f)
		{
			float ret = ImGuiPNative.ImFloor(f);
			return ret;
		}
		public static Vector2 ImFloor(Vector2 v)
		{
			Vector2 ret;
			ImGuiPNative.ImFloor(&ret, v);
			return ret;
		}
		public static void ImFloor(Vector2* pOut, Vector2 v)
		{
			ImGuiPNative.ImFloor(pOut, v);
		}
		public static void ImFloor(ref Vector2 pOut, Vector2 v)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImFloor((Vector2*)ppOut, v);
			}
		}
		public static float ImFloorSigned(float f)
		{
			float ret = ImGuiPNative.ImFloorSigned(f);
			return ret;
		}
		public static Vector2 ImFloorSigned(Vector2 v)
		{
			Vector2 ret;
			ImGuiPNative.ImFloorSigned(&ret, v);
			return ret;
		}
		public static void ImFloorSigned(Vector2* pOut, Vector2 v)
		{
			ImGuiPNative.ImFloorSigned(pOut, v);
		}
		public static void ImFloorSigned(ref Vector2 pOut, Vector2 v)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImFloorSigned((Vector2*)ppOut, v);
			}
		}
		public static int ImModPositive(int a, int b)
		{
			int ret = ImGuiPNative.ImModPositive(a, b);
			return ret;
		}
		public static float ImDot(Vector2 a, Vector2 b)
		{
			float ret = ImGuiPNative.ImDot(a, b);
			return ret;
		}
		public static Vector2 ImRotate(Vector2 v, float cosA, float sinA)
		{
			Vector2 ret;
			ImGuiPNative.ImRotate(&ret, v, cosA, sinA);
			return ret;
		}
		public static void ImRotate(Vector2* pOut, Vector2 v, float cosA, float sinA)
		{
			ImGuiPNative.ImRotate(pOut, v, cosA, sinA);
		}
		public static void ImRotate(ref Vector2 pOut, Vector2 v, float cosA, float sinA)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImRotate((Vector2*)ppOut, v, cosA, sinA);
			}
		}
		public static float ImLinearSweep(float current, float target, float speed)
		{
			float ret = ImGuiPNative.ImLinearSweep(current, target, speed);
			return ret;
		}
		public static Vector2 ImMul(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImGuiPNative.ImMul(&ret, lhs, rhs);
			return ret;
		}
		public static void ImMul(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImGuiPNative.ImMul(pOut, lhs, rhs);
		}
		public static void ImMul(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImMul((Vector2*)ppOut, lhs, rhs);
			}
		}
		public static bool ImIsFloatAboveGuaranteedIntegerPrecision(float f)
		{
			byte ret = ImGuiPNative.ImIsFloatAboveGuaranteedIntegerPrecision(f);
			return ret != 0;
		}
		public static Vector2 ImBezierCubicCalc(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			Vector2 ret;
			ImGuiPNative.ImBezierCubicCalc(&ret, p1, p2, p3, p4, t);
			return ret;
		}
		public static void ImBezierCubicCalc(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			ImGuiPNative.ImBezierCubicCalc(pOut, p1, p2, p3, p4, t);
		}
		public static void ImBezierCubicCalc(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImBezierCubicCalc((Vector2*)ppOut, p1, p2, p3, p4, t);
			}
		}
		public static Vector2 ImBezierCubicClosestPoint(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			Vector2 ret;
			ImGuiPNative.ImBezierCubicClosestPoint(&ret, p1, p2, p3, p4, p, numSegments);
			return ret;
		}
		public static void ImBezierCubicClosestPoint(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			ImGuiPNative.ImBezierCubicClosestPoint(pOut, p1, p2, p3, p4, p, numSegments);
		}
		public static void ImBezierCubicClosestPoint(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImBezierCubicClosestPoint((Vector2*)ppOut, p1, p2, p3, p4, p, numSegments);
			}
		}
		public static Vector2 ImBezierCubicClosestPointCasteljau(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			Vector2 ret;
			ImGuiPNative.ImBezierCubicClosestPointCasteljau(&ret, p1, p2, p3, p4, p, tessTol);
			return ret;
		}
		public static void ImBezierCubicClosestPointCasteljau(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			ImGuiPNative.ImBezierCubicClosestPointCasteljau(pOut, p1, p2, p3, p4, p, tessTol);
		}
		public static void ImBezierCubicClosestPointCasteljau(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImBezierCubicClosestPointCasteljau((Vector2*)ppOut, p1, p2, p3, p4, p, tessTol);
			}
		}
		public static Vector2 ImBezierQuadraticCalc(Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			Vector2 ret;
			ImGuiPNative.ImBezierQuadraticCalc(&ret, p1, p2, p3, t);
			return ret;
		}
		public static void ImBezierQuadraticCalc(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			ImGuiPNative.ImBezierQuadraticCalc(pOut, p1, p2, p3, t);
		}
		public static void ImBezierQuadraticCalc(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImBezierQuadraticCalc((Vector2*)ppOut, p1, p2, p3, t);
			}
		}
		public static Vector2 ImLineClosestPoint(Vector2 a, Vector2 b, Vector2 p)
		{
			Vector2 ret;
			ImGuiPNative.ImLineClosestPoint(&ret, a, b, p);
			return ret;
		}
		public static void ImLineClosestPoint(Vector2* pOut, Vector2 a, Vector2 b, Vector2 p)
		{
			ImGuiPNative.ImLineClosestPoint(pOut, a, b, p);
		}
		public static void ImLineClosestPoint(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 p)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImLineClosestPoint((Vector2*)ppOut, a, b, p);
			}
		}
		public static bool ImTriangleContainsPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			byte ret = ImGuiPNative.ImTriangleContainsPoint(a, b, c, p);
			return ret != 0;
		}
		public static Vector2 ImTriangleClosestPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			Vector2 ret;
			ImGuiPNative.ImTriangleClosestPoint(&ret, a, b, c, p);
			return ret;
		}
		public static void ImTriangleClosestPoint(Vector2* pOut, Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			ImGuiPNative.ImTriangleClosestPoint(pOut, a, b, c, p);
		}
		public static void ImTriangleClosestPoint(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ImTriangleClosestPoint((Vector2*)ppOut, a, b, c, p);
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, float* outV, float* outW)
		{
			ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, outU, outV, outW);
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, float* outV, float* outW)
		{
			fixed (float* poutU = &outU)
			{
				ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, (float*)poutU, outV, outW);
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, ref float outV, float* outW)
		{
			fixed (float* poutV = &outV)
			{
				ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, outU, (float*)poutV, outW);
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, ref float outV, float* outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutV = &outV)
				{
					ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, (float*)poutU, (float*)poutV, outW);
				}
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, float* outV, ref float outW)
		{
			fixed (float* poutW = &outW)
			{
				ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, outU, outV, (float*)poutW);
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, float* outV, ref float outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutW = &outW)
				{
					ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, (float*)poutU, outV, (float*)poutW);
				}
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, ref float outV, ref float outW)
		{
			fixed (float* poutV = &outV)
			{
				fixed (float* poutW = &outW)
				{
					ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, outU, (float*)poutV, (float*)poutW);
				}
			}
		}
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, ref float outV, ref float outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutV = &outV)
				{
					fixed (float* poutW = &outW)
					{
						ImGuiPNative.ImTriangleBarycentricCoords(a, b, c, p, (float*)poutU, (float*)poutV, (float*)poutW);
					}
				}
			}
		}
		public static float ImTriangleArea(Vector2 a, Vector2 b, Vector2 c)
		{
			float ret = ImGuiPNative.ImTriangleArea(a, b, c);
			return ret;
		}
		public static ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy)
		{
			ImGuiDir ret = ImGuiPNative.ImGetDirQuadrantFromDelta(dx, dy);
			return ret;
		}
		public static ImVec1Ptr ImVec1()
		{
			ImVec1Ptr ret = ImGuiPNative.ImVec1();
			return ret;
		}
		public static ImVec1Ptr ImVec1(float x)
		{
			ImVec1Ptr ret = ImGuiPNative.ImVec1(x);
			return ret;
		}
		public static ImVec2IhPtr ImVec2ih()
		{
			ImVec2IhPtr ret = ImGuiPNative.ImVec2ih();
			return ret;
		}
		public static ImVec2IhPtr ImVec2ih(short x, short y)
		{
			ImVec2IhPtr ret = ImGuiPNative.ImVec2ih(x, y);
			return ret;
		}
		public static ImVec2IhPtr ImVec2ih(Vector2 rhs)
		{
			ImVec2IhPtr ret = ImGuiPNative.ImVec2ih(rhs);
			return ret;
		}
		public static ImRectPtr ImRect()
		{
			ImRectPtr ret = ImGuiPNative.ImRect();
			return ret;
		}
		public static ImRectPtr ImRect(Vector2 min, Vector2 max)
		{
			ImRectPtr ret = ImGuiPNative.ImRect(min, max);
			return ret;
		}
		public static ImRectPtr ImRect(Vector4 v)
		{
			ImRectPtr ret = ImGuiPNative.ImRect(v);
			return ret;
		}
		public static ImRectPtr ImRect(float x1, float y1, float x2, float y2)
		{
			ImRectPtr ret = ImGuiPNative.ImRect(x1, y1, x2, y2);
			return ret;
		}
		public static Vector2 GetCenter(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetCenter(&ret, self);
			return ret;
		}
		public static void GetCenter(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetCenter(pOut, self);
		}
		public static void GetCenter(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetCenter((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetCenter(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetCenter(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetCenter(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetCenter(pOut, (ImRect*)pself);
			}
		}
		public static void GetCenter(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetCenter((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static Vector2 GetSize(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetSize(&ret, self);
			return ret;
		}
		public static void GetSize(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetSize(pOut, self);
		}
		public static void GetSize(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetSize((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetSize(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetSize(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetSize(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetSize(pOut, (ImRect*)pself);
			}
		}
		public static void GetSize(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetSize((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static float GetWidth(this ImRectPtr self)
		{
			float ret = ImGuiPNative.GetWidth(self);
			return ret;
		}
		public static float GetWidth(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = ImGuiPNative.GetWidth((ImRect*)pself);
				return ret;
			}
		}
		public static float GetHeight(this ImRectPtr self)
		{
			float ret = ImGuiPNative.GetHeight(self);
			return ret;
		}
		public static float GetHeight(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = ImGuiPNative.GetHeight((ImRect*)pself);
				return ret;
			}
		}
		public static float GetArea(this ImRectPtr self)
		{
			float ret = ImGuiPNative.GetArea(self);
			return ret;
		}
		public static float GetArea(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = ImGuiPNative.GetArea((ImRect*)pself);
				return ret;
			}
		}
		public static Vector2 GetTL(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetTL(&ret, self);
			return ret;
		}
		public static void GetTL(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetTL(pOut, self);
		}
		public static void GetTL(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetTL((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetTL(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetTL(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetTL(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetTL(pOut, (ImRect*)pself);
			}
		}
		public static void GetTL(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetTL((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static Vector2 GetTR(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetTR(&ret, self);
			return ret;
		}
		public static void GetTR(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetTR(pOut, self);
		}
		public static void GetTR(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetTR((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetTR(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetTR(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetTR(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetTR(pOut, (ImRect*)pself);
			}
		}
		public static void GetTR(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetTR((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static Vector2 GetBL(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetBL(&ret, self);
			return ret;
		}
		public static void GetBL(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetBL(pOut, self);
		}
		public static void GetBL(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetBL((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetBL(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetBL(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetBL(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetBL(pOut, (ImRect*)pself);
			}
		}
		public static void GetBL(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetBL((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static Vector2 GetBR(this ImRectPtr self)
		{
			Vector2 ret;
			ImGuiPNative.GetBR(&ret, self);
			return ret;
		}
		public static void GetBR(Vector2* pOut, ImRectPtr self)
		{
			ImGuiPNative.GetBR(pOut, self);
		}
		public static void GetBR(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetBR((Vector2*)ppOut, self);
			}
		}
		public static Vector2 GetBR(this scoped in ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.GetBR(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void GetBR(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.GetBR(pOut, (ImRect*)pself);
			}
		}
		public static void GetBR(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.GetBR((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static bool Contains(this ImRectPtr self, Vector2 p)
		{
			byte ret = ImGuiPNative.Contains(self, p);
			return ret != 0;
		}
		public static bool Contains(this ref ImRect self, Vector2 p)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ImGuiPNative.Contains((ImRect*)pself, p);
				return ret != 0;
			}
		}
		public static bool Contains(this ImRectPtr self, ImRect r)
		{
			byte ret = ImGuiPNative.Contains(self, r);
			return ret != 0;
		}
		public static bool Contains(this ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ImGuiPNative.Contains((ImRect*)pself, r);
				return ret != 0;
			}
		}
		public static bool Overlaps(this ImRectPtr self, ImRect r)
		{
			byte ret = ImGuiPNative.Overlaps(self, r);
			return ret != 0;
		}
		public static bool Overlaps(this ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ImGuiPNative.Overlaps((ImRect*)pself, r);
				return ret != 0;
			}
		}
		public static void Add(this ImRectPtr self, Vector2 p)
		{
			ImGuiPNative.Add(self, p);
		}
		public static void Add(this ref ImRect self, Vector2 p)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Add((ImRect*)pself, p);
			}
		}
		public static void Add(this ImRectPtr self, ImRect r)
		{
			ImGuiPNative.Add(self, r);
		}
		public static void Add(this ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Add((ImRect*)pself, r);
			}
		}
		public static void Expand(this ImRectPtr self, float amount)
		{
			ImGuiPNative.Expand(self, amount);
		}
		public static void Expand(this ref ImRect self, float amount)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Expand((ImRect*)pself, amount);
			}
		}
		public static void Expand(this ImRectPtr self, Vector2 amount)
		{
			ImGuiPNative.Expand(self, amount);
		}
		public static void Expand(this ref ImRect self, Vector2 amount)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Expand((ImRect*)pself, amount);
			}
		}
		public static void Translate(this ImRectPtr self, Vector2 d)
		{
			ImGuiPNative.Translate(self, d);
		}
		public static void Translate(this ref ImRect self, Vector2 d)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Translate((ImRect*)pself, d);
			}
		}
		public static void TranslateX(this ImRectPtr self, float dx)
		{
			ImGuiPNative.TranslateX(self, dx);
		}
		public static void TranslateX(this ref ImRect self, float dx)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.TranslateX((ImRect*)pself, dx);
			}
		}
		public static void TranslateY(this ImRectPtr self, float dy)
		{
			ImGuiPNative.TranslateY(self, dy);
		}
		public static void TranslateY(this ref ImRect self, float dy)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.TranslateY((ImRect*)pself, dy);
			}
		}
		public static void ClipWith(this ImRectPtr self, ImRect r)
		{
			ImGuiPNative.ClipWith(self, r);
		}
		public static void ClipWith(this ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.ClipWith((ImRect*)pself, r);
			}
		}
		public static void ClipWithFull(this ImRectPtr self, ImRect r)
		{
			ImGuiPNative.ClipWithFull(self, r);
		}
		public static void ClipWithFull(this ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.ClipWithFull((ImRect*)pself, r);
			}
		}
		public static void Floor(this ImRectPtr self)
		{
			ImGuiPNative.Floor(self);
		}
		public static void Floor(this ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.Floor((ImRect*)pself);
			}
		}
		public static bool IsInverted(this ImRectPtr self)
		{
			byte ret = ImGuiPNative.IsInverted(self);
			return ret != 0;
		}
		public static bool IsInverted(this ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ImGuiPNative.IsInverted((ImRect*)pself);
				return ret != 0;
			}
		}
		public static Vector4 ToVec4(this ImRectPtr self)
		{
			Vector4 ret;
			ImGuiPNative.ToVec4(&ret, self);
			return ret;
		}
		public static void ToVec4(Vector4* pOut, ImRectPtr self)
		{
			ImGuiPNative.ToVec4(pOut, self);
		}
		public static void ToVec4(ref Vector4 pOut, ImRectPtr self)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				ImGuiPNative.ToVec4((Vector4*)ppOut, self);
			}
		}
		public static Vector4 ToVec4(this ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector4 ret;
				ImGuiPNative.ToVec4(&ret, (ImRect*)pself);
				return ret;
			}
		}
		public static void ToVec4(Vector4* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ImGuiPNative.ToVec4(pOut, (ImRect*)pself);
			}
		}
		public static void ToVec4(ref Vector4 pOut, ref ImRect self)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ImGuiPNative.ToVec4((Vector4*)ppOut, (ImRect*)pself);
				}
			}
		}
		public static bool ImBitArrayTestBit(uint* arr, int n)
		{
			byte ret = ImGuiPNative.ImBitArrayTestBit(arr, n);
			return ret != 0;
		}
		public static void ImBitArrayClearBit(uint* arr, int n)
		{
			ImGuiPNative.ImBitArrayClearBit(arr, n);
		}
		public static void ImBitArraySetBit(uint* arr, int n)
		{
			ImGuiPNative.ImBitArraySetBit(arr, n);
		}
		public static void ImBitArraySetBitRange(uint* arr, int n, int n2)
		{
			ImGuiPNative.ImBitArraySetBitRange(arr, n, n2);
		}
		public static void Create(this ImBitVectorPtr self, int sz)
		{
			ImGuiPNative.Create(self, sz);
		}
		public static void Create(this ref ImBitVector self, int sz)
		{
			fixed (ImBitVector* pself = &self)
			{
				ImGuiPNative.Create((ImBitVector*)pself, sz);
			}
		}
		public static void Clear(this ImBitVectorPtr self)
		{
			ImGuiPNative.Clear(self);
		}
		public static void Clear(this ref ImBitVector self)
		{
			fixed (ImBitVector* pself = &self)
			{
				ImGuiPNative.Clear((ImBitVector*)pself);
			}
		}
		public static void Clear(this ImDrawDataBuilderPtr self)
		{
			ImGuiPNative.Clear(self);
		}
		public static void Clear(this ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				ImGuiPNative.Clear((ImDrawDataBuilder*)pself);
			}
		}
		public static void Clear(this ImGuiNavItemDataPtr self)
		{
			ImGuiPNative.Clear(self);
		}
		public static void Clear(this ref ImGuiNavItemData self)
		{
			fixed (ImGuiNavItemData* pself = &self)
			{
				ImGuiPNative.Clear((ImGuiNavItemData*)pself);
			}
		}
		public static bool TestBit(this ImBitVectorPtr self, int n)
		{
			byte ret = ImGuiPNative.TestBit(self, n);
			return ret != 0;
		}
		public static bool TestBit(this ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				byte ret = ImGuiPNative.TestBit((ImBitVector*)pself, n);
				return ret != 0;
			}
		}
		public static void SetBit(this ImBitVectorPtr self, int n)
		{
			ImGuiPNative.SetBit(self, n);
		}
		public static void SetBit(this ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				ImGuiPNative.SetBit((ImBitVector*)pself, n);
			}
		}
		public static void ClearBit(this ImBitVectorPtr self, int n)
		{
			ImGuiPNative.ClearBit(self, n);
		}
		public static void ClearBit(this ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				ImGuiPNative.ClearBit((ImBitVector*)pself, n);
			}
		}
		public static ImDrawListSharedDataPtr ImDrawListSharedData()
		{
			ImDrawListSharedDataPtr ret = ImGuiPNative.ImDrawListSharedData();
			return ret;
		}
		public static void SetCircleTessellationMaxError(this ImDrawListSharedDataPtr self, float maxError)
		{
			ImGuiPNative.SetCircleTessellationMaxError(self, maxError);
		}
		public static void SetCircleTessellationMaxError(this ref ImDrawListSharedData self, float maxError)
		{
			fixed (ImDrawListSharedData* pself = &self)
			{
				ImGuiPNative.SetCircleTessellationMaxError((ImDrawListSharedData*)pself, maxError);
			}
		}
		public static void ClearFreeMemory(this ImDrawDataBuilderPtr self)
		{
			ImGuiPNative.ClearFreeMemory(self);
		}
		public static void ClearFreeMemory(this ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				ImGuiPNative.ClearFreeMemory((ImDrawDataBuilder*)pself);
			}
		}
		public static void ClearFreeMemory(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.ClearFreeMemory(self);
		}
		public static void ClearFreeMemory(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.ClearFreeMemory((ImGuiInputTextState*)pself);
			}
		}
		public static int GetDrawListCount(this ImDrawDataBuilderPtr self)
		{
			int ret = ImGuiPNative.GetDrawListCount(self);
			return ret;
		}
		public static int GetDrawListCount(this scoped in ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				int ret = ImGuiPNative.GetDrawListCount((ImDrawDataBuilder*)pself);
				return ret;
			}
		}
		public static void FlattenIntoSingleLayer(this ImDrawDataBuilderPtr self)
		{
			ImGuiPNative.FlattenIntoSingleLayer(self);
		}
		public static void FlattenIntoSingleLayer(this ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				ImGuiPNative.FlattenIntoSingleLayer((ImDrawDataBuilder*)pself);
			}
		}
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, int v)
		{
			ImGuiStyleModPtr ret = ImGuiPNative.ImGuiStyleMod(idx, v);
			return ret;
		}
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, float v)
		{
			ImGuiStyleModPtr ret = ImGuiPNative.ImGuiStyleMod(idx, v);
			return ret;
		}
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, Vector2 v)
		{
			ImGuiStyleModPtr ret = ImGuiPNative.ImGuiStyleMod(idx, v);
			return ret;
		}
		public static ImGuiComboPreviewDataPtr ImGuiComboPreviewData()
		{
			ImGuiComboPreviewDataPtr ret = ImGuiPNative.ImGuiComboPreviewData();
			return ret;
		}
		public static ImGuiMenuColumnsPtr ImGuiMenuColumns()
		{
			ImGuiMenuColumnsPtr ret = ImGuiPNative.ImGuiMenuColumns();
			return ret;
		}
		public static void Update(this ImGuiMenuColumnsPtr self, float spacing, bool windowReappearing)
		{
			ImGuiPNative.Update(self, spacing, windowReappearing ? (byte)1 : (byte)0);
		}
		public static void Update(this ref ImGuiMenuColumns self, float spacing, bool windowReappearing)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				ImGuiPNative.Update((ImGuiMenuColumns*)pself, spacing, windowReappearing ? (byte)1 : (byte)0);
			}
		}
		public static float DeclColumns(this ImGuiMenuColumnsPtr self, float wIcon, float wLabel, float wShortcut, float wMark)
		{
			float ret = ImGuiPNative.DeclColumns(self, wIcon, wLabel, wShortcut, wMark);
			return ret;
		}
		public static float DeclColumns(this ref ImGuiMenuColumns self, float wIcon, float wLabel, float wShortcut, float wMark)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				float ret = ImGuiPNative.DeclColumns((ImGuiMenuColumns*)pself, wIcon, wLabel, wShortcut, wMark);
				return ret;
			}
		}
		public static void CalcNextTotalWidth(this ImGuiMenuColumnsPtr self, bool updateOffsets)
		{
			ImGuiPNative.CalcNextTotalWidth(self, updateOffsets ? (byte)1 : (byte)0);
		}
		public static void CalcNextTotalWidth(this ref ImGuiMenuColumns self, bool updateOffsets)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				ImGuiPNative.CalcNextTotalWidth((ImGuiMenuColumns*)pself, updateOffsets ? (byte)1 : (byte)0);
			}
		}
		public static ImGuiInputTextStatePtr ImGuiInputTextState()
		{
			ImGuiInputTextStatePtr ret = ImGuiPNative.ImGuiInputTextState();
			return ret;
		}
		public static void ClearText(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.ClearText(self);
		}
		public static void ClearText(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.ClearText((ImGuiInputTextState*)pself);
			}
		}
		public static int GetUndoAvailCount(this ImGuiInputTextStatePtr self)
		{
			int ret = ImGuiPNative.GetUndoAvailCount(self);
			return ret;
		}
		public static int GetUndoAvailCount(this scoped in ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = ImGuiPNative.GetUndoAvailCount((ImGuiInputTextState*)pself);
				return ret;
			}
		}
		public static int GetRedoAvailCount(this ImGuiInputTextStatePtr self)
		{
			int ret = ImGuiPNative.GetRedoAvailCount(self);
			return ret;
		}
		public static int GetRedoAvailCount(this scoped in ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = ImGuiPNative.GetRedoAvailCount((ImGuiInputTextState*)pself);
				return ret;
			}
		}
		public static void OnKeyPressed(this ImGuiInputTextStatePtr self, int key)
		{
			ImGuiPNative.OnKeyPressed(self, key);
		}
		public static void OnKeyPressed(this ref ImGuiInputTextState self, int key)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.OnKeyPressed((ImGuiInputTextState*)pself, key);
			}
		}
		public static void CursorAnimReset(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.CursorAnimReset(self);
		}
		public static void CursorAnimReset(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.CursorAnimReset((ImGuiInputTextState*)pself);
			}
		}
		public static void CursorClamp(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.CursorClamp(self);
		}
		public static void CursorClamp(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.CursorClamp((ImGuiInputTextState*)pself);
			}
		}
		public static bool HasSelection(this ImGuiInputTextStatePtr self)
		{
			byte ret = ImGuiPNative.HasSelection(self);
			return ret != 0;
		}
		public static bool HasSelection(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				byte ret = ImGuiPNative.HasSelection((ImGuiInputTextState*)pself);
				return ret != 0;
			}
		}
		public static void ClearSelection(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.ClearSelection(self);
		}
		public static void ClearSelection(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.ClearSelection((ImGuiInputTextState*)pself);
			}
		}
		public static int GetCursorPos(this ImGuiInputTextStatePtr self)
		{
			int ret = ImGuiPNative.GetCursorPos(self);
			return ret;
		}
		public static int GetCursorPos(this scoped in ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = ImGuiPNative.GetCursorPos((ImGuiInputTextState*)pself);
				return ret;
			}
		}
		public static int GetSelectionStart(this ImGuiInputTextStatePtr self)
		{
			int ret = ImGuiPNative.GetSelectionStart(self);
			return ret;
		}
		public static int GetSelectionStart(this scoped in ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = ImGuiPNative.GetSelectionStart((ImGuiInputTextState*)pself);
				return ret;
			}
		}
		public static int GetSelectionEnd(this ImGuiInputTextStatePtr self)
		{
			int ret = ImGuiPNative.GetSelectionEnd(self);
			return ret;
		}
		public static int GetSelectionEnd(this scoped in ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = ImGuiPNative.GetSelectionEnd((ImGuiInputTextState*)pself);
				return ret;
			}
		}
		public static void SelectAll(this ImGuiInputTextStatePtr self)
		{
			ImGuiPNative.SelectAll(self);
		}
		public static void SelectAll(this ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ImGuiPNative.SelectAll((ImGuiInputTextState*)pself);
			}
		}
		public static ImGuiPopupDataPtr ImGuiPopupData()
		{
			ImGuiPopupDataPtr ret = ImGuiPNative.ImGuiPopupData();
			return ret;
		}
		public static ImGuiNextWindowDataPtr ImGuiNextWindowData()
		{
			ImGuiNextWindowDataPtr ret = ImGuiPNative.ImGuiNextWindowData();
			return ret;
		}
		public static void ClearFlags(this ImGuiNextWindowDataPtr self)
		{
			ImGuiPNative.ClearFlags(self);
		}
		public static void ClearFlags(this ref ImGuiNextWindowData self)
		{
			fixed (ImGuiNextWindowData* pself = &self)
			{
				ImGuiPNative.ClearFlags((ImGuiNextWindowData*)pself);
			}
		}
		public static void ClearFlags(this ImGuiNextItemDataPtr self)
		{
			ImGuiPNative.ClearFlags(self);
		}
		public static void ClearFlags(this ref ImGuiNextItemData self)
		{
			fixed (ImGuiNextItemData* pself = &self)
			{
				ImGuiPNative.ClearFlags((ImGuiNextItemData*)pself);
			}
		}
		public static ImGuiNextItemDataPtr ImGuiNextItemData()
		{
			ImGuiNextItemDataPtr ret = ImGuiPNative.ImGuiNextItemData();
			return ret;
		}
		public static ImGuiLastItemDataPtr ImGuiLastItemData()
		{
			ImGuiLastItemDataPtr ret = ImGuiPNative.ImGuiLastItemData();
			return ret;
		}
		public static ImGuiStackSizesPtr ImGuiStackSizes()
		{
			ImGuiStackSizesPtr ret = ImGuiPNative.ImGuiStackSizes();
			return ret;
		}
		public static void SetToCurrentState(this ImGuiStackSizesPtr self)
		{
			ImGuiPNative.SetToCurrentState(self);
		}
		public static void SetToCurrentState(this ref ImGuiStackSizes self)
		{
			fixed (ImGuiStackSizes* pself = &self)
			{
				ImGuiPNative.SetToCurrentState((ImGuiStackSizes*)pself);
			}
		}
		public static void CompareWithCurrentState(this ImGuiStackSizesPtr self)
		{
			ImGuiPNative.CompareWithCurrentState(self);
		}
		public static void CompareWithCurrentState(this ref ImGuiStackSizes self)
		{
			fixed (ImGuiStackSizes* pself = &self)
			{
				ImGuiPNative.CompareWithCurrentState((ImGuiStackSizes*)pself);
			}
		}
		public static ImGuiPtrOrIndexPtr ImGuiPtrOrIndex(void* ptr)
		{
			ImGuiPtrOrIndexPtr ret = ImGuiPNative.ImGuiPtrOrIndex(ptr);
			return ret;
		}
		public static ImGuiPtrOrIndexPtr ImGuiPtrOrIndex(int index)
		{
			ImGuiPtrOrIndexPtr ret = ImGuiPNative.ImGuiPtrOrIndex(index);
			return ret;
		}
		public static ImGuiInputEventPtr ImGuiInputEvent()
		{
			ImGuiInputEventPtr ret = ImGuiPNative.ImGuiInputEvent();
			return ret;
		}
		public static ImGuiListClipperRange FromIndices(int min, int max)
		{
			ImGuiListClipperRange ret = ImGuiPNative.FromIndices(min, max);
			return ret;
		}
		public static ImGuiListClipperRange FromPositions(float y1, float y2, int offMin, int offMax)
		{
			ImGuiListClipperRange ret = ImGuiPNative.FromPositions(y1, y2, offMin, offMax);
			return ret;
		}
		public static ImGuiListClipperDataPtr ImGuiListClipperData()
		{
			ImGuiListClipperDataPtr ret = ImGuiPNative.ImGuiListClipperData();
			return ret;
		}
		public static void Reset(this ImGuiListClipperDataPtr self, ImGuiListClipperPtr clipper)
		{
			ImGuiPNative.Reset(self, clipper);
		}
		public static void Reset(this ref ImGuiListClipperData self, ImGuiListClipperPtr clipper)
		{
			fixed (ImGuiListClipperData* pself = &self)
			{
				ImGuiPNative.Reset((ImGuiListClipperData*)pself, clipper);
			}
		}
		public static void Reset(this ImGuiListClipperDataPtr self, ref ImGuiListClipper clipper)
		{
			fixed (ImGuiListClipper* pclipper = &clipper)
			{
				ImGuiPNative.Reset(self, (ImGuiListClipper*)pclipper);
			}
		}
		public static void Reset(this ref ImGuiListClipperData self, ref ImGuiListClipper clipper)
		{
			fixed (ImGuiListClipperData* pself = &self)
			{
				fixed (ImGuiListClipper* pclipper = &clipper)
				{
					ImGuiPNative.Reset((ImGuiListClipperData*)pself, (ImGuiListClipper*)pclipper);
				}
			}
		}
		public static ImGuiNavItemDataPtr ImGuiNavItemData()
		{
			ImGuiNavItemDataPtr ret = ImGuiPNative.ImGuiNavItemData();
			return ret;
		}
		public static ImGuiOldColumnDataPtr ImGuiOldColumnData()
		{
			ImGuiOldColumnDataPtr ret = ImGuiPNative.ImGuiOldColumnData();
			return ret;
		}
		public static ImGuiOldColumnsPtr ImGuiOldColumns()
		{
			ImGuiOldColumnsPtr ret = ImGuiPNative.ImGuiOldColumns();
			return ret;
		}
		public static ImGuiDockNodePtr ImGuiDockNode(uint id)
		{
			ImGuiDockNodePtr ret = ImGuiPNative.ImGuiDockNode(id);
			return ret;
		}
		public static void Destroy(this ImGuiDockNodePtr self)
		{
			ImGuiPNative.Destroy(self);
		}
		public static void Destroy(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				ImGuiPNative.Destroy((ImGuiDockNode*)pself);
			}
		}
		public static void Destroy(this ImGuiViewportPPtr self)
		{
			ImGuiPNative.Destroy(self);
		}
		public static void Destroy(this ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.Destroy((ImGuiViewportP*)pself);
			}
		}
		public static void Destroy(this ImGuiWindowPtr self)
		{
			ImGuiPNative.Destroy(self);
		}
		public static void Destroy(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImGuiPNative.Destroy((ImGuiWindow*)pself);
			}
		}
		public static void Destroy(this ImGuiTablePtr self)
		{
			ImGuiPNative.Destroy(self);
		}
		public static void Destroy(this ref ImGuiTable self)
		{
			fixed (ImGuiTable* pself = &self)
			{
				ImGuiPNative.Destroy((ImGuiTable*)pself);
			}
		}
		public static bool IsRootNode(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsRootNode(self);
			return ret != 0;
		}
		public static bool IsRootNode(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsRootNode((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsDockSpace(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsDockSpace(self);
			return ret != 0;
		}
		public static bool IsDockSpace(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsDockSpace((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsFloatingNode(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsFloatingNode(self);
			return ret != 0;
		}
		public static bool IsFloatingNode(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsFloatingNode((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsCentralNode(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsCentralNode(self);
			return ret != 0;
		}
		public static bool IsCentralNode(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsCentralNode((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsHiddenTabBar(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsHiddenTabBar(self);
			return ret != 0;
		}
		public static bool IsHiddenTabBar(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsHiddenTabBar((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsNoTabBar(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsNoTabBar(self);
			return ret != 0;
		}
		public static bool IsNoTabBar(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsNoTabBar((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsSplitNode(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsSplitNode(self);
			return ret != 0;
		}
		public static bool IsSplitNode(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsSplitNode((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsLeafNode(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsLeafNode(self);
			return ret != 0;
		}
		public static bool IsLeafNode(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsLeafNode((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static bool IsEmpty(this ImGuiDockNodePtr self)
		{
			byte ret = ImGuiPNative.IsEmpty(self);
			return ret != 0;
		}
		public static bool IsEmpty(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				byte ret = ImGuiPNative.IsEmpty((ImGuiDockNode*)pself);
				return ret != 0;
			}
		}
		public static ImRect Rect(this ImGuiDockNodePtr self)
		{
			ImRect ret;
			ImGuiPNative.Rect(&ret, self);
			return ret;
		}
		public static void Rect(ImRectPtr pOut, ImGuiDockNodePtr self)
		{
			ImGuiPNative.Rect(pOut, self);
		}
		public static void Rect(ref ImRect pOut, ImGuiDockNodePtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.Rect((ImRect*)ppOut, self);
			}
		}
		public static ImRect Rect(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.Rect(&ret, (ImGuiDockNode*)pself);
				return ret;
			}
		}
		public static void Rect(ImRectPtr pOut, ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				ImGuiPNative.Rect(pOut, (ImGuiDockNode*)pself);
			}
		}
		public static void Rect(ref ImRect pOut, ref ImGuiDockNode self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiDockNode* pself = &self)
				{
					ImGuiPNative.Rect((ImRect*)ppOut, (ImGuiDockNode*)pself);
				}
			}
		}
		public static ImRect Rect(this ImGuiWindowPtr self)
		{
			ImRect ret;
			ImGuiPNative.Rect(&ret, self);
			return ret;
		}
		public static void Rect(ImRectPtr pOut, ImGuiWindowPtr self)
		{
			ImGuiPNative.Rect(pOut, self);
		}
		public static void Rect(ref ImRect pOut, ImGuiWindowPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.Rect((ImRect*)ppOut, self);
			}
		}
		public static ImRect Rect(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.Rect(&ret, (ImGuiWindow*)pself);
				return ret;
			}
		}
		public static void Rect(ImRectPtr pOut, ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImGuiPNative.Rect(pOut, (ImGuiWindow*)pself);
			}
		}
		public static void Rect(ref ImRect pOut, ref ImGuiWindow self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pself = &self)
				{
					ImGuiPNative.Rect((ImRect*)ppOut, (ImGuiWindow*)pself);
				}
			}
		}
		public static void SetLocalFlags(this ImGuiDockNodePtr self, ImGuiDockNodeFlags flags)
		{
			ImGuiPNative.SetLocalFlags(self, flags);
		}
		public static void SetLocalFlags(this ref ImGuiDockNode self, ImGuiDockNodeFlags flags)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				ImGuiPNative.SetLocalFlags((ImGuiDockNode*)pself, flags);
			}
		}
		public static void UpdateMergedFlags(this ImGuiDockNodePtr self)
		{
			ImGuiPNative.UpdateMergedFlags(self);
		}
		public static void UpdateMergedFlags(this ref ImGuiDockNode self)
		{
			fixed (ImGuiDockNode* pself = &self)
			{
				ImGuiPNative.UpdateMergedFlags((ImGuiDockNode*)pself);
			}
		}
		public static ImGuiDockContextPtr ImGuiDockContext()
		{
			ImGuiDockContextPtr ret = ImGuiPNative.ImGuiDockContext();
			return ret;
		}
		public static ImGuiViewportPPtr ImGuiViewportP()
		{
			ImGuiViewportPPtr ret = ImGuiPNative.ImGuiViewportP();
			return ret;
		}
		public static void ClearRequestFlags(this ImGuiViewportPPtr self)
		{
			ImGuiPNative.ClearRequestFlags(self);
		}
		public static void ClearRequestFlags(this ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.ClearRequestFlags((ImGuiViewportP*)pself);
			}
		}
		public static Vector2 CalcWorkRectPos(this ImGuiViewportPPtr self, Vector2 offMin)
		{
			Vector2 ret;
			ImGuiPNative.CalcWorkRectPos(&ret, self, offMin);
			return ret;
		}
		public static void CalcWorkRectPos(Vector2* pOut, ImGuiViewportPPtr self, Vector2 offMin)
		{
			ImGuiPNative.CalcWorkRectPos(pOut, self, offMin);
		}
		public static void CalcWorkRectPos(ref Vector2 pOut, ImGuiViewportPPtr self, Vector2 offMin)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.CalcWorkRectPos((Vector2*)ppOut, self, offMin);
			}
		}
		public static Vector2 CalcWorkRectPos(this ref ImGuiViewportP self, Vector2 offMin)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.CalcWorkRectPos(&ret, (ImGuiViewportP*)pself, offMin);
				return ret;
			}
		}
		public static void CalcWorkRectPos(Vector2* pOut, ref ImGuiViewportP self, Vector2 offMin)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.CalcWorkRectPos(pOut, (ImGuiViewportP*)pself, offMin);
			}
		}
		public static void CalcWorkRectPos(ref Vector2 pOut, ref ImGuiViewportP self, Vector2 offMin)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiViewportP* pself = &self)
				{
					ImGuiPNative.CalcWorkRectPos((Vector2*)ppOut, (ImGuiViewportP*)pself, offMin);
				}
			}
		}
		public static Vector2 CalcWorkRectSize(this ImGuiViewportPPtr self, Vector2 offMin, Vector2 offMax)
		{
			Vector2 ret;
			ImGuiPNative.CalcWorkRectSize(&ret, self, offMin, offMax);
			return ret;
		}
		public static void CalcWorkRectSize(Vector2* pOut, ImGuiViewportPPtr self, Vector2 offMin, Vector2 offMax)
		{
			ImGuiPNative.CalcWorkRectSize(pOut, self, offMin, offMax);
		}
		public static void CalcWorkRectSize(ref Vector2 pOut, ImGuiViewportPPtr self, Vector2 offMin, Vector2 offMax)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.CalcWorkRectSize((Vector2*)ppOut, self, offMin, offMax);
			}
		}
		public static Vector2 CalcWorkRectSize(this ref ImGuiViewportP self, Vector2 offMin, Vector2 offMax)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				Vector2 ret;
				ImGuiPNative.CalcWorkRectSize(&ret, (ImGuiViewportP*)pself, offMin, offMax);
				return ret;
			}
		}
		public static void CalcWorkRectSize(Vector2* pOut, ref ImGuiViewportP self, Vector2 offMin, Vector2 offMax)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.CalcWorkRectSize(pOut, (ImGuiViewportP*)pself, offMin, offMax);
			}
		}
		public static void CalcWorkRectSize(ref Vector2 pOut, ref ImGuiViewportP self, Vector2 offMin, Vector2 offMax)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiViewportP* pself = &self)
				{
					ImGuiPNative.CalcWorkRectSize((Vector2*)ppOut, (ImGuiViewportP*)pself, offMin, offMax);
				}
			}
		}
		public static void UpdateWorkRect(this ImGuiViewportPPtr self)
		{
			ImGuiPNative.UpdateWorkRect(self);
		}
		public static void UpdateWorkRect(this ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.UpdateWorkRect((ImGuiViewportP*)pself);
			}
		}
		public static ImRect GetMainRect(this ImGuiViewportPPtr self)
		{
			ImRect ret;
			ImGuiPNative.GetMainRect(&ret, self);
			return ret;
		}
		public static void GetMainRect(ImRectPtr pOut, ImGuiViewportPPtr self)
		{
			ImGuiPNative.GetMainRect(pOut, self);
		}
		public static void GetMainRect(ref ImRect pOut, ImGuiViewportPPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.GetMainRect((ImRect*)ppOut, self);
			}
		}
		public static ImRect GetMainRect(this scoped in ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.GetMainRect(&ret, (ImGuiViewportP*)pself);
				return ret;
			}
		}
		public static void GetMainRect(ImRectPtr pOut, ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.GetMainRect(pOut, (ImGuiViewportP*)pself);
			}
		}
		public static void GetMainRect(ref ImRect pOut, ref ImGuiViewportP self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiViewportP* pself = &self)
				{
					ImGuiPNative.GetMainRect((ImRect*)ppOut, (ImGuiViewportP*)pself);
				}
			}
		}
		public static ImRect GetWorkRect(this ImGuiViewportPPtr self)
		{
			ImRect ret;
			ImGuiPNative.GetWorkRect(&ret, self);
			return ret;
		}
		public static void GetWorkRect(ImRectPtr pOut, ImGuiViewportPPtr self)
		{
			ImGuiPNative.GetWorkRect(pOut, self);
		}
		public static void GetWorkRect(ref ImRect pOut, ImGuiViewportPPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.GetWorkRect((ImRect*)ppOut, self);
			}
		}
		public static ImRect GetWorkRect(this scoped in ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.GetWorkRect(&ret, (ImGuiViewportP*)pself);
				return ret;
			}
		}
		public static void GetWorkRect(ImRectPtr pOut, ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.GetWorkRect(pOut, (ImGuiViewportP*)pself);
			}
		}
		public static void GetWorkRect(ref ImRect pOut, ref ImGuiViewportP self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiViewportP* pself = &self)
				{
					ImGuiPNative.GetWorkRect((ImRect*)ppOut, (ImGuiViewportP*)pself);
				}
			}
		}
		public static ImRect GetBuildWorkRect(this ImGuiViewportPPtr self)
		{
			ImRect ret;
			ImGuiPNative.GetBuildWorkRect(&ret, self);
			return ret;
		}
		public static void GetBuildWorkRect(ImRectPtr pOut, ImGuiViewportPPtr self)
		{
			ImGuiPNative.GetBuildWorkRect(pOut, self);
		}
		public static void GetBuildWorkRect(ref ImRect pOut, ImGuiViewportPPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.GetBuildWorkRect((ImRect*)ppOut, self);
			}
		}
		public static ImRect GetBuildWorkRect(this scoped in ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.GetBuildWorkRect(&ret, (ImGuiViewportP*)pself);
				return ret;
			}
		}
		public static void GetBuildWorkRect(ImRectPtr pOut, ref ImGuiViewportP self)
		{
			fixed (ImGuiViewportP* pself = &self)
			{
				ImGuiPNative.GetBuildWorkRect(pOut, (ImGuiViewportP*)pself);
			}
		}
		public static void GetBuildWorkRect(ref ImRect pOut, ref ImGuiViewportP self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiViewportP* pself = &self)
				{
					ImGuiPNative.GetBuildWorkRect((ImRect*)ppOut, (ImGuiViewportP*)pself);
				}
			}
		}
		public static ImGuiWindowSettingsPtr ImGuiWindowSettings()
		{
			ImGuiWindowSettingsPtr ret = ImGuiPNative.ImGuiWindowSettings();
			return ret;
		}
		public static ImGuiSettingsHandlerPtr ImGuiSettingsHandler()
		{
			ImGuiSettingsHandlerPtr ret = ImGuiPNative.ImGuiSettingsHandler();
			return ret;
		}
		public static ImGuiMetricsConfigPtr ImGuiMetricsConfig()
		{
			ImGuiMetricsConfigPtr ret = ImGuiPNative.ImGuiMetricsConfig();
			return ret;
		}
		public static ImGuiStackLevelInfoPtr ImGuiStackLevelInfo()
		{
			ImGuiStackLevelInfoPtr ret = ImGuiPNative.ImGuiStackLevelInfo();
			return ret;
		}
		public static ImGuiStackToolPtr ImGuiStackTool()
		{
			ImGuiStackToolPtr ret = ImGuiPNative.ImGuiStackTool();
			return ret;
		}
		public static ImGuiContextHookPtr ImGuiContextHook()
		{
			ImGuiContextHookPtr ret = ImGuiPNative.ImGuiContextHook();
			return ret;
		}
		public static ImGuiContextPtr ImGuiContext(ImFontAtlasPtr sharedFontAtlas)
		{
			ImGuiContextPtr ret = ImGuiPNative.ImGuiContext(sharedFontAtlas);
			return ret;
		}
		public static ImGuiContextPtr ImGuiContext(ref ImFontAtlas sharedFontAtlas)
		{
			fixed (ImFontAtlas* psharedFontAtlas = &sharedFontAtlas)
			{
				ImGuiContextPtr ret = ImGuiPNative.ImGuiContext((ImFontAtlas*)psharedFontAtlas);
				return ret;
			}
		}
		public static uint GetIDFromRectangle(this ImGuiWindowPtr self, ImRect rAbs)
		{
			uint ret = ImGuiPNative.GetIDFromRectangle(self, rAbs);
			return ret;
		}
		public static uint GetIDFromRectangle(this scoped in ImGuiWindow self, ImRect rAbs)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				uint ret = ImGuiPNative.GetIDFromRectangle((ImGuiWindow*)pself, rAbs);
				return ret;
			}
		}
		public static float CalcFontSize(this ImGuiWindowPtr self)
		{
			float ret = ImGuiPNative.CalcFontSize(self);
			return ret;
		}
		public static float CalcFontSize(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				float ret = ImGuiPNative.CalcFontSize((ImGuiWindow*)pself);
				return ret;
			}
		}
		public static float TitleBarHeight(this ImGuiWindowPtr self)
		{
			float ret = ImGuiPNative.TitleBarHeight(self);
			return ret;
		}
		public static float TitleBarHeight(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				float ret = ImGuiPNative.TitleBarHeight((ImGuiWindow*)pself);
				return ret;
			}
		}
		public static ImRect TitleBarRect(this ImGuiWindowPtr self)
		{
			ImRect ret;
			ImGuiPNative.TitleBarRect(&ret, self);
			return ret;
		}
		public static void TitleBarRect(ImRectPtr pOut, ImGuiWindowPtr self)
		{
			ImGuiPNative.TitleBarRect(pOut, self);
		}
		public static void TitleBarRect(ref ImRect pOut, ImGuiWindowPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.TitleBarRect((ImRect*)ppOut, self);
			}
		}
		public static ImRect TitleBarRect(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.TitleBarRect(&ret, (ImGuiWindow*)pself);
				return ret;
			}
		}
		public static void TitleBarRect(ImRectPtr pOut, ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImGuiPNative.TitleBarRect(pOut, (ImGuiWindow*)pself);
			}
		}
		public static void TitleBarRect(ref ImRect pOut, ref ImGuiWindow self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pself = &self)
				{
					ImGuiPNative.TitleBarRect((ImRect*)ppOut, (ImGuiWindow*)pself);
				}
			}
		}
		public static float MenuBarHeight(this ImGuiWindowPtr self)
		{
			float ret = ImGuiPNative.MenuBarHeight(self);
			return ret;
		}
		public static float MenuBarHeight(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				float ret = ImGuiPNative.MenuBarHeight((ImGuiWindow*)pself);
				return ret;
			}
		}
		public static ImRect MenuBarRect(this ImGuiWindowPtr self)
		{
			ImRect ret;
			ImGuiPNative.MenuBarRect(&ret, self);
			return ret;
		}
		public static void MenuBarRect(ImRectPtr pOut, ImGuiWindowPtr self)
		{
			ImGuiPNative.MenuBarRect(pOut, self);
		}
		public static void MenuBarRect(ref ImRect pOut, ImGuiWindowPtr self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.MenuBarRect((ImRect*)ppOut, self);
			}
		}
		public static ImRect MenuBarRect(this ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImRect ret;
				ImGuiPNative.MenuBarRect(&ret, (ImGuiWindow*)pself);
				return ret;
			}
		}
		public static void MenuBarRect(ImRectPtr pOut, ref ImGuiWindow self)
		{
			fixed (ImGuiWindow* pself = &self)
			{
				ImGuiPNative.MenuBarRect(pOut, (ImGuiWindow*)pself);
			}
		}
		public static void MenuBarRect(ref ImRect pOut, ref ImGuiWindow self)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pself = &self)
				{
					ImGuiPNative.MenuBarRect((ImRect*)ppOut, (ImGuiWindow*)pself);
				}
			}
		}
		public static ImGuiTabItemPtr ImGuiTabItem()
		{
			ImGuiTabItemPtr ret = ImGuiPNative.ImGuiTabItem();
			return ret;
		}
		public static ImGuiTabBarPtr ImGuiTabBar()
		{
			ImGuiTabBarPtr ret = ImGuiPNative.ImGuiTabBar();
			return ret;
		}
		public static int GetTabOrder(this ImGuiTabBarPtr self, ImGuiTabItemPtr tab)
		{
			int ret = ImGuiPNative.GetTabOrder(self, tab);
			return ret;
		}
		public static int GetTabOrder(this scoped in ImGuiTabBar self, ImGuiTabItemPtr tab)
		{
			fixed (ImGuiTabBar* pself = &self)
			{
				int ret = ImGuiPNative.GetTabOrder((ImGuiTabBar*)pself, tab);
				return ret;
			}
		}
		public static int GetTabOrder(this ImGuiTabBarPtr self, ref ImGuiTabItem tab)
		{
			fixed (ImGuiTabItem* ptab = &tab)
			{
				int ret = ImGuiPNative.GetTabOrder(self, (ImGuiTabItem*)ptab);
				return ret;
			}
		}
		public static int GetTabOrder(this scoped in ImGuiTabBar self, ref ImGuiTabItem tab)
		{
			fixed (ImGuiTabBar* pself = &self)
			{
				fixed (ImGuiTabItem* ptab = &tab)
				{
					int ret = ImGuiPNative.GetTabOrder((ImGuiTabBar*)pself, (ImGuiTabItem*)ptab);
					return ret;
				}
			}
		}
		public static ImGuiTableColumnPtr ImGuiTableColumn()
		{
			ImGuiTableColumnPtr ret = ImGuiPNative.ImGuiTableColumn();
			return ret;
		}
		public static ImGuiTableInstanceDataPtr ImGuiTableInstanceData()
		{
			ImGuiTableInstanceDataPtr ret = ImGuiPNative.ImGuiTableInstanceData();
			return ret;
		}
		public static ImGuiTablePtr ImGuiTable()
		{
			ImGuiTablePtr ret = ImGuiPNative.ImGuiTable();
			return ret;
		}
		public static ImGuiTableTempDataPtr ImGuiTableTempData()
		{
			ImGuiTableTempDataPtr ret = ImGuiPNative.ImGuiTableTempData();
			return ret;
		}
		public static ImGuiTableColumnSettingsPtr ImGuiTableColumnSettings()
		{
			ImGuiTableColumnSettingsPtr ret = ImGuiPNative.ImGuiTableColumnSettings();
			return ret;
		}
		public static ImGuiTableSettingsPtr ImGuiTableSettings()
		{
			ImGuiTableSettingsPtr ret = ImGuiPNative.ImGuiTableSettings();
			return ret;
		}
		public static ImGuiTableColumnSettingsPtr GetColumnSettings(this ImGuiTableSettingsPtr self)
		{
			ImGuiTableColumnSettingsPtr ret = ImGuiPNative.GetColumnSettings(self);
			return ret;
		}
		public static ImGuiTableColumnSettingsPtr GetColumnSettings(this scoped in ImGuiTableSettings self)
		{
			fixed (ImGuiTableSettings* pself = &self)
			{
				ImGuiTableColumnSettingsPtr ret = ImGuiPNative.GetColumnSettings((ImGuiTableSettings*)pself);
				return ret;
			}
		}
		public static ImGuiWindowPtr GetCurrentWindowRead()
		{
			ImGuiWindowPtr ret = ImGuiPNative.GetCurrentWindowRead();
			return ret;
		}
		public static ImGuiWindowPtr GetCurrentWindow()
		{
			ImGuiWindowPtr ret = ImGuiPNative.GetCurrentWindow();
			return ret;
		}
		public static ImGuiWindowPtr FindWindowByID(uint id)
		{
			ImGuiWindowPtr ret = ImGuiPNative.FindWindowByID(id);
			return ret;
		}
		public static void UpdateWindowParentAndRootLinks(ImGuiWindowPtr window, ImGuiWindowFlags flags, ImGuiWindowPtr parentWindow)
		{
			ImGuiPNative.UpdateWindowParentAndRootLinks(window, flags, parentWindow);
		}
		public static void UpdateWindowParentAndRootLinks(ref ImGuiWindow window, ImGuiWindowFlags flags, ImGuiWindowPtr parentWindow)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.UpdateWindowParentAndRootLinks((ImGuiWindow*)pwindow, flags, parentWindow);
			}
		}
		public static void UpdateWindowParentAndRootLinks(ImGuiWindowPtr window, ImGuiWindowFlags flags, ref ImGuiWindow parentWindow)
		{
			fixed (ImGuiWindow* pparentWindow = &parentWindow)
			{
				ImGuiPNative.UpdateWindowParentAndRootLinks(window, flags, (ImGuiWindow*)pparentWindow);
			}
		}
		public static void UpdateWindowParentAndRootLinks(ref ImGuiWindow window, ImGuiWindowFlags flags, ref ImGuiWindow parentWindow)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiWindow* pparentWindow = &parentWindow)
				{
					ImGuiPNative.UpdateWindowParentAndRootLinks((ImGuiWindow*)pwindow, flags, (ImGuiWindow*)pparentWindow);
				}
			}
		}
		public static Vector2 CalcWindowNextAutoFitSize(ImGuiWindowPtr window)
		{
			Vector2 ret;
			ImGuiPNative.CalcWindowNextAutoFitSize(&ret, window);
			return ret;
		}
		public static void CalcWindowNextAutoFitSize(Vector2* pOut, ImGuiWindowPtr window)
		{
			ImGuiPNative.CalcWindowNextAutoFitSize(pOut, window);
		}
		public static void CalcWindowNextAutoFitSize(ref Vector2 pOut, ImGuiWindowPtr window)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.CalcWindowNextAutoFitSize((Vector2*)ppOut, window);
			}
		}
		public static Vector2 CalcWindowNextAutoFitSize(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				Vector2 ret;
				ImGuiPNative.CalcWindowNextAutoFitSize(&ret, (ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static void CalcWindowNextAutoFitSize(Vector2* pOut, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.CalcWindowNextAutoFitSize(pOut, (ImGuiWindow*)pwindow);
			}
		}
		public static void CalcWindowNextAutoFitSize(ref Vector2 pOut, ref ImGuiWindow window)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.CalcWindowNextAutoFitSize((Vector2*)ppOut, (ImGuiWindow*)pwindow);
				}
			}
		}
		public static bool IsWindowChildOf(ImGuiWindowPtr window, ImGuiWindowPtr potentialParent, bool popupHierarchy, bool dockHierarchy)
		{
			byte ret = ImGuiPNative.IsWindowChildOf(window, potentialParent, popupHierarchy ? (byte)1 : (byte)0, dockHierarchy ? (byte)1 : (byte)0);
			return ret != 0;
		}
		public static bool IsWindowChildOf(ref ImGuiWindow window, ImGuiWindowPtr potentialParent, bool popupHierarchy, bool dockHierarchy)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				byte ret = ImGuiPNative.IsWindowChildOf((ImGuiWindow*)pwindow, potentialParent, popupHierarchy ? (byte)1 : (byte)0, dockHierarchy ? (byte)1 : (byte)0);
				return ret != 0;
			}
		}
		public static bool IsWindowChildOf(ImGuiWindowPtr window, ref ImGuiWindow potentialParent, bool popupHierarchy, bool dockHierarchy)
		{
			fixed (ImGuiWindow* ppotentialParent = &potentialParent)
			{
				byte ret = ImGuiPNative.IsWindowChildOf(window, (ImGuiWindow*)ppotentialParent, popupHierarchy ? (byte)1 : (byte)0, dockHierarchy ? (byte)1 : (byte)0);
				return ret != 0;
			}
		}
		public static bool IsWindowChildOf(ref ImGuiWindow window, ref ImGuiWindow potentialParent, bool popupHierarchy, bool dockHierarchy)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiWindow* ppotentialParent = &potentialParent)
				{
					byte ret = ImGuiPNative.IsWindowChildOf((ImGuiWindow*)pwindow, (ImGuiWindow*)ppotentialParent, popupHierarchy ? (byte)1 : (byte)0, dockHierarchy ? (byte)1 : (byte)0);
					return ret != 0;
				}
			}
		}
		public static bool IsWindowWithinBeginStackOf(ImGuiWindowPtr window, ImGuiWindowPtr potentialParent)
		{
			byte ret = ImGuiPNative.IsWindowWithinBeginStackOf(window, potentialParent);
			return ret != 0;
		}
		public static bool IsWindowWithinBeginStackOf(ref ImGuiWindow window, ImGuiWindowPtr potentialParent)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				byte ret = ImGuiPNative.IsWindowWithinBeginStackOf((ImGuiWindow*)pwindow, potentialParent);
				return ret != 0;
			}
		}
		public static bool IsWindowWithinBeginStackOf(ImGuiWindowPtr window, ref ImGuiWindow potentialParent)
		{
			fixed (ImGuiWindow* ppotentialParent = &potentialParent)
			{
				byte ret = ImGuiPNative.IsWindowWithinBeginStackOf(window, (ImGuiWindow*)ppotentialParent);
				return ret != 0;
			}
		}
		public static bool IsWindowWithinBeginStackOf(ref ImGuiWindow window, ref ImGuiWindow potentialParent)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiWindow* ppotentialParent = &potentialParent)
				{
					byte ret = ImGuiPNative.IsWindowWithinBeginStackOf((ImGuiWindow*)pwindow, (ImGuiWindow*)ppotentialParent);
					return ret != 0;
				}
			}
		}
		public static bool IsWindowAbove(ImGuiWindowPtr potentialAbove, ImGuiWindowPtr potentialBelow)
		{
			byte ret = ImGuiPNative.IsWindowAbove(potentialAbove, potentialBelow);
			return ret != 0;
		}
		public static bool IsWindowAbove(ref ImGuiWindow potentialAbove, ImGuiWindowPtr potentialBelow)
		{
			fixed (ImGuiWindow* ppotentialAbove = &potentialAbove)
			{
				byte ret = ImGuiPNative.IsWindowAbove((ImGuiWindow*)ppotentialAbove, potentialBelow);
				return ret != 0;
			}
		}
		public static bool IsWindowAbove(ImGuiWindowPtr potentialAbove, ref ImGuiWindow potentialBelow)
		{
			fixed (ImGuiWindow* ppotentialBelow = &potentialBelow)
			{
				byte ret = ImGuiPNative.IsWindowAbove(potentialAbove, (ImGuiWindow*)ppotentialBelow);
				return ret != 0;
			}
		}
		public static bool IsWindowAbove(ref ImGuiWindow potentialAbove, ref ImGuiWindow potentialBelow)
		{
			fixed (ImGuiWindow* ppotentialAbove = &potentialAbove)
			{
				fixed (ImGuiWindow* ppotentialBelow = &potentialBelow)
				{
					byte ret = ImGuiPNative.IsWindowAbove((ImGuiWindow*)ppotentialAbove, (ImGuiWindow*)ppotentialBelow);
					return ret != 0;
				}
			}
		}
		public static bool IsWindowNavFocusable(ImGuiWindowPtr window)
		{
			byte ret = ImGuiPNative.IsWindowNavFocusable(window);
			return ret != 0;
		}
		public static bool IsWindowNavFocusable(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				byte ret = ImGuiPNative.IsWindowNavFocusable((ImGuiWindow*)pwindow);
				return ret != 0;
			}
		}
		public static void SetWindowPos(ImGuiWindowPtr window, Vector2 pos, ImGuiCond cond)
		{
			ImGuiPNative.SetWindowPos(window, pos, cond);
		}
		public static void SetWindowPos(ImGuiWindowPtr window, Vector2 pos)
		{
			ImGuiPNative.SetWindowPos(window, pos, (ImGuiCond)(0));
		}
		public static void SetWindowPos(ref ImGuiWindow window, Vector2 pos, ImGuiCond cond)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowPos((ImGuiWindow*)pwindow, pos, cond);
			}
		}
		public static void SetWindowPos(ref ImGuiWindow window, Vector2 pos)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowPos((ImGuiWindow*)pwindow, pos, (ImGuiCond)(0));
			}
		}
		public static void SetWindowSize(ImGuiWindowPtr window, Vector2 size, ImGuiCond cond)
		{
			ImGuiPNative.SetWindowSize(window, size, cond);
		}
		public static void SetWindowSize(ImGuiWindowPtr window, Vector2 size)
		{
			ImGuiPNative.SetWindowSize(window, size, (ImGuiCond)(0));
		}
		public static void SetWindowSize(ref ImGuiWindow window, Vector2 size, ImGuiCond cond)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowSize((ImGuiWindow*)pwindow, size, cond);
			}
		}
		public static void SetWindowSize(ref ImGuiWindow window, Vector2 size)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowSize((ImGuiWindow*)pwindow, size, (ImGuiCond)(0));
			}
		}
		public static void SetWindowCollapsed(ImGuiWindowPtr window, bool collapsed, ImGuiCond cond)
		{
			ImGuiPNative.SetWindowCollapsed(window, collapsed ? (byte)1 : (byte)0, cond);
		}
		public static void SetWindowCollapsed(ImGuiWindowPtr window, bool collapsed)
		{
			ImGuiPNative.SetWindowCollapsed(window, collapsed ? (byte)1 : (byte)0, (ImGuiCond)(0));
		}
		public static void SetWindowCollapsed(ref ImGuiWindow window, bool collapsed, ImGuiCond cond)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowCollapsed((ImGuiWindow*)pwindow, collapsed ? (byte)1 : (byte)0, cond);
			}
		}
		public static void SetWindowCollapsed(ref ImGuiWindow window, bool collapsed)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowCollapsed((ImGuiWindow*)pwindow, collapsed ? (byte)1 : (byte)0, (ImGuiCond)(0));
			}
		}
		public static void SetWindowHitTestHole(ImGuiWindowPtr window, Vector2 pos, Vector2 size)
		{
			ImGuiPNative.SetWindowHitTestHole(window, pos, size);
		}
		public static void SetWindowHitTestHole(ref ImGuiWindow window, Vector2 pos, Vector2 size)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowHitTestHole((ImGuiWindow*)pwindow, pos, size);
			}
		}
		public static ImRect WindowRectAbsToRel(ImGuiWindowPtr window, ImRect r)
		{
			ImRect ret;
			ImGuiPNative.WindowRectAbsToRel(&ret, window, r);
			return ret;
		}
		public static void WindowRectAbsToRel(ImRectPtr pOut, ImGuiWindowPtr window, ImRect r)
		{
			ImGuiPNative.WindowRectAbsToRel(pOut, window, r);
		}
		public static void WindowRectAbsToRel(ref ImRect pOut, ImGuiWindowPtr window, ImRect r)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.WindowRectAbsToRel((ImRect*)ppOut, window, r);
			}
		}
		public static ImRect WindowRectAbsToRel(ref ImGuiWindow window, ImRect r)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImRect ret;
				ImGuiPNative.WindowRectAbsToRel(&ret, (ImGuiWindow*)pwindow, r);
				return ret;
			}
		}
		public static void WindowRectAbsToRel(ImRectPtr pOut, ref ImGuiWindow window, ImRect r)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.WindowRectAbsToRel(pOut, (ImGuiWindow*)pwindow, r);
			}
		}
		public static void WindowRectAbsToRel(ref ImRect pOut, ref ImGuiWindow window, ImRect r)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.WindowRectAbsToRel((ImRect*)ppOut, (ImGuiWindow*)pwindow, r);
				}
			}
		}
		public static ImRect WindowRectRelToAbs(ImGuiWindowPtr window, ImRect r)
		{
			ImRect ret;
			ImGuiPNative.WindowRectRelToAbs(&ret, window, r);
			return ret;
		}
		public static void WindowRectRelToAbs(ImRectPtr pOut, ImGuiWindowPtr window, ImRect r)
		{
			ImGuiPNative.WindowRectRelToAbs(pOut, window, r);
		}
		public static void WindowRectRelToAbs(ref ImRect pOut, ImGuiWindowPtr window, ImRect r)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.WindowRectRelToAbs((ImRect*)ppOut, window, r);
			}
		}
		public static ImRect WindowRectRelToAbs(ref ImGuiWindow window, ImRect r)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImRect ret;
				ImGuiPNative.WindowRectRelToAbs(&ret, (ImGuiWindow*)pwindow, r);
				return ret;
			}
		}
		public static void WindowRectRelToAbs(ImRectPtr pOut, ref ImGuiWindow window, ImRect r)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.WindowRectRelToAbs(pOut, (ImGuiWindow*)pwindow, r);
			}
		}
		public static void WindowRectRelToAbs(ref ImRect pOut, ref ImGuiWindow window, ImRect r)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.WindowRectRelToAbs((ImRect*)ppOut, (ImGuiWindow*)pwindow, r);
				}
			}
		}
		public static void FocusWindow(ImGuiWindowPtr window)
		{
			ImGuiPNative.FocusWindow(window);
		}
		public static void FocusWindow(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.FocusWindow((ImGuiWindow*)pwindow);
			}
		}
		public static void FocusTopMostWindowUnderOne(ImGuiWindowPtr underThisWindow, ImGuiWindowPtr ignoreWindow)
		{
			ImGuiPNative.FocusTopMostWindowUnderOne(underThisWindow, ignoreWindow);
		}
		public static void FocusTopMostWindowUnderOne(ref ImGuiWindow underThisWindow, ImGuiWindowPtr ignoreWindow)
		{
			fixed (ImGuiWindow* punderThisWindow = &underThisWindow)
			{
				ImGuiPNative.FocusTopMostWindowUnderOne((ImGuiWindow*)punderThisWindow, ignoreWindow);
			}
		}
		public static void FocusTopMostWindowUnderOne(ImGuiWindowPtr underThisWindow, ref ImGuiWindow ignoreWindow)
		{
			fixed (ImGuiWindow* pignoreWindow = &ignoreWindow)
			{
				ImGuiPNative.FocusTopMostWindowUnderOne(underThisWindow, (ImGuiWindow*)pignoreWindow);
			}
		}
		public static void FocusTopMostWindowUnderOne(ref ImGuiWindow underThisWindow, ref ImGuiWindow ignoreWindow)
		{
			fixed (ImGuiWindow* punderThisWindow = &underThisWindow)
			{
				fixed (ImGuiWindow* pignoreWindow = &ignoreWindow)
				{
					ImGuiPNative.FocusTopMostWindowUnderOne((ImGuiWindow*)punderThisWindow, (ImGuiWindow*)pignoreWindow);
				}
			}
		}
		public static void BringWindowToFocusFront(ImGuiWindowPtr window)
		{
			ImGuiPNative.BringWindowToFocusFront(window);
		}
		public static void BringWindowToFocusFront(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BringWindowToFocusFront((ImGuiWindow*)pwindow);
			}
		}
		public static void BringWindowToDisplayFront(ImGuiWindowPtr window)
		{
			ImGuiPNative.BringWindowToDisplayFront(window);
		}
		public static void BringWindowToDisplayFront(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BringWindowToDisplayFront((ImGuiWindow*)pwindow);
			}
		}
		public static void BringWindowToDisplayBack(ImGuiWindowPtr window)
		{
			ImGuiPNative.BringWindowToDisplayBack(window);
		}
		public static void BringWindowToDisplayBack(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BringWindowToDisplayBack((ImGuiWindow*)pwindow);
			}
		}
		public static void BringWindowToDisplayBehind(ImGuiWindowPtr window, ImGuiWindowPtr aboveWindow)
		{
			ImGuiPNative.BringWindowToDisplayBehind(window, aboveWindow);
		}
		public static void BringWindowToDisplayBehind(ref ImGuiWindow window, ImGuiWindowPtr aboveWindow)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BringWindowToDisplayBehind((ImGuiWindow*)pwindow, aboveWindow);
			}
		}
		public static void BringWindowToDisplayBehind(ImGuiWindowPtr window, ref ImGuiWindow aboveWindow)
		{
			fixed (ImGuiWindow* paboveWindow = &aboveWindow)
			{
				ImGuiPNative.BringWindowToDisplayBehind(window, (ImGuiWindow*)paboveWindow);
			}
		}
		public static void BringWindowToDisplayBehind(ref ImGuiWindow window, ref ImGuiWindow aboveWindow)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiWindow* paboveWindow = &aboveWindow)
				{
					ImGuiPNative.BringWindowToDisplayBehind((ImGuiWindow*)pwindow, (ImGuiWindow*)paboveWindow);
				}
			}
		}
		public static int FindWindowDisplayIndex(ImGuiWindowPtr window)
		{
			int ret = ImGuiPNative.FindWindowDisplayIndex(window);
			return ret;
		}
		public static int FindWindowDisplayIndex(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				int ret = ImGuiPNative.FindWindowDisplayIndex((ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static ImGuiWindowPtr FindBottomMostVisibleWindowWithinBeginStack(ImGuiWindowPtr window)
		{
			ImGuiWindowPtr ret = ImGuiPNative.FindBottomMostVisibleWindowWithinBeginStack(window);
			return ret;
		}
		public static ImGuiWindowPtr FindBottomMostVisibleWindowWithinBeginStack(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiWindowPtr ret = ImGuiPNative.FindBottomMostVisibleWindowWithinBeginStack((ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static void SetCurrentFont(ImFontPtr font)
		{
			ImGuiPNative.SetCurrentFont(font);
		}
		public static void SetCurrentFont(ref ImFont font)
		{
			fixed (ImFont* pfont = &font)
			{
				ImGuiPNative.SetCurrentFont((ImFont*)pfont);
			}
		}
		public static ImFontPtr GetDefaultFont()
		{
			ImFontPtr ret = ImGuiPNative.GetDefaultFont();
			return ret;
		}
		public static ImDrawListPtr GetForegroundDrawList(ImGuiWindowPtr window)
		{
			ImDrawListPtr ret = ImGuiPNative.GetForegroundDrawList(window);
			return ret;
		}
		public static ImDrawListPtr GetForegroundDrawList(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImDrawListPtr ret = ImGuiPNative.GetForegroundDrawList((ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static void Initialize()
		{
			ImGuiPNative.Initialize();
		}
		public static void Shutdown()
		{
			ImGuiPNative.Shutdown();
		}
		public static void UpdateInputEvents(bool trickleFastInputs)
		{
			ImGuiPNative.UpdateInputEvents(trickleFastInputs ? (byte)1 : (byte)0);
		}
		public static void UpdateHoveredWindowAndCaptureFlags()
		{
			ImGuiPNative.UpdateHoveredWindowAndCaptureFlags();
		}
		public static void StartMouseMovingWindow(ImGuiWindowPtr window)
		{
			ImGuiPNative.StartMouseMovingWindow(window);
		}
		public static void StartMouseMovingWindow(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.StartMouseMovingWindow((ImGuiWindow*)pwindow);
			}
		}
		public static void StartMouseMovingWindowOrNode(ImGuiWindowPtr window, ImGuiDockNodePtr node, bool undockFloatingNode)
		{
			ImGuiPNative.StartMouseMovingWindowOrNode(window, node, undockFloatingNode ? (byte)1 : (byte)0);
		}
		public static void StartMouseMovingWindowOrNode(ref ImGuiWindow window, ImGuiDockNodePtr node, bool undockFloatingNode)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.StartMouseMovingWindowOrNode((ImGuiWindow*)pwindow, node, undockFloatingNode ? (byte)1 : (byte)0);
			}
		}
		public static void StartMouseMovingWindowOrNode(ImGuiWindowPtr window, ref ImGuiDockNode node, bool undockFloatingNode)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				ImGuiPNative.StartMouseMovingWindowOrNode(window, (ImGuiDockNode*)pnode, undockFloatingNode ? (byte)1 : (byte)0);
			}
		}
		public static void StartMouseMovingWindowOrNode(ref ImGuiWindow window, ref ImGuiDockNode node, bool undockFloatingNode)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiDockNode* pnode = &node)
				{
					ImGuiPNative.StartMouseMovingWindowOrNode((ImGuiWindow*)pwindow, (ImGuiDockNode*)pnode, undockFloatingNode ? (byte)1 : (byte)0);
				}
			}
		}
		public static void UpdateMouseMovingWindowNewFrame()
		{
			ImGuiPNative.UpdateMouseMovingWindowNewFrame();
		}
		public static void UpdateMouseMovingWindowEndFrame()
		{
			ImGuiPNative.UpdateMouseMovingWindowEndFrame();
		}
		public static uint AddContextHook(ImGuiContextPtr context, ImGuiContextHookPtr hook)
		{
			uint ret = ImGuiPNative.AddContextHook(context, hook);
			return ret;
		}
		public static uint AddContextHook(ref ImGuiContext context, ImGuiContextHookPtr hook)
		{
			fixed (ImGuiContext* pcontext = &context)
			{
				uint ret = ImGuiPNative.AddContextHook((ImGuiContext*)pcontext, hook);
				return ret;
			}
		}
		public static uint AddContextHook(ImGuiContextPtr context, ref ImGuiContextHook hook)
		{
			fixed (ImGuiContextHook* phook = &hook)
			{
				uint ret = ImGuiPNative.AddContextHook(context, (ImGuiContextHook*)phook);
				return ret;
			}
		}
		public static uint AddContextHook(ref ImGuiContext context, ref ImGuiContextHook hook)
		{
			fixed (ImGuiContext* pcontext = &context)
			{
				fixed (ImGuiContextHook* phook = &hook)
				{
					uint ret = ImGuiPNative.AddContextHook((ImGuiContext*)pcontext, (ImGuiContextHook*)phook);
					return ret;
				}
			}
		}
		public static void RemoveContextHook(ImGuiContextPtr context, uint hookToRemove)
		{
			ImGuiPNative.RemoveContextHook(context, hookToRemove);
		}
		public static void RemoveContextHook(ref ImGuiContext context, uint hookToRemove)
		{
			fixed (ImGuiContext* pcontext = &context)
			{
				ImGuiPNative.RemoveContextHook((ImGuiContext*)pcontext, hookToRemove);
			}
		}
		public static void CallContextHooks(ImGuiContextPtr context, ImGuiContextHookType type)
		{
			ImGuiPNative.CallContextHooks(context, type);
		}
		public static void CallContextHooks(ref ImGuiContext context, ImGuiContextHookType type)
		{
			fixed (ImGuiContext* pcontext = &context)
			{
				ImGuiPNative.CallContextHooks((ImGuiContext*)pcontext, type);
			}
		}
		public static void TranslateWindowsInViewport(ImGuiViewportPPtr viewport, Vector2 oldPos, Vector2 newPos)
		{
			ImGuiPNative.TranslateWindowsInViewport(viewport, oldPos, newPos);
		}
		public static void TranslateWindowsInViewport(ref ImGuiViewportP viewport, Vector2 oldPos, Vector2 newPos)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.TranslateWindowsInViewport((ImGuiViewportP*)pviewport, oldPos, newPos);
			}
		}
		public static void ScaleWindowsInViewport(ImGuiViewportPPtr viewport, float scale)
		{
			ImGuiPNative.ScaleWindowsInViewport(viewport, scale);
		}
		public static void ScaleWindowsInViewport(ref ImGuiViewportP viewport, float scale)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.ScaleWindowsInViewport((ImGuiViewportP*)pviewport, scale);
			}
		}
		public static void DestroyPlatformWindow(ImGuiViewportPPtr viewport)
		{
			ImGuiPNative.DestroyPlatformWindow(viewport);
		}
		public static void DestroyPlatformWindow(ref ImGuiViewportP viewport)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.DestroyPlatformWindow((ImGuiViewportP*)pviewport);
			}
		}
		public static void SetWindowViewport(ImGuiWindowPtr window, ImGuiViewportPPtr viewport)
		{
			ImGuiPNative.SetWindowViewport(window, viewport);
		}
		public static void SetWindowViewport(ref ImGuiWindow window, ImGuiViewportPPtr viewport)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowViewport((ImGuiWindow*)pwindow, viewport);
			}
		}
		public static void SetWindowViewport(ImGuiWindowPtr window, ref ImGuiViewportP viewport)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.SetWindowViewport(window, (ImGuiViewportP*)pviewport);
			}
		}
		public static void SetWindowViewport(ref ImGuiWindow window, ref ImGuiViewportP viewport)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiViewportP* pviewport = &viewport)
				{
					ImGuiPNative.SetWindowViewport((ImGuiWindow*)pwindow, (ImGuiViewportP*)pviewport);
				}
			}
		}
		public static void SetCurrentViewport(ImGuiWindowPtr window, ImGuiViewportPPtr viewport)
		{
			ImGuiPNative.SetCurrentViewport(window, viewport);
		}
		public static void SetCurrentViewport(ref ImGuiWindow window, ImGuiViewportPPtr viewport)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetCurrentViewport((ImGuiWindow*)pwindow, viewport);
			}
		}
		public static void SetCurrentViewport(ImGuiWindowPtr window, ref ImGuiViewportP viewport)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.SetCurrentViewport(window, (ImGuiViewportP*)pviewport);
			}
		}
		public static void SetCurrentViewport(ref ImGuiWindow window, ref ImGuiViewportP viewport)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (ImGuiViewportP* pviewport = &viewport)
				{
					ImGuiPNative.SetCurrentViewport((ImGuiWindow*)pwindow, (ImGuiViewportP*)pviewport);
				}
			}
		}
		public static ImGuiPlatformMonitorPtr GetViewportPlatformMonitor(ImGuiViewportPtr viewport)
		{
			ImGuiPlatformMonitorPtr ret = ImGuiPNative.GetViewportPlatformMonitor(viewport);
			return ret;
		}
		public static ImGuiPlatformMonitorPtr GetViewportPlatformMonitor(ref ImGuiViewport viewport)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				ImGuiPlatformMonitorPtr ret = ImGuiPNative.GetViewportPlatformMonitor((ImGuiViewport*)pviewport);
				return ret;
			}
		}
		public static ImGuiViewportPPtr FindHoveredViewportFromPlatformWindowStack(Vector2 mousePlatformPos)
		{
			ImGuiViewportPPtr ret = ImGuiPNative.FindHoveredViewportFromPlatformWindowStack(mousePlatformPos);
			return ret;
		}
		public static void MarkIniSettingsDirty()
		{
			ImGuiPNative.MarkIniSettingsDirty();
		}
		public static void MarkIniSettingsDirty(ImGuiWindowPtr window)
		{
			ImGuiPNative.MarkIniSettingsDirty(window);
		}
		public static void MarkIniSettingsDirty(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.MarkIniSettingsDirty((ImGuiWindow*)pwindow);
			}
		}
		public static void ClearIniSettings()
		{
			ImGuiPNative.ClearIniSettings();
		}
		public static ImGuiWindowSettingsPtr FindWindowSettings(uint id)
		{
			ImGuiWindowSettingsPtr ret = ImGuiPNative.FindWindowSettings(id);
			return ret;
		}
		public static void AddSettingsHandler(ImGuiSettingsHandlerPtr handler)
		{
			ImGuiPNative.AddSettingsHandler(handler);
		}
		public static void AddSettingsHandler(ref ImGuiSettingsHandler handler)
		{
			fixed (ImGuiSettingsHandler* phandler = &handler)
			{
				ImGuiPNative.AddSettingsHandler((ImGuiSettingsHandler*)phandler);
			}
		}
		public static void SetNextWindowScroll(Vector2 scroll)
		{
			ImGuiPNative.SetNextWindowScroll(scroll);
		}
		public static void SetScrollX(ImGuiWindowPtr window, float scrollX)
		{
			ImGuiPNative.SetScrollX(window, scrollX);
		}
		public static void SetScrollX(ref ImGuiWindow window, float scrollX)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetScrollX((ImGuiWindow*)pwindow, scrollX);
			}
		}
		public static void SetScrollY(ImGuiWindowPtr window, float scrollY)
		{
			ImGuiPNative.SetScrollY(window, scrollY);
		}
		public static void SetScrollY(ref ImGuiWindow window, float scrollY)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetScrollY((ImGuiWindow*)pwindow, scrollY);
			}
		}
		public static void SetScrollFromPosX(ImGuiWindowPtr window, float localX, float centerXRatio)
		{
			ImGuiPNative.SetScrollFromPosX(window, localX, centerXRatio);
		}
		public static void SetScrollFromPosX(ref ImGuiWindow window, float localX, float centerXRatio)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetScrollFromPosX((ImGuiWindow*)pwindow, localX, centerXRatio);
			}
		}
		public static void SetScrollFromPosY(ImGuiWindowPtr window, float localY, float centerYRatio)
		{
			ImGuiPNative.SetScrollFromPosY(window, localY, centerYRatio);
		}
		public static void SetScrollFromPosY(ref ImGuiWindow window, float localY, float centerYRatio)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetScrollFromPosY((ImGuiWindow*)pwindow, localY, centerYRatio);
			}
		}
		public static void ScrollToItem(ImGuiScrollFlags flags)
		{
			ImGuiPNative.ScrollToItem(flags);
		}
		public static void ScrollToItem()
		{
			ImGuiPNative.ScrollToItem((ImGuiScrollFlags)(0));
		}
		public static void ScrollToRect(ImGuiWindowPtr window, ImRect rect, ImGuiScrollFlags flags)
		{
			ImGuiPNative.ScrollToRect(window, rect, flags);
		}
		public static void ScrollToRect(ImGuiWindowPtr window, ImRect rect)
		{
			ImGuiPNative.ScrollToRect(window, rect, (ImGuiScrollFlags)(0));
		}
		public static void ScrollToRect(ref ImGuiWindow window, ImRect rect, ImGuiScrollFlags flags)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.ScrollToRect((ImGuiWindow*)pwindow, rect, flags);
			}
		}
		public static void ScrollToRect(ref ImGuiWindow window, ImRect rect)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.ScrollToRect((ImGuiWindow*)pwindow, rect, (ImGuiScrollFlags)(0));
			}
		}
		public static Vector2 ScrollToRectEx(ImGuiWindowPtr window, ImRect rect)
		{
			Vector2 ret;
			ImGuiPNative.ScrollToRectEx(&ret, window, rect, (ImGuiScrollFlags)(0));
			return ret;
		}
		public static Vector2 ScrollToRectEx(ImGuiWindowPtr window, ImRect rect, ImGuiScrollFlags flags)
		{
			Vector2 ret;
			ImGuiPNative.ScrollToRectEx(&ret, window, rect, flags);
			return ret;
		}
		public static void ScrollToRectEx(Vector2* pOut, ImGuiWindowPtr window, ImRect rect, ImGuiScrollFlags flags)
		{
			ImGuiPNative.ScrollToRectEx(pOut, window, rect, flags);
		}
		public static void ScrollToRectEx(Vector2* pOut, ImGuiWindowPtr window, ImRect rect)
		{
			ImGuiPNative.ScrollToRectEx(pOut, window, rect, (ImGuiScrollFlags)(0));
		}
		public static void ScrollToRectEx(ref Vector2 pOut, ImGuiWindowPtr window, ImRect rect, ImGuiScrollFlags flags)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ScrollToRectEx((Vector2*)ppOut, window, rect, flags);
			}
		}
		public static void ScrollToRectEx(ref Vector2 pOut, ImGuiWindowPtr window, ImRect rect)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.ScrollToRectEx((Vector2*)ppOut, window, rect, (ImGuiScrollFlags)(0));
			}
		}
		public static Vector2 ScrollToRectEx(ref ImGuiWindow window, ImRect rect)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				Vector2 ret;
				ImGuiPNative.ScrollToRectEx(&ret, (ImGuiWindow*)pwindow, rect, (ImGuiScrollFlags)(0));
				return ret;
			}
		}
		public static Vector2 ScrollToRectEx(ref ImGuiWindow window, ImRect rect, ImGuiScrollFlags flags)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				Vector2 ret;
				ImGuiPNative.ScrollToRectEx(&ret, (ImGuiWindow*)pwindow, rect, flags);
				return ret;
			}
		}
		public static void ScrollToRectEx(Vector2* pOut, ref ImGuiWindow window, ImRect rect, ImGuiScrollFlags flags)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.ScrollToRectEx(pOut, (ImGuiWindow*)pwindow, rect, flags);
			}
		}
		public static void ScrollToRectEx(Vector2* pOut, ref ImGuiWindow window, ImRect rect)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.ScrollToRectEx(pOut, (ImGuiWindow*)pwindow, rect, (ImGuiScrollFlags)(0));
			}
		}
		public static void ScrollToRectEx(ref Vector2 pOut, ref ImGuiWindow window, ImRect rect, ImGuiScrollFlags flags)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.ScrollToRectEx((Vector2*)ppOut, (ImGuiWindow*)pwindow, rect, flags);
				}
			}
		}
		public static void ScrollToRectEx(ref Vector2 pOut, ref ImGuiWindow window, ImRect rect)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.ScrollToRectEx((Vector2*)ppOut, (ImGuiWindow*)pwindow, rect, (ImGuiScrollFlags)(0));
				}
			}
		}
		public static void ScrollToBringRectIntoView(ImGuiWindowPtr window, ImRect rect)
		{
			ImGuiPNative.ScrollToBringRectIntoView(window, rect);
		}
		public static void ScrollToBringRectIntoView(ref ImGuiWindow window, ImRect rect)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.ScrollToBringRectIntoView((ImGuiWindow*)pwindow, rect);
			}
		}
		public static uint GetItemID()
		{
			uint ret = ImGuiPNative.GetItemID();
			return ret;
		}
		public static ImGuiItemStatusFlags GetItemStatusFlags()
		{
			ImGuiItemStatusFlags ret = ImGuiPNative.GetItemStatusFlags();
			return ret;
		}
		public static ImGuiItemFlags GetItemFlags()
		{
			ImGuiItemFlags ret = ImGuiPNative.GetItemFlags();
			return ret;
		}
		public static uint GetActiveID()
		{
			uint ret = ImGuiPNative.GetActiveID();
			return ret;
		}
		public static uint GetFocusID()
		{
			uint ret = ImGuiPNative.GetFocusID();
			return ret;
		}
		public static void SetActiveID(uint id, ImGuiWindowPtr window)
		{
			ImGuiPNative.SetActiveID(id, window);
		}
		public static void SetActiveID(uint id, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetActiveID(id, (ImGuiWindow*)pwindow);
			}
		}
		public static void SetFocusID(uint id, ImGuiWindowPtr window)
		{
			ImGuiPNative.SetFocusID(id, window);
		}
		public static void SetFocusID(uint id, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetFocusID(id, (ImGuiWindow*)pwindow);
			}
		}
		public static void ClearActiveID()
		{
			ImGuiPNative.ClearActiveID();
		}
		public static uint GetHoveredID()
		{
			uint ret = ImGuiPNative.GetHoveredID();
			return ret;
		}
		public static void SetHoveredID(uint id)
		{
			ImGuiPNative.SetHoveredID(id);
		}
		public static void KeepAliveID(uint id)
		{
			ImGuiPNative.KeepAliveID(id);
		}
		public static void MarkItemEdited(uint id)
		{
			ImGuiPNative.MarkItemEdited(id);
		}
		public static void PushOverrideID(uint id)
		{
			ImGuiPNative.PushOverrideID(id);
		}
		public static void ItemSize(Vector2 size, float textBaselineY)
		{
			ImGuiPNative.ItemSize(size, textBaselineY);
		}
		public static void ItemSize(Vector2 size)
		{
			ImGuiPNative.ItemSize(size, (float)(-1.0f));
		}
		public static void ItemSize(ImRect bb, float textBaselineY)
		{
			ImGuiPNative.ItemSize(bb, textBaselineY);
		}
		public static void ItemSize(ImRect bb)
		{
			ImGuiPNative.ItemSize(bb, (float)(-1.0f));
		}
		public static bool ItemAdd(ImRect bb, uint id, ImRectPtr navBb, ImGuiItemFlags extraFlags)
		{
			byte ret = ImGuiPNative.ItemAdd(bb, id, navBb, extraFlags);
			return ret != 0;
		}
		public static bool ItemAdd(ImRect bb, uint id, ImRectPtr navBb)
		{
			byte ret = ImGuiPNative.ItemAdd(bb, id, navBb, (ImGuiItemFlags)(0));
			return ret != 0;
		}
		public static bool ItemAdd(ImRect bb, uint id)
		{
			byte ret = ImGuiPNative.ItemAdd(bb, id, (ImRect*)(default), (ImGuiItemFlags)(0));
			return ret != 0;
		}
		public static bool ItemAdd(ImRect bb, uint id, ImGuiItemFlags extraFlags)
		{
			byte ret = ImGuiPNative.ItemAdd(bb, id, (ImRect*)(default), extraFlags);
			return ret != 0;
		}
		public static bool ItemAdd(ImRect bb, uint id, ref ImRect navBb, ImGuiItemFlags extraFlags)
		{
			fixed (ImRect* pnavBb = &navBb)
			{
				byte ret = ImGuiPNative.ItemAdd(bb, id, (ImRect*)pnavBb, extraFlags);
				return ret != 0;
			}
		}
		public static bool ItemAdd(ImRect bb, uint id, ref ImRect navBb)
		{
			fixed (ImRect* pnavBb = &navBb)
			{
				byte ret = ImGuiPNative.ItemAdd(bb, id, (ImRect*)pnavBb, (ImGuiItemFlags)(0));
				return ret != 0;
			}
		}
		public static bool ItemHoverable(ImRect bb, uint id)
		{
			byte ret = ImGuiPNative.ItemHoverable(bb, id);
			return ret != 0;
		}
		public static bool IsClippedEx(ImRect bb, uint id)
		{
			byte ret = ImGuiPNative.IsClippedEx(bb, id);
			return ret != 0;
		}
		public static void SetLastItemData(uint itemId, ImGuiItemFlags inFlags, ImGuiItemStatusFlags statusFlags, ImRect itemRect)
		{
			ImGuiPNative.SetLastItemData(itemId, inFlags, statusFlags, itemRect);
		}
		public static Vector2 CalcItemSize(Vector2 size, float defaultW, float defaultH)
		{
			Vector2 ret;
			ImGuiPNative.CalcItemSize(&ret, size, defaultW, defaultH);
			return ret;
		}
		public static void CalcItemSize(Vector2* pOut, Vector2 size, float defaultW, float defaultH)
		{
			ImGuiPNative.CalcItemSize(pOut, size, defaultW, defaultH);
		}
		public static void CalcItemSize(ref Vector2 pOut, Vector2 size, float defaultW, float defaultH)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.CalcItemSize((Vector2*)ppOut, size, defaultW, defaultH);
			}
		}
		public static float CalcWrapWidthForPos(Vector2 pos, float wrapPosX)
		{
			float ret = ImGuiPNative.CalcWrapWidthForPos(pos, wrapPosX);
			return ret;
		}
		public static void PushMultiItemsWidths(int components, float widthFull)
		{
			ImGuiPNative.PushMultiItemsWidths(components, widthFull);
		}
		public static bool IsItemToggledSelection()
		{
			byte ret = ImGuiPNative.IsItemToggledSelection();
			return ret != 0;
		}
		public static Vector2 GetContentRegionMaxAbs()
		{
			Vector2 ret;
			ImGuiPNative.GetContentRegionMaxAbs(&ret);
			return ret;
		}
		public static void GetContentRegionMaxAbs(Vector2* pOut)
		{
			ImGuiPNative.GetContentRegionMaxAbs(pOut);
		}
		public static void GetContentRegionMaxAbs(ref Vector2 pOut)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetContentRegionMaxAbs((Vector2*)ppOut);
			}
		}
		public static void ShrinkWidths(ImGuiShrinkWidthItemPtr items, int count, float widthExcess)
		{
			ImGuiPNative.ShrinkWidths(items, count, widthExcess);
		}
		public static void ShrinkWidths(ref ImGuiShrinkWidthItem items, int count, float widthExcess)
		{
			fixed (ImGuiShrinkWidthItem* pitems = &items)
			{
				ImGuiPNative.ShrinkWidths((ImGuiShrinkWidthItem*)pitems, count, widthExcess);
			}
		}
		public static void PushItemFlag(ImGuiItemFlags option, bool enabled)
		{
			ImGuiPNative.PushItemFlag(option, enabled ? (byte)1 : (byte)0);
		}
		public static void PopItemFlag()
		{
			ImGuiPNative.PopItemFlag();
		}
		public static void LogBegin(ImGuiLogType type, int autoOpenDepth)
		{
			ImGuiPNative.LogBegin(type, autoOpenDepth);
		}
		public static void LogToBuffer(int autoOpenDepth)
		{
			ImGuiPNative.LogToBuffer(autoOpenDepth);
		}
		public static void LogToBuffer()
		{
			ImGuiPNative.LogToBuffer((int)(-1));
		}
		public static void OpenPopupEx(uint id, ImGuiPopupFlags popupFlags)
		{
			ImGuiPNative.OpenPopupEx(id, popupFlags);
		}
		public static void OpenPopupEx(uint id)
		{
			ImGuiPNative.OpenPopupEx(id, (ImGuiPopupFlags)(ImGuiPopupFlags.None));
		}
		public static void ClosePopupToLevel(int remaining, bool restoreFocusToWindowUnderPopup)
		{
			ImGuiPNative.ClosePopupToLevel(remaining, restoreFocusToWindowUnderPopup ? (byte)1 : (byte)0);
		}
		public static void ClosePopupsOverWindow(ImGuiWindowPtr refWindow, bool restoreFocusToWindowUnderPopup)
		{
			ImGuiPNative.ClosePopupsOverWindow(refWindow, restoreFocusToWindowUnderPopup ? (byte)1 : (byte)0);
		}
		public static void ClosePopupsOverWindow(ref ImGuiWindow refWindow, bool restoreFocusToWindowUnderPopup)
		{
			fixed (ImGuiWindow* prefWindow = &refWindow)
			{
				ImGuiPNative.ClosePopupsOverWindow((ImGuiWindow*)prefWindow, restoreFocusToWindowUnderPopup ? (byte)1 : (byte)0);
			}
		}
		public static void ClosePopupsExceptModals()
		{
			ImGuiPNative.ClosePopupsExceptModals();
		}
		public static bool IsPopupOpen(uint id, ImGuiPopupFlags popupFlags)
		{
			byte ret = ImGuiPNative.IsPopupOpen(id, popupFlags);
			return ret != 0;
		}
		public static bool BeginPopupEx(uint id, ImGuiWindowFlags extraFlags)
		{
			byte ret = ImGuiPNative.BeginPopupEx(id, extraFlags);
			return ret != 0;
		}
		public static void BeginTooltipEx(ImGuiTooltipFlags tooltipFlags, ImGuiWindowFlags extraWindowFlags)
		{
			ImGuiPNative.BeginTooltipEx(tooltipFlags, extraWindowFlags);
		}
		public static ImRect GetPopupAllowedExtentRect(ImGuiWindowPtr window)
		{
			ImRect ret;
			ImGuiPNative.GetPopupAllowedExtentRect(&ret, window);
			return ret;
		}
		public static void GetPopupAllowedExtentRect(ImRectPtr pOut, ImGuiWindowPtr window)
		{
			ImGuiPNative.GetPopupAllowedExtentRect(pOut, window);
		}
		public static void GetPopupAllowedExtentRect(ref ImRect pOut, ImGuiWindowPtr window)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.GetPopupAllowedExtentRect((ImRect*)ppOut, window);
			}
		}
		public static ImRect GetPopupAllowedExtentRect(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImRect ret;
				ImGuiPNative.GetPopupAllowedExtentRect(&ret, (ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static void GetPopupAllowedExtentRect(ImRectPtr pOut, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.GetPopupAllowedExtentRect(pOut, (ImGuiWindow*)pwindow);
			}
		}
		public static void GetPopupAllowedExtentRect(ref ImRect pOut, ref ImGuiWindow window)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.GetPopupAllowedExtentRect((ImRect*)ppOut, (ImGuiWindow*)pwindow);
				}
			}
		}
		public static ImGuiWindowPtr GetTopMostPopupModal()
		{
			ImGuiWindowPtr ret = ImGuiPNative.GetTopMostPopupModal();
			return ret;
		}
		public static ImGuiWindowPtr GetTopMostAndVisiblePopupModal()
		{
			ImGuiWindowPtr ret = ImGuiPNative.GetTopMostAndVisiblePopupModal();
			return ret;
		}
		public static Vector2 FindBestWindowPosForPopup(ImGuiWindowPtr window)
		{
			Vector2 ret;
			ImGuiPNative.FindBestWindowPosForPopup(&ret, window);
			return ret;
		}
		public static void FindBestWindowPosForPopup(Vector2* pOut, ImGuiWindowPtr window)
		{
			ImGuiPNative.FindBestWindowPosForPopup(pOut, window);
		}
		public static void FindBestWindowPosForPopup(ref Vector2 pOut, ImGuiWindowPtr window)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.FindBestWindowPosForPopup((Vector2*)ppOut, window);
			}
		}
		public static Vector2 FindBestWindowPosForPopup(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				Vector2 ret;
				ImGuiPNative.FindBestWindowPosForPopup(&ret, (ImGuiWindow*)pwindow);
				return ret;
			}
		}
		public static void FindBestWindowPosForPopup(Vector2* pOut, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.FindBestWindowPosForPopup(pOut, (ImGuiWindow*)pwindow);
			}
		}
		public static void FindBestWindowPosForPopup(ref Vector2 pOut, ref ImGuiWindow window)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.FindBestWindowPosForPopup((Vector2*)ppOut, (ImGuiWindow*)pwindow);
				}
			}
		}
		public static Vector2 FindBestWindowPosForPopupEx(Vector2 refPos, Vector2 size, ImGuiDir* lastDir, ImRect rOuter, ImRect rAvoid, ImGuiPopupPositionPolicy policy)
		{
			Vector2 ret;
			ImGuiPNative.FindBestWindowPosForPopupEx(&ret, refPos, size, lastDir, rOuter, rAvoid, policy);
			return ret;
		}
		public static void FindBestWindowPosForPopupEx(Vector2* pOut, Vector2 refPos, Vector2 size, ImGuiDir* lastDir, ImRect rOuter, ImRect rAvoid, ImGuiPopupPositionPolicy policy)
		{
			ImGuiPNative.FindBestWindowPosForPopupEx(pOut, refPos, size, lastDir, rOuter, rAvoid, policy);
		}
		public static void FindBestWindowPosForPopupEx(ref Vector2 pOut, Vector2 refPos, Vector2 size, ImGuiDir* lastDir, ImRect rOuter, ImRect rAvoid, ImGuiPopupPositionPolicy policy)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.FindBestWindowPosForPopupEx((Vector2*)ppOut, refPos, size, lastDir, rOuter, rAvoid, policy);
			}
		}
		public static bool BeginComboPopup(uint popupId, ImRect bb, ImGuiComboFlags flags)
		{
			byte ret = ImGuiPNative.BeginComboPopup(popupId, bb, flags);
			return ret != 0;
		}
		public static bool BeginComboPreview()
		{
			byte ret = ImGuiPNative.BeginComboPreview();
			return ret != 0;
		}
		public static void EndComboPreview()
		{
			ImGuiPNative.EndComboPreview();
		}
		public static void NavInitWindow(ImGuiWindowPtr window, bool forceReinit)
		{
			ImGuiPNative.NavInitWindow(window, forceReinit ? (byte)1 : (byte)0);
		}
		public static void NavInitWindow(ref ImGuiWindow window, bool forceReinit)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.NavInitWindow((ImGuiWindow*)pwindow, forceReinit ? (byte)1 : (byte)0);
			}
		}
		public static void NavInitRequestApplyResult()
		{
			ImGuiPNative.NavInitRequestApplyResult();
		}
		public static bool NavMoveRequestButNoResultYet()
		{
			byte ret = ImGuiPNative.NavMoveRequestButNoResultYet();
			return ret != 0;
		}
		public static void NavMoveRequestSubmit(ImGuiDir moveDir, ImGuiDir clipDir, ImGuiNavMoveFlags moveFlags, ImGuiScrollFlags scrollFlags)
		{
			ImGuiPNative.NavMoveRequestSubmit(moveDir, clipDir, moveFlags, scrollFlags);
		}
		public static void NavMoveRequestForward(ImGuiDir moveDir, ImGuiDir clipDir, ImGuiNavMoveFlags moveFlags, ImGuiScrollFlags scrollFlags)
		{
			ImGuiPNative.NavMoveRequestForward(moveDir, clipDir, moveFlags, scrollFlags);
		}
		public static void NavMoveRequestResolveWithLastItem(ImGuiNavItemDataPtr result)
		{
			ImGuiPNative.NavMoveRequestResolveWithLastItem(result);
		}
		public static void NavMoveRequestResolveWithLastItem(ref ImGuiNavItemData result)
		{
			fixed (ImGuiNavItemData* presult = &result)
			{
				ImGuiPNative.NavMoveRequestResolveWithLastItem((ImGuiNavItemData*)presult);
			}
		}
		public static void NavMoveRequestCancel()
		{
			ImGuiPNative.NavMoveRequestCancel();
		}
		public static void NavMoveRequestApplyResult()
		{
			ImGuiPNative.NavMoveRequestApplyResult();
		}
		public static void NavMoveRequestTryWrapping(ImGuiWindowPtr window, ImGuiNavMoveFlags moveFlags)
		{
			ImGuiPNative.NavMoveRequestTryWrapping(window, moveFlags);
		}
		public static void NavMoveRequestTryWrapping(ref ImGuiWindow window, ImGuiNavMoveFlags moveFlags)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.NavMoveRequestTryWrapping((ImGuiWindow*)pwindow, moveFlags);
			}
		}
		public static float GetNavInputAmount(ImGuiNavInput n, ImGuiNavReadMode mode)
		{
			float ret = ImGuiPNative.GetNavInputAmount(n, mode);
			return ret;
		}
		public static Vector2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode)
		{
			Vector2 ret;
			ImGuiPNative.GetNavInputAmount2d(&ret, dirSources, mode, (float)(0.0f), (float)(0.0f));
			return ret;
		}
		public static Vector2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor)
		{
			Vector2 ret;
			ImGuiPNative.GetNavInputAmount2d(&ret, dirSources, mode, slowFactor, (float)(0.0f));
			return ret;
		}
		public static void GetNavInputAmount2d(Vector2* pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode)
		{
			ImGuiPNative.GetNavInputAmount2d(pOut, dirSources, mode, (float)(0.0f), (float)(0.0f));
		}
		public static Vector2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor, float fastFactor)
		{
			Vector2 ret;
			ImGuiPNative.GetNavInputAmount2d(&ret, dirSources, mode, slowFactor, fastFactor);
			return ret;
		}
		public static void GetNavInputAmount2d(Vector2* pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor, float fastFactor)
		{
			ImGuiPNative.GetNavInputAmount2d(pOut, dirSources, mode, slowFactor, fastFactor);
		}
		public static void GetNavInputAmount2d(Vector2* pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor)
		{
			ImGuiPNative.GetNavInputAmount2d(pOut, dirSources, mode, slowFactor, (float)(0.0f));
		}
		public static void GetNavInputAmount2d(ref Vector2 pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor, float fastFactor)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetNavInputAmount2d((Vector2*)ppOut, dirSources, mode, slowFactor, fastFactor);
			}
		}
		public static void GetNavInputAmount2d(ref Vector2 pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode, float slowFactor)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetNavInputAmount2d((Vector2*)ppOut, dirSources, mode, slowFactor, (float)(0.0f));
			}
		}
		public static void GetNavInputAmount2d(ref Vector2 pOut, ImGuiNavDirSourceFlags dirSources, ImGuiNavReadMode mode)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImGuiPNative.GetNavInputAmount2d((Vector2*)ppOut, dirSources, mode, (float)(0.0f), (float)(0.0f));
			}
		}
		public static int CalcTypematicRepeatAmount(float t0, float t1, float repeatDelay, float repeatRate)
		{
			int ret = ImGuiPNative.CalcTypematicRepeatAmount(t0, t1, repeatDelay, repeatRate);
			return ret;
		}
		public static void ActivateItem(uint id)
		{
			ImGuiPNative.ActivateItem(id);
		}
		public static void SetNavWindow(ImGuiWindowPtr window)
		{
			ImGuiPNative.SetNavWindow(window);
		}
		public static void SetNavWindow(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetNavWindow((ImGuiWindow*)pwindow);
			}
		}
		public static void SetNavID(uint id, ImGuiNavLayer navLayer, uint focusScopeId, ImRect rectRel)
		{
			ImGuiPNative.SetNavID(id, navLayer, focusScopeId, rectRel);
		}
		public static void PushFocusScope(uint id)
		{
			ImGuiPNative.PushFocusScope(id);
		}
		public static void PopFocusScope()
		{
			ImGuiPNative.PopFocusScope();
		}
		public static uint GetFocusedFocusScope()
		{
			uint ret = ImGuiPNative.GetFocusedFocusScope();
			return ret;
		}
		public static uint GetFocusScope()
		{
			uint ret = ImGuiPNative.GetFocusScope();
			return ret;
		}
		public static bool IsNamedKey(ImGuiKey key)
		{
			byte ret = ImGuiPNative.IsNamedKey(key);
			return ret != 0;
		}
		public static bool IsLegacyKey(ImGuiKey key)
		{
			byte ret = ImGuiPNative.IsLegacyKey(key);
			return ret != 0;
		}
		public static bool IsGamepadKey(ImGuiKey key)
		{
			byte ret = ImGuiPNative.IsGamepadKey(key);
			return ret != 0;
		}
		public static ImGuiKeyDataPtr GetKeyData(ImGuiKey key)
		{
			ImGuiKeyDataPtr ret = ImGuiPNative.GetKeyData(key);
			return ret;
		}
		public static void SetItemUsingMouseWheel()
		{
			ImGuiPNative.SetItemUsingMouseWheel();
		}
		public static void SetActiveIdUsingNavAndKeys()
		{
			ImGuiPNative.SetActiveIdUsingNavAndKeys();
		}
		public static bool IsActiveIdUsingNavDir(ImGuiDir dir)
		{
			byte ret = ImGuiPNative.IsActiveIdUsingNavDir(dir);
			return ret != 0;
		}
		public static bool IsActiveIdUsingNavInput(ImGuiNavInput input)
		{
			byte ret = ImGuiPNative.IsActiveIdUsingNavInput(input);
			return ret != 0;
		}
		public static bool IsActiveIdUsingKey(ImGuiKey key)
		{
			byte ret = ImGuiPNative.IsActiveIdUsingKey(key);
			return ret != 0;
		}
		public static void SetActiveIdUsingKey(ImGuiKey key)
		{
			ImGuiPNative.SetActiveIdUsingKey(key);
		}
		public static bool IsMouseDragPastThreshold(ImGuiMouseButton button, float lockThreshold)
		{
			byte ret = ImGuiPNative.IsMouseDragPastThreshold(button, lockThreshold);
			return ret != 0;
		}
		public static bool IsMouseDragPastThreshold(ImGuiMouseButton button)
		{
			byte ret = ImGuiPNative.IsMouseDragPastThreshold(button, (float)(-1.0f));
			return ret != 0;
		}
		public static bool IsNavInputDown(ImGuiNavInput n)
		{
			byte ret = ImGuiPNative.IsNavInputDown(n);
			return ret != 0;
		}
		public static bool IsNavInputTest(ImGuiNavInput n, ImGuiNavReadMode rm)
		{
			byte ret = ImGuiPNative.IsNavInputTest(n, rm);
			return ret != 0;
		}
		public static ImGuiModFlags GetMergedModFlags()
		{
			ImGuiModFlags ret = ImGuiPNative.GetMergedModFlags();
			return ret;
		}
		public static bool IsKeyPressedMap(ImGuiKey key, bool repeat)
		{
			byte ret = ImGuiPNative.IsKeyPressedMap(key, repeat ? (byte)1 : (byte)0);
			return ret != 0;
		}
		public static bool IsKeyPressedMap(ImGuiKey key)
		{
			byte ret = ImGuiPNative.IsKeyPressedMap(key, (byte)(1));
			return ret != 0;
		}
		public static void DockContextInitialize(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextInitialize(ctx);
		}
		public static void DockContextInitialize(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextInitialize((ImGuiContext*)pctx);
			}
		}
		public static void DockContextShutdown(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextShutdown(ctx);
		}
		public static void DockContextShutdown(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextShutdown((ImGuiContext*)pctx);
			}
		}
		public static void DockContextClearNodes(ImGuiContextPtr ctx, uint rootId, bool clearSettingsRefs)
		{
			ImGuiPNative.DockContextClearNodes(ctx, rootId, clearSettingsRefs ? (byte)1 : (byte)0);
		}
		public static void DockContextClearNodes(ref ImGuiContext ctx, uint rootId, bool clearSettingsRefs)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextClearNodes((ImGuiContext*)pctx, rootId, clearSettingsRefs ? (byte)1 : (byte)0);
			}
		}
		public static void DockContextRebuildNodes(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextRebuildNodes(ctx);
		}
		public static void DockContextRebuildNodes(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextRebuildNodes((ImGuiContext*)pctx);
			}
		}
		public static void DockContextNewFrameUpdateUndocking(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextNewFrameUpdateUndocking(ctx);
		}
		public static void DockContextNewFrameUpdateUndocking(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextNewFrameUpdateUndocking((ImGuiContext*)pctx);
			}
		}
		public static void DockContextNewFrameUpdateDocking(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextNewFrameUpdateDocking(ctx);
		}
		public static void DockContextNewFrameUpdateDocking(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextNewFrameUpdateDocking((ImGuiContext*)pctx);
			}
		}
		public static void DockContextEndFrame(ImGuiContextPtr ctx)
		{
			ImGuiPNative.DockContextEndFrame(ctx);
		}
		public static void DockContextEndFrame(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextEndFrame((ImGuiContext*)pctx);
			}
		}
		public static uint DockContextGenNodeID(ImGuiContextPtr ctx)
		{
			uint ret = ImGuiPNative.DockContextGenNodeID(ctx);
			return ret;
		}
		public static uint DockContextGenNodeID(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				uint ret = ImGuiPNative.DockContextGenNodeID((ImGuiContext*)pctx);
				return ret;
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			ImGuiPNative.DockContextQueueDock(ctx, target, targetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, target, targetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				ImGuiPNative.DockContextQueueDock(ctx, (ImGuiWindow*)ptarget, targetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* ptarget = &target)
				{
					ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, (ImGuiWindow*)ptarget, targetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				ImGuiPNative.DockContextQueueDock(ctx, target, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, target, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ref ImGuiWindow target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					ImGuiPNative.DockContextQueueDock(ctx, (ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ref ImGuiWindow target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* ptarget = &target)
				{
					fixed (ImGuiDockNode* ptargetNode = &targetNode)
					{
						ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, (ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
					}
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiWindow* ppayload = &payload)
			{
				ImGuiPNative.DockContextQueueDock(ctx, target, targetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, target, targetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					ImGuiPNative.DockContextQueueDock(ctx, (ImGuiWindow*)ptarget, targetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* ptarget = &target)
				{
					fixed (ImGuiWindow* ppayload = &payload)
					{
						ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, (ImGuiWindow*)ptarget, targetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
					}
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					ImGuiPNative.DockContextQueueDock(ctx, target, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					fixed (ImGuiWindow* ppayload = &payload)
					{
						ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, target, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
					}
				}
			}
		}
		public static void DockContextQueueDock(ImGuiContextPtr ctx, ref ImGuiWindow target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					fixed (ImGuiWindow* ppayload = &payload)
					{
						ImGuiPNative.DockContextQueueDock(ctx, (ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
					}
				}
			}
		}
		public static void DockContextQueueDock(ref ImGuiContext ctx, ref ImGuiWindow target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, float splitRatio, bool splitOuter)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* ptarget = &target)
				{
					fixed (ImGuiDockNode* ptargetNode = &targetNode)
					{
						fixed (ImGuiWindow* ppayload = &payload)
						{
							ImGuiPNative.DockContextQueueDock((ImGuiContext*)pctx, (ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitRatio, splitOuter ? (byte)1 : (byte)0);
						}
					}
				}
			}
		}
		public static void DockContextQueueUndockWindow(ImGuiContextPtr ctx, ImGuiWindowPtr window)
		{
			ImGuiPNative.DockContextQueueUndockWindow(ctx, window);
		}
		public static void DockContextQueueUndockWindow(ref ImGuiContext ctx, ImGuiWindowPtr window)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextQueueUndockWindow((ImGuiContext*)pctx, window);
			}
		}
		public static void DockContextQueueUndockWindow(ImGuiContextPtr ctx, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.DockContextQueueUndockWindow(ctx, (ImGuiWindow*)pwindow);
			}
		}
		public static void DockContextQueueUndockWindow(ref ImGuiContext ctx, ref ImGuiWindow window)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.DockContextQueueUndockWindow((ImGuiContext*)pctx, (ImGuiWindow*)pwindow);
				}
			}
		}
		public static void DockContextQueueUndockNode(ImGuiContextPtr ctx, ImGuiDockNodePtr node)
		{
			ImGuiPNative.DockContextQueueUndockNode(ctx, node);
		}
		public static void DockContextQueueUndockNode(ref ImGuiContext ctx, ImGuiDockNodePtr node)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				ImGuiPNative.DockContextQueueUndockNode((ImGuiContext*)pctx, node);
			}
		}
		public static void DockContextQueueUndockNode(ImGuiContextPtr ctx, ref ImGuiDockNode node)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				ImGuiPNative.DockContextQueueUndockNode(ctx, (ImGuiDockNode*)pnode);
			}
		}
		public static void DockContextQueueUndockNode(ref ImGuiContext ctx, ref ImGuiDockNode node)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				fixed (ImGuiDockNode* pnode = &node)
				{
					ImGuiPNative.DockContextQueueUndockNode((ImGuiContext*)pctx, (ImGuiDockNode*)pnode);
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, targetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
			return ret != 0;
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, targetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
				return ret != 0;
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
				return ret != 0;
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiWindow* ppayload = &payload)
			{
				byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, targetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
				return ret != 0;
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, targetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, Vector2* outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					fixed (ImGuiWindow* ppayload = &payload)
					{
						byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, outPos);
						return ret != 0;
					}
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (Vector2* poutPos = &outPos)
			{
				byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, targetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
				return ret != 0;
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (Vector2* poutPos = &outPos)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, targetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				fixed (Vector2* poutPos = &outPos)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ref ImGuiDockNode targetNode, ImGuiWindowPtr payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					fixed (Vector2* poutPos = &outPos)
					{
						byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, payload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
						return ret != 0;
					}
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiWindow* ppayload = &payload)
			{
				fixed (Vector2* poutPos = &outPos)
				{
					byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, targetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
					return ret != 0;
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ImGuiDockNodePtr targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					fixed (Vector2* poutPos = &outPos)
					{
						byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, targetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
						return ret != 0;
					}
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ImGuiWindowPtr target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiDockNode* ptargetNode = &targetNode)
			{
				fixed (ImGuiWindow* ppayload = &payload)
				{
					fixed (Vector2* poutPos = &outPos)
					{
						byte ret = ImGuiPNative.DockContextCalcDropPosForDocking(target, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
						return ret != 0;
					}
				}
			}
		}
		public static bool DockContextCalcDropPosForDocking(ref ImGuiWindow target, ref ImGuiDockNode targetNode, ref ImGuiWindow payload, ImGuiDir splitDir, bool splitOuter, ref Vector2 outPos)
		{
			fixed (ImGuiWindow* ptarget = &target)
			{
				fixed (ImGuiDockNode* ptargetNode = &targetNode)
				{
					fixed (ImGuiWindow* ppayload = &payload)
					{
						fixed (Vector2* poutPos = &outPos)
						{
							byte ret = ImGuiPNative.DockContextCalcDropPosForDocking((ImGuiWindow*)ptarget, (ImGuiDockNode*)ptargetNode, (ImGuiWindow*)ppayload, splitDir, splitOuter ? (byte)1 : (byte)0, (Vector2*)poutPos);
							return ret != 0;
						}
					}
				}
			}
		}
		public static bool DockNodeBeginAmendTabBar(ImGuiDockNodePtr node)
		{
			byte ret = ImGuiPNative.DockNodeBeginAmendTabBar(node);
			return ret != 0;
		}
		public static bool DockNodeBeginAmendTabBar(ref ImGuiDockNode node)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				byte ret = ImGuiPNative.DockNodeBeginAmendTabBar((ImGuiDockNode*)pnode);
				return ret != 0;
			}
		}
		public static void DockNodeEndAmendTabBar()
		{
			ImGuiPNative.DockNodeEndAmendTabBar();
		}
		public static ImGuiDockNodePtr DockNodeGetRootNode(ImGuiDockNodePtr node)
		{
			ImGuiDockNodePtr ret = ImGuiPNative.DockNodeGetRootNode(node);
			return ret;
		}
		public static ImGuiDockNodePtr DockNodeGetRootNode(ref ImGuiDockNode node)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				ImGuiDockNodePtr ret = ImGuiPNative.DockNodeGetRootNode((ImGuiDockNode*)pnode);
				return ret;
			}
		}
		public static bool DockNodeIsInHierarchyOf(ImGuiDockNodePtr node, ImGuiDockNodePtr parent)
		{
			byte ret = ImGuiPNative.DockNodeIsInHierarchyOf(node, parent);
			return ret != 0;
		}
		public static bool DockNodeIsInHierarchyOf(ref ImGuiDockNode node, ImGuiDockNodePtr parent)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				byte ret = ImGuiPNative.DockNodeIsInHierarchyOf((ImGuiDockNode*)pnode, parent);
				return ret != 0;
			}
		}
		public static bool DockNodeIsInHierarchyOf(ImGuiDockNodePtr node, ref ImGuiDockNode parent)
		{
			fixed (ImGuiDockNode* pparent = &parent)
			{
				byte ret = ImGuiPNative.DockNodeIsInHierarchyOf(node, (ImGuiDockNode*)pparent);
				return ret != 0;
			}
		}
		public static bool DockNodeIsInHierarchyOf(ref ImGuiDockNode node, ref ImGuiDockNode parent)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				fixed (ImGuiDockNode* pparent = &parent)
				{
					byte ret = ImGuiPNative.DockNodeIsInHierarchyOf((ImGuiDockNode*)pnode, (ImGuiDockNode*)pparent);
					return ret != 0;
				}
			}
		}
		public static int DockNodeGetDepth(ImGuiDockNodePtr node)
		{
			int ret = ImGuiPNative.DockNodeGetDepth(node);
			return ret;
		}
		public static int DockNodeGetDepth(ref ImGuiDockNode node)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				int ret = ImGuiPNative.DockNodeGetDepth((ImGuiDockNode*)pnode);
				return ret;
			}
		}
		public static uint DockNodeGetWindowMenuButtonId(ImGuiDockNodePtr node)
		{
			uint ret = ImGuiPNative.DockNodeGetWindowMenuButtonId(node);
			return ret;
		}
		public static uint DockNodeGetWindowMenuButtonId(ref ImGuiDockNode node)
		{
			fixed (ImGuiDockNode* pnode = &node)
			{
				uint ret = ImGuiPNative.DockNodeGetWindowMenuButtonId((ImGuiDockNode*)pnode);
				return ret;
			}
		}
		public static ImGuiDockNodePtr GetWindowDockNode()
		{
			ImGuiDockNodePtr ret = ImGuiPNative.GetWindowDockNode();
			return ret;
		}
		public static bool GetWindowAlwaysWantOwnTabBar(ImGuiWindowPtr window)
		{
			byte ret = ImGuiPNative.GetWindowAlwaysWantOwnTabBar(window);
			return ret != 0;
		}
		public static bool GetWindowAlwaysWantOwnTabBar(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				byte ret = ImGuiPNative.GetWindowAlwaysWantOwnTabBar((ImGuiWindow*)pwindow);
				return ret != 0;
			}
		}
		public static void BeginDocked(ImGuiWindowPtr window, bool* pOpen)
		{
			ImGuiPNative.BeginDocked(window, pOpen);
		}
		public static void BeginDocked(ref ImGuiWindow window, bool* pOpen)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BeginDocked((ImGuiWindow*)pwindow, pOpen);
			}
		}
		public static void BeginDocked(ImGuiWindowPtr window, ref bool pOpen)
		{
			fixed (bool* ppOpen = &pOpen)
			{
				ImGuiPNative.BeginDocked(window, (bool*)ppOpen);
			}
		}
		public static void BeginDocked(ref ImGuiWindow window, ref bool pOpen)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				fixed (bool* ppOpen = &pOpen)
				{
					ImGuiPNative.BeginDocked((ImGuiWindow*)pwindow, (bool*)ppOpen);
				}
			}
		}
		public static void BeginDockableDragDropSource(ImGuiWindowPtr window)
		{
			ImGuiPNative.BeginDockableDragDropSource(window);
		}
		public static void BeginDockableDragDropSource(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BeginDockableDragDropSource((ImGuiWindow*)pwindow);
			}
		}
		public static void BeginDockableDragDropTarget(ImGuiWindowPtr window)
		{
			ImGuiPNative.BeginDockableDragDropTarget(window);
		}
		public static void BeginDockableDragDropTarget(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.BeginDockableDragDropTarget((ImGuiWindow*)pwindow);
			}
		}
		public static void SetWindowDock(ImGuiWindowPtr window, uint dockId, ImGuiCond cond)
		{
			ImGuiPNative.SetWindowDock(window, dockId, cond);
		}
		public static void SetWindowDock(ref ImGuiWindow window, uint dockId, ImGuiCond cond)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowDock((ImGuiWindow*)pwindow, dockId, cond);
			}
		}
		public static ImGuiDockNodePtr DockBuilderGetNode(uint nodeId)
		{
			ImGuiDockNodePtr ret = ImGuiPNative.DockBuilderGetNode(nodeId);
			return ret;
		}
		public static ImGuiDockNodePtr DockBuilderGetCentralNode(uint nodeId)
		{
			ImGuiDockNodePtr ret = ImGuiPNative.DockBuilderGetCentralNode(nodeId);
			return ret;
		}
		public static uint DockBuilderAddNode(uint nodeId, ImGuiDockNodeFlags flags)
		{
			uint ret = ImGuiPNative.DockBuilderAddNode(nodeId, flags);
			return ret;
		}
		public static uint DockBuilderAddNode(uint nodeId)
		{
			uint ret = ImGuiPNative.DockBuilderAddNode(nodeId, (ImGuiDockNodeFlags)(0));
			return ret;
		}
		public static uint DockBuilderAddNode()
		{
			uint ret = ImGuiPNative.DockBuilderAddNode((uint)(0), (ImGuiDockNodeFlags)(0));
			return ret;
		}
		public static uint DockBuilderAddNode(ImGuiDockNodeFlags flags)
		{
			uint ret = ImGuiPNative.DockBuilderAddNode((uint)(0), flags);
			return ret;
		}
		public static void DockBuilderRemoveNode(uint nodeId)
		{
			ImGuiPNative.DockBuilderRemoveNode(nodeId);
		}
		public static void DockBuilderRemoveNodeDockedWindows(uint nodeId, bool clearSettingsRefs)
		{
			ImGuiPNative.DockBuilderRemoveNodeDockedWindows(nodeId, clearSettingsRefs ? (byte)1 : (byte)0);
		}
		public static void DockBuilderRemoveNodeDockedWindows(uint nodeId)
		{
			ImGuiPNative.DockBuilderRemoveNodeDockedWindows(nodeId, (byte)(1));
		}
		public static void DockBuilderRemoveNodeChildNodes(uint nodeId)
		{
			ImGuiPNative.DockBuilderRemoveNodeChildNodes(nodeId);
		}
		public static void DockBuilderSetNodePos(uint nodeId, Vector2 pos)
		{
			ImGuiPNative.DockBuilderSetNodePos(nodeId, pos);
		}
		public static void DockBuilderSetNodeSize(uint nodeId, Vector2 size)
		{
			ImGuiPNative.DockBuilderSetNodeSize(nodeId, size);
		}
		public static uint DockBuilderSplitNode(uint nodeId, ImGuiDir splitDir, float sizeRatioForNodeAtDir, uint* outIdAtDir, uint* outIdAtOppositeDir)
		{
			uint ret = ImGuiPNative.DockBuilderSplitNode(nodeId, splitDir, sizeRatioForNodeAtDir, outIdAtDir, outIdAtOppositeDir);
			return ret;
		}
		public static void DockBuilderCopyDockSpace(uint srcDockspaceId, uint dstDockspaceId, ImVector<ConstPointer<byte>>* inWindowRemapPairs)
		{
			ImGuiPNative.DockBuilderCopyDockSpace(srcDockspaceId, dstDockspaceId, inWindowRemapPairs);
		}
		public static void DockBuilderCopyDockSpace(uint srcDockspaceId, uint dstDockspaceId, ref ImVector<ConstPointer<byte>> inWindowRemapPairs)
		{
			fixed (ImVector<ConstPointer<byte>>* pinWindowRemapPairs = &inWindowRemapPairs)
			{
				ImGuiPNative.DockBuilderCopyDockSpace(srcDockspaceId, dstDockspaceId, (ImVector<ConstPointer<byte>>*)pinWindowRemapPairs);
			}
		}
		public static void DockBuilderCopyNode(uint srcNodeId, uint dstNodeId, ImVector<uint>* outNodeRemapPairs)
		{
			ImGuiPNative.DockBuilderCopyNode(srcNodeId, dstNodeId, outNodeRemapPairs);
		}
		public static void DockBuilderCopyNode(uint srcNodeId, uint dstNodeId, ref ImVector<uint> outNodeRemapPairs)
		{
			fixed (ImVector<uint>* poutNodeRemapPairs = &outNodeRemapPairs)
			{
				ImGuiPNative.DockBuilderCopyNode(srcNodeId, dstNodeId, (ImVector<uint>*)poutNodeRemapPairs);
			}
		}
		public static void DockBuilderFinish(uint nodeId)
		{
			ImGuiPNative.DockBuilderFinish(nodeId);
		}
		public static bool IsDragDropActive()
		{
			byte ret = ImGuiPNative.IsDragDropActive();
			return ret != 0;
		}
		public static bool BeginDragDropTargetCustom(ImRect bb, uint id)
		{
			byte ret = ImGuiPNative.BeginDragDropTargetCustom(bb, id);
			return ret != 0;
		}
		public static void ClearDragDrop()
		{
			ImGuiPNative.ClearDragDrop();
		}
		public static bool IsDragDropPayloadBeingAccepted()
		{
			byte ret = ImGuiPNative.IsDragDropPayloadBeingAccepted();
			return ret != 0;
		}
		public static void SetWindowClipRectBeforeSetChannel(ImGuiWindowPtr window, ImRect clipRect)
		{
			ImGuiPNative.SetWindowClipRectBeforeSetChannel(window, clipRect);
		}
		public static void SetWindowClipRectBeforeSetChannel(ref ImGuiWindow window, ImRect clipRect)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.SetWindowClipRectBeforeSetChannel((ImGuiWindow*)pwindow, clipRect);
			}
		}
		public static void EndColumns()
		{
			ImGuiPNative.EndColumns();
		}
		public static void PushColumnClipRect(int columnIndex)
		{
			ImGuiPNative.PushColumnClipRect(columnIndex);
		}
		public static void PushColumnsBackground()
		{
			ImGuiPNative.PushColumnsBackground();
		}
		public static void PopColumnsBackground()
		{
			ImGuiPNative.PopColumnsBackground();
		}
		public static ImGuiOldColumnsPtr FindOrCreateColumns(ImGuiWindowPtr window, uint id)
		{
			ImGuiOldColumnsPtr ret = ImGuiPNative.FindOrCreateColumns(window, id);
			return ret;
		}
		public static ImGuiOldColumnsPtr FindOrCreateColumns(ref ImGuiWindow window, uint id)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiOldColumnsPtr ret = ImGuiPNative.FindOrCreateColumns((ImGuiWindow*)pwindow, id);
				return ret;
			}
		}
		public static float GetColumnOffsetFromNorm(ImGuiOldColumnsPtr columns, float offsetNorm)
		{
			float ret = ImGuiPNative.GetColumnOffsetFromNorm(columns, offsetNorm);
			return ret;
		}
		public static float GetColumnOffsetFromNorm(ref ImGuiOldColumns columns, float offsetNorm)
		{
			fixed (ImGuiOldColumns* pcolumns = &columns)
			{
				float ret = ImGuiPNative.GetColumnOffsetFromNorm((ImGuiOldColumns*)pcolumns, offsetNorm);
				return ret;
			}
		}
		public static float GetColumnNormFromOffset(ImGuiOldColumnsPtr columns, float offset)
		{
			float ret = ImGuiPNative.GetColumnNormFromOffset(columns, offset);
			return ret;
		}
		public static float GetColumnNormFromOffset(ref ImGuiOldColumns columns, float offset)
		{
			fixed (ImGuiOldColumns* pcolumns = &columns)
			{
				float ret = ImGuiPNative.GetColumnNormFromOffset((ImGuiOldColumns*)pcolumns, offset);
				return ret;
			}
		}
		public static void TableOpenContextMenu(int columnN)
		{
			ImGuiPNative.TableOpenContextMenu(columnN);
		}
		public static void TableOpenContextMenu()
		{
			ImGuiPNative.TableOpenContextMenu((int)(-1));
		}
		public static void TableSetColumnWidth(int columnN, float width)
		{
			ImGuiPNative.TableSetColumnWidth(columnN, width);
		}
		public static void TableSetColumnSortDirection(int columnN, ImGuiSortDirection sortDirection, bool appendToSortSpecs)
		{
			ImGuiPNative.TableSetColumnSortDirection(columnN, sortDirection, appendToSortSpecs ? (byte)1 : (byte)0);
		}
		public static int TableGetHoveredColumn()
		{
			int ret = ImGuiPNative.TableGetHoveredColumn();
			return ret;
		}
		public static float TableGetHeaderRowHeight()
		{
			float ret = ImGuiPNative.TableGetHeaderRowHeight();
			return ret;
		}
		public static void TablePushBackgroundChannel()
		{
			ImGuiPNative.TablePushBackgroundChannel();
		}
		public static void TablePopBackgroundChannel()
		{
			ImGuiPNative.TablePopBackgroundChannel();
		}
		public static ImGuiTablePtr GetCurrentTable()
		{
			ImGuiTablePtr ret = ImGuiPNative.GetCurrentTable();
			return ret;
		}
		public static ImGuiTablePtr TableFindByID(uint id)
		{
			ImGuiTablePtr ret = ImGuiPNative.TableFindByID(id);
			return ret;
		}
		public static void TableBeginInitMemory(ImGuiTablePtr table, int columnsCount)
		{
			ImGuiPNative.TableBeginInitMemory(table, columnsCount);
		}
		public static void TableBeginInitMemory(ref ImGuiTable table, int columnsCount)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableBeginInitMemory((ImGuiTable*)ptable, columnsCount);
			}
		}
		public static void TableBeginApplyRequests(ImGuiTablePtr table)
		{
			ImGuiPNative.TableBeginApplyRequests(table);
		}
		public static void TableBeginApplyRequests(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableBeginApplyRequests((ImGuiTable*)ptable);
			}
		}
		public static void TableSetupDrawChannels(ImGuiTablePtr table)
		{
			ImGuiPNative.TableSetupDrawChannels(table);
		}
		public static void TableSetupDrawChannels(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSetupDrawChannels((ImGuiTable*)ptable);
			}
		}
		public static void TableUpdateLayout(ImGuiTablePtr table)
		{
			ImGuiPNative.TableUpdateLayout(table);
		}
		public static void TableUpdateLayout(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableUpdateLayout((ImGuiTable*)ptable);
			}
		}
		public static void TableUpdateBorders(ImGuiTablePtr table)
		{
			ImGuiPNative.TableUpdateBorders(table);
		}
		public static void TableUpdateBorders(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableUpdateBorders((ImGuiTable*)ptable);
			}
		}
		public static void TableUpdateColumnsWeightFromWidth(ImGuiTablePtr table)
		{
			ImGuiPNative.TableUpdateColumnsWeightFromWidth(table);
		}
		public static void TableUpdateColumnsWeightFromWidth(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableUpdateColumnsWeightFromWidth((ImGuiTable*)ptable);
			}
		}
		public static void TableDrawBorders(ImGuiTablePtr table)
		{
			ImGuiPNative.TableDrawBorders(table);
		}
		public static void TableDrawBorders(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableDrawBorders((ImGuiTable*)ptable);
			}
		}
		public static void TableDrawContextMenu(ImGuiTablePtr table)
		{
			ImGuiPNative.TableDrawContextMenu(table);
		}
		public static void TableDrawContextMenu(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableDrawContextMenu((ImGuiTable*)ptable);
			}
		}
		public static void TableMergeDrawChannels(ImGuiTablePtr table)
		{
			ImGuiPNative.TableMergeDrawChannels(table);
		}
		public static void TableMergeDrawChannels(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableMergeDrawChannels((ImGuiTable*)ptable);
			}
		}
		public static ImGuiTableInstanceDataPtr TableGetInstanceData(ImGuiTablePtr table, int instanceNo)
		{
			ImGuiTableInstanceDataPtr ret = ImGuiPNative.TableGetInstanceData(table, instanceNo);
			return ret;
		}
		public static ImGuiTableInstanceDataPtr TableGetInstanceData(ref ImGuiTable table, int instanceNo)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiTableInstanceDataPtr ret = ImGuiPNative.TableGetInstanceData((ImGuiTable*)ptable, instanceNo);
				return ret;
			}
		}
		public static void TableSortSpecsSanitize(ImGuiTablePtr table)
		{
			ImGuiPNative.TableSortSpecsSanitize(table);
		}
		public static void TableSortSpecsSanitize(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSortSpecsSanitize((ImGuiTable*)ptable);
			}
		}
		public static void TableSortSpecsBuild(ImGuiTablePtr table)
		{
			ImGuiPNative.TableSortSpecsBuild(table);
		}
		public static void TableSortSpecsBuild(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSortSpecsBuild((ImGuiTable*)ptable);
			}
		}
		public static ImGuiSortDirection TableGetColumnNextSortDirection(ImGuiTableColumnPtr column)
		{
			ImGuiSortDirection ret = ImGuiPNative.TableGetColumnNextSortDirection(column);
			return ret;
		}
		public static ImGuiSortDirection TableGetColumnNextSortDirection(ref ImGuiTableColumn column)
		{
			fixed (ImGuiTableColumn* pcolumn = &column)
			{
				ImGuiSortDirection ret = ImGuiPNative.TableGetColumnNextSortDirection((ImGuiTableColumn*)pcolumn);
				return ret;
			}
		}
		public static void TableFixColumnSortDirection(ImGuiTablePtr table, ImGuiTableColumnPtr column)
		{
			ImGuiPNative.TableFixColumnSortDirection(table, column);
		}
		public static void TableFixColumnSortDirection(ref ImGuiTable table, ImGuiTableColumnPtr column)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableFixColumnSortDirection((ImGuiTable*)ptable, column);
			}
		}
		public static void TableFixColumnSortDirection(ImGuiTablePtr table, ref ImGuiTableColumn column)
		{
			fixed (ImGuiTableColumn* pcolumn = &column)
			{
				ImGuiPNative.TableFixColumnSortDirection(table, (ImGuiTableColumn*)pcolumn);
			}
		}
		public static void TableFixColumnSortDirection(ref ImGuiTable table, ref ImGuiTableColumn column)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				fixed (ImGuiTableColumn* pcolumn = &column)
				{
					ImGuiPNative.TableFixColumnSortDirection((ImGuiTable*)ptable, (ImGuiTableColumn*)pcolumn);
				}
			}
		}
		public static float TableGetColumnWidthAuto(ImGuiTablePtr table, ImGuiTableColumnPtr column)
		{
			float ret = ImGuiPNative.TableGetColumnWidthAuto(table, column);
			return ret;
		}
		public static float TableGetColumnWidthAuto(ref ImGuiTable table, ImGuiTableColumnPtr column)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				float ret = ImGuiPNative.TableGetColumnWidthAuto((ImGuiTable*)ptable, column);
				return ret;
			}
		}
		public static float TableGetColumnWidthAuto(ImGuiTablePtr table, ref ImGuiTableColumn column)
		{
			fixed (ImGuiTableColumn* pcolumn = &column)
			{
				float ret = ImGuiPNative.TableGetColumnWidthAuto(table, (ImGuiTableColumn*)pcolumn);
				return ret;
			}
		}
		public static float TableGetColumnWidthAuto(ref ImGuiTable table, ref ImGuiTableColumn column)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				fixed (ImGuiTableColumn* pcolumn = &column)
				{
					float ret = ImGuiPNative.TableGetColumnWidthAuto((ImGuiTable*)ptable, (ImGuiTableColumn*)pcolumn);
					return ret;
				}
			}
		}
		public static void TableBeginRow(ImGuiTablePtr table)
		{
			ImGuiPNative.TableBeginRow(table);
		}
		public static void TableBeginRow(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableBeginRow((ImGuiTable*)ptable);
			}
		}
		public static void TableEndRow(ImGuiTablePtr table)
		{
			ImGuiPNative.TableEndRow(table);
		}
		public static void TableEndRow(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableEndRow((ImGuiTable*)ptable);
			}
		}
		public static void TableBeginCell(ImGuiTablePtr table, int columnN)
		{
			ImGuiPNative.TableBeginCell(table, columnN);
		}
		public static void TableBeginCell(ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableBeginCell((ImGuiTable*)ptable, columnN);
			}
		}
		public static void TableEndCell(ImGuiTablePtr table)
		{
			ImGuiPNative.TableEndCell(table);
		}
		public static void TableEndCell(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableEndCell((ImGuiTable*)ptable);
			}
		}
		public static ImRect TableGetCellBgRect(ImGuiTablePtr table, int columnN)
		{
			ImRect ret;
			ImGuiPNative.TableGetCellBgRect(&ret, table, columnN);
			return ret;
		}
		public static void TableGetCellBgRect(ImRectPtr pOut, ImGuiTablePtr table, int columnN)
		{
			ImGuiPNative.TableGetCellBgRect(pOut, table, columnN);
		}
		public static void TableGetCellBgRect(ref ImRect pOut, ImGuiTablePtr table, int columnN)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.TableGetCellBgRect((ImRect*)ppOut, table, columnN);
			}
		}
		public static ImRect TableGetCellBgRect(ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImRect ret;
				ImGuiPNative.TableGetCellBgRect(&ret, (ImGuiTable*)ptable, columnN);
				return ret;
			}
		}
		public static void TableGetCellBgRect(ImRectPtr pOut, ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableGetCellBgRect(pOut, (ImGuiTable*)ptable, columnN);
			}
		}
		public static void TableGetCellBgRect(ref ImRect pOut, ref ImGuiTable table, int columnN)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiTable* ptable = &table)
				{
					ImGuiPNative.TableGetCellBgRect((ImRect*)ppOut, (ImGuiTable*)ptable, columnN);
				}
			}
		}
		public static uint TableGetColumnResizeID(ImGuiTablePtr table, int columnN, int instanceNo)
		{
			uint ret = ImGuiPNative.TableGetColumnResizeID(table, columnN, instanceNo);
			return ret;
		}
		public static uint TableGetColumnResizeID(ImGuiTablePtr table, int columnN)
		{
			uint ret = ImGuiPNative.TableGetColumnResizeID(table, columnN, (int)(0));
			return ret;
		}
		public static uint TableGetColumnResizeID(ref ImGuiTable table, int columnN, int instanceNo)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				uint ret = ImGuiPNative.TableGetColumnResizeID((ImGuiTable*)ptable, columnN, instanceNo);
				return ret;
			}
		}
		public static uint TableGetColumnResizeID(ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				uint ret = ImGuiPNative.TableGetColumnResizeID((ImGuiTable*)ptable, columnN, (int)(0));
				return ret;
			}
		}
		public static float TableGetMaxColumnWidth(ImGuiTablePtr table, int columnN)
		{
			float ret = ImGuiPNative.TableGetMaxColumnWidth(table, columnN);
			return ret;
		}
		public static float TableGetMaxColumnWidth(ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				float ret = ImGuiPNative.TableGetMaxColumnWidth((ImGuiTable*)ptable, columnN);
				return ret;
			}
		}
		public static void TableSetColumnWidthAutoSingle(ImGuiTablePtr table, int columnN)
		{
			ImGuiPNative.TableSetColumnWidthAutoSingle(table, columnN);
		}
		public static void TableSetColumnWidthAutoSingle(ref ImGuiTable table, int columnN)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSetColumnWidthAutoSingle((ImGuiTable*)ptable, columnN);
			}
		}
		public static void TableSetColumnWidthAutoAll(ImGuiTablePtr table)
		{
			ImGuiPNative.TableSetColumnWidthAutoAll(table);
		}
		public static void TableSetColumnWidthAutoAll(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSetColumnWidthAutoAll((ImGuiTable*)ptable);
			}
		}
		public static void TableRemove(ImGuiTablePtr table)
		{
			ImGuiPNative.TableRemove(table);
		}
		public static void TableRemove(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableRemove((ImGuiTable*)ptable);
			}
		}
		public static void TableGcCompactTransientBuffers(ImGuiTablePtr table)
		{
			ImGuiPNative.TableGcCompactTransientBuffers(table);
		}
		public static void TableGcCompactTransientBuffers(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableGcCompactTransientBuffers((ImGuiTable*)ptable);
			}
		}
		public static void TableGcCompactTransientBuffers(ImGuiTableTempDataPtr table)
		{
			ImGuiPNative.TableGcCompactTransientBuffers(table);
		}
		public static void TableGcCompactTransientBuffers(ref ImGuiTableTempData table)
		{
			fixed (ImGuiTableTempData* ptable = &table)
			{
				ImGuiPNative.TableGcCompactTransientBuffers((ImGuiTableTempData*)ptable);
			}
		}
		public static void TableGcCompactSettings()
		{
			ImGuiPNative.TableGcCompactSettings();
		}
		public static void TableLoadSettings(ImGuiTablePtr table)
		{
			ImGuiPNative.TableLoadSettings(table);
		}
		public static void TableLoadSettings(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableLoadSettings((ImGuiTable*)ptable);
			}
		}
		public static void TableSaveSettings(ImGuiTablePtr table)
		{
			ImGuiPNative.TableSaveSettings(table);
		}
		public static void TableSaveSettings(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableSaveSettings((ImGuiTable*)ptable);
			}
		}
		public static void TableResetSettings(ImGuiTablePtr table)
		{
			ImGuiPNative.TableResetSettings(table);
		}
		public static void TableResetSettings(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.TableResetSettings((ImGuiTable*)ptable);
			}
		}
		public static ImGuiTableSettingsPtr TableGetBoundSettings(ImGuiTablePtr table)
		{
			ImGuiTableSettingsPtr ret = ImGuiPNative.TableGetBoundSettings(table);
			return ret;
		}
		public static ImGuiTableSettingsPtr TableGetBoundSettings(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiTableSettingsPtr ret = ImGuiPNative.TableGetBoundSettings((ImGuiTable*)ptable);
				return ret;
			}
		}
		public static void TableSettingsAddSettingsHandler()
		{
			ImGuiPNative.TableSettingsAddSettingsHandler();
		}
		public static ImGuiTableSettingsPtr TableSettingsCreate(uint id, int columnsCount)
		{
			ImGuiTableSettingsPtr ret = ImGuiPNative.TableSettingsCreate(id, columnsCount);
			return ret;
		}
		public static ImGuiTableSettingsPtr TableSettingsFindByID(uint id)
		{
			ImGuiTableSettingsPtr ret = ImGuiPNative.TableSettingsFindByID(id);
			return ret;
		}
		public static bool BeginTabBarEx(ImGuiTabBarPtr tabBar, ImRect bb, ImGuiTabBarFlags flags, ImGuiDockNodePtr dockNode)
		{
			byte ret = ImGuiPNative.BeginTabBarEx(tabBar, bb, flags, dockNode);
			return ret != 0;
		}
		public static bool BeginTabBarEx(ref ImGuiTabBar tabBar, ImRect bb, ImGuiTabBarFlags flags, ImGuiDockNodePtr dockNode)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				byte ret = ImGuiPNative.BeginTabBarEx((ImGuiTabBar*)ptabBar, bb, flags, dockNode);
				return ret != 0;
			}
		}
		public static bool BeginTabBarEx(ImGuiTabBarPtr tabBar, ImRect bb, ImGuiTabBarFlags flags, ref ImGuiDockNode dockNode)
		{
			fixed (ImGuiDockNode* pdockNode = &dockNode)
			{
				byte ret = ImGuiPNative.BeginTabBarEx(tabBar, bb, flags, (ImGuiDockNode*)pdockNode);
				return ret != 0;
			}
		}
		public static bool BeginTabBarEx(ref ImGuiTabBar tabBar, ImRect bb, ImGuiTabBarFlags flags, ref ImGuiDockNode dockNode)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				fixed (ImGuiDockNode* pdockNode = &dockNode)
				{
					byte ret = ImGuiPNative.BeginTabBarEx((ImGuiTabBar*)ptabBar, bb, flags, (ImGuiDockNode*)pdockNode);
					return ret != 0;
				}
			}
		}
		public static ImGuiTabItemPtr TabBarFindTabByID(ImGuiTabBarPtr tabBar, uint tabId)
		{
			ImGuiTabItemPtr ret = ImGuiPNative.TabBarFindTabByID(tabBar, tabId);
			return ret;
		}
		public static ImGuiTabItemPtr TabBarFindTabByID(ref ImGuiTabBar tabBar, uint tabId)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiTabItemPtr ret = ImGuiPNative.TabBarFindTabByID((ImGuiTabBar*)ptabBar, tabId);
				return ret;
			}
		}
		public static ImGuiTabItemPtr TabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBarPtr tabBar)
		{
			ImGuiTabItemPtr ret = ImGuiPNative.TabBarFindMostRecentlySelectedTabForActiveWindow(tabBar);
			return ret;
		}
		public static ImGuiTabItemPtr TabBarFindMostRecentlySelectedTabForActiveWindow(ref ImGuiTabBar tabBar)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiTabItemPtr ret = ImGuiPNative.TabBarFindMostRecentlySelectedTabForActiveWindow((ImGuiTabBar*)ptabBar);
				return ret;
			}
		}
		public static void TabBarAddTab(ImGuiTabBarPtr tabBar, ImGuiTabItemFlags tabFlags, ImGuiWindowPtr window)
		{
			ImGuiPNative.TabBarAddTab(tabBar, tabFlags, window);
		}
		public static void TabBarAddTab(ref ImGuiTabBar tabBar, ImGuiTabItemFlags tabFlags, ImGuiWindowPtr window)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiPNative.TabBarAddTab((ImGuiTabBar*)ptabBar, tabFlags, window);
			}
		}
		public static void TabBarAddTab(ImGuiTabBarPtr tabBar, ImGuiTabItemFlags tabFlags, ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.TabBarAddTab(tabBar, tabFlags, (ImGuiWindow*)pwindow);
			}
		}
		public static void TabBarAddTab(ref ImGuiTabBar tabBar, ImGuiTabItemFlags tabFlags, ref ImGuiWindow window)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.TabBarAddTab((ImGuiTabBar*)ptabBar, tabFlags, (ImGuiWindow*)pwindow);
				}
			}
		}
		public static void TabBarRemoveTab(ImGuiTabBarPtr tabBar, uint tabId)
		{
			ImGuiPNative.TabBarRemoveTab(tabBar, tabId);
		}
		public static void TabBarRemoveTab(ref ImGuiTabBar tabBar, uint tabId)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiPNative.TabBarRemoveTab((ImGuiTabBar*)ptabBar, tabId);
			}
		}
		public static void TabBarCloseTab(ImGuiTabBarPtr tabBar, ImGuiTabItemPtr tab)
		{
			ImGuiPNative.TabBarCloseTab(tabBar, tab);
		}
		public static void TabBarCloseTab(ref ImGuiTabBar tabBar, ImGuiTabItemPtr tab)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiPNative.TabBarCloseTab((ImGuiTabBar*)ptabBar, tab);
			}
		}
		public static void TabBarCloseTab(ImGuiTabBarPtr tabBar, ref ImGuiTabItem tab)
		{
			fixed (ImGuiTabItem* ptab = &tab)
			{
				ImGuiPNative.TabBarCloseTab(tabBar, (ImGuiTabItem*)ptab);
			}
		}
		public static void TabBarCloseTab(ref ImGuiTabBar tabBar, ref ImGuiTabItem tab)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				fixed (ImGuiTabItem* ptab = &tab)
				{
					ImGuiPNative.TabBarCloseTab((ImGuiTabBar*)ptabBar, (ImGuiTabItem*)ptab);
				}
			}
		}
		public static void TabBarQueueReorder(ImGuiTabBarPtr tabBar, ImGuiTabItemPtr tab, int offset)
		{
			ImGuiPNative.TabBarQueueReorder(tabBar, tab, offset);
		}
		public static void TabBarQueueReorder(ref ImGuiTabBar tabBar, ImGuiTabItemPtr tab, int offset)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiPNative.TabBarQueueReorder((ImGuiTabBar*)ptabBar, tab, offset);
			}
		}
		public static void TabBarQueueReorder(ImGuiTabBarPtr tabBar, ref ImGuiTabItem tab, int offset)
		{
			fixed (ImGuiTabItem* ptab = &tab)
			{
				ImGuiPNative.TabBarQueueReorder(tabBar, (ImGuiTabItem*)ptab, offset);
			}
		}
		public static void TabBarQueueReorder(ref ImGuiTabBar tabBar, ref ImGuiTabItem tab, int offset)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				fixed (ImGuiTabItem* ptab = &tab)
				{
					ImGuiPNative.TabBarQueueReorder((ImGuiTabBar*)ptabBar, (ImGuiTabItem*)ptab, offset);
				}
			}
		}
		public static void TabBarQueueReorderFromMousePos(ImGuiTabBarPtr tabBar, ImGuiTabItemPtr tab, Vector2 mousePos)
		{
			ImGuiPNative.TabBarQueueReorderFromMousePos(tabBar, tab, mousePos);
		}
		public static void TabBarQueueReorderFromMousePos(ref ImGuiTabBar tabBar, ImGuiTabItemPtr tab, Vector2 mousePos)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				ImGuiPNative.TabBarQueueReorderFromMousePos((ImGuiTabBar*)ptabBar, tab, mousePos);
			}
		}
		public static void TabBarQueueReorderFromMousePos(ImGuiTabBarPtr tabBar, ref ImGuiTabItem tab, Vector2 mousePos)
		{
			fixed (ImGuiTabItem* ptab = &tab)
			{
				ImGuiPNative.TabBarQueueReorderFromMousePos(tabBar, (ImGuiTabItem*)ptab, mousePos);
			}
		}
		public static void TabBarQueueReorderFromMousePos(ref ImGuiTabBar tabBar, ref ImGuiTabItem tab, Vector2 mousePos)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				fixed (ImGuiTabItem* ptab = &tab)
				{
					ImGuiPNative.TabBarQueueReorderFromMousePos((ImGuiTabBar*)ptabBar, (ImGuiTabItem*)ptab, mousePos);
				}
			}
		}
		public static bool TabBarProcessReorder(ImGuiTabBarPtr tabBar)
		{
			byte ret = ImGuiPNative.TabBarProcessReorder(tabBar);
			return ret != 0;
		}
		public static bool TabBarProcessReorder(ref ImGuiTabBar tabBar)
		{
			fixed (ImGuiTabBar* ptabBar = &tabBar)
			{
				byte ret = ImGuiPNative.TabBarProcessReorder((ImGuiTabBar*)ptabBar);
				return ret != 0;
			}
		}
		public static void TabItemBackground(ImDrawListPtr drawList, ImRect bb, ImGuiTabItemFlags flags, uint col)
		{
			ImGuiPNative.TabItemBackground(drawList, bb, flags, col);
		}
		public static void TabItemBackground(ref ImDrawList drawList, ImRect bb, ImGuiTabItemFlags flags, uint col)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.TabItemBackground((ImDrawList*)pdrawList, bb, flags, col);
			}
		}
		public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, bool border, float rounding)
		{
			ImGuiPNative.RenderFrame(pMin, pMax, fillCol, border ? (byte)1 : (byte)0, rounding);
		}
		public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, bool border)
		{
			ImGuiPNative.RenderFrame(pMin, pMax, fillCol, border ? (byte)1 : (byte)0, (float)(0.0f));
		}
		public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol)
		{
			ImGuiPNative.RenderFrame(pMin, pMax, fillCol, (byte)(1), (float)(0.0f));
		}
		public static void RenderFrame(Vector2 pMin, Vector2 pMax, uint fillCol, float rounding)
		{
			ImGuiPNative.RenderFrame(pMin, pMax, fillCol, (byte)(1), rounding);
		}
		public static void RenderFrameBorder(Vector2 pMin, Vector2 pMax, float rounding)
		{
			ImGuiPNative.RenderFrameBorder(pMin, pMax, rounding);
		}
		public static void RenderFrameBorder(Vector2 pMin, Vector2 pMax)
		{
			ImGuiPNative.RenderFrameBorder(pMin, pMax, (float)(0.0f));
		}
		public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding, ImDrawFlags flags)
		{
			ImGuiPNative.RenderColorRectWithAlphaCheckerboard(drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
		}
		public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding)
		{
			ImGuiPNative.RenderColorRectWithAlphaCheckerboard(drawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, (ImDrawFlags)(0));
		}
		public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff)
		{
			ImGuiPNative.RenderColorRectWithAlphaCheckerboard(drawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), (ImDrawFlags)(0));
		}
		public static void RenderColorRectWithAlphaCheckerboard(ImDrawListPtr drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, ImDrawFlags flags)
		{
			ImGuiPNative.RenderColorRectWithAlphaCheckerboard(drawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), flags);
		}
		public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding, ImDrawFlags flags)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderColorRectWithAlphaCheckerboard((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, flags);
			}
		}
		public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, float rounding)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderColorRectWithAlphaCheckerboard((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, rounding, (ImDrawFlags)(0));
			}
		}
		public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderColorRectWithAlphaCheckerboard((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), (ImDrawFlags)(0));
			}
		}
		public static void RenderColorRectWithAlphaCheckerboard(ref ImDrawList drawList, Vector2 pMin, Vector2 pMax, uint fillCol, float gridStep, Vector2 gridOff, ImDrawFlags flags)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderColorRectWithAlphaCheckerboard((ImDrawList*)pdrawList, pMin, pMax, fillCol, gridStep, gridOff, (float)(0.0f), flags);
			}
		}
		public static void RenderNavHighlight(ImRect bb, uint id, ImGuiNavHighlightFlags flags)
		{
			ImGuiPNative.RenderNavHighlight(bb, id, flags);
		}
		public static void RenderNavHighlight(ImRect bb, uint id)
		{
			ImGuiPNative.RenderNavHighlight(bb, id, (ImGuiNavHighlightFlags)(ImGuiNavHighlightFlags.TypeDefault));
		}
		public static void RenderMouseCursor(Vector2 pos, float scale, ImGuiMouseCursor mouseCursor, uint colFill, uint colBorder, uint colShadow)
		{
			ImGuiPNative.RenderMouseCursor(pos, scale, mouseCursor, colFill, colBorder, colShadow);
		}
		public static void RenderArrow(ImDrawListPtr drawList, Vector2 pos, uint col, ImGuiDir dir, float scale)
		{
			ImGuiPNative.RenderArrow(drawList, pos, col, dir, scale);
		}
		public static void RenderArrow(ImDrawListPtr drawList, Vector2 pos, uint col, ImGuiDir dir)
		{
			ImGuiPNative.RenderArrow(drawList, pos, col, dir, (float)(1.0f));
		}
		public static void RenderArrow(ref ImDrawList drawList, Vector2 pos, uint col, ImGuiDir dir, float scale)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderArrow((ImDrawList*)pdrawList, pos, col, dir, scale);
			}
		}
		public static void RenderArrow(ref ImDrawList drawList, Vector2 pos, uint col, ImGuiDir dir)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderArrow((ImDrawList*)pdrawList, pos, col, dir, (float)(1.0f));
			}
		}
		public static void RenderBullet(ImDrawListPtr drawList, Vector2 pos, uint col)
		{
			ImGuiPNative.RenderBullet(drawList, pos, col);
		}
		public static void RenderBullet(ref ImDrawList drawList, Vector2 pos, uint col)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderBullet((ImDrawList*)pdrawList, pos, col);
			}
		}
		public static void RenderCheckMark(ImDrawListPtr drawList, Vector2 pos, uint col, float sz)
		{
			ImGuiPNative.RenderCheckMark(drawList, pos, col, sz);
		}
		public static void RenderCheckMark(ref ImDrawList drawList, Vector2 pos, uint col, float sz)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderCheckMark((ImDrawList*)pdrawList, pos, col, sz);
			}
		}
		public static void RenderArrowPointingAt(ImDrawListPtr drawList, Vector2 pos, Vector2 halfSz, ImGuiDir direction, uint col)
		{
			ImGuiPNative.RenderArrowPointingAt(drawList, pos, halfSz, direction, col);
		}
		public static void RenderArrowPointingAt(ref ImDrawList drawList, Vector2 pos, Vector2 halfSz, ImGuiDir direction, uint col)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderArrowPointingAt((ImDrawList*)pdrawList, pos, halfSz, direction, col);
			}
		}
		public static void RenderArrowDockMenu(ImDrawListPtr drawList, Vector2 pMin, float sz, uint col)
		{
			ImGuiPNative.RenderArrowDockMenu(drawList, pMin, sz, col);
		}
		public static void RenderArrowDockMenu(ref ImDrawList drawList, Vector2 pMin, float sz, uint col)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderArrowDockMenu((ImDrawList*)pdrawList, pMin, sz, col);
			}
		}
		public static void RenderRectFilledRangeH(ImDrawListPtr drawList, ImRect rect, uint col, float xStartNorm, float xEndNorm, float rounding)
		{
			ImGuiPNative.RenderRectFilledRangeH(drawList, rect, col, xStartNorm, xEndNorm, rounding);
		}
		public static void RenderRectFilledRangeH(ref ImDrawList drawList, ImRect rect, uint col, float xStartNorm, float xEndNorm, float rounding)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderRectFilledRangeH((ImDrawList*)pdrawList, rect, col, xStartNorm, xEndNorm, rounding);
			}
		}
		public static void RenderRectFilledWithHole(ImDrawListPtr drawList, ImRect outer, ImRect inner, uint col, float rounding)
		{
			ImGuiPNative.RenderRectFilledWithHole(drawList, outer, inner, col, rounding);
		}
		public static void RenderRectFilledWithHole(ref ImDrawList drawList, ImRect outer, ImRect inner, uint col, float rounding)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.RenderRectFilledWithHole((ImDrawList*)pdrawList, outer, inner, col, rounding);
			}
		}
		public static ImDrawFlags CalcRoundingFlagsForRectInRect(ImRect rIn, ImRect rOuter, float threshold)
		{
			ImDrawFlags ret = ImGuiPNative.CalcRoundingFlagsForRectInRect(rIn, rOuter, threshold);
			return ret;
		}
		public static bool CloseButton(uint id, Vector2 pos)
		{
			byte ret = ImGuiPNative.CloseButton(id, pos);
			return ret != 0;
		}
		public static bool CollapseButton(uint id, Vector2 pos, ImGuiDockNodePtr dockNode)
		{
			byte ret = ImGuiPNative.CollapseButton(id, pos, dockNode);
			return ret != 0;
		}
		public static bool CollapseButton(uint id, Vector2 pos, ref ImGuiDockNode dockNode)
		{
			fixed (ImGuiDockNode* pdockNode = &dockNode)
			{
				byte ret = ImGuiPNative.CollapseButton(id, pos, (ImGuiDockNode*)pdockNode);
				return ret != 0;
			}
		}
		public static void Scrollbar(ImGuiAxis axis)
		{
			ImGuiPNative.Scrollbar(axis);
		}
		public static bool ScrollbarEx(ImRect bb, uint id, ImGuiAxis axis, long* pScrollV, long availV, long contentsV, ImDrawFlags flags)
		{
			byte ret = ImGuiPNative.ScrollbarEx(bb, id, axis, pScrollV, availV, contentsV, flags);
			return ret != 0;
		}
		public static bool ImageButtonEx(uint id, ImTextureID textureId, Vector2 size, Vector2 uv0, Vector2 uv1, Vector2 padding, Vector4 bgCol, Vector4 tintCol)
		{
			byte ret = ImGuiPNative.ImageButtonEx(id, textureId, size, uv0, uv1, padding, bgCol, tintCol);
			return ret != 0;
		}
		public static ImRect GetWindowScrollbarRect(ImGuiWindowPtr window, ImGuiAxis axis)
		{
			ImRect ret;
			ImGuiPNative.GetWindowScrollbarRect(&ret, window, axis);
			return ret;
		}
		public static void GetWindowScrollbarRect(ImRectPtr pOut, ImGuiWindowPtr window, ImGuiAxis axis)
		{
			ImGuiPNative.GetWindowScrollbarRect(pOut, window, axis);
		}
		public static void GetWindowScrollbarRect(ref ImRect pOut, ImGuiWindowPtr window, ImGuiAxis axis)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				ImGuiPNative.GetWindowScrollbarRect((ImRect*)ppOut, window, axis);
			}
		}
		public static ImRect GetWindowScrollbarRect(ref ImGuiWindow window, ImGuiAxis axis)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImRect ret;
				ImGuiPNative.GetWindowScrollbarRect(&ret, (ImGuiWindow*)pwindow, axis);
				return ret;
			}
		}
		public static void GetWindowScrollbarRect(ImRectPtr pOut, ref ImGuiWindow window, ImGuiAxis axis)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.GetWindowScrollbarRect(pOut, (ImGuiWindow*)pwindow, axis);
			}
		}
		public static void GetWindowScrollbarRect(ref ImRect pOut, ref ImGuiWindow window, ImGuiAxis axis)
		{
			fixed (ImRect* ppOut = &pOut)
			{
				fixed (ImGuiWindow* pwindow = &window)
				{
					ImGuiPNative.GetWindowScrollbarRect((ImRect*)ppOut, (ImGuiWindow*)pwindow, axis);
				}
			}
		}
		public static uint GetWindowScrollbarID(ImGuiWindowPtr window, ImGuiAxis axis)
		{
			uint ret = ImGuiPNative.GetWindowScrollbarID(window, axis);
			return ret;
		}
		public static uint GetWindowScrollbarID(ref ImGuiWindow window, ImGuiAxis axis)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				uint ret = ImGuiPNative.GetWindowScrollbarID((ImGuiWindow*)pwindow, axis);
				return ret;
			}
		}
		public static uint GetWindowResizeCornerID(ImGuiWindowPtr window, int n)
		{
			uint ret = ImGuiPNative.GetWindowResizeCornerID(window, n);
			return ret;
		}
		public static uint GetWindowResizeCornerID(ref ImGuiWindow window, int n)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				uint ret = ImGuiPNative.GetWindowResizeCornerID((ImGuiWindow*)pwindow, n);
				return ret;
			}
		}
		public static uint GetWindowResizeBorderID(ImGuiWindowPtr window, ImGuiDir dir)
		{
			uint ret = ImGuiPNative.GetWindowResizeBorderID(window, dir);
			return ret;
		}
		public static uint GetWindowResizeBorderID(ref ImGuiWindow window, ImGuiDir dir)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				uint ret = ImGuiPNative.GetWindowResizeBorderID((ImGuiWindow*)pwindow, dir);
				return ret;
			}
		}
		public static void SeparatorEx(ImGuiSeparatorFlags flags)
		{
			ImGuiPNative.SeparatorEx(flags);
		}
		public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, bool* outHeld, ImGuiButtonFlags flags)
		{
			byte ret = ImGuiPNative.ButtonBehavior(bb, id, outHovered, outHeld, flags);
			return ret != 0;
		}
		public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, bool* outHeld)
		{
			byte ret = ImGuiPNative.ButtonBehavior(bb, id, outHovered, outHeld, (ImGuiButtonFlags)(0));
			return ret != 0;
		}
		public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, bool* outHeld, ImGuiButtonFlags flags)
		{
			fixed (bool* poutHovered = &outHovered)
			{
				byte ret = ImGuiPNative.ButtonBehavior(bb, id, (bool*)poutHovered, outHeld, flags);
				return ret != 0;
			}
		}
		public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, bool* outHeld)
		{
			fixed (bool* poutHovered = &outHovered)
			{
				byte ret = ImGuiPNative.ButtonBehavior(bb, id, (bool*)poutHovered, outHeld, (ImGuiButtonFlags)(0));
				return ret != 0;
			}
		}
		public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, ref bool outHeld, ImGuiButtonFlags flags)
		{
			fixed (bool* poutHeld = &outHeld)
			{
				byte ret = ImGuiPNative.ButtonBehavior(bb, id, outHovered, (bool*)poutHeld, flags);
				return ret != 0;
			}
		}
		public static bool ButtonBehavior(ImRect bb, uint id, bool* outHovered, ref bool outHeld)
		{
			fixed (bool* poutHeld = &outHeld)
			{
				byte ret = ImGuiPNative.ButtonBehavior(bb, id, outHovered, (bool*)poutHeld, (ImGuiButtonFlags)(0));
				return ret != 0;
			}
		}
		public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, ref bool outHeld, ImGuiButtonFlags flags)
		{
			fixed (bool* poutHovered = &outHovered)
			{
				fixed (bool* poutHeld = &outHeld)
				{
					byte ret = ImGuiPNative.ButtonBehavior(bb, id, (bool*)poutHovered, (bool*)poutHeld, flags);
					return ret != 0;
				}
			}
		}
		public static bool ButtonBehavior(ImRect bb, uint id, ref bool outHovered, ref bool outHeld)
		{
			fixed (bool* poutHovered = &outHovered)
			{
				fixed (bool* poutHeld = &outHeld)
				{
					byte ret = ImGuiPNative.ButtonBehavior(bb, id, (bool*)poutHovered, (bool*)poutHeld, (ImGuiButtonFlags)(0));
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, float* size2, float minsize1, float minsize2, uint bgCol)
		{
			byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
			return ret != 0;
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, float* size2, float minsize1, float minsize2, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, size2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, float* size1, ref float size2, float minsize1, float minsize2, uint bgCol)
		{
			fixed (float* psize2 = &size2)
			{
				byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, size1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
				return ret != 0;
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, bgCol);
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, float hoverVisibilityDelay)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, hoverVisibilityDelay, (uint)(0));
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), (uint)(0));
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), (uint)(0));
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, float hoverExtend, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, hoverExtend, (float)(0.0f), bgCol);
					return ret != 0;
				}
			}
		}
		public static bool SplitterBehavior(ImRect bb, uint id, ImGuiAxis axis, ref float size1, ref float size2, float minsize1, float minsize2, uint bgCol)
		{
			fixed (float* psize1 = &size1)
			{
				fixed (float* psize2 = &size2)
				{
					byte ret = ImGuiPNative.SplitterBehavior(bb, id, axis, (float*)psize1, (float*)psize2, minsize1, minsize2, (float)(0.0f), (float)(0.0f), bgCol);
					return ret != 0;
				}
			}
		}
		public static bool TreeNodeBehaviorIsOpen(uint id, ImGuiTreeNodeFlags flags)
		{
			byte ret = ImGuiPNative.TreeNodeBehaviorIsOpen(id, flags);
			return ret != 0;
		}
		public static bool TreeNodeBehaviorIsOpen(uint id)
		{
			byte ret = ImGuiPNative.TreeNodeBehaviorIsOpen(id, (ImGuiTreeNodeFlags)(0));
			return ret != 0;
		}
		public static void TreePushOverrideID(uint id)
		{
			ImGuiPNative.TreePushOverrideID(id);
		}
		public static ImGuiDataTypeInfoPtr DataTypeGetInfo(ImGuiDataType dataType)
		{
			ImGuiDataTypeInfoPtr ret = ImGuiPNative.DataTypeGetInfo(dataType);
			return ret;
		}
		public static void DataTypeApplyOp(ImGuiDataType dataType, int op, void* output, void* arg1, void* arg2)
		{
			ImGuiPNative.DataTypeApplyOp(dataType, op, output, arg1, arg2);
		}
		public static int DataTypeCompare(ImGuiDataType dataType, void* arg1, void* arg2)
		{
			int ret = ImGuiPNative.DataTypeCompare(dataType, arg1, arg2);
			return ret;
		}
		public static bool DataTypeClamp(ImGuiDataType dataType, void* pData, void* pMin, void* pMax)
		{
			byte ret = ImGuiPNative.DataTypeClamp(dataType, pData, pMin, pMax);
			return ret != 0;
		}
		public static bool TempInputIsActive(uint id)
		{
			byte ret = ImGuiPNative.TempInputIsActive(id);
			return ret != 0;
		}
		public static ImGuiInputTextStatePtr GetInputTextState(uint id)
		{
			ImGuiInputTextStatePtr ret = ImGuiPNative.GetInputTextState(id);
			return ret;
		}
		public static void ShadeVertsLinearColorGradientKeepAlpha(ImDrawListPtr drawList, int vertStartIdx, int vertEndIdx, Vector2 gradientp0, Vector2 gradientp1, uint col0, uint col1)
		{
			ImGuiPNative.ShadeVertsLinearColorGradientKeepAlpha(drawList, vertStartIdx, vertEndIdx, gradientp0, gradientp1, col0, col1);
		}
		public static void ShadeVertsLinearColorGradientKeepAlpha(ref ImDrawList drawList, int vertStartIdx, int vertEndIdx, Vector2 gradientp0, Vector2 gradientp1, uint col0, uint col1)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.ShadeVertsLinearColorGradientKeepAlpha((ImDrawList*)pdrawList, vertStartIdx, vertEndIdx, gradientp0, gradientp1, col0, col1);
			}
		}
		public static void ShadeVertsLinearUV(ImDrawListPtr drawList, int vertStartIdx, int vertEndIdx, Vector2 a, Vector2 b, Vector2 uvA, Vector2 uvB, bool clamp)
		{
			ImGuiPNative.ShadeVertsLinearUV(drawList, vertStartIdx, vertEndIdx, a, b, uvA, uvB, clamp ? (byte)1 : (byte)0);
		}
		public static void ShadeVertsLinearUV(ref ImDrawList drawList, int vertStartIdx, int vertEndIdx, Vector2 a, Vector2 b, Vector2 uvA, Vector2 uvB, bool clamp)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.ShadeVertsLinearUV((ImDrawList*)pdrawList, vertStartIdx, vertEndIdx, a, b, uvA, uvB, clamp ? (byte)1 : (byte)0);
			}
		}
		public static void GcCompactTransientMiscBuffers()
		{
			ImGuiPNative.GcCompactTransientMiscBuffers();
		}
		public static void GcCompactTransientWindowBuffers(ImGuiWindowPtr window)
		{
			ImGuiPNative.GcCompactTransientWindowBuffers(window);
		}
		public static void GcCompactTransientWindowBuffers(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.GcCompactTransientWindowBuffers((ImGuiWindow*)pwindow);
			}
		}
		public static void GcAwakeTransientWindowBuffers(ImGuiWindowPtr window)
		{
			ImGuiPNative.GcAwakeTransientWindowBuffers(window);
		}
		public static void GcAwakeTransientWindowBuffers(ref ImGuiWindow window)
		{
			fixed (ImGuiWindow* pwindow = &window)
			{
				ImGuiPNative.GcAwakeTransientWindowBuffers((ImGuiWindow*)pwindow);
			}
		}
		public static void ErrorCheckEndFrameRecover(ImGuiErrorLogCallback logCallback, void* userData)
		{
			ImGuiPNative.ErrorCheckEndFrameRecover(logCallback, userData);
		}
		public static void ErrorCheckEndFrameRecover(ImGuiErrorLogCallback logCallback)
		{
			ImGuiPNative.ErrorCheckEndFrameRecover(logCallback, (void*)(default));
		}
		public static void ErrorCheckEndWindowRecover(ImGuiErrorLogCallback logCallback, void* userData)
		{
			ImGuiPNative.ErrorCheckEndWindowRecover(logCallback, userData);
		}
		public static void ErrorCheckEndWindowRecover(ImGuiErrorLogCallback logCallback)
		{
			ImGuiPNative.ErrorCheckEndWindowRecover(logCallback, (void*)(default));
		}
		public static void DebugDrawItemRect(uint col)
		{
			ImGuiPNative.DebugDrawItemRect(col);
		}
		public static void DebugDrawItemRect()
		{
			ImGuiPNative.DebugDrawItemRect((uint)(4278190335));
		}
		public static void DebugStartItemPicker()
		{
			ImGuiPNative.DebugStartItemPicker();
		}
		public static void ShowFontAtlas(ImFontAtlasPtr atlas)
		{
			ImGuiPNative.ShowFontAtlas(atlas);
		}
		public static void ShowFontAtlas(ref ImFontAtlas atlas)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				ImGuiPNative.ShowFontAtlas((ImFontAtlas*)patlas);
			}
		}
		public static void DebugHookIdInfo(uint id, ImGuiDataType dataType, void* dataId, void* dataIdEnd)
		{
			ImGuiPNative.DebugHookIdInfo(id, dataType, dataId, dataIdEnd);
		}
		public static void DebugNodeColumns(ImGuiOldColumnsPtr columns)
		{
			ImGuiPNative.DebugNodeColumns(columns);
		}
		public static void DebugNodeColumns(ref ImGuiOldColumns columns)
		{
			fixed (ImGuiOldColumns* pcolumns = &columns)
			{
				ImGuiPNative.DebugNodeColumns((ImGuiOldColumns*)pcolumns);
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawListPtr outDrawList, ImDrawListPtr drawList, ImDrawCmdPtr drawCmd, bool showMesh, bool showAabb)
		{
			ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox(outDrawList, drawList, drawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ref ImDrawList outDrawList, ImDrawListPtr drawList, ImDrawCmdPtr drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* poutDrawList = &outDrawList)
			{
				ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox((ImDrawList*)poutDrawList, drawList, drawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawListPtr outDrawList, ref ImDrawList drawList, ImDrawCmdPtr drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox(outDrawList, (ImDrawList*)pdrawList, drawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ref ImDrawList outDrawList, ref ImDrawList drawList, ImDrawCmdPtr drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* poutDrawList = &outDrawList)
			{
				fixed (ImDrawList* pdrawList = &drawList)
				{
					ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox((ImDrawList*)poutDrawList, (ImDrawList*)pdrawList, drawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawListPtr outDrawList, ImDrawListPtr drawList, ref ImDrawCmd drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawCmd* pdrawCmd = &drawCmd)
			{
				ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox(outDrawList, drawList, (ImDrawCmd*)pdrawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ref ImDrawList outDrawList, ImDrawListPtr drawList, ref ImDrawCmd drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* poutDrawList = &outDrawList)
			{
				fixed (ImDrawCmd* pdrawCmd = &drawCmd)
				{
					ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox((ImDrawList*)poutDrawList, drawList, (ImDrawCmd*)pdrawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawListPtr outDrawList, ref ImDrawList drawList, ref ImDrawCmd drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				fixed (ImDrawCmd* pdrawCmd = &drawCmd)
				{
					ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox(outDrawList, (ImDrawList*)pdrawList, (ImDrawCmd*)pdrawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
				}
			}
		}
		public static void DebugNodeDrawCmdShowMeshAndBoundingBox(ref ImDrawList outDrawList, ref ImDrawList drawList, ref ImDrawCmd drawCmd, bool showMesh, bool showAabb)
		{
			fixed (ImDrawList* poutDrawList = &outDrawList)
			{
				fixed (ImDrawList* pdrawList = &drawList)
				{
					fixed (ImDrawCmd* pdrawCmd = &drawCmd)
					{
						ImGuiPNative.DebugNodeDrawCmdShowMeshAndBoundingBox((ImDrawList*)poutDrawList, (ImDrawList*)pdrawList, (ImDrawCmd*)pdrawCmd, showMesh ? (byte)1 : (byte)0, showAabb ? (byte)1 : (byte)0);
					}
				}
			}
		}
		public static void DebugNodeFont(ImFontPtr font)
		{
			ImGuiPNative.DebugNodeFont(font);
		}
		public static void DebugNodeFont(ref ImFont font)
		{
			fixed (ImFont* pfont = &font)
			{
				ImGuiPNative.DebugNodeFont((ImFont*)pfont);
			}
		}
		public static void DebugNodeFontGlyph(ImFontPtr font, ImFontGlyphPtr glyph)
		{
			ImGuiPNative.DebugNodeFontGlyph(font, glyph);
		}
		public static void DebugNodeFontGlyph(ref ImFont font, ImFontGlyphPtr glyph)
		{
			fixed (ImFont* pfont = &font)
			{
				ImGuiPNative.DebugNodeFontGlyph((ImFont*)pfont, glyph);
			}
		}
		public static void DebugNodeFontGlyph(ImFontPtr font, ref ImFontGlyph glyph)
		{
			fixed (ImFontGlyph* pglyph = &glyph)
			{
				ImGuiPNative.DebugNodeFontGlyph(font, (ImFontGlyph*)pglyph);
			}
		}
		public static void DebugNodeFontGlyph(ref ImFont font, ref ImFontGlyph glyph)
		{
			fixed (ImFont* pfont = &font)
			{
				fixed (ImFontGlyph* pglyph = &glyph)
				{
					ImGuiPNative.DebugNodeFontGlyph((ImFont*)pfont, (ImFontGlyph*)pglyph);
				}
			}
		}
		public static void DebugNodeTable(ImGuiTablePtr table)
		{
			ImGuiPNative.DebugNodeTable(table);
		}
		public static void DebugNodeTable(ref ImGuiTable table)
		{
			fixed (ImGuiTable* ptable = &table)
			{
				ImGuiPNative.DebugNodeTable((ImGuiTable*)ptable);
			}
		}
		public static void DebugNodeTableSettings(ImGuiTableSettingsPtr settings)
		{
			ImGuiPNative.DebugNodeTableSettings(settings);
		}
		public static void DebugNodeTableSettings(ref ImGuiTableSettings settings)
		{
			fixed (ImGuiTableSettings* psettings = &settings)
			{
				ImGuiPNative.DebugNodeTableSettings((ImGuiTableSettings*)psettings);
			}
		}
		public static void DebugNodeInputTextState(ImGuiInputTextStatePtr state)
		{
			ImGuiPNative.DebugNodeInputTextState(state);
		}
		public static void DebugNodeInputTextState(ref ImGuiInputTextState state)
		{
			fixed (ImGuiInputTextState* pstate = &state)
			{
				ImGuiPNative.DebugNodeInputTextState((ImGuiInputTextState*)pstate);
			}
		}
		public static void DebugNodeWindowSettings(ImGuiWindowSettingsPtr settings)
		{
			ImGuiPNative.DebugNodeWindowSettings(settings);
		}
		public static void DebugNodeWindowSettings(ref ImGuiWindowSettings settings)
		{
			fixed (ImGuiWindowSettings* psettings = &settings)
			{
				ImGuiPNative.DebugNodeWindowSettings((ImGuiWindowSettings*)psettings);
			}
		}
		public static void DebugNodeWindowsListByBeginStackParent(ImGuiWindowPtrPtr windows, int windowsSize, ImGuiWindowPtr parentInBeginStack)
		{
			ImGuiPNative.DebugNodeWindowsListByBeginStackParent(windows, windowsSize, parentInBeginStack);
		}
		public static void DebugNodeWindowsListByBeginStackParent(ref ImGuiWindow* windows, int windowsSize, ImGuiWindowPtr parentInBeginStack)
		{
			fixed (ImGuiWindow** pwindows = &windows)
			{
				ImGuiPNative.DebugNodeWindowsListByBeginStackParent((ImGuiWindow**)pwindows, windowsSize, parentInBeginStack);
			}
		}
		public static void DebugNodeWindowsListByBeginStackParent(ImGuiWindowPtrPtr windows, int windowsSize, ref ImGuiWindow parentInBeginStack)
		{
			fixed (ImGuiWindow* pparentInBeginStack = &parentInBeginStack)
			{
				ImGuiPNative.DebugNodeWindowsListByBeginStackParent(windows, windowsSize, (ImGuiWindow*)pparentInBeginStack);
			}
		}
		public static void DebugNodeWindowsListByBeginStackParent(ref ImGuiWindow* windows, int windowsSize, ref ImGuiWindow parentInBeginStack)
		{
			fixed (ImGuiWindow** pwindows = &windows)
			{
				fixed (ImGuiWindow* pparentInBeginStack = &parentInBeginStack)
				{
					ImGuiPNative.DebugNodeWindowsListByBeginStackParent((ImGuiWindow**)pwindows, windowsSize, (ImGuiWindow*)pparentInBeginStack);
				}
			}
		}
		public static void DebugNodeViewport(ImGuiViewportPPtr viewport)
		{
			ImGuiPNative.DebugNodeViewport(viewport);
		}
		public static void DebugNodeViewport(ref ImGuiViewportP viewport)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.DebugNodeViewport((ImGuiViewportP*)pviewport);
			}
		}
		public static void DebugRenderViewportThumbnail(ImDrawListPtr drawList, ImGuiViewportPPtr viewport, ImRect bb)
		{
			ImGuiPNative.DebugRenderViewportThumbnail(drawList, viewport, bb);
		}
		public static void DebugRenderViewportThumbnail(ref ImDrawList drawList, ImGuiViewportPPtr viewport, ImRect bb)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				ImGuiPNative.DebugRenderViewportThumbnail((ImDrawList*)pdrawList, viewport, bb);
			}
		}
		public static void DebugRenderViewportThumbnail(ImDrawListPtr drawList, ref ImGuiViewportP viewport, ImRect bb)
		{
			fixed (ImGuiViewportP* pviewport = &viewport)
			{
				ImGuiPNative.DebugRenderViewportThumbnail(drawList, (ImGuiViewportP*)pviewport, bb);
			}
		}
		public static void DebugRenderViewportThumbnail(ref ImDrawList drawList, ref ImGuiViewportP viewport, ImRect bb)
		{
			fixed (ImDrawList* pdrawList = &drawList)
			{
				fixed (ImGuiViewportP* pviewport = &viewport)
				{
					ImGuiPNative.DebugRenderViewportThumbnail((ImDrawList*)pdrawList, (ImGuiViewportP*)pviewport, bb);
				}
			}
		}
		public static ImFontBuilderIOPtr ImFontAtlasGetBuilderForStbTruetype()
		{
			ImFontBuilderIOPtr ret = ImGuiPNative.ImFontAtlasGetBuilderForStbTruetype();
			return ret;
		}
		public static void ImFontAtlasBuildInit(ImFontAtlasPtr atlas)
		{
			ImGuiPNative.ImFontAtlasBuildInit(atlas);
		}
		public static void ImFontAtlasBuildInit(ref ImFontAtlas atlas)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				ImGuiPNative.ImFontAtlasBuildInit((ImFontAtlas*)patlas);
			}
		}
		public static void ImFontAtlasBuildSetupFont(ImFontAtlasPtr atlas, ImFontPtr font, ImFontConfigPtr fontConfig, float ascent, float descent)
		{
			ImGuiPNative.ImFontAtlasBuildSetupFont(atlas, font, fontConfig, ascent, descent);
		}
		public static void ImFontAtlasBuildSetupFont(ref ImFontAtlas atlas, ImFontPtr font, ImFontConfigPtr fontConfig, float ascent, float descent)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				ImGuiPNative.ImFontAtlasBuildSetupFont((ImFontAtlas*)patlas, font, fontConfig, ascent, descent);
			}
		}
		public static void ImFontAtlasBuildSetupFont(ImFontAtlasPtr atlas, ref ImFont font, ImFontConfigPtr fontConfig, float ascent, float descent)
		{
			fixed (ImFont* pfont = &font)
			{
				ImGuiPNative.ImFontAtlasBuildSetupFont(atlas, (ImFont*)pfont, fontConfig, ascent, descent);
			}
		}
		public static void ImFontAtlasBuildSetupFont(ref ImFontAtlas atlas, ref ImFont font, ImFontConfigPtr fontConfig, float ascent, float descent)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				fixed (ImFont* pfont = &font)
				{
					ImGuiPNative.ImFontAtlasBuildSetupFont((ImFontAtlas*)patlas, (ImFont*)pfont, fontConfig, ascent, descent);
				}
			}
		}
		public static void ImFontAtlasBuildSetupFont(ImFontAtlasPtr atlas, ImFontPtr font, ref ImFontConfig fontConfig, float ascent, float descent)
		{
			fixed (ImFontConfig* pfontConfig = &fontConfig)
			{
				ImGuiPNative.ImFontAtlasBuildSetupFont(atlas, font, (ImFontConfig*)pfontConfig, ascent, descent);
			}
		}
		public static void ImFontAtlasBuildSetupFont(ref ImFontAtlas atlas, ImFontPtr font, ref ImFontConfig fontConfig, float ascent, float descent)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				fixed (ImFontConfig* pfontConfig = &fontConfig)
				{
					ImGuiPNative.ImFontAtlasBuildSetupFont((ImFontAtlas*)patlas, font, (ImFontConfig*)pfontConfig, ascent, descent);
				}
			}
		}
		public static void ImFontAtlasBuildSetupFont(ImFontAtlasPtr atlas, ref ImFont font, ref ImFontConfig fontConfig, float ascent, float descent)
		{
			fixed (ImFont* pfont = &font)
			{
				fixed (ImFontConfig* pfontConfig = &fontConfig)
				{
					ImGuiPNative.ImFontAtlasBuildSetupFont(atlas, (ImFont*)pfont, (ImFontConfig*)pfontConfig, ascent, descent);
				}
			}
		}
		public static void ImFontAtlasBuildSetupFont(ref ImFontAtlas atlas, ref ImFont font, ref ImFontConfig fontConfig, float ascent, float descent)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				fixed (ImFont* pfont = &font)
				{
					fixed (ImFontConfig* pfontConfig = &fontConfig)
					{
						ImGuiPNative.ImFontAtlasBuildSetupFont((ImFontAtlas*)patlas, (ImFont*)pfont, (ImFontConfig*)pfontConfig, ascent, descent);
					}
				}
			}
		}
		public static void ImFontAtlasBuildFinish(ImFontAtlasPtr atlas)
		{
			ImGuiPNative.ImFontAtlasBuildFinish(atlas);
		}
		public static void ImFontAtlasBuildFinish(ref ImFontAtlas atlas)
		{
			fixed (ImFontAtlas* patlas = &atlas)
			{
				ImGuiPNative.ImFontAtlasBuildFinish((ImFontAtlas*)patlas);
			}
		}
		public static void ImFontAtlasBuildMultiplyCalcLookupTable(byte* outTable, float inMultiplyFactor, float gammaFactor)
		{
			ImGuiPNative.ImFontAtlasBuildMultiplyCalcLookupTable(outTable, inMultiplyFactor, gammaFactor);
		}
		public static void ImFontAtlasBuildMultiplyCalcLookupTable(ref byte outTable, float inMultiplyFactor, float gammaFactor)
		{
			fixed (byte* poutTable = &outTable)
			{
				ImGuiPNative.ImFontAtlasBuildMultiplyCalcLookupTable((byte*)poutTable, inMultiplyFactor, gammaFactor);
			}
		}
		public static void ImFontAtlasBuildMultiplyCalcLookupTable(ReadOnlySpan<byte> outTable, float inMultiplyFactor, float gammaFactor)
		{
			fixed (byte* poutTable = outTable)
			{
				ImGuiPNative.ImFontAtlasBuildMultiplyCalcLookupTable((byte*)poutTable, inMultiplyFactor, gammaFactor);
			}
		}
}
// DISCARDED: internal static byte ArrowButtonExNative(byte* strId, ImGuiDir dir, Vector2 sizeArg, ImGuiButtonFlags flags)
// DISCARDED: internal static byte BeginChildExNative(byte* name, uint id, Vector2 sizeArg, byte border, ImGuiWindowFlags flags)
// DISCARDED: internal static void BeginColumnsNative(byte* strId, int count, ImGuiOldColumnFlags flags)
// DISCARDED: internal static byte BeginMenuExNative(byte* label, byte* icon, byte enabled)
// DISCARDED: internal static byte BeginTableExNative(byte* name, uint id, int columnsCount, ImGuiTableFlags flags, Vector2 outerSize, float innerWidth)
// DISCARDED: internal static byte BeginViewportSideBarNative(byte* name, ImGuiViewport* viewport, ImGuiDir dir, float size, ImGuiWindowFlags windowFlags)
// DISCARDED: internal static byte ButtonExNative(byte* label, Vector2 sizeArg, ImGuiButtonFlags flags)
// DISCARDED: internal static byte CheckboxFlagsNative(byte* label, long* flags, long flagsValue)
// DISCARDED: internal static byte CheckboxFlagsNative(byte* label, ulong* flags, ulong flagsValue)
// DISCARDED: internal static void ColorEditOptionsPopupNative(float* col, ImGuiColorEditFlags flags)
// DISCARDED: internal static void ColorPickerOptionsPopupNative(float* refCol, ImGuiColorEditFlags flags)
// DISCARDED: internal static void ColorTooltipNative(byte* text, float* col, ImGuiColorEditFlags flags)
// DISCARDED: internal static ImGuiWindowSettings* CreateNewWindowSettingsNative(byte* name)
// DISCARDED: internal static void Custom_StbTextMakeUndoReplaceNative(ImGuiInputTextState* str, int where, int oldLength, int newLength)
// DISCARDED: internal static void Custom_StbTextUndoNative(ImGuiInputTextState* str)
// DISCARDED: internal static byte DataTypeApplyFromTextNative(byte* buf, ImGuiDataType dataType, void* pData, byte* format)
// DISCARDED: internal static void DebugLogNative(byte* fmt)
// DISCARDED: internal static void DebugLogVNative(byte* fmt, nuint args)
// DISCARDED: internal static void DebugNodeDockNodeNative(ImGuiDockNode* node, byte* label)
// DISCARDED: internal static void DebugNodeDrawListNative(ImGuiWindow* window, ImGuiViewportP* viewport, ImDrawList* drawList, byte* label)
// DISCARDED: internal static void DebugNodeStorageNative(ImGuiStorage* storage, byte* label)
// DISCARDED: internal static void DebugNodeTabBarNative(ImGuiTabBar* tabBar, byte* label)
// DISCARDED: internal static void DebugNodeWindowNative(ImGuiWindow* window, byte* label)
// DISCARDED: internal static void DebugNodeWindowsListNative(ImVector<ImGuiWindowPtr>* windows, byte* label)
// DISCARDED: internal static void DockBuilderCopyWindowSettingsNative(byte* srcName, byte* dstName)
// DISCARDED: internal static void DockBuilderDockWindowNative(byte* windowName, uint nodeId)
// DISCARDED: internal static byte DragBehaviorNative(uint id, ImGuiDataType dataType, void* pV, float vSpeed, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags)
// DISCARDED: internal static ImGuiWindowSettings* FindOrCreateWindowSettingsNative(byte* name)
// DISCARDED: internal static byte* FindRenderedTextEndNative(byte* text, byte* textEnd)
// DISCARDED: FindRenderedTextEndS
// DISCARDED: internal static ImGuiSettingsHandler* FindSettingsHandlerNative(byte* typeName)
// DISCARDED: internal static ImGuiWindow* FindWindowByNameNative(byte* name)
// DISCARDED: internal static uint GetColumnsIDNative(byte* strId, int count)
// DISCARDED: internal static uint GetIDNative(ImGuiWindow* self, byte* str, byte* strEnd)
// DISCARDED: internal static uint GetIDNative(ImGuiWindow* self, void* ptr)
// DISCARDED: internal static uint GetIDNative(ImGuiWindow* self, int n)
// DISCARDED: internal static uint GetIDWithSeedNative(byte* strIdBegin, byte* strIdEnd, uint seed)
// DISCARDED: internal static byte* GetNameNative(ImGuiWindowSettings* self)
// DISCARDED: GetNameS
// DISCARDED: internal static byte* GetNavInputNameNative(ImGuiNavInput n)
// DISCARDED: GetNavInputNameS
// DISCARDED: internal static byte* GetTabNameNative(ImGuiTabBar* self, ImGuiTabItem* tab)
// DISCARDED: GetTabNameS
// DISCARDED: internal static void* ImFileLoadToMemoryNative(byte* filename, byte* mode, nuint* outFileSize, int paddingBytes)
// DISCARDED: internal static ImFileHandle ImFileOpenNative(byte* filename, byte* mode)
// DISCARDED: internal static void ImFontAtlasBuildMultiplyRectAlpha8Native(byte* table, byte* pixels, int x, int y, int w, int h, int stride)
// DISCARDED: internal static void ImFontAtlasBuildRender32bppRectFromStringNative(ImFontAtlas* atlas, int textureIndex, int x, int y, int w, int h, byte* inStr, byte inMarkerChar, uint inMarkerPixelValue)
// DISCARDED: internal static void ImFontAtlasBuildRender8bppRectFromStringNative(ImFontAtlas* atlas, int textureIndex, int x, int y, int w, int h, byte* inStr, byte inMarkerChar, byte inMarkerPixelValue)
// DISCARDED: internal static void ImFormatStringToTempBufferNative(byte** outBuf, byte** outBufEnd, byte* fmt)
// DISCARDED: internal static void ImFormatStringToTempBufferVNative(byte** outBuf, byte** outBufEnd, byte* fmt, nuint args)
// DISCARDED: internal static ImGuiWindow* ImGuiWindowNative(ImGuiContext* context, byte* name)
// DISCARDED: internal static uint ImHashDataNative(void* data, nuint dataSize, uint seed)
// DISCARDED: internal static uint ImHashStrNative(byte* data, nuint dataSize, uint seed)
// DISCARDED: internal static byte* ImParseFormatFindEndNative(byte* format)
// DISCARDED: ImParseFormatFindEndS
// DISCARDED: internal static byte* ImParseFormatFindStartNative(byte* format)
// DISCARDED: ImParseFormatFindStartS
// DISCARDED: internal static int ImParseFormatPrecisionNative(byte* format, int defaultValue)
// DISCARDED: internal static void ImParseFormatSanitizeForPrintingNative(byte* fmtIn, byte* fmtOut, nuint fmtOutSize)
// DISCARDED: internal static byte* ImParseFormatSanitizeForScanningNative(byte* fmtIn, byte* fmtOut, nuint fmtOutSize)
// DISCARDED: ImParseFormatSanitizeForScanningS
// DISCARDED: internal static byte* ImStrchrRangeNative(byte* strBegin, byte* strEnd, byte c)
// DISCARDED: ImStrchrRangeS
// DISCARDED: internal static byte* ImStrdupNative(byte* str)
// DISCARDED: internal static byte* ImStrdupcpyNative(byte* dst, nuint* pDstSize, byte* str)
// DISCARDED: ImStrdupcpyS
// DISCARDED: ImStrdupS
// DISCARDED: internal static byte* ImStreolRangeNative(byte* str, byte* strEnd)
// DISCARDED: ImStreolRangeS
// DISCARDED: internal static int ImStricmpNative(byte* str1, byte* str2)
// DISCARDED: internal static byte* ImStristrNative(byte* haystack, byte* haystackEnd, byte* needle, byte* needleEnd)
// DISCARDED: ImStristrS
// DISCARDED: internal static int ImStrlenWNative(ushort* str)
// DISCARDED: internal static void ImStrncpyNative(byte* dst, byte* src, nuint count)
// DISCARDED: internal static int ImStrnicmpNative(byte* str1, byte* str2, nuint count)
// DISCARDED: internal static byte* ImStrSkipBlankNative(byte* str)
// DISCARDED: ImStrSkipBlankS
// DISCARDED: internal static void ImStrTrimBlanksNative(byte* str)
// DISCARDED: internal static int ImTextCharFromUtf8Native(uint* outChar, byte* inText, byte* inTextEnd)
// DISCARDED: internal static byte* ImTextCharToUtf8Native(byte* outBuf, uint c)
// DISCARDED: ImTextCharToUtf8S
// DISCARDED: internal static int ImTextCountCharsFromUtf8Native(byte* inText, byte* inTextEnd)
// DISCARDED: internal static int ImTextCountUtf8BytesFromCharNative(byte* inText, byte* inTextEnd)
// DISCARDED: internal static void LogRenderedTextNative(Vector2* refPos, byte* text, byte* textEnd)
// DISCARDED: internal static void LogSetNextTextDecorationNative(byte* prefix, byte* suffix)
// DISCARDED: internal static byte MenuItemExNative(byte* label, byte* icon, byte* shortcut, byte selected, byte enabled)
// DISCARDED: internal static int PlotExNative(ImGuiPlotType plotType, byte* label, delegate*<ImGuiPlotType, byte*, delegate*<void*, int, float>, void*, int, int, byte*, float, float, Vector2, float> valuesGetter, void* data, int valuesCount, int valuesOffset, byte* overlayText, float scaleMin, float scaleMax, Vector2 frameSize)
// DISCARDED: internal static void RemoveSettingsHandlerNative(byte* typeName)
// DISCARDED: internal static void RenderTextNative(Vector2 pos, byte* text, byte* textEnd, byte hideTextAfterHash)
// DISCARDED: internal static void RenderTextClippedNative(Vector2 posMin, Vector2 posMax, byte* text, byte* textEnd, Vector2* textSizeIfKnown, Vector2 align, ImRect* clipRect)
// DISCARDED: internal static void RenderTextClippedExNative(ImDrawList* drawList, Vector2 posMin, Vector2 posMax, byte* text, byte* textEnd, Vector2* textSizeIfKnown, Vector2 align, ImRect* clipRect)
// DISCARDED: internal static void RenderTextEllipsisNative(ImDrawList* drawList, Vector2 posMin, Vector2 posMax, float clipMaxX, float ellipsisMaxX, byte* text, byte* textEnd, Vector2* textSizeIfKnown)
// DISCARDED: internal static void RenderTextWrappedNative(Vector2 pos, byte* text, byte* textEnd, float wrapWidth)
// DISCARDED: internal static byte SliderBehaviorNative(ImRect bb, uint id, ImGuiDataType dataType, void* pV, void* pMin, void* pMax, byte* format, ImGuiSliderFlags flags, ImRect* outGrabBb)
// DISCARDED: internal static void TabItemCalcSizeNative(Vector2* pOut, byte* label, byte hasCloseButton)
// DISCARDED: internal static byte TabItemExNative(ImGuiTabBar* tabBar, byte* label, bool* pOpen, ImGuiTabItemFlags flags, ImGuiWindow* dockedWindow)
// DISCARDED: internal static void TabItemLabelAndCloseButtonNative(ImDrawList* drawList, ImRect bb, ImGuiTabItemFlags flags, Vector2 framePadding, byte* label, uint tabId, uint closeButtonId, byte isContentsVisible, bool* outJustClosed, bool* outTextClipped)
// DISCARDED: internal static byte* TableGetColumnNameNative(ImGuiTable* table, int columnN)
// DISCARDED: TableGetColumnNameS
// DISCARDED: internal static byte TempInputScalarNative(ImRect bb, uint id, byte* label, ImGuiDataType dataType, void* pData, byte* format, void* pClampMin, void* pClampMax)
// DISCARDED: internal static void TextExNative(byte* text, byte* textEnd, ImGuiTextFlags flags)
// DISCARDED: internal static byte TreeNodeBehaviorNative(uint id, ImGuiTreeNodeFlags flags, byte* label, byte* labelEnd)