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

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using HexaGen.Runtime;
using System.Numerics;
using Dalamud.Bindings.ImGui;

namespace Dalamud.Bindings.ImGuizmo
{
	public unsafe partial class ImGuizmo
	{
		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetDrawlistNative(ImDrawList* drawlist)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[0])(drawlist);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[0])((nint)drawlist);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetDrawlist(ImDrawListPtr drawlist)
		{
			SetDrawlistNative(drawlist);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetDrawlist()
		{
			SetDrawlistNative((ImDrawList*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetDrawlist(ref ImDrawList drawlist)
		{
			fixed (ImDrawList* pdrawlist = &drawlist)
			{
				SetDrawlistNative((ImDrawList*)pdrawlist);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void BeginFrameNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[1])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[1])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BeginFrame()
		{
			BeginFrameNative();
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetImGuiContext(ImGuiContextPtr ctx)
		{
			SetImGuiContextNative(ctx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetImGuiContext(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				SetImGuiContextNative((ImGuiContext*)pctx);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsOver()
		{
			byte ret = IsOverNative();
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsUsing()
		{
			byte ret = IsUsingNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EnableNative(byte enable)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[5])(enable);
			#else
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[5])(enable);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Enable(bool enable)
		{
			EnableNative(enable ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DecomposeMatrixToComponentsNative(float* matrix, float* translation, float* rotation, float* scale)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float*, float*, float*, float*, void>)funcTable[6])(matrix, translation, rotation, scale);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, nint, void>)funcTable[6])((nint)matrix, (nint)translation, (nint)rotation, (nint)scale);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, float* scale)
		{
			DecomposeMatrixToComponentsNative(matrix, translation, rotation, scale);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref Matrix4x4 matrix, ref Matrix4x4 translation, ref Matrix4x4 rotation, ref Matrix4x4 scale)
		{
			fixed (Matrix4x4* pmatrix = &matrix)
			{
				fixed (Matrix4x4* ptranslation = &translation)
				{
					fixed (Matrix4x4* protation = &rotation)
					{
						fixed (Matrix4x4* pscale = &scale)
						{
							DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, (float*)pscale);
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, float* translation, float* rotation, float* scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				DecomposeMatrixToComponentsNative((float*)pmatrix, translation, rotation, scale);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, ref float translation, float* rotation, float* scale)
		{
			fixed (float* ptranslation = &translation)
			{
				DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, rotation, scale);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, float* rotation, float* scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* ptranslation = &translation)
				{
					DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, rotation, scale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, float* translation, ref float rotation, float* scale)
		{
			fixed (float* protation = &rotation)
			{
				DecomposeMatrixToComponentsNative(matrix, translation, (float*)protation, scale);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, float* translation, ref float rotation, float* scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* protation = &rotation)
				{
					DecomposeMatrixToComponentsNative((float*)pmatrix, translation, (float*)protation, scale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, ref float translation, ref float rotation, float* scale)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, (float*)protation, scale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, float* scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* ptranslation = &translation)
				{
					fixed (float* protation = &rotation)
					{
						DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, scale);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, ref float scale)
		{
			fixed (float* pscale = &scale)
			{
				DecomposeMatrixToComponentsNative(matrix, translation, rotation, (float*)pscale);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, float* translation, float* rotation, ref float scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pscale = &scale)
				{
					DecomposeMatrixToComponentsNative((float*)pmatrix, translation, rotation, (float*)pscale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, ref float translation, float* rotation, ref float scale)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* pscale = &scale)
				{
					DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, rotation, (float*)pscale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, float* rotation, ref float scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* ptranslation = &translation)
				{
					fixed (float* pscale = &scale)
					{
						DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, rotation, (float*)pscale);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, float* translation, ref float rotation, ref float scale)
		{
			fixed (float* protation = &rotation)
			{
				fixed (float* pscale = &scale)
				{
					DecomposeMatrixToComponentsNative(matrix, translation, (float*)protation, (float*)pscale);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, float* translation, ref float rotation, ref float scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* protation = &rotation)
				{
					fixed (float* pscale = &scale)
					{
						DecomposeMatrixToComponentsNative((float*)pmatrix, translation, (float*)protation, (float*)pscale);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(float* matrix, ref float translation, ref float rotation, ref float scale)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					fixed (float* pscale = &scale)
					{
						DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, (float*)protation, (float*)pscale);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, ref float scale)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* ptranslation = &translation)
				{
					fixed (float* protation = &rotation)
					{
						fixed (float* pscale = &scale)
						{
							DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, (float*)pscale);
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void RecomposeMatrixFromComponentsNative(float* translation, float* rotation, float* scale, float* matrix)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float*, float*, float*, float*, void>)funcTable[7])(translation, rotation, scale, matrix);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, nint, void>)funcTable[7])((nint)translation, (nint)rotation, (nint)scale, (nint)matrix);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, float* matrix)
		{
			RecomposeMatrixFromComponentsNative(translation, rotation, scale, matrix);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref Matrix4x4 translation, ref Matrix4x4 rotation, ref Matrix4x4 scale, ref Matrix4x4 matrix)
		{
			fixed (Matrix4x4* ptranslation = &translation)
			{
				fixed (Matrix4x4* protation = &rotation)
				{
					fixed (Matrix4x4* pscale = &scale)
					{
						fixed (Matrix4x4* pmatrix = &matrix)
						{
							RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, (float*)pmatrix);
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, float* scale, float* matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, scale, matrix);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, float* scale, float* matrix)
		{
			fixed (float* protation = &rotation)
			{
				RecomposeMatrixFromComponentsNative(translation, (float*)protation, scale, matrix);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, float* scale, float* matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, scale, matrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, float* rotation, ref float scale, float* matrix)
		{
			fixed (float* pscale = &scale)
			{
				RecomposeMatrixFromComponentsNative(translation, rotation, (float*)pscale, matrix);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, ref float scale, float* matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* pscale = &scale)
				{
					RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, (float*)pscale, matrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, ref float scale, float* matrix)
		{
			fixed (float* protation = &rotation)
			{
				fixed (float* pscale = &scale)
				{
					RecomposeMatrixFromComponentsNative(translation, (float*)protation, (float*)pscale, matrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, float* matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					fixed (float* pscale = &scale)
					{
						RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, matrix);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, ref float matrix)
		{
			fixed (float* pmatrix = &matrix)
			{
				RecomposeMatrixFromComponentsNative(translation, rotation, scale, (float*)pmatrix);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, float* scale, ref float matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* pmatrix = &matrix)
				{
					RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, scale, (float*)pmatrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, float* scale, ref float matrix)
		{
			fixed (float* protation = &rotation)
			{
				fixed (float* pmatrix = &matrix)
				{
					RecomposeMatrixFromComponentsNative(translation, (float*)protation, scale, (float*)pmatrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, float* scale, ref float matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					fixed (float* pmatrix = &matrix)
					{
						RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, scale, (float*)pmatrix);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, float* rotation, ref float scale, ref float matrix)
		{
			fixed (float* pscale = &scale)
			{
				fixed (float* pmatrix = &matrix)
				{
					RecomposeMatrixFromComponentsNative(translation, rotation, (float*)pscale, (float*)pmatrix);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, ref float scale, ref float matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* pscale = &scale)
				{
					fixed (float* pmatrix = &matrix)
					{
						RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, (float*)pscale, (float*)pmatrix);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, ref float scale, ref float matrix)
		{
			fixed (float* protation = &rotation)
			{
				fixed (float* pscale = &scale)
				{
					fixed (float* pmatrix = &matrix)
					{
						RecomposeMatrixFromComponentsNative(translation, (float*)protation, (float*)pscale, (float*)pmatrix);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, ref float matrix)
		{
			fixed (float* ptranslation = &translation)
			{
				fixed (float* protation = &rotation)
				{
					fixed (float* pscale = &scale)
					{
						fixed (float* pmatrix = &matrix)
						{
							RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, (float*)pmatrix);
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetRectNative(float x, float y, float width, float height)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float, float, float, float, void>)funcTable[8])(x, y, width, height);
			#else
			((delegate* unmanaged[Cdecl]<float, float, float, float, void>)funcTable[8])(x, y, width, height);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetRect(float x, float y, float width, float height)
		{
			SetRectNative(x, y, width, height);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetOrthographicNative(byte isOrthographic)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[9])(isOrthographic);
			#else
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[9])(isOrthographic);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetOrthographic(bool isOrthographic)
		{
			SetOrthographicNative(isOrthographic ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DrawCubesNative(float* view, float* projection, float* matrices, int matrixCount)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float*, float*, float*, int, void>)funcTable[10])(view, projection, matrices, matrixCount);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, int, void>)funcTable[10])((nint)view, (nint)projection, (nint)matrices, matrixCount);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(float* view, float* projection, float* matrices, int matrixCount)
		{
			DrawCubesNative(view, projection, matrices, matrixCount);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref Matrix4x4 view, ref Matrix4x4 projection, Matrix4x4[] matrices, int matrixCount)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrices = matrices)
					{
						DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref Matrix4x4 view, ref Matrix4x4 projection, ref Matrix4x4 matrices, int matrixCount)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrices = &matrices)
					{
						DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref float view, float* projection, float* matrices, int matrixCount)
		{
			fixed (float* pview = &view)
			{
				DrawCubesNative((float*)pview, projection, matrices, matrixCount);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(float* view, ref float projection, float* matrices, int matrixCount)
		{
			fixed (float* pprojection = &projection)
			{
				DrawCubesNative(view, (float*)pprojection, matrices, matrixCount);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref float view, ref float projection, float* matrices, int matrixCount)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					DrawCubesNative((float*)pview, (float*)pprojection, matrices, matrixCount);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(float* view, float* projection, ref float matrices, int matrixCount)
		{
			fixed (float* pmatrices = &matrices)
			{
				DrawCubesNative(view, projection, (float*)pmatrices, matrixCount);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref float view, float* projection, ref float matrices, int matrixCount)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrices = &matrices)
				{
					DrawCubesNative((float*)pview, projection, (float*)pmatrices, matrixCount);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(float* view, ref float projection, ref float matrices, int matrixCount)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrices = &matrices)
				{
					DrawCubesNative(view, (float*)pprojection, (float*)pmatrices, matrixCount);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawCubes(ref float view, ref float projection, ref float matrices, int matrixCount)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrices = &matrices)
					{
						DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void DrawGridNative(float* view, float* projection, float* matrix, float gridSize)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float*, float*, float*, float, void>)funcTable[11])(view, projection, matrix, gridSize);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, float, void>)funcTable[11])((nint)view, (nint)projection, (nint)matrix, gridSize);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(float* view, float* projection, float* matrix, float gridSize)
		{
			DrawGridNative(view, projection, matrix, gridSize);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(ref Matrix4x4 view, ref Matrix4x4 projection, ref Matrix4x4 matrix, float gridSize)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						DrawGridNative((float*)pview, (float*)pprojection, (float*)pmatrix, gridSize);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(ref float view, float* projection, float* matrix, float gridSize)
		{
			fixed (float* pview = &view)
			{
				DrawGridNative((float*)pview, projection, matrix, gridSize);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(float* view, ref float projection, float* matrix, float gridSize)
		{
			fixed (float* pprojection = &projection)
			{
				DrawGridNative(view, (float*)pprojection, matrix, gridSize);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(ref float view, ref float projection, float* matrix, float gridSize)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					DrawGridNative((float*)pview, (float*)pprojection, matrix, gridSize);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(float* view, float* projection, ref float matrix, float gridSize)
		{
			fixed (float* pmatrix = &matrix)
			{
				DrawGridNative(view, projection, (float*)pmatrix, gridSize);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(ref float view, float* projection, ref float matrix, float gridSize)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					DrawGridNative((float*)pview, projection, (float*)pmatrix, gridSize);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(float* view, ref float projection, ref float matrix, float gridSize)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					DrawGridNative(view, (float*)pprojection, (float*)pmatrix, gridSize);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DrawGrid(ref float view, ref float projection, ref float matrix, float gridSize)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						DrawGridNative((float*)pview, (float*)pprojection, (float*)pmatrix, gridSize);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ManipulateNative(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float*, float*, ImGuizmoOperation, ImGuizmoMode, float*, float*, float*, float*, float*, byte>)funcTable[12])(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, nint, ImGuizmoOperation, ImGuizmoMode, nint, nint, nint, nint, nint, byte>)funcTable[12])((nint)view, (nint)projection, operation, mode, (nint)matrix, (nint)deltaMatrix, (nint)snap, (nint)localBounds, (nint)boundsSnap);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
		{
			byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
		{
			byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
		{
			byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap, ref float localBounds, ref float boundsSnap)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								fixed (float* plocalBounds = &localBounds)
								{
									fixed (float* pboundsSnap = &boundsSnap)
									{
										byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)pboundsSnap);
										return ret != 0;
									}
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								fixed (float* plocalBounds = &localBounds)
								{
									byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, default);
									return ret != 0;
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, default, default);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, default, default, default);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, default, default, default);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, default, default);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap, ref float localBounds)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, (float*)plocalBounds, default);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap, ref float localBounds, ref float boundsSnap)
		{
			fixed (Matrix4x4* pview = &view)
			{
				fixed (Matrix4x4* pprojection = &projection)
				{
					fixed (Matrix4x4* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								fixed (float* pboundsSnap = &boundsSnap)
								{
									byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, (float*)plocalBounds, (float*)pboundsSnap);
									return ret != 0;
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
		{
			fixed (float* pview = &view)
			{
				byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pprojection = &projection)
			{
				byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
		{
			fixed (float* pprojection = &projection)
			{
				byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
		{
			fixed (float* pprojection = &projection)
			{
				byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pmatrix = &matrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
		{
			fixed (float* pmatrix = &matrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
		{
			fixed (float* pmatrix = &matrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* psnap = &snap)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* psnap = &snap)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* psnap = &snap)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* plocalBounds = &localBounds)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* plocalBounds = &localBounds)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* psnap = &snap)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* psnap = &snap)
			{
				fixed (float* plocalBounds = &localBounds)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* plocalBounds = &localBounds)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* plocalBounds = &localBounds)
						{
							byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* plocalBounds = &localBounds)
							{
								byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								fixed (float* plocalBounds = &localBounds)
								{
									byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
									return ret != 0;
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								fixed (float* plocalBounds = &localBounds)
								{
									byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
									return ret != 0;
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pboundsSnap = &boundsSnap)
			{
				byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pboundsSnap = &boundsSnap)
				{
					byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pboundsSnap = &boundsSnap)
				{
					byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pboundsSnap = &boundsSnap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* pboundsSnap = &boundsSnap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* pboundsSnap = &boundsSnap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* psnap = &snap)
			{
				fixed (float* pboundsSnap = &boundsSnap)
				{
					byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* pboundsSnap = &boundsSnap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pdeltaMatrix = &deltaMatrix)
			{
				fixed (float* psnap = &snap)
				{
					fixed (float* pboundsSnap = &boundsSnap)
					{
						byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* pboundsSnap = &boundsSnap)
							{
								byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pmatrix = &matrix)
			{
				fixed (float* pdeltaMatrix = &deltaMatrix)
				{
					fixed (float* psnap = &snap)
					{
						fixed (float* pboundsSnap = &boundsSnap)
						{
							byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* pboundsSnap = &boundsSnap)
							{
								byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pprojection = &projection)
			{
				fixed (float* pmatrix = &matrix)
				{
					fixed (float* pdeltaMatrix = &deltaMatrix)
					{
						fixed (float* psnap = &snap)
						{
							fixed (float* pboundsSnap = &boundsSnap)
							{
								byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
								return ret != 0;
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
		{
			fixed (float* pview = &view)
			{
				fixed (float* pprojection = &projection)
				{
					fixed (float* pmatrix = &matrix)
					{
						fixed (float* pdeltaMatrix = &deltaMatrix)
						{
							fixed (float* psnap = &snap)
							{
								fixed (float* pboundsSnap = &boundsSnap)
								{
									byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
									return ret != 0;
								}
							}
						}
					}
				}
			}
		}
	}
}