using System;
using System.Runtime.InteropServices;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Runtime.InteropServices;
using UnityEngine;

// Token: 0x02000371 RID: 881
public static class Oni : Il2CppSystem.Object
{
	// Token: 0x06007245 RID: 29253 RVA: 0x001CF4B4 File Offset: 0x001CD6B4
	[CallerCount(43)]
	[CachedScanResults(RefRangeStart = 586302, RefRangeEnd = 586345, XrefRangeStart = 586301, XrefRangeEnd = 586302, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static GCHandle PinMemory(Il2CppSystem.Object data)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(data);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_PinMemory_Public_Static_GCHandle_Object_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06007246 RID: 29254 RVA: 0x001CF50C File Offset: 0x001CD70C
	[CallerCount(70)]
	[CachedScanResults(RefRangeStart = 586347, RefRangeEnd = 586417, XrefRangeStart = 586345, XrefRangeEnd = 586347, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UnpinMemory(GCHandle handle)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref handle;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007247 RID: 29255 RVA: 0x001CF554 File Offset: 0x001CD754
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586419, RefRangeEnd = 586420, XrefRangeStart = 586417, XrefRangeEnd = 586419, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateCollider()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007248 RID: 29256 RVA: 0x001CF598 File Offset: 0x001CD798
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586422, RefRangeEnd = 586423, XrefRangeStart = 586420, XrefRangeEnd = 586422, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyCollider(IntPtr collider)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref collider;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007249 RID: 29257 RVA: 0x001CF5E0 File Offset: 0x001CD7E0
	[CallerCount(14)]
	[CachedScanResults(RefRangeStart = 586425, RefRangeEnd = 586439, XrefRangeStart = 586423, XrefRangeEnd = 586425, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateShape(Oni.ShapeType shapeType)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref shapeType;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x0600724A RID: 29258 RVA: 0x001CF634 File Offset: 0x001CD834
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586441, RefRangeEnd = 586443, XrefRangeStart = 586439, XrefRangeEnd = 586441, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyShape(IntPtr shape)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref shape;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600724B RID: 29259 RVA: 0x001CF67C File Offset: 0x001CD87C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586445, RefRangeEnd = 586446, XrefRangeStart = 586443, XrefRangeEnd = 586445, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateRigidbody()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600724C RID: 29260 RVA: 0x001CF6C0 File Offset: 0x001CD8C0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586448, RefRangeEnd = 586449, XrefRangeStart = 586446, XrefRangeEnd = 586448, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyRigidbody(IntPtr rigidbody)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref rigidbody;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600724D RID: 29261 RVA: 0x001CF708 File Offset: 0x001CD908
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586451, RefRangeEnd = 586453, XrefRangeStart = 586449, XrefRangeEnd = 586451, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateCollider(IntPtr collider, ref Oni.Collider adaptor)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref collider;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &adaptor;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600724E RID: 29262 RVA: 0x001CF764 File Offset: 0x001CD964
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 586455, RefRangeEnd = 586465, XrefRangeStart = 586453, XrefRangeEnd = 586455, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateShape(IntPtr shape, ref Oni.Shape adaptor)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref shape;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &adaptor;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600724F RID: 29263 RVA: 0x001CF7C0 File Offset: 0x001CD9C0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586467, RefRangeEnd = 586469, XrefRangeStart = 586465, XrefRangeEnd = 586467, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateRigidbody(IntPtr rigidbody, ref Oni.Rigidbody adaptor)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref rigidbody;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &adaptor;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007250 RID: 29264 RVA: 0x001CF81C File Offset: 0x001CDA1C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586471, RefRangeEnd = 586472, XrefRangeStart = 586469, XrefRangeEnd = 586471, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetRigidbodyVelocity(IntPtr rigidbody, ref Oni.RigidbodyVelocities velocities)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref rigidbody;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &velocities;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007251 RID: 29265 RVA: 0x001CF878 File Offset: 0x001CDA78
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586474, RefRangeEnd = 586475, XrefRangeStart = 586472, XrefRangeEnd = 586474, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetColliderShape(IntPtr collider, IntPtr shape)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref collider;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref shape;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007252 RID: 29266 RVA: 0x001CF8D0 File Offset: 0x001CDAD0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586477, RefRangeEnd = 586479, XrefRangeStart = 586475, XrefRangeEnd = 586477, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetColliderRigidbody(IntPtr collider, IntPtr rigidbody)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref collider;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rigidbody;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007253 RID: 29267 RVA: 0x001CF928 File Offset: 0x001CDB28
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586481, RefRangeEnd = 586483, XrefRangeStart = 586479, XrefRangeEnd = 586481, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetColliderMaterial(IntPtr collider, IntPtr material)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref collider;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref material;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007254 RID: 29268 RVA: 0x001CF980 File Offset: 0x001CDB80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586485, RefRangeEnd = 586486, XrefRangeStart = 586483, XrefRangeEnd = 586485, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateCollisionMaterial()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007255 RID: 29269 RVA: 0x001CF9C4 File Offset: 0x001CDBC4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586488, RefRangeEnd = 586489, XrefRangeStart = 586486, XrefRangeEnd = 586488, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyCollisionMaterial(IntPtr material)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref material;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007256 RID: 29270 RVA: 0x001CFA0C File Offset: 0x001CDC0C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586491, RefRangeEnd = 586493, XrefRangeStart = 586489, XrefRangeEnd = 586491, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateCollisionMaterial(IntPtr material, ref Oni.CollisionMaterial adaptor)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref material;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &adaptor;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007257 RID: 29271 RVA: 0x001CFA68 File Offset: 0x001CDC68
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586495, RefRangeEnd = 586497, XrefRangeStart = 586493, XrefRangeEnd = 586495, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateSolver(int maxParticles, int maxNeighbours)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref maxParticles;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref maxNeighbours;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007258 RID: 29272 RVA: 0x001CFAD0 File Offset: 0x001CDCD0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586499, RefRangeEnd = 586501, XrefRangeStart = 586497, XrefRangeEnd = 586499, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroySolver(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007259 RID: 29273 RVA: 0x001CFB18 File Offset: 0x001CDD18
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586503, RefRangeEnd = 586507, XrefRangeStart = 586501, XrefRangeEnd = 586503, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void AddCollider(IntPtr solver, IntPtr collider)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref collider;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600725A RID: 29274 RVA: 0x001CFB70 File Offset: 0x001CDD70
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586509, RefRangeEnd = 586513, XrefRangeStart = 586507, XrefRangeEnd = 586509, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void RemoveCollider(IntPtr solver, IntPtr collider)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref collider;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600725B RID: 29275 RVA: 0x001CFBC8 File Offset: 0x001CDDC8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586515, RefRangeEnd = 586516, XrefRangeStart = 586513, XrefRangeEnd = 586515, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetBounds(IntPtr solver, ref Vector3 min, ref Vector3 max)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &min;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &max;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600725C RID: 29276 RVA: 0x001CFC38 File Offset: 0x001CDE38
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586518, RefRangeEnd = 586519, XrefRangeStart = 586516, XrefRangeEnd = 586518, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetParticleGridSize(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x0600725D RID: 29277 RVA: 0x001CFC8C File Offset: 0x001CDE8C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586521, RefRangeEnd = 586522, XrefRangeStart = 586519, XrefRangeEnd = 586521, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetParticleGrid(IntPtr solver, Il2CppStructArray<Oni.GridCell> cells)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(cells);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600725E RID: 29278 RVA: 0x001CFCEC File Offset: 0x001CDEEC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586524, RefRangeEnd = 586526, XrefRangeStart = 586522, XrefRangeEnd = 586524, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetSolverParameters(IntPtr solver, ref Oni.SolverParameters parameters)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &parameters;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600725F RID: 29279 RVA: 0x001CFD48 File Offset: 0x001CDF48
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586526, XrefRangeEnd = 586528, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetSolverParameters(IntPtr solver, ref Oni.SolverParameters parameters)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &parameters;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007260 RID: 29280 RVA: 0x001CFDA4 File Offset: 0x001CDFA4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586530, RefRangeEnd = 586531, XrefRangeStart = 586528, XrefRangeEnd = 586530, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetActiveParticles(IntPtr solver, Il2CppStructArray<int> active, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(active);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007261 RID: 29281 RVA: 0x001CFE24 File Offset: 0x001CE024
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586533, RefRangeEnd = 586536, XrefRangeStart = 586531, XrefRangeEnd = 586533, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void AddSimulationTime(IntPtr solver, float step_dt)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref step_dt;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007262 RID: 29282 RVA: 0x001CFE7C File Offset: 0x001CE07C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586538, RefRangeEnd = 586539, XrefRangeStart = 586536, XrefRangeEnd = 586538, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void ResetSimulationTime(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007263 RID: 29283 RVA: 0x001CFEC4 File Offset: 0x001CE0C4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586541, RefRangeEnd = 586542, XrefRangeStart = 586539, XrefRangeEnd = 586541, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateSolver(IntPtr solver, float substep_dt)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref substep_dt;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007264 RID: 29284 RVA: 0x001CFF1C File Offset: 0x001CE11C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586544, RefRangeEnd = 586545, XrefRangeStart = 586542, XrefRangeEnd = 586544, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void ApplyPositionInterpolation(IntPtr solver, float substep_dt)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref substep_dt;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007265 RID: 29285 RVA: 0x001CFF74 File Offset: 0x001CE174
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586547, RefRangeEnd = 586548, XrefRangeStart = 586545, XrefRangeEnd = 586547, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void UpdateSkeletalAnimation(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06007266 RID: 29286 RVA: 0x001CFFBC File Offset: 0x001CE1BC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586548, XrefRangeEnd = 586550, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetConstraintsOrder(IntPtr solver, Il2CppStructArray<int> order)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(order);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007267 RID: 29287 RVA: 0x001D001C File Offset: 0x001CE21C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586552, RefRangeEnd = 586554, XrefRangeStart = 586550, XrefRangeEnd = 586552, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetConstraintsOrder(IntPtr solver, Il2CppStructArray<int> order)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(order);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007268 RID: 29288 RVA: 0x001D007C File Offset: 0x001CE27C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586556, RefRangeEnd = 586560, XrefRangeStart = 586554, XrefRangeEnd = 586556, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetConstraintCount(IntPtr solver, int type)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref type;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007269 RID: 29289 RVA: 0x001D00E4 File Offset: 0x001CE2E4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586562, RefRangeEnd = 586564, XrefRangeStart = 586560, XrefRangeEnd = 586562, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetActiveConstraintIndices(IntPtr solver, Il2CppStructArray<int> indices, int num, int type)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref type;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600726A RID: 29290 RVA: 0x001D0168 File Offset: 0x001CE368
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586564, XrefRangeEnd = 586566, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetRenderableParticlePositions(IntPtr solver, Il2CppStructArray<Vector4> positions, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600726B RID: 29291 RVA: 0x001D01FC File Offset: 0x001CE3FC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586568, RefRangeEnd = 586569, XrefRangeStart = 586566, XrefRangeEnd = 586568, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetRenderableParticlePositions(IntPtr solver, Il2CppStructArray<Vector4> positions, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600726C RID: 29292 RVA: 0x001D0290 File Offset: 0x001CE490
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586571, RefRangeEnd = 586573, XrefRangeStart = 586569, XrefRangeEnd = 586571, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetParticlePhases(IntPtr solver, Il2CppStructArray<int> phases, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(phases);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600726D RID: 29293 RVA: 0x001D0324 File Offset: 0x001CE524
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 586575, RefRangeEnd = 586584, XrefRangeStart = 586573, XrefRangeEnd = 586575, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetParticlePositions(IntPtr solver, Il2CppStructArray<Vector4> positions, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600726E RID: 29294 RVA: 0x001D03B8 File Offset: 0x001CE5B8
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 586586, RefRangeEnd = 586591, XrefRangeStart = 586584, XrefRangeEnd = 586586, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetParticlePositions(IntPtr solver, Il2CppStructArray<Vector4> positions, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600726F RID: 29295 RVA: 0x001D044C File Offset: 0x001CE64C
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 586593, RefRangeEnd = 586600, XrefRangeStart = 586591, XrefRangeEnd = 586593, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetParticleInverseMasses(IntPtr solver, Il2CppStructArray<float> invMasses, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(invMasses);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007270 RID: 29296 RVA: 0x001D04E0 File Offset: 0x001CE6E0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586602, RefRangeEnd = 586604, XrefRangeStart = 586600, XrefRangeEnd = 586602, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetParticleSolidRadii(IntPtr solver, Il2CppStructArray<float> radii, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(radii);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007271 RID: 29297 RVA: 0x001D0574 File Offset: 0x001CE774
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 586606, RefRangeEnd = 586612, XrefRangeStart = 586604, XrefRangeEnd = 586606, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetParticleVelocities(IntPtr solver, Il2CppStructArray<Vector4> velocities, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(velocities);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007272 RID: 29298 RVA: 0x001D0608 File Offset: 0x001CE808
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586614, RefRangeEnd = 586616, XrefRangeStart = 586612, XrefRangeEnd = 586614, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetParticleVelocities(IntPtr solver, Il2CppStructArray<Vector4> velocities, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(velocities);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007273 RID: 29299 RVA: 0x001D069C File Offset: 0x001CE89C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586618, RefRangeEnd = 586619, XrefRangeStart = 586616, XrefRangeEnd = 586618, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void AddParticleExternalForces(IntPtr solver, Il2CppStructArray<Vector4> forces, Il2CppStructArray<int> indices, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(forces);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007274 RID: 29300 RVA: 0x001D0724 File Offset: 0x001CE924
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586621, RefRangeEnd = 586622, XrefRangeStart = 586619, XrefRangeEnd = 586621, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void AddParticleExternalForce(IntPtr solver, ref Vector4 force, Il2CppStructArray<int> indices, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &force;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007275 RID: 29301 RVA: 0x001D07A8 File Offset: 0x001CE9A8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586624, RefRangeEnd = 586626, XrefRangeStart = 586622, XrefRangeEnd = 586624, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetParticleVorticities(IntPtr solver, Il2CppStructArray<Vector4> vorticities, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(vorticities);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007276 RID: 29302 RVA: 0x001D083C File Offset: 0x001CEA3C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586628, RefRangeEnd = 586630, XrefRangeStart = 586626, XrefRangeEnd = 586628, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetParticleDensities(IntPtr solver, Il2CppStructArray<float> densities, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(densities);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007277 RID: 29303 RVA: 0x001D08D0 File Offset: 0x001CEAD0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586632, RefRangeEnd = 586633, XrefRangeStart = 586630, XrefRangeEnd = 586632, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetDeformableTriangleCount(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06007278 RID: 29304 RVA: 0x001D0924 File Offset: 0x001CEB24
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586635, RefRangeEnd = 586637, XrefRangeStart = 586633, XrefRangeEnd = 586635, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableTriangles(IntPtr solver, Il2CppStructArray<int> indices, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007279 RID: 29305 RVA: 0x001D09A8 File Offset: 0x001CEBA8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586639, RefRangeEnd = 586640, XrefRangeStart = 586637, XrefRangeEnd = 586639, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int RemoveDeformableTriangles(IntPtr solver, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600727A RID: 29306 RVA: 0x001D0A24 File Offset: 0x001CEC24
	[CallerCount(20)]
	[CachedScanResults(RefRangeStart = 586642, RefRangeEnd = 586662, XrefRangeStart = 586640, XrefRangeEnd = 586642, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetConstraintGroupParameters(IntPtr solver, int type, ref Oni.ConstraintParameters parameters)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref type;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &parameters;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600727B RID: 29307 RVA: 0x001D0A90 File Offset: 0x001CEC90
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586662, XrefRangeEnd = 586664, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetConstraintGroupParameters(IntPtr solver, int type, ref Oni.ConstraintParameters parameters)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref type;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &parameters;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600727C RID: 29308 RVA: 0x001D0AFC File Offset: 0x001CECFC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586666, RefRangeEnd = 586667, XrefRangeStart = 586664, XrefRangeEnd = 586666, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetCollisionMaterials(IntPtr solver, Il2CppStructArray<IntPtr> materials, Il2CppStructArray<int> indices, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(materials);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600727D RID: 29309 RVA: 0x001D0B84 File Offset: 0x001CED84
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586669, RefRangeEnd = 586671, XrefRangeStart = 586667, XrefRangeEnd = 586669, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetRestPositions(IntPtr solver, Il2CppStructArray<Vector4> positions, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600727E RID: 29310 RVA: 0x001D0C18 File Offset: 0x001CEE18
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586673, RefRangeEnd = 586675, XrefRangeStart = 586671, XrefRangeEnd = 586673, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetFluidMaterials(IntPtr solver, Il2CppStructArray<Oni.FluidMaterial> materials, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(materials);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600727F RID: 29311 RVA: 0x001D0C9C File Offset: 0x001CEE9C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586677, RefRangeEnd = 586678, XrefRangeStart = 586675, XrefRangeEnd = 586677, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetFluidMaterialIndices(IntPtr solver, Il2CppStructArray<int> indices, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007280 RID: 29312 RVA: 0x001D0D30 File Offset: 0x001CEF30
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 586680, RefRangeEnd = 586685, XrefRangeStart = 586678, XrefRangeEnd = 586680, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateDeformableMesh(IntPtr solver, IntPtr halfEdge, IntPtr skinConstraintBatch, Il2CppStructArray<float> worldToLocal, IntPtr particleIndices, int vertexCapacity, int vertexCount)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref halfEdge;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref skinConstraintBatch;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(worldToLocal);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref particleIndices;
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertexCapacity;
		ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertexCount;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007281 RID: 29313 RVA: 0x001D0DFC File Offset: 0x001CEFFC
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 586687, RefRangeEnd = 586693, XrefRangeStart = 586685, XrefRangeEnd = 586687, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyDeformableMesh(IntPtr solver, IntPtr mesh)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref mesh;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007282 RID: 29314 RVA: 0x001D0E54 File Offset: 0x001CF054
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586695, RefRangeEnd = 586697, XrefRangeStart = 586693, XrefRangeEnd = 586695, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static bool TearDeformableMeshAtVertex(IntPtr mesh, int vertexIndex, ref Vector3 planePoint, ref Vector3 planeNormal, Il2CppStructArray<int> updated_edges, ref int num_edges)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertexIndex;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &planePoint;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &planeNormal;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(updated_edges);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &num_edges;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007283 RID: 29315 RVA: 0x001D0F10 File Offset: 0x001CF110
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586699, RefRangeEnd = 586703, XrefRangeStart = 586697, XrefRangeEnd = 586699, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshTBNUpdate(IntPtr mesh, Oni.NormalsUpdate normalsUpdate, bool skinTangents)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref normalsUpdate;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref skinTangents;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007284 RID: 29316 RVA: 0x001D0F7C File Offset: 0x001CF17C
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586705, RefRangeEnd = 586708, XrefRangeStart = 586703, XrefRangeEnd = 586705, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshTransform(IntPtr mesh, Il2CppStructArray<float> worldToLocal)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(worldToLocal);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007285 RID: 29317 RVA: 0x001D0FDC File Offset: 0x001CF1DC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586710, RefRangeEnd = 586711, XrefRangeStart = 586708, XrefRangeEnd = 586710, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshSkinMap(IntPtr mesh, IntPtr sourceMesh, IntPtr triangleSkinMap)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceMesh;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref triangleSkinMap;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007286 RID: 29318 RVA: 0x001D1048 File Offset: 0x001CF248
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586711, XrefRangeEnd = 586713, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshParticleIndices(IntPtr mesh, IntPtr particleIndices)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref particleIndices;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007287 RID: 29319 RVA: 0x001D10A0 File Offset: 0x001CF2A0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586715, RefRangeEnd = 586718, XrefRangeStart = 586713, XrefRangeEnd = 586715, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshData(IntPtr mesh, IntPtr triangles, IntPtr vertices, IntPtr normals, IntPtr tangents, IntPtr colors, IntPtr uv1, IntPtr uv2, IntPtr uv3, IntPtr uv4)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)10) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref triangles;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertices;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref normals;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref tangents;
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref colors;
		ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uv1;
		ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uv2;
		ptr[checked(unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uv3;
		ptr[checked(unchecked((UIntPtr)9) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uv4;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007288 RID: 29320 RVA: 0x001D1194 File Offset: 0x001CF394
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586720, RefRangeEnd = 586722, XrefRangeStart = 586718, XrefRangeEnd = 586720, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshAnimationData(IntPtr mesh, Il2CppStructArray<float> bindPoses, Il2CppStructArray<Oni.BoneWeights> weights, int numBones)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bindPoses);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(weights);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref numBones;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007289 RID: 29321 RVA: 0x001D121C File Offset: 0x001CF41C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586724, RefRangeEnd = 586726, XrefRangeStart = 586722, XrefRangeEnd = 586724, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDeformableMeshBoneTransforms(IntPtr mesh, Il2CppStructArray<float> boneTransforms)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(boneTransforms);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600728A RID: 29322 RVA: 0x001D127C File Offset: 0x001CF47C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586728, RefRangeEnd = 586729, XrefRangeStart = 586726, XrefRangeEnd = 586728, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void ForceDeformableMeshSkeletalSkinning(IntPtr mesh)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600728B RID: 29323 RVA: 0x001D12C4 File Offset: 0x001CF4C4
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 586731, RefRangeEnd = 586739, XrefRangeStart = 586729, XrefRangeEnd = 586731, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateBatch(int type, bool cooked)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref type;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref cooked;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600728C RID: 29324 RVA: 0x001D132C File Offset: 0x001CF52C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586741, RefRangeEnd = 586745, XrefRangeStart = 586739, XrefRangeEnd = 586741, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyBatch(IntPtr batch)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600728D RID: 29325 RVA: 0x001D1374 File Offset: 0x001CF574
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586747, RefRangeEnd = 586751, XrefRangeStart = 586745, XrefRangeEnd = 586747, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr AddBatch(IntPtr solver, IntPtr batch, bool sharesParticles)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref batch;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sharesParticles;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600728E RID: 29326 RVA: 0x001D13F0 File Offset: 0x001CF5F0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586753, RefRangeEnd = 586757, XrefRangeStart = 586751, XrefRangeEnd = 586753, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void RemoveBatch(IntPtr solver, IntPtr batch)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref batch;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600728F RID: 29327 RVA: 0x001D1448 File Offset: 0x001CF648
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 586759, RefRangeEnd = 586767, XrefRangeStart = 586757, XrefRangeEnd = 586759, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static bool EnableBatch(IntPtr batch, bool enabled)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref enabled;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007290 RID: 29328 RVA: 0x001D14B0 File Offset: 0x001CF6B0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586769, RefRangeEnd = 586773, XrefRangeStart = 586767, XrefRangeEnd = 586769, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetBatchConstraintCount(IntPtr batch)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06007291 RID: 29329 RVA: 0x001D1504 File Offset: 0x001CF704
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586775, RefRangeEnd = 586777, XrefRangeStart = 586773, XrefRangeEnd = 586775, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetBatchConstraintForces(IntPtr batch, Il2CppStructArray<float> forces, int num, int destOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(forces);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref destOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007292 RID: 29330 RVA: 0x001D1598 File Offset: 0x001CF798
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586779, RefRangeEnd = 586783, XrefRangeStart = 586777, XrefRangeEnd = 586779, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetBatchPhaseCount(IntPtr batch)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06007293 RID: 29331 RVA: 0x001D15EC File Offset: 0x001CF7EC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586785, RefRangeEnd = 586789, XrefRangeStart = 586783, XrefRangeEnd = 586785, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetBatchPhaseSizes(IntPtr batch, Il2CppStructArray<int> phaseSizes)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(phaseSizes);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007294 RID: 29332 RVA: 0x001D164C File Offset: 0x001CF84C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586791, RefRangeEnd = 586795, XrefRangeStart = 586789, XrefRangeEnd = 586791, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetBatchPhaseSizes(IntPtr batch, Il2CppStructArray<int> phaseSizes, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(phaseSizes);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007295 RID: 29333 RVA: 0x001D16BC File Offset: 0x001CF8BC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586797, RefRangeEnd = 586801, XrefRangeStart = 586795, XrefRangeEnd = 586797, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static bool CookBatch(IntPtr batch)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06007296 RID: 29334 RVA: 0x001D1710 File Offset: 0x001CF910
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586803, RefRangeEnd = 586806, XrefRangeStart = 586801, XrefRangeEnd = 586803, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetActiveConstraints(IntPtr batch, Il2CppStructArray<int> active, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(active);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06007297 RID: 29335 RVA: 0x001D1790 File Offset: 0x001CF990
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586808, RefRangeEnd = 586810, XrefRangeStart = 586806, XrefRangeEnd = 586808, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDistanceConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<float> restLengths, Il2CppStructArray<Vector2> stiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(restLengths);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007298 RID: 29336 RVA: 0x001D1830 File Offset: 0x001CFA30
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586812, RefRangeEnd = 586813, XrefRangeStart = 586810, XrefRangeEnd = 586812, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetDistanceConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<float> restLengths, Il2CppStructArray<Vector2> stiffnesses)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(restLengths);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06007299 RID: 29337 RVA: 0x001D18C0 File Offset: 0x001CFAC0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586815, RefRangeEnd = 586817, XrefRangeStart = 586813, XrefRangeEnd = 586815, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetBendingConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<float> restBends, Il2CppStructArray<Vector2> bendingStiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(restBends);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bendingStiffnesses);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729A RID: 29338 RVA: 0x001D1960 File Offset: 0x001CFB60
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586819, RefRangeEnd = 586820, XrefRangeStart = 586817, XrefRangeEnd = 586819, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetBendingConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<float> restBends, Il2CppStructArray<Vector2> bendingStiffnesses)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(restBends);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bendingStiffnesses);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729B RID: 29339 RVA: 0x001D19F0 File Offset: 0x001CFBF0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586822, RefRangeEnd = 586824, XrefRangeStart = 586820, XrefRangeEnd = 586822, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetSkinConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<Vector4> points, Il2CppStructArray<Vector4> normals, Il2CppStructArray<float> radiiBackstops, Il2CppStructArray<float> stiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(points);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(normals);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(radiiBackstops);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729C RID: 29340 RVA: 0x001D1AC0 File Offset: 0x001CFCC0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586826, RefRangeEnd = 586828, XrefRangeStart = 586824, XrefRangeEnd = 586826, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetSkinConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<Vector4> points, Il2CppStructArray<Vector4> normals, Il2CppStructArray<float> radiiBackstops, Il2CppStructArray<float> stiffnesses)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(points);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(normals);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(radiiBackstops);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729D RID: 29341 RVA: 0x001D1B80 File Offset: 0x001CFD80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586830, RefRangeEnd = 586831, XrefRangeStart = 586828, XrefRangeEnd = 586830, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetAerodynamicConstraints(IntPtr batch, Il2CppStructArray<int> particleIndices, Il2CppStructArray<float> aerodynamicCoeffs, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(particleIndices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(aerodynamicCoeffs);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729E RID: 29342 RVA: 0x001D1C08 File Offset: 0x001CFE08
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586833, RefRangeEnd = 586834, XrefRangeStart = 586831, XrefRangeEnd = 586833, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetVolumeConstraints(IntPtr batch, Il2CppStructArray<int> triangleIndices, Il2CppStructArray<int> firstTriangle, Il2CppStructArray<int> numTriangles, Il2CppStructArray<float> restVolumes, Il2CppStructArray<Vector2> pressureStiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(triangleIndices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(firstTriangle);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(numTriangles);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(restVolumes);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(pressureStiffnesses);
		ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetVolumeConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600729F RID: 29343 RVA: 0x001D1CD8 File Offset: 0x001CFED8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586836, RefRangeEnd = 586838, XrefRangeStart = 586834, XrefRangeEnd = 586836, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetTetherConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<Vector2> maxLenghtsScales, Il2CppStructArray<float> stiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(maxLenghtsScales);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A0 RID: 29344 RVA: 0x001D1D78 File Offset: 0x001CFF78
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586840, RefRangeEnd = 586841, XrefRangeStart = 586838, XrefRangeEnd = 586840, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetTetherConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<Vector2> maxLenghtsScales, Il2CppStructArray<float> stiffnesses)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(maxLenghtsScales);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A1 RID: 29345 RVA: 0x001D1E08 File Offset: 0x001D0008
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586843, RefRangeEnd = 586844, XrefRangeStart = 586841, XrefRangeEnd = 586843, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetPinConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<Vector4> pinOffsets, Il2CppStructArray<IntPtr> colliders, Il2CppStructArray<float> stiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(pinOffsets);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(colliders);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetPinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A2 RID: 29346 RVA: 0x001D1EC0 File Offset: 0x001D00C0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586846, RefRangeEnd = 586847, XrefRangeStart = 586844, XrefRangeEnd = 586846, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetStitchConstraints(IntPtr batch, Il2CppStructArray<int> indices, Il2CppStructArray<float> stiffnesses, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref batch;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(indices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(stiffnesses);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A3 RID: 29347 RVA: 0x001D1F48 File Offset: 0x001D0148
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586849, RefRangeEnd = 586851, XrefRangeStart = 586847, XrefRangeEnd = 586849, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetCollisionContacts(IntPtr solver, Il2CppStructArray<Oni.Contact> contacts, int n)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(contacts);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref n;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A4 RID: 29348 RVA: 0x001D1FB8 File Offset: 0x001D01B8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586853, RefRangeEnd = 586854, XrefRangeStart = 586851, XrefRangeEnd = 586853, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void ClearDiffuseParticles(IntPtr solver)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060072A5 RID: 29349 RVA: 0x001D2000 File Offset: 0x001D0200
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586854, XrefRangeEnd = 586856, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int SetDiffuseParticles(IntPtr solver, Il2CppStructArray<Vector4> positions, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(positions);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072A6 RID: 29350 RVA: 0x001D2080 File Offset: 0x001D0280
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586856, XrefRangeEnd = 586858, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetDiffuseParticleVelocities(IntPtr solver, Il2CppStructArray<Vector4> velocities, int num, int sourceOffset)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(velocities);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourceOffset;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072A7 RID: 29351 RVA: 0x001D2114 File Offset: 0x001D0314
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586858, XrefRangeEnd = 586860, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetDiffuseParticleNeighbourCounts(IntPtr solver, IntPtr neighbourCounts)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref solver;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref neighbourCounts;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072A8 RID: 29352 RVA: 0x001D216C File Offset: 0x001D036C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586862, RefRangeEnd = 586863, XrefRangeStart = 586860, XrefRangeEnd = 586862, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateHalfEdgeMesh()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072A9 RID: 29353 RVA: 0x001D21B0 File Offset: 0x001D03B0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586865, RefRangeEnd = 586866, XrefRangeStart = 586863, XrefRangeEnd = 586865, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyHalfEdgeMesh(IntPtr mesh)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060072AA RID: 29354 RVA: 0x001D21F8 File Offset: 0x001D03F8
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586868, RefRangeEnd = 586872, XrefRangeStart = 586866, XrefRangeEnd = 586868, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetVertices(IntPtr mesh, IntPtr vertices, int n)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertices;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref n;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072AB RID: 29355 RVA: 0x001D2264 File Offset: 0x001D0464
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586874, RefRangeEnd = 586877, XrefRangeStart = 586872, XrefRangeEnd = 586874, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetHalfEdges(IntPtr mesh, IntPtr halfedges, int n)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref halfedges;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref n;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072AC RID: 29356 RVA: 0x001D22D0 File Offset: 0x001D04D0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586879, RefRangeEnd = 586882, XrefRangeStart = 586877, XrefRangeEnd = 586879, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetFaces(IntPtr mesh, IntPtr faces, int n)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref faces;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref n;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072AD RID: 29357 RVA: 0x001D233C File Offset: 0x001D053C
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586884, RefRangeEnd = 586887, XrefRangeStart = 586882, XrefRangeEnd = 586884, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetNormals(IntPtr mesh, IntPtr normals)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref normals;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072AE RID: 29358 RVA: 0x001D2394 File Offset: 0x001D0594
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 586889, RefRangeEnd = 586892, XrefRangeStart = 586887, XrefRangeEnd = 586889, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetTangents(IntPtr mesh, IntPtr tangents)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref tangents;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072AF RID: 29359 RVA: 0x001D23EC File Offset: 0x001D05EC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586894, RefRangeEnd = 586898, XrefRangeStart = 586892, XrefRangeEnd = 586894, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetInverseOrientations(IntPtr mesh, IntPtr orientations)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref orientations;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072B0 RID: 29360 RVA: 0x001D2444 File Offset: 0x001D0644
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586900, RefRangeEnd = 586904, XrefRangeStart = 586898, XrefRangeEnd = 586900, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetVisualMap(IntPtr mesh, IntPtr map)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref map;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072B1 RID: 29361 RVA: 0x001D249C File Offset: 0x001D069C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586906, RefRangeEnd = 586908, XrefRangeStart = 586904, XrefRangeEnd = 586906, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetVertexCount(IntPtr mesh)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072B2 RID: 29362 RVA: 0x001D24F0 File Offset: 0x001D06F0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586910, RefRangeEnd = 586911, XrefRangeStart = 586908, XrefRangeEnd = 586910, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetHalfEdgeCount(IntPtr mesh)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072B3 RID: 29363 RVA: 0x001D2544 File Offset: 0x001D0744
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586913, RefRangeEnd = 586914, XrefRangeStart = 586911, XrefRangeEnd = 586913, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetFaceCount(IntPtr mesh)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072B4 RID: 29364 RVA: 0x001D2598 File Offset: 0x001D0798
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586916, RefRangeEnd = 586917, XrefRangeStart = 586914, XrefRangeEnd = 586916, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetHalfEdgeMeshInfo(IntPtr mesh, ref Oni.MeshInformation meshInfo)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &meshInfo;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072B5 RID: 29365 RVA: 0x001D2600 File Offset: 0x001D0800
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586919, RefRangeEnd = 586920, XrefRangeStart = 586917, XrefRangeEnd = 586919, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void CalculatePrimitiveCounts(IntPtr mesh, Il2CppStructArray<Vector3> vertices, Il2CppStructArray<int> triangles, int vertexCount, int triangleCount)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(vertices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(triangles);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertexCount;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref triangleCount;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072B6 RID: 29366 RVA: 0x001D269C File Offset: 0x001D089C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586922, RefRangeEnd = 586923, XrefRangeStart = 586920, XrefRangeEnd = 586922, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void Generate(IntPtr mesh, Il2CppStructArray<Vector3> vertices, Il2CppStructArray<int> triangles, int vertexCount, int triangleCount, ref Vector3 scale)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref mesh;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(vertices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(triangles);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref vertexCount;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref triangleCount;
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &scale;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072B7 RID: 29367 RVA: 0x001D274C File Offset: 0x001D094C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 586925, RefRangeEnd = 586929, XrefRangeStart = 586923, XrefRangeEnd = 586925, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int MakePhase(int group, Oni.ParticlePhase flags)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref group;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref flags;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072B8 RID: 29368 RVA: 0x001D27B4 File Offset: 0x001D09B4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586931, RefRangeEnd = 586932, XrefRangeStart = 586929, XrefRangeEnd = 586931, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetGroupFromPhase(int phase)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref phase;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072B9 RID: 29369 RVA: 0x001D2808 File Offset: 0x001D0A08
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586934, RefRangeEnd = 586935, XrefRangeStart = 586932, XrefRangeEnd = 586934, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static float BendingConstraintRest(Il2CppStructArray<float> constraintCoordinates)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(constraintCoordinates);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072BA RID: 29370 RVA: 0x001D2860 File Offset: 0x001D0A60
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586937, RefRangeEnd = 586938, XrefRangeStart = 586935, XrefRangeEnd = 586937, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static IntPtr CreateTriangleSkinMap()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072BB RID: 29371 RVA: 0x001D28A4 File Offset: 0x001D0AA4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586938, XrefRangeEnd = 586940, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void DestroyTriangleSkinMap(IntPtr skinmap)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref skinmap;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060072BC RID: 29372 RVA: 0x001D28EC File Offset: 0x001D0AEC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586942, RefRangeEnd = 586943, XrefRangeStart = 586940, XrefRangeEnd = 586942, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void Bind(IntPtr skinmap, IntPtr sourcemesh, IntPtr targetmesh, Il2CppStructArray<uint> sourceMasterFlags, Il2CppStructArray<uint> targetSlaveFlags)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref skinmap;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sourcemesh;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetmesh;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(sourceMasterFlags);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(targetSlaveFlags);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072BD RID: 29373 RVA: 0x001D2988 File Offset: 0x001D0B88
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586945, RefRangeEnd = 586946, XrefRangeStart = 586943, XrefRangeEnd = 586945, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetSkinnedVertexCount(IntPtr skinmap)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref skinmap;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060072BE RID: 29374 RVA: 0x001D29DC File Offset: 0x001D0BDC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586948, RefRangeEnd = 586949, XrefRangeStart = 586946, XrefRangeEnd = 586948, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetSkinInfo(IntPtr skinmap, Il2CppStructArray<int> skinIndices, Il2CppStructArray<int> sourceTriIndices, Il2CppStructArray<Vector3> baryPositions, Il2CppStructArray<Vector3> baryNormals, Il2CppStructArray<Vector3> baryTangents)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref skinmap;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(skinIndices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(sourceTriIndices);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryPositions);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryNormals);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryTangents);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072BF RID: 29375 RVA: 0x001D2A9C File Offset: 0x001D0C9C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586951, RefRangeEnd = 586952, XrefRangeStart = 586949, XrefRangeEnd = 586951, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SetSkinInfo(IntPtr skinmap, Il2CppStructArray<int> skinIndices, Il2CppStructArray<int> sourceTriIndices, Il2CppStructArray<Vector3> baryPositions, Il2CppStructArray<Vector3> baryNormals, Il2CppStructArray<Vector3> baryTangents, int num)
	{
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref skinmap;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(skinIndices);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(sourceTriIndices);
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryPositions);
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryNormals);
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(baryTangents);
		ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072C0 RID: 29376 RVA: 0x001D2B6C File Offset: 0x001D0D6C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586954, RefRangeEnd = 586955, XrefRangeStart = 586952, XrefRangeEnd = 586954, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void WaitForAllTasks()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072C1 RID: 29377 RVA: 0x001D2BA0 File Offset: 0x001D0DA0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586955, XrefRangeEnd = 586957, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void ClearTasks()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072C2 RID: 29378 RVA: 0x001D2BD4 File Offset: 0x001D0DD4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586959, RefRangeEnd = 586960, XrefRangeStart = 586957, XrefRangeEnd = 586959, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetMaxSystemConcurrency()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072C3 RID: 29379 RVA: 0x001D2C18 File Offset: 0x001D0E18
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 586962, RefRangeEnd = 586963, XrefRangeStart = 586960, XrefRangeEnd = 586962, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void SignalFrameStart()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060072C4 RID: 29380 RVA: 0x001D2C4C File Offset: 0x001D0E4C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586965, RefRangeEnd = 586967, XrefRangeStart = 586963, XrefRangeEnd = 586965, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static double SignalFrameEnd()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072C5 RID: 29381 RVA: 0x001D2C90 File Offset: 0x001D0E90
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586969, RefRangeEnd = 586971, XrefRangeStart = 586967, XrefRangeEnd = 586969, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void EnableProfiler(bool cooked)
	{
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref cooked;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060072C6 RID: 29382 RVA: 0x001D2CD8 File Offset: 0x001D0ED8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586973, RefRangeEnd = 586975, XrefRangeStart = 586971, XrefRangeEnd = 586973, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static int GetProfilingInfoCount()
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0, 0, (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x060072C7 RID: 29383 RVA: 0x001D2D1C File Offset: 0x001D0F1C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 586984, RefRangeEnd = 586986, XrefRangeStart = 586975, XrefRangeEnd = 586984, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe static void GetProfilingInfo([Out] Il2CppReferenceArray<Oni.ProfileInfo> info, int num)
	{
		IntPtr* ptr;
		IntPtr intPtr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			ref IntPtr ptr2 = ref *ptr;
			intPtr = 0;
			ptr2 = &intPtr;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref num;
		IntPtr intPtr3;
		IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(Oni.NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0, 0, (void**)ptr, ref intPtr3);
		Il2CppException.RaiseExceptionIfNecessary(intPtr3);
		IntPtr intPtr4 = intPtr;
		*info = ((intPtr4 == 0) ? null : new Il2CppReferenceArray(intPtr4));
	}

	// Token: 0x060072C8 RID: 29384 RVA: 0x001D2D90 File Offset: 0x001D0F90
	// Note: this type is marked as 'beforefieldinit'.
	static Oni()
	{
		Il2CppClassPointerStore<Oni>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "Oni");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni>.NativeClassPtr);
		Oni.NativeMethodInfoPtr_PinMemory_Public_Static_GCHandle_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671800);
		Oni.NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671801);
		Oni.NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671802);
		Oni.NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671803);
		Oni.NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671804);
		Oni.NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671805);
		Oni.NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671806);
		Oni.NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671807);
		Oni.NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671808);
		Oni.NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671809);
		Oni.NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671810);
		Oni.NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671811);
		Oni.NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671812);
		Oni.NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671813);
		Oni.NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671814);
		Oni.NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671815);
		Oni.NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671816);
		Oni.NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671817);
		Oni.NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671818);
		Oni.NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671819);
		Oni.NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671820);
		Oni.NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671821);
		Oni.NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671822);
		Oni.NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671823);
		Oni.NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671824);
		Oni.NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671825);
		Oni.NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671826);
		Oni.NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671827);
		Oni.NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671828);
		Oni.NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671829);
		Oni.NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671830);
		Oni.NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671831);
		Oni.NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671832);
		Oni.NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671833);
		Oni.NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671834);
		Oni.NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671835);
		Oni.NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671836);
		Oni.NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671837);
		Oni.NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671838);
		Oni.NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671839);
		Oni.NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671840);
		Oni.NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671841);
		Oni.NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671842);
		Oni.NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671843);
		Oni.NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671844);
		Oni.NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671845);
		Oni.NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671846);
		Oni.NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671847);
		Oni.NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671848);
		Oni.NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671849);
		Oni.NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671850);
		Oni.NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671851);
		Oni.NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671852);
		Oni.NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671853);
		Oni.NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671854);
		Oni.NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671855);
		Oni.NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671856);
		Oni.NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671857);
		Oni.NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671858);
		Oni.NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671859);
		Oni.NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671860);
		Oni.NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671861);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671862);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671863);
		Oni.NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671864);
		Oni.NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671865);
		Oni.NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671866);
		Oni.NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671867);
		Oni.NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671868);
		Oni.NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671869);
		Oni.NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671870);
		Oni.NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671871);
		Oni.NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671872);
		Oni.NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671873);
		Oni.NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671874);
		Oni.NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671875);
		Oni.NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671876);
		Oni.NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671877);
		Oni.NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671878);
		Oni.NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671879);
		Oni.NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671880);
		Oni.NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671881);
		Oni.NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671882);
		Oni.NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671883);
		Oni.NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671884);
		Oni.NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671885);
		Oni.NativeMethodInfoPtr_SetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671886);
		Oni.NativeMethodInfoPtr_GetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671887);
		Oni.NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671888);
		Oni.NativeMethodInfoPtr_SetVolumeConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671889);
		Oni.NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671890);
		Oni.NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671891);
		Oni.NativeMethodInfoPtr_SetPinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671892);
		Oni.NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671893);
		Oni.NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671894);
		Oni.NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671895);
		Oni.NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671896);
		Oni.NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671897);
		Oni.NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671898);
		Oni.NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671899);
		Oni.NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671900);
		Oni.NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671901);
		Oni.NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671902);
		Oni.NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671903);
		Oni.NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671904);
		Oni.NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671905);
		Oni.NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671906);
		Oni.NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671907);
		Oni.NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671908);
		Oni.NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671909);
		Oni.NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671910);
		Oni.NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671911);
		Oni.NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671912);
		Oni.NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671913);
		Oni.NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671914);
		Oni.NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671915);
		Oni.NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671916);
		Oni.NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671917);
		Oni.NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671918);
		Oni.NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671919);
		Oni.NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671920);
		Oni.NativeMethodInfoPtr_GetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671921);
		Oni.NativeMethodInfoPtr_SetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671922);
		Oni.NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671923);
		Oni.NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671924);
		Oni.NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671925);
		Oni.NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671926);
		Oni.NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671927);
		Oni.NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671928);
		Oni.NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671929);
		Oni.NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671930);
	}

	// Token: 0x060072C9 RID: 29385 RVA: 0x0000A688 File Offset: 0x00008888
	public Oni(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x04004BC1 RID: 19393
	private static readonly IntPtr NativeMethodInfoPtr_PinMemory_Public_Static_GCHandle_Object_0;

	// Token: 0x04004BC2 RID: 19394
	private static readonly IntPtr NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0;

	// Token: 0x04004BC3 RID: 19395
	private static readonly IntPtr NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0;

	// Token: 0x04004BC4 RID: 19396
	private static readonly IntPtr NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BC5 RID: 19397
	private static readonly IntPtr NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0;

	// Token: 0x04004BC6 RID: 19398
	private static readonly IntPtr NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BC7 RID: 19399
	private static readonly IntPtr NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0;

	// Token: 0x04004BC8 RID: 19400
	private static readonly IntPtr NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BC9 RID: 19401
	private static readonly IntPtr NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0;

	// Token: 0x04004BCA RID: 19402
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0;

	// Token: 0x04004BCB RID: 19403
	private static readonly IntPtr NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0;

	// Token: 0x04004BCC RID: 19404
	private static readonly IntPtr NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0;

	// Token: 0x04004BCD RID: 19405
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BCE RID: 19406
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BCF RID: 19407
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BD0 RID: 19408
	private static readonly IntPtr NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0;

	// Token: 0x04004BD1 RID: 19409
	private static readonly IntPtr NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BD2 RID: 19410
	private static readonly IntPtr NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0;

	// Token: 0x04004BD3 RID: 19411
	private static readonly IntPtr NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0;

	// Token: 0x04004BD4 RID: 19412
	private static readonly IntPtr NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BD5 RID: 19413
	private static readonly IntPtr NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BD6 RID: 19414
	private static readonly IntPtr NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BD7 RID: 19415
	private static readonly IntPtr NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0;

	// Token: 0x04004BD8 RID: 19416
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004BD9 RID: 19417
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0;

	// Token: 0x04004BDA RID: 19418
	private static readonly IntPtr NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04004BDB RID: 19419
	private static readonly IntPtr NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04004BDC RID: 19420
	private static readonly IntPtr NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004BDD RID: 19421
	private static readonly IntPtr NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004BDE RID: 19422
	private static readonly IntPtr NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BDF RID: 19423
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004BE0 RID: 19424
	private static readonly IntPtr NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004BE1 RID: 19425
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0;

	// Token: 0x04004BE2 RID: 19426
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x04004BE3 RID: 19427
	private static readonly IntPtr NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x04004BE4 RID: 19428
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0;

	// Token: 0x04004BE5 RID: 19429
	private static readonly IntPtr NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004BE6 RID: 19430
	private static readonly IntPtr NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BE7 RID: 19431
	private static readonly IntPtr NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BE8 RID: 19432
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004BE9 RID: 19433
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BEA RID: 19434
	private static readonly IntPtr NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BEB RID: 19435
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004BEC RID: 19436
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004BED RID: 19437
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BEE RID: 19438
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BEF RID: 19439
	private static readonly IntPtr NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004BF0 RID: 19440
	private static readonly IntPtr NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004BF1 RID: 19441
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BF2 RID: 19442
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004BF3 RID: 19443
	private static readonly IntPtr NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004BF4 RID: 19444
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004BF5 RID: 19445
	private static readonly IntPtr NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0;

	// Token: 0x04004BF6 RID: 19446
	private static readonly IntPtr NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0;

	// Token: 0x04004BF7 RID: 19447
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0;

	// Token: 0x04004BF8 RID: 19448
	private static readonly IntPtr NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004BF9 RID: 19449
	private static readonly IntPtr NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004BFA RID: 19450
	private static readonly IntPtr NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0;

	// Token: 0x04004BFB RID: 19451
	private static readonly IntPtr NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004BFC RID: 19452
	private static readonly IntPtr NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0;

	// Token: 0x04004BFD RID: 19453
	private static readonly IntPtr NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004BFE RID: 19454
	private static readonly IntPtr NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0;

	// Token: 0x04004BFF RID: 19455
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0;

	// Token: 0x04004C00 RID: 19456
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C01 RID: 19457
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0;

	// Token: 0x04004C02 RID: 19458
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C03 RID: 19459
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0;

	// Token: 0x04004C04 RID: 19460
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0;

	// Token: 0x04004C05 RID: 19461
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C06 RID: 19462
	private static readonly IntPtr NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C07 RID: 19463
	private static readonly IntPtr NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0;

	// Token: 0x04004C08 RID: 19464
	private static readonly IntPtr NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C09 RID: 19465
	private static readonly IntPtr NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0;

	// Token: 0x04004C0A RID: 19466
	private static readonly IntPtr NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C0B RID: 19467
	private static readonly IntPtr NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0;

	// Token: 0x04004C0C RID: 19468
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C0D RID: 19469
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004C0E RID: 19470
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C0F RID: 19471
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x04004C10 RID: 19472
	private static readonly IntPtr NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004C11 RID: 19473
	private static readonly IntPtr NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0;

	// Token: 0x04004C12 RID: 19474
	private static readonly IntPtr NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004C13 RID: 19475
	private static readonly IntPtr NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x04004C14 RID: 19476
	private static readonly IntPtr NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0;

	// Token: 0x04004C15 RID: 19477
	private static readonly IntPtr NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x04004C16 RID: 19478
	private static readonly IntPtr NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0;

	// Token: 0x04004C17 RID: 19479
	private static readonly IntPtr NativeMethodInfoPtr_SetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C18 RID: 19480
	private static readonly IntPtr NativeMethodInfoPtr_GetSkinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Single_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C19 RID: 19481
	private static readonly IntPtr NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C1A RID: 19482
	private static readonly IntPtr NativeMethodInfoPtr_SetVolumeConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x04004C1B RID: 19483
	private static readonly IntPtr NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C1C RID: 19484
	private static readonly IntPtr NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C1D RID: 19485
	private static readonly IntPtr NativeMethodInfoPtr_SetPinConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C1E RID: 19486
	private static readonly IntPtr NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C1F RID: 19487
	private static readonly IntPtr NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0;

	// Token: 0x04004C20 RID: 19488
	private static readonly IntPtr NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C21 RID: 19489
	private static readonly IntPtr NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0;

	// Token: 0x04004C22 RID: 19490
	private static readonly IntPtr NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C23 RID: 19491
	private static readonly IntPtr NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C24 RID: 19492
	private static readonly IntPtr NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0;

	// Token: 0x04004C25 RID: 19493
	private static readonly IntPtr NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C26 RID: 19494
	private static readonly IntPtr NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x04004C27 RID: 19495
	private static readonly IntPtr NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x04004C28 RID: 19496
	private static readonly IntPtr NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x04004C29 RID: 19497
	private static readonly IntPtr NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C2A RID: 19498
	private static readonly IntPtr NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C2B RID: 19499
	private static readonly IntPtr NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C2C RID: 19500
	private static readonly IntPtr NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C2D RID: 19501
	private static readonly IntPtr NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C2E RID: 19502
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C2F RID: 19503
	private static readonly IntPtr NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C30 RID: 19504
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0;

	// Token: 0x04004C31 RID: 19505
	private static readonly IntPtr NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004C32 RID: 19506
	private static readonly IntPtr NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0;

	// Token: 0x04004C33 RID: 19507
	private static readonly IntPtr NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0;

	// Token: 0x04004C34 RID: 19508
	private static readonly IntPtr NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0;

	// Token: 0x04004C35 RID: 19509
	private static readonly IntPtr NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C36 RID: 19510
	private static readonly IntPtr NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0;

	// Token: 0x04004C37 RID: 19511
	private static readonly IntPtr NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C38 RID: 19512
	private static readonly IntPtr NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0;

	// Token: 0x04004C39 RID: 19513
	private static readonly IntPtr NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C3A RID: 19514
	private static readonly IntPtr NativeMethodInfoPtr_GetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_0;

	// Token: 0x04004C3B RID: 19515
	private static readonly IntPtr NativeMethodInfoPtr_SetSkinInfo_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Vector3_Int32_0;

	// Token: 0x04004C3C RID: 19516
	private static readonly IntPtr NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0;

	// Token: 0x04004C3D RID: 19517
	private static readonly IntPtr NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0;

	// Token: 0x04004C3E RID: 19518
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0;

	// Token: 0x04004C3F RID: 19519
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0;

	// Token: 0x04004C40 RID: 19520
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0;

	// Token: 0x04004C41 RID: 19521
	private static readonly IntPtr NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0;

	// Token: 0x04004C42 RID: 19522
	private static readonly IntPtr NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0;

	// Token: 0x04004C43 RID: 19523
	private static readonly IntPtr NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0;

	// Token: 0x02000372 RID: 882
	public enum ConstraintType
	{
		// Token: 0x04004C45 RID: 19525
		Tether,
		// Token: 0x04004C46 RID: 19526
		Pin,
		// Token: 0x04004C47 RID: 19527
		Volume,
		// Token: 0x04004C48 RID: 19528
		Bending,
		// Token: 0x04004C49 RID: 19529
		Distance,
		// Token: 0x04004C4A RID: 19530
		ParticleCollision,
		// Token: 0x04004C4B RID: 19531
		Density,
		// Token: 0x04004C4C RID: 19532
		Collision,
		// Token: 0x04004C4D RID: 19533
		Skin,
		// Token: 0x04004C4E RID: 19534
		Aerodynamics,
		// Token: 0x04004C4F RID: 19535
		Stitch,
		// Token: 0x04004C50 RID: 19536
		ShapeMatching
	}

	// Token: 0x02000373 RID: 883
	public enum ParticlePhase
	{
		// Token: 0x04004C52 RID: 19538
		SelfCollide = 16777216,
		// Token: 0x04004C53 RID: 19539
		Fluid = 33554432
	}

	// Token: 0x02000374 RID: 884
	public enum ShapeType
	{
		// Token: 0x04004C55 RID: 19541
		Sphere,
		// Token: 0x04004C56 RID: 19542
		Box,
		// Token: 0x04004C57 RID: 19543
		Capsule,
		// Token: 0x04004C58 RID: 19544
		Heightmap,
		// Token: 0x04004C59 RID: 19545
		TriangleMesh,
		// Token: 0x04004C5A RID: 19546
		EdgeMesh
	}

	// Token: 0x02000375 RID: 885
	public enum MaterialCombineMode
	{
		// Token: 0x04004C5C RID: 19548
		Average,
		// Token: 0x04004C5D RID: 19549
		Minimium,
		// Token: 0x04004C5E RID: 19550
		Multiply,
		// Token: 0x04004C5F RID: 19551
		Maximum
	}

	// Token: 0x02000376 RID: 886
	public enum NormalsUpdate
	{
		// Token: 0x04004C61 RID: 19553
		Recalculate,
		// Token: 0x04004C62 RID: 19554
		Skin
	}

	// Token: 0x02000377 RID: 887
	public sealed class ProfileInfo : ValueType
	{
		// Token: 0x060072CA RID: 29386 RVA: 0x001D37FC File Offset: 0x001D19FC
		// Note: this type is marked as 'beforefieldinit'.
		static ProfileInfo()
		{
			Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "ProfileInfo");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr);
			Oni.ProfileInfo.NativeFieldInfoPtr_start = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "start");
			Oni.ProfileInfo.NativeFieldInfoPtr_end = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "end");
			Oni.ProfileInfo.NativeFieldInfoPtr_childDuration = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "childDuration");
			Oni.ProfileInfo.NativeFieldInfoPtr_threadID = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "threadID");
			Oni.ProfileInfo.NativeFieldInfoPtr_level = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "level");
			Oni.ProfileInfo.NativeFieldInfoPtr_name = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, "name");
		}

		// Token: 0x060072CB RID: 29387 RVA: 0x0011646F File Offset: 0x0011466F
		public ProfileInfo(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x060072CC RID: 29388 RVA: 0x001D38A0 File Offset: 0x001D1AA0
		public unsafe ProfileInfo()
		{
			IntPtr intPtr = stackalloc byte[(UIntPtr)IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, (UIntPtr)0)];
			base..ctor(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.ProfileInfo>.NativeClassPtr, intPtr));
		}

		// Token: 0x1700275F RID: 10079
		// (get) Token: 0x060072CD RID: 29389 RVA: 0x001D38D0 File Offset: 0x001D1AD0
		// (set) Token: 0x060072CE RID: 29390 RVA: 0x001D38F8 File Offset: 0x001D1AF8
		public unsafe double start
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_start);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_start)) = value;
			}
		}

		// Token: 0x17002760 RID: 10080
		// (get) Token: 0x060072CF RID: 29391 RVA: 0x001D391C File Offset: 0x001D1B1C
		// (set) Token: 0x060072D0 RID: 29392 RVA: 0x001D3944 File Offset: 0x001D1B44
		public unsafe double end
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_end);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_end)) = value;
			}
		}

		// Token: 0x17002761 RID: 10081
		// (get) Token: 0x060072D1 RID: 29393 RVA: 0x001D3968 File Offset: 0x001D1B68
		// (set) Token: 0x060072D2 RID: 29394 RVA: 0x001D3990 File Offset: 0x001D1B90
		public unsafe double childDuration
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_childDuration);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_childDuration)) = value;
			}
		}

		// Token: 0x17002762 RID: 10082
		// (get) Token: 0x060072D3 RID: 29395 RVA: 0x001D39B4 File Offset: 0x001D1BB4
		// (set) Token: 0x060072D4 RID: 29396 RVA: 0x001D39DC File Offset: 0x001D1BDC
		public unsafe int threadID
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_threadID);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_threadID)) = value;
			}
		}

		// Token: 0x17002763 RID: 10083
		// (get) Token: 0x060072D5 RID: 29397 RVA: 0x001D3A00 File Offset: 0x001D1C00
		// (set) Token: 0x060072D6 RID: 29398 RVA: 0x001D3A28 File Offset: 0x001D1C28
		public unsafe int level
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_level);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_level)) = value;
			}
		}

		// Token: 0x17002764 RID: 10084
		// (get) Token: 0x060072D7 RID: 29399 RVA: 0x001D3A4C File Offset: 0x001D1C4C
		// (set) Token: 0x060072D8 RID: 29400 RVA: 0x001D3A75 File Offset: 0x001D1C75
		public unsafe string name
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_name);
				return IL2CPP.Il2CppStringToManaged(*intPtr);
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Oni.ProfileInfo.NativeFieldInfoPtr_name), IL2CPP.ManagedStringToIl2Cpp(value));
			}
		}

		// Token: 0x04004C63 RID: 19555
		private static readonly IntPtr NativeFieldInfoPtr_start;

		// Token: 0x04004C64 RID: 19556
		private static readonly IntPtr NativeFieldInfoPtr_end;

		// Token: 0x04004C65 RID: 19557
		private static readonly IntPtr NativeFieldInfoPtr_childDuration;

		// Token: 0x04004C66 RID: 19558
		private static readonly IntPtr NativeFieldInfoPtr_threadID;

		// Token: 0x04004C67 RID: 19559
		private static readonly IntPtr NativeFieldInfoPtr_level;

		// Token: 0x04004C68 RID: 19560
		private static readonly IntPtr NativeFieldInfoPtr_name;
	}

	// Token: 0x02000378 RID: 888
	[StructLayout(LayoutKind.Explicit)]
	public struct GridCell
	{
		// Token: 0x060072D9 RID: 29401 RVA: 0x001D3A9C File Offset: 0x001D1C9C
		// Note: this type is marked as 'beforefieldinit'.
		static GridCell()
		{
			Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "GridCell");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr);
			Oni.GridCell.NativeFieldInfoPtr_center = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, "center");
			Oni.GridCell.NativeFieldInfoPtr_size = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, "size");
			Oni.GridCell.NativeFieldInfoPtr_count = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, "count");
		}

		// Token: 0x060072DA RID: 29402 RVA: 0x001D3B03 File Offset: 0x001D1D03
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, ref this));
		}

		// Token: 0x04004C69 RID: 19561
		private static readonly IntPtr NativeFieldInfoPtr_center;

		// Token: 0x04004C6A RID: 19562
		private static readonly IntPtr NativeFieldInfoPtr_size;

		// Token: 0x04004C6B RID: 19563
		private static readonly IntPtr NativeFieldInfoPtr_count;

		// Token: 0x04004C6C RID: 19564
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04004C6D RID: 19565
		[FieldOffset(12)]
		public Vector3 size;

		// Token: 0x04004C6E RID: 19566
		[FieldOffset(24)]
		public int count;
	}

	// Token: 0x02000379 RID: 889
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct SolverParameters
	{
		// Token: 0x060072DB RID: 29403 RVA: 0x001D3B18 File Offset: 0x001D1D18
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 586120, RefRangeEnd = 586121, XrefRangeStart = 586119, XrefRangeEnd = 586120, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe SolverParameters(Oni.SolverParameters.Interpolation interpolation, Vector4 gravity)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref interpolation;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref gravity;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.SolverParameters.NativeMethodInfoPtr__ctor_Public_Void_Interpolation_Vector4_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072DC RID: 29404 RVA: 0x001D3B70 File Offset: 0x001D1D70
		// Note: this type is marked as 'beforefieldinit'.
		static SolverParameters()
		{
			Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "SolverParameters");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr);
			Oni.SolverParameters.NativeFieldInfoPtr_mode = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "mode");
			Oni.SolverParameters.NativeFieldInfoPtr_interpolation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "interpolation");
			Oni.SolverParameters.NativeFieldInfoPtr_gravity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "gravity");
			Oni.SolverParameters.NativeFieldInfoPtr_damping = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "damping");
			Oni.SolverParameters.NativeFieldInfoPtr_fluidDenoising = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "fluidDenoising");
			Oni.SolverParameters.NativeFieldInfoPtr_advectionRadius = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "advectionRadius");
			Oni.SolverParameters.NativeFieldInfoPtr_sleepThreshold = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, "sleepThreshold");
			Oni.SolverParameters.NativeMethodInfoPtr__ctor_Public_Void_Interpolation_Vector4_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, 100671931);
		}

		// Token: 0x060072DD RID: 29405 RVA: 0x001D3C3B File Offset: 0x001D1E3B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, ref this));
		}

		// Token: 0x04004C6F RID: 19567
		private static readonly IntPtr NativeFieldInfoPtr_mode;

		// Token: 0x04004C70 RID: 19568
		private static readonly IntPtr NativeFieldInfoPtr_interpolation;

		// Token: 0x04004C71 RID: 19569
		private static readonly IntPtr NativeFieldInfoPtr_gravity;

		// Token: 0x04004C72 RID: 19570
		private static readonly IntPtr NativeFieldInfoPtr_damping;

		// Token: 0x04004C73 RID: 19571
		private static readonly IntPtr NativeFieldInfoPtr_fluidDenoising;

		// Token: 0x04004C74 RID: 19572
		private static readonly IntPtr NativeFieldInfoPtr_advectionRadius;

		// Token: 0x04004C75 RID: 19573
		private static readonly IntPtr NativeFieldInfoPtr_sleepThreshold;

		// Token: 0x04004C76 RID: 19574
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Interpolation_Vector4_0;

		// Token: 0x04004C77 RID: 19575
		[FieldOffset(0)]
		public Oni.SolverParameters.Mode mode;

		// Token: 0x04004C78 RID: 19576
		[FieldOffset(4)]
		public Oni.SolverParameters.Interpolation interpolation;

		// Token: 0x04004C79 RID: 19577
		[FieldOffset(8)]
		public Vector3 gravity;

		// Token: 0x04004C7A RID: 19578
		[FieldOffset(20)]
		public float damping;

		// Token: 0x04004C7B RID: 19579
		[FieldOffset(24)]
		public float fluidDenoising;

		// Token: 0x04004C7C RID: 19580
		[FieldOffset(28)]
		public float advectionRadius;

		// Token: 0x04004C7D RID: 19581
		[FieldOffset(32)]
		public float sleepThreshold;

		// Token: 0x0200037A RID: 890
		public enum Interpolation
		{
			// Token: 0x04004C7F RID: 19583
			None,
			// Token: 0x04004C80 RID: 19584
			Interpolate
		}

		// Token: 0x0200037B RID: 891
		public enum Mode
		{
			// Token: 0x04004C82 RID: 19586
			Mode3D,
			// Token: 0x04004C83 RID: 19587
			Mode2D
		}
	}

	// Token: 0x0200037C RID: 892
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct ConstraintParameters
	{
		// Token: 0x060072DE RID: 29406 RVA: 0x001D3C50 File Offset: 0x001D1E50
		[CallerCount(10)]
		[CachedScanResults(RefRangeStart = 586121, RefRangeEnd = 586131, XrefRangeStart = 586121, XrefRangeEnd = 586121, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe ConstraintParameters(bool enabled, Oni.ConstraintParameters.EvaluationOrder order, int iterations)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref enabled;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref order;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref iterations;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.ConstraintParameters.NativeMethodInfoPtr__ctor_Public_Void_Boolean_EvaluationOrder_Int32_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072DF RID: 29407 RVA: 0x001D3CBC File Offset: 0x001D1EBC
		// Note: this type is marked as 'beforefieldinit'.
		static ConstraintParameters()
		{
			Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "ConstraintParameters");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr);
			Oni.ConstraintParameters.NativeFieldInfoPtr_enabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, "enabled");
			Oni.ConstraintParameters.NativeFieldInfoPtr_evaluationOrder = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, "evaluationOrder");
			Oni.ConstraintParameters.NativeFieldInfoPtr_iterations = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, "iterations");
			Oni.ConstraintParameters.NativeFieldInfoPtr_SORFactor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, "SORFactor");
			Oni.ConstraintParameters.NativeMethodInfoPtr__ctor_Public_Void_Boolean_EvaluationOrder_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, 100671932);
		}

		// Token: 0x060072E0 RID: 29408 RVA: 0x001D3D4B File Offset: 0x001D1F4B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, ref this));
		}

		// Token: 0x04004C84 RID: 19588
		private static readonly IntPtr NativeFieldInfoPtr_enabled;

		// Token: 0x04004C85 RID: 19589
		private static readonly IntPtr NativeFieldInfoPtr_evaluationOrder;

		// Token: 0x04004C86 RID: 19590
		private static readonly IntPtr NativeFieldInfoPtr_iterations;

		// Token: 0x04004C87 RID: 19591
		private static readonly IntPtr NativeFieldInfoPtr_SORFactor;

		// Token: 0x04004C88 RID: 19592
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Boolean_EvaluationOrder_Int32_0;

		// Token: 0x04004C89 RID: 19593
		[FieldOffset(0)]
		[MarshalAs(UnmanagedType.U1)]
		public bool enabled;

		// Token: 0x04004C8A RID: 19594
		[FieldOffset(1)]
		public Oni.ConstraintParameters.EvaluationOrder evaluationOrder;

		// Token: 0x04004C8B RID: 19595
		[FieldOffset(5)]
		public int iterations;

		// Token: 0x04004C8C RID: 19596
		[FieldOffset(9)]
		public float SORFactor;

		// Token: 0x0200037D RID: 893
		public enum EvaluationOrder
		{
			// Token: 0x04004C8E RID: 19598
			Sequential,
			// Token: 0x04004C8F RID: 19599
			Parallel
		}
	}

	// Token: 0x0200037E RID: 894
	[StructLayout(LayoutKind.Explicit)]
	public struct Contact
	{
		// Token: 0x060072E1 RID: 29409 RVA: 0x001D3D60 File Offset: 0x001D1F60
		// Note: this type is marked as 'beforefieldinit'.
		static Contact()
		{
			Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Contact");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr);
			Oni.Contact.NativeFieldInfoPtr_point = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "point");
			Oni.Contact.NativeFieldInfoPtr_normal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "normal");
			Oni.Contact.NativeFieldInfoPtr_tangent = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "tangent");
			Oni.Contact.NativeFieldInfoPtr_bitangent = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "bitangent");
			Oni.Contact.NativeFieldInfoPtr_distance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "distance");
			Oni.Contact.NativeFieldInfoPtr_normalImpulse = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "normalImpulse");
			Oni.Contact.NativeFieldInfoPtr_tangentImpulse = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "tangentImpulse");
			Oni.Contact.NativeFieldInfoPtr_bitangentImpulse = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "bitangentImpulse");
			Oni.Contact.NativeFieldInfoPtr_stickImpulse = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "stickImpulse");
			Oni.Contact.NativeFieldInfoPtr_particle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "particle");
			Oni.Contact.NativeFieldInfoPtr_other = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, "other");
		}

		// Token: 0x060072E2 RID: 29410 RVA: 0x001D3E67 File Offset: 0x001D2067
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, ref this));
		}

		// Token: 0x04004C90 RID: 19600
		private static readonly IntPtr NativeFieldInfoPtr_point;

		// Token: 0x04004C91 RID: 19601
		private static readonly IntPtr NativeFieldInfoPtr_normal;

		// Token: 0x04004C92 RID: 19602
		private static readonly IntPtr NativeFieldInfoPtr_tangent;

		// Token: 0x04004C93 RID: 19603
		private static readonly IntPtr NativeFieldInfoPtr_bitangent;

		// Token: 0x04004C94 RID: 19604
		private static readonly IntPtr NativeFieldInfoPtr_distance;

		// Token: 0x04004C95 RID: 19605
		private static readonly IntPtr NativeFieldInfoPtr_normalImpulse;

		// Token: 0x04004C96 RID: 19606
		private static readonly IntPtr NativeFieldInfoPtr_tangentImpulse;

		// Token: 0x04004C97 RID: 19607
		private static readonly IntPtr NativeFieldInfoPtr_bitangentImpulse;

		// Token: 0x04004C98 RID: 19608
		private static readonly IntPtr NativeFieldInfoPtr_stickImpulse;

		// Token: 0x04004C99 RID: 19609
		private static readonly IntPtr NativeFieldInfoPtr_particle;

		// Token: 0x04004C9A RID: 19610
		private static readonly IntPtr NativeFieldInfoPtr_other;

		// Token: 0x04004C9B RID: 19611
		[FieldOffset(0)]
		public Vector4 point;

		// Token: 0x04004C9C RID: 19612
		[FieldOffset(16)]
		public Vector4 normal;

		// Token: 0x04004C9D RID: 19613
		[FieldOffset(32)]
		public Vector4 tangent;

		// Token: 0x04004C9E RID: 19614
		[FieldOffset(48)]
		public Vector4 bitangent;

		// Token: 0x04004C9F RID: 19615
		[FieldOffset(64)]
		public float distance;

		// Token: 0x04004CA0 RID: 19616
		[FieldOffset(68)]
		public float normalImpulse;

		// Token: 0x04004CA1 RID: 19617
		[FieldOffset(72)]
		public float tangentImpulse;

		// Token: 0x04004CA2 RID: 19618
		[FieldOffset(76)]
		public float bitangentImpulse;

		// Token: 0x04004CA3 RID: 19619
		[FieldOffset(80)]
		public float stickImpulse;

		// Token: 0x04004CA4 RID: 19620
		[FieldOffset(84)]
		public int particle;

		// Token: 0x04004CA5 RID: 19621
		[FieldOffset(88)]
		public int other;
	}

	// Token: 0x0200037F RID: 895
	[StructLayout(LayoutKind.Explicit)]
	public struct BoneWeights
	{
		// Token: 0x060072E3 RID: 29411 RVA: 0x001D3E7C File Offset: 0x001D207C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 586139, RefRangeEnd = 586141, XrefRangeStart = 586131, XrefRangeEnd = 586139, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe BoneWeights(BoneWeight weight)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.BoneWeights.NativeMethodInfoPtr__ctor_Public_Void_BoneWeight_0, ref this, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060072E4 RID: 29412 RVA: 0x001D3EC4 File Offset: 0x001D20C4
		// Note: this type is marked as 'beforefieldinit'.
		static BoneWeights()
		{
			Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "BoneWeights");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr);
			Oni.BoneWeights.NativeFieldInfoPtr_bone0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "bone0");
			Oni.BoneWeights.NativeFieldInfoPtr_bone1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "bone1");
			Oni.BoneWeights.NativeFieldInfoPtr_bone2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "bone2");
			Oni.BoneWeights.NativeFieldInfoPtr_bone3 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "bone3");
			Oni.BoneWeights.NativeFieldInfoPtr_weight0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "weight0");
			Oni.BoneWeights.NativeFieldInfoPtr_weight1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "weight1");
			Oni.BoneWeights.NativeFieldInfoPtr_weight2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "weight2");
			Oni.BoneWeights.NativeFieldInfoPtr_weight3 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, "weight3");
			Oni.BoneWeights.NativeMethodInfoPtr__ctor_Public_Void_BoneWeight_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, 100671933);
		}

		// Token: 0x060072E5 RID: 29413 RVA: 0x001D3FA3 File Offset: 0x001D21A3
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CA6 RID: 19622
		private static readonly IntPtr NativeFieldInfoPtr_bone0;

		// Token: 0x04004CA7 RID: 19623
		private static readonly IntPtr NativeFieldInfoPtr_bone1;

		// Token: 0x04004CA8 RID: 19624
		private static readonly IntPtr NativeFieldInfoPtr_bone2;

		// Token: 0x04004CA9 RID: 19625
		private static readonly IntPtr NativeFieldInfoPtr_bone3;

		// Token: 0x04004CAA RID: 19626
		private static readonly IntPtr NativeFieldInfoPtr_weight0;

		// Token: 0x04004CAB RID: 19627
		private static readonly IntPtr NativeFieldInfoPtr_weight1;

		// Token: 0x04004CAC RID: 19628
		private static readonly IntPtr NativeFieldInfoPtr_weight2;

		// Token: 0x04004CAD RID: 19629
		private static readonly IntPtr NativeFieldInfoPtr_weight3;

		// Token: 0x04004CAE RID: 19630
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_BoneWeight_0;

		// Token: 0x04004CAF RID: 19631
		[FieldOffset(0)]
		public int bone0;

		// Token: 0x04004CB0 RID: 19632
		[FieldOffset(4)]
		public int bone1;

		// Token: 0x04004CB1 RID: 19633
		[FieldOffset(8)]
		public int bone2;

		// Token: 0x04004CB2 RID: 19634
		[FieldOffset(12)]
		public int bone3;

		// Token: 0x04004CB3 RID: 19635
		[FieldOffset(16)]
		public float weight0;

		// Token: 0x04004CB4 RID: 19636
		[FieldOffset(20)]
		public float weight1;

		// Token: 0x04004CB5 RID: 19637
		[FieldOffset(24)]
		public float weight2;

		// Token: 0x04004CB6 RID: 19638
		[FieldOffset(28)]
		public float weight3;
	}

	// Token: 0x02000380 RID: 896
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Rigidbody
	{
		// Token: 0x060072E6 RID: 29414 RVA: 0x001D3FB8 File Offset: 0x001D21B8
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 586168, RefRangeEnd = 586170, XrefRangeStart = 586141, XrefRangeEnd = 586168, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(UnityEngine.Rigidbody source, bool kinematicForParticles)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref kinematicForParticles;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody_Boolean_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072E7 RID: 29415 RVA: 0x001D4018 File Offset: 0x001D2218
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 586170, XrefRangeEnd = 586191, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Rigidbody2D source, bool kinematicForParticles)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref kinematicForParticles;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072E8 RID: 29416 RVA: 0x001D4078 File Offset: 0x001D2278
		// Note: this type is marked as 'beforefieldinit'.
		static Rigidbody()
		{
			Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Rigidbody");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr);
			Oni.Rigidbody.NativeFieldInfoPtr_rotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "rotation");
			Oni.Rigidbody.NativeFieldInfoPtr_linearVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "linearVelocity");
			Oni.Rigidbody.NativeFieldInfoPtr_angularVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "angularVelocity");
			Oni.Rigidbody.NativeFieldInfoPtr_centerOfMass = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "centerOfMass");
			Oni.Rigidbody.NativeFieldInfoPtr_inertiaTensor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "inertiaTensor");
			Oni.Rigidbody.NativeFieldInfoPtr_inverseMass = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, "inverseMass");
			Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, 100671934);
			Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, 100671935);
		}

		// Token: 0x060072E9 RID: 29417 RVA: 0x001D4143 File Offset: 0x001D2343
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CB7 RID: 19639
		private static readonly IntPtr NativeFieldInfoPtr_rotation;

		// Token: 0x04004CB8 RID: 19640
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x04004CB9 RID: 19641
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

		// Token: 0x04004CBA RID: 19642
		private static readonly IntPtr NativeFieldInfoPtr_centerOfMass;

		// Token: 0x04004CBB RID: 19643
		private static readonly IntPtr NativeFieldInfoPtr_inertiaTensor;

		// Token: 0x04004CBC RID: 19644
		private static readonly IntPtr NativeFieldInfoPtr_inverseMass;

		// Token: 0x04004CBD RID: 19645
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Rigidbody_Boolean_0;

		// Token: 0x04004CBE RID: 19646
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0;

		// Token: 0x04004CBF RID: 19647
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x04004CC0 RID: 19648
		[FieldOffset(16)]
		public Vector3 linearVelocity;

		// Token: 0x04004CC1 RID: 19649
		[FieldOffset(28)]
		public Vector3 angularVelocity;

		// Token: 0x04004CC2 RID: 19650
		[FieldOffset(40)]
		public Vector3 centerOfMass;

		// Token: 0x04004CC3 RID: 19651
		[FieldOffset(52)]
		public Vector3 inertiaTensor;

		// Token: 0x04004CC4 RID: 19652
		[FieldOffset(64)]
		public float inverseMass;
	}

	// Token: 0x02000381 RID: 897
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct RigidbodyVelocities
	{
		// Token: 0x060072EA RID: 29418 RVA: 0x001D4158 File Offset: 0x001D2358
		// Note: this type is marked as 'beforefieldinit'.
		static RigidbodyVelocities()
		{
			Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "RigidbodyVelocities");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr);
			Oni.RigidbodyVelocities.NativeFieldInfoPtr_linearVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr, "linearVelocity");
			Oni.RigidbodyVelocities.NativeFieldInfoPtr_angularVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr, "angularVelocity");
		}

		// Token: 0x060072EB RID: 29419 RVA: 0x001D41AB File Offset: 0x001D23AB
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CC5 RID: 19653
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x04004CC6 RID: 19654
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

		// Token: 0x04004CC7 RID: 19655
		[FieldOffset(0)]
		public Vector3 linearVelocity;

		// Token: 0x04004CC8 RID: 19656
		[FieldOffset(12)]
		public Vector3 angularVelocity;
	}

	// Token: 0x02000382 RID: 898
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Collider
	{
		// Token: 0x060072EC RID: 29420 RVA: 0x001D41C0 File Offset: 0x001D23C0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 586213, RefRangeEnd = 586214, XrefRangeStart = 586191, XrefRangeEnd = 586213, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(UnityEngine.Collider source, int phase, float thickness)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref phase;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref thickness;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider_Int32_Single_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072ED RID: 29421 RVA: 0x001D4230 File Offset: 0x001D2430
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 586234, RefRangeEnd = 586235, XrefRangeStart = 586214, XrefRangeEnd = 586234, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Collider2D source, int phase, float thickness)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref phase;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref thickness;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072EE RID: 29422 RVA: 0x001D42A0 File Offset: 0x001D24A0
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 586290, RefRangeEnd = 586292, XrefRangeStart = 586235, XrefRangeEnd = 586290, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetSpaceTransform(Transform space)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(space);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Collider.NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0, ref this, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060072EF RID: 29423 RVA: 0x001D42EC File Offset: 0x001D24EC
		// Note: this type is marked as 'beforefieldinit'.
		static Collider()
		{
			Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Collider");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr);
			Oni.Collider.NativeFieldInfoPtr_rotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "rotation");
			Oni.Collider.NativeFieldInfoPtr_translation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "translation");
			Oni.Collider.NativeFieldInfoPtr_scale = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "scale");
			Oni.Collider.NativeFieldInfoPtr_boundsMin = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "boundsMin");
			Oni.Collider.NativeFieldInfoPtr_boundsMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "boundsMax");
			Oni.Collider.NativeFieldInfoPtr_id = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "id");
			Oni.Collider.NativeFieldInfoPtr_contactOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "contactOffset");
			Oni.Collider.NativeFieldInfoPtr_collisionGroup = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "collisionGroup");
			Oni.Collider.NativeFieldInfoPtr_trigger = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, "trigger");
			Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100671936);
			Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100671937);
			Oni.Collider.NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100671938);
		}

		// Token: 0x060072F0 RID: 29424 RVA: 0x001D4407 File Offset: 0x001D2607
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CC9 RID: 19657
		private static readonly IntPtr NativeFieldInfoPtr_rotation;

		// Token: 0x04004CCA RID: 19658
		private static readonly IntPtr NativeFieldInfoPtr_translation;

		// Token: 0x04004CCB RID: 19659
		private static readonly IntPtr NativeFieldInfoPtr_scale;

		// Token: 0x04004CCC RID: 19660
		private static readonly IntPtr NativeFieldInfoPtr_boundsMin;

		// Token: 0x04004CCD RID: 19661
		private static readonly IntPtr NativeFieldInfoPtr_boundsMax;

		// Token: 0x04004CCE RID: 19662
		private static readonly IntPtr NativeFieldInfoPtr_id;

		// Token: 0x04004CCF RID: 19663
		private static readonly IntPtr NativeFieldInfoPtr_contactOffset;

		// Token: 0x04004CD0 RID: 19664
		private static readonly IntPtr NativeFieldInfoPtr_collisionGroup;

		// Token: 0x04004CD1 RID: 19665
		private static readonly IntPtr NativeFieldInfoPtr_trigger;

		// Token: 0x04004CD2 RID: 19666
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider_Int32_Single_0;

		// Token: 0x04004CD3 RID: 19667
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0;

		// Token: 0x04004CD4 RID: 19668
		private static readonly IntPtr NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0;

		// Token: 0x04004CD5 RID: 19669
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x04004CD6 RID: 19670
		[FieldOffset(16)]
		public Vector3 translation;

		// Token: 0x04004CD7 RID: 19671
		[FieldOffset(28)]
		public Vector3 scale;

		// Token: 0x04004CD8 RID: 19672
		[FieldOffset(40)]
		public Vector3 boundsMin;

		// Token: 0x04004CD9 RID: 19673
		[FieldOffset(52)]
		public Vector3 boundsMax;

		// Token: 0x04004CDA RID: 19674
		[FieldOffset(64)]
		public int id;

		// Token: 0x04004CDB RID: 19675
		[FieldOffset(68)]
		public float contactOffset;

		// Token: 0x04004CDC RID: 19676
		[FieldOffset(72)]
		public int collisionGroup;

		// Token: 0x04004CDD RID: 19677
		[FieldOffset(76)]
		[MarshalAs(UnmanagedType.U1)]
		public bool trigger;
	}

	// Token: 0x02000383 RID: 899
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Shape
	{
		// Token: 0x060072F1 RID: 29425 RVA: 0x001D441C File Offset: 0x001D261C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 586293, RefRangeEnd = 586295, XrefRangeStart = 586292, XrefRangeEnd = 586293, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Vector3 center, float radius)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref center;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref radius;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072F2 RID: 29426 RVA: 0x001D4474 File Offset: 0x001D2674
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 359899, RefRangeEnd = 359904, XrefRangeStart = 359899, XrefRangeEnd = 359904, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Vector3 center, Vector3 size)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref center;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref size;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072F3 RID: 29427 RVA: 0x001D44CC File Offset: 0x001D26CC
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 586295, RefRangeEnd = 586298, XrefRangeStart = 586295, XrefRangeEnd = 586295, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Vector3 center, float radius, float height, int direction)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref center;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref radius;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref height;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072F4 RID: 29428 RVA: 0x001D454C File Offset: 0x001D274C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 586298, RefRangeEnd = 586299, XrefRangeStart = 586298, XrefRangeEnd = 586298, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(Vector3 size, int resolutionU, int resolutionV, IntPtr data)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref size;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref resolutionU;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref resolutionV;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref data;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072F5 RID: 29429 RVA: 0x001D45CC File Offset: 0x001D27CC
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 586299, RefRangeEnd = 586301, XrefRangeStart = 586299, XrefRangeEnd = 586299, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Set(IntPtr data, IntPtr indices, int dataCount, int indicesCount)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref data;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref indices;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref dataCount;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref indicesCount;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060072F6 RID: 29430 RVA: 0x001D464C File Offset: 0x001D284C
		// Note: this type is marked as 'beforefieldinit'.
		static Shape()
		{
			Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Shape");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr);
			Oni.Shape.NativeFieldInfoPtr_center = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "center");
			Oni.Shape.NativeFieldInfoPtr_size = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "size");
			Oni.Shape.NativeFieldInfoPtr_data = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "data");
			Oni.Shape.NativeFieldInfoPtr_indices = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "indices");
			Oni.Shape.NativeFieldInfoPtr_dataCount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "dataCount");
			Oni.Shape.NativeFieldInfoPtr_indexCount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "indexCount");
			Oni.Shape.NativeFieldInfoPtr_resolutionU = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "resolutionU");
			Oni.Shape.NativeFieldInfoPtr_resolutionV = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "resolutionV");
			Oni.Shape.NativeFieldInfoPtr_is2D = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, "is2D");
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671939);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671940);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671941);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671942);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671943);
		}

		// Token: 0x060072F7 RID: 29431 RVA: 0x001D478F File Offset: 0x001D298F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CDE RID: 19678
		private static readonly IntPtr NativeFieldInfoPtr_center;

		// Token: 0x04004CDF RID: 19679
		private static readonly IntPtr NativeFieldInfoPtr_size;

		// Token: 0x04004CE0 RID: 19680
		private static readonly IntPtr NativeFieldInfoPtr_data;

		// Token: 0x04004CE1 RID: 19681
		private static readonly IntPtr NativeFieldInfoPtr_indices;

		// Token: 0x04004CE2 RID: 19682
		private static readonly IntPtr NativeFieldInfoPtr_dataCount;

		// Token: 0x04004CE3 RID: 19683
		private static readonly IntPtr NativeFieldInfoPtr_indexCount;

		// Token: 0x04004CE4 RID: 19684
		private static readonly IntPtr NativeFieldInfoPtr_resolutionU;

		// Token: 0x04004CE5 RID: 19685
		private static readonly IntPtr NativeFieldInfoPtr_resolutionV;

		// Token: 0x04004CE6 RID: 19686
		private static readonly IntPtr NativeFieldInfoPtr_is2D;

		// Token: 0x04004CE7 RID: 19687
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_0;

		// Token: 0x04004CE8 RID: 19688
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0;

		// Token: 0x04004CE9 RID: 19689
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0;

		// Token: 0x04004CEA RID: 19690
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0;

		// Token: 0x04004CEB RID: 19691
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0;

		// Token: 0x04004CEC RID: 19692
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04004CED RID: 19693
		[FieldOffset(12)]
		public Vector3 size;

		// Token: 0x04004CEE RID: 19694
		[FieldOffset(24)]
		public IntPtr data;

		// Token: 0x04004CEF RID: 19695
		[FieldOffset(32)]
		public IntPtr indices;

		// Token: 0x04004CF0 RID: 19696
		[FieldOffset(40)]
		public int dataCount;

		// Token: 0x04004CF1 RID: 19697
		[FieldOffset(44)]
		public int indexCount;

		// Token: 0x04004CF2 RID: 19698
		[FieldOffset(48)]
		public int resolutionU;

		// Token: 0x04004CF3 RID: 19699
		[FieldOffset(52)]
		public int resolutionV;

		// Token: 0x04004CF4 RID: 19700
		[FieldOffset(56)]
		[MarshalAs(UnmanagedType.U1)]
		public bool is2D;
	}

	// Token: 0x02000384 RID: 900
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct CollisionMaterial
	{
		// Token: 0x060072F8 RID: 29432 RVA: 0x001D47A4 File Offset: 0x001D29A4
		// Note: this type is marked as 'beforefieldinit'.
		static CollisionMaterial()
		{
			Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "CollisionMaterial");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr);
			Oni.CollisionMaterial.NativeFieldInfoPtr_friction = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, "friction");
			Oni.CollisionMaterial.NativeFieldInfoPtr_stickiness = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, "stickiness");
			Oni.CollisionMaterial.NativeFieldInfoPtr_stickDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, "stickDistance");
			Oni.CollisionMaterial.NativeFieldInfoPtr_frictionCombine = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, "frictionCombine");
			Oni.CollisionMaterial.NativeFieldInfoPtr_stickinessCombine = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, "stickinessCombine");
		}

		// Token: 0x060072F9 RID: 29433 RVA: 0x001D4833 File Offset: 0x001D2A33
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CF5 RID: 19701
		private static readonly IntPtr NativeFieldInfoPtr_friction;

		// Token: 0x04004CF6 RID: 19702
		private static readonly IntPtr NativeFieldInfoPtr_stickiness;

		// Token: 0x04004CF7 RID: 19703
		private static readonly IntPtr NativeFieldInfoPtr_stickDistance;

		// Token: 0x04004CF8 RID: 19704
		private static readonly IntPtr NativeFieldInfoPtr_frictionCombine;

		// Token: 0x04004CF9 RID: 19705
		private static readonly IntPtr NativeFieldInfoPtr_stickinessCombine;

		// Token: 0x04004CFA RID: 19706
		[FieldOffset(0)]
		public float friction;

		// Token: 0x04004CFB RID: 19707
		[FieldOffset(4)]
		public float stickiness;

		// Token: 0x04004CFC RID: 19708
		[FieldOffset(8)]
		public float stickDistance;

		// Token: 0x04004CFD RID: 19709
		[FieldOffset(12)]
		public Oni.MaterialCombineMode frictionCombine;

		// Token: 0x04004CFE RID: 19710
		[FieldOffset(16)]
		public Oni.MaterialCombineMode stickinessCombine;
	}

	// Token: 0x02000385 RID: 901
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct FluidMaterial
	{
		// Token: 0x060072FA RID: 29434 RVA: 0x001D4848 File Offset: 0x001D2A48
		// Note: this type is marked as 'beforefieldinit'.
		static FluidMaterial()
		{
			Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "FluidMaterial");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr);
			Oni.FluidMaterial.NativeFieldInfoPtr_smoothingRadius = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "smoothingRadius");
			Oni.FluidMaterial.NativeFieldInfoPtr_restDensity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "restDensity");
			Oni.FluidMaterial.NativeFieldInfoPtr_viscosity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "viscosity");
			Oni.FluidMaterial.NativeFieldInfoPtr_surfaceTension = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "surfaceTension");
			Oni.FluidMaterial.NativeFieldInfoPtr_buoyancy = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "buoyancy");
			Oni.FluidMaterial.NativeFieldInfoPtr_atmosphericDrag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "atmosphericDrag");
			Oni.FluidMaterial.NativeFieldInfoPtr_atmosphericPressure = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "atmosphericPressure");
			Oni.FluidMaterial.NativeFieldInfoPtr_vorticity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "vorticity");
			Oni.FluidMaterial.NativeFieldInfoPtr_elasticRange = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "elasticRange");
			Oni.FluidMaterial.NativeFieldInfoPtr_plasticCreep = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "plasticCreep");
			Oni.FluidMaterial.NativeFieldInfoPtr_plasticThreshold = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, "plasticThreshold");
		}

		// Token: 0x060072FB RID: 29435 RVA: 0x001D494F File Offset: 0x001D2B4F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CFF RID: 19711
		private static readonly IntPtr NativeFieldInfoPtr_smoothingRadius;

		// Token: 0x04004D00 RID: 19712
		private static readonly IntPtr NativeFieldInfoPtr_restDensity;

		// Token: 0x04004D01 RID: 19713
		private static readonly IntPtr NativeFieldInfoPtr_viscosity;

		// Token: 0x04004D02 RID: 19714
		private static readonly IntPtr NativeFieldInfoPtr_surfaceTension;

		// Token: 0x04004D03 RID: 19715
		private static readonly IntPtr NativeFieldInfoPtr_buoyancy;

		// Token: 0x04004D04 RID: 19716
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericDrag;

		// Token: 0x04004D05 RID: 19717
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericPressure;

		// Token: 0x04004D06 RID: 19718
		private static readonly IntPtr NativeFieldInfoPtr_vorticity;

		// Token: 0x04004D07 RID: 19719
		private static readonly IntPtr NativeFieldInfoPtr_elasticRange;

		// Token: 0x04004D08 RID: 19720
		private static readonly IntPtr NativeFieldInfoPtr_plasticCreep;

		// Token: 0x04004D09 RID: 19721
		private static readonly IntPtr NativeFieldInfoPtr_plasticThreshold;

		// Token: 0x04004D0A RID: 19722
		[FieldOffset(0)]
		public float smoothingRadius;

		// Token: 0x04004D0B RID: 19723
		[FieldOffset(4)]
		public float restDensity;

		// Token: 0x04004D0C RID: 19724
		[FieldOffset(8)]
		public float viscosity;

		// Token: 0x04004D0D RID: 19725
		[FieldOffset(12)]
		public float surfaceTension;

		// Token: 0x04004D0E RID: 19726
		[FieldOffset(16)]
		public float buoyancy;

		// Token: 0x04004D0F RID: 19727
		[FieldOffset(20)]
		public float atmosphericDrag;

		// Token: 0x04004D10 RID: 19728
		[FieldOffset(24)]
		public float atmosphericPressure;

		// Token: 0x04004D11 RID: 19729
		[FieldOffset(28)]
		public float vorticity;

		// Token: 0x04004D12 RID: 19730
		[FieldOffset(32)]
		public float elasticRange;

		// Token: 0x04004D13 RID: 19731
		[FieldOffset(36)]
		public float plasticCreep;

		// Token: 0x04004D14 RID: 19732
		[FieldOffset(40)]
		public float plasticThreshold;
	}

	// Token: 0x02000386 RID: 902
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct HalfEdge
	{
		// Token: 0x060072FC RID: 29436 RVA: 0x001D4964 File Offset: 0x001D2B64
		[CallerCount(0)]
		public unsafe HalfEdge(int index)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.HalfEdge.NativeMethodInfoPtr__ctor_Public_Void_Int32_0, ref this, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060072FD RID: 29437 RVA: 0x001D49AC File Offset: 0x001D2BAC
		// Note: this type is marked as 'beforefieldinit'.
		static HalfEdge()
		{
			Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "HalfEdge");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr);
			Oni.HalfEdge.NativeFieldInfoPtr_index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "index");
			Oni.HalfEdge.NativeFieldInfoPtr_indexInFace = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "indexInFace");
			Oni.HalfEdge.NativeFieldInfoPtr_face = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "face");
			Oni.HalfEdge.NativeFieldInfoPtr_nextHalfEdge = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "nextHalfEdge");
			Oni.HalfEdge.NativeFieldInfoPtr_pair = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "pair");
			Oni.HalfEdge.NativeFieldInfoPtr_endVertex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, "endVertex");
			Oni.HalfEdge.NativeMethodInfoPtr__ctor_Public_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, 100671944);
		}

		// Token: 0x060072FE RID: 29438 RVA: 0x001D4A63 File Offset: 0x001D2C63
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D15 RID: 19733
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D16 RID: 19734
		private static readonly IntPtr NativeFieldInfoPtr_indexInFace;

		// Token: 0x04004D17 RID: 19735
		private static readonly IntPtr NativeFieldInfoPtr_face;

		// Token: 0x04004D18 RID: 19736
		private static readonly IntPtr NativeFieldInfoPtr_nextHalfEdge;

		// Token: 0x04004D19 RID: 19737
		private static readonly IntPtr NativeFieldInfoPtr_pair;

		// Token: 0x04004D1A RID: 19738
		private static readonly IntPtr NativeFieldInfoPtr_endVertex;

		// Token: 0x04004D1B RID: 19739
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x04004D1C RID: 19740
		[FieldOffset(0)]
		public int index;

		// Token: 0x04004D1D RID: 19741
		[FieldOffset(4)]
		public int indexInFace;

		// Token: 0x04004D1E RID: 19742
		[FieldOffset(8)]
		public int face;

		// Token: 0x04004D1F RID: 19743
		[FieldOffset(12)]
		public int nextHalfEdge;

		// Token: 0x04004D20 RID: 19744
		[FieldOffset(16)]
		public int pair;

		// Token: 0x04004D21 RID: 19745
		[FieldOffset(20)]
		public int endVertex;
	}

	// Token: 0x02000387 RID: 903
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Vertex
	{
		// Token: 0x060072FF RID: 29439 RVA: 0x001D4A78 File Offset: 0x001D2C78
		[CallerCount(0)]
		public unsafe Vertex(Vector3 position, int index, int halfEdge)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref position;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref halfEdge;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Vertex.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Int32_Int32_0, ref this, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007300 RID: 29440 RVA: 0x001D4AE4 File Offset: 0x001D2CE4
		// Note: this type is marked as 'beforefieldinit'.
		static Vertex()
		{
			Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Vertex");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr);
			Oni.Vertex.NativeFieldInfoPtr_index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, "index");
			Oni.Vertex.NativeFieldInfoPtr_halfEdge = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, "halfEdge");
			Oni.Vertex.NativeFieldInfoPtr_position = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, "position");
			Oni.Vertex.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, 100671945);
		}

		// Token: 0x06007301 RID: 29441 RVA: 0x001D4B5F File Offset: 0x001D2D5F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D22 RID: 19746
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D23 RID: 19747
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x04004D24 RID: 19748
		private static readonly IntPtr NativeFieldInfoPtr_position;

		// Token: 0x04004D25 RID: 19749
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Int32_Int32_0;

		// Token: 0x04004D26 RID: 19750
		[FieldOffset(0)]
		public int index;

		// Token: 0x04004D27 RID: 19751
		[FieldOffset(4)]
		public int halfEdge;

		// Token: 0x04004D28 RID: 19752
		[FieldOffset(8)]
		public Vector3 position;
	}

	// Token: 0x02000388 RID: 904
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Face
	{
		// Token: 0x06007302 RID: 29442 RVA: 0x001D4B74 File Offset: 0x001D2D74
		[CallerCount(0)]
		public unsafe Face(int index)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Oni.Face.NativeMethodInfoPtr__ctor_Public_Void_Int32_0, ref this, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007303 RID: 29443 RVA: 0x001D4BBC File Offset: 0x001D2DBC
		// Note: this type is marked as 'beforefieldinit'.
		static Face()
		{
			Il2CppClassPointerStore<Oni.Face>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "Face");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr);
			Oni.Face.NativeFieldInfoPtr_index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, "index");
			Oni.Face.NativeFieldInfoPtr_halfEdge = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, "halfEdge");
			Oni.Face.NativeMethodInfoPtr__ctor_Public_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, 100671946);
		}

		// Token: 0x06007304 RID: 29444 RVA: 0x001D4C23 File Offset: 0x001D2E23
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D29 RID: 19753
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D2A RID: 19754
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x04004D2B RID: 19755
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x04004D2C RID: 19756
		[FieldOffset(0)]
		public int index;

		// Token: 0x04004D2D RID: 19757
		[FieldOffset(4)]
		public int halfEdge;
	}

	// Token: 0x02000389 RID: 905
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct MeshInformation
	{
		// Token: 0x06007305 RID: 29445 RVA: 0x001D4C38 File Offset: 0x001D2E38
		// Note: this type is marked as 'beforefieldinit'.
		static MeshInformation()
		{
			Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Oni>.NativeClassPtr, "MeshInformation");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr);
			Oni.MeshInformation.NativeFieldInfoPtr_volume = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, "volume");
			Oni.MeshInformation.NativeFieldInfoPtr_area = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, "area");
			Oni.MeshInformation.NativeFieldInfoPtr_borderEdgeCount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, "borderEdgeCount");
			Oni.MeshInformation.NativeFieldInfoPtr_closed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, "closed");
			Oni.MeshInformation.NativeFieldInfoPtr_nonManifold = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, "nonManifold");
		}

		// Token: 0x06007306 RID: 29446 RVA: 0x001D4CC7 File Offset: 0x001D2EC7
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D2E RID: 19758
		private static readonly IntPtr NativeFieldInfoPtr_volume;

		// Token: 0x04004D2F RID: 19759
		private static readonly IntPtr NativeFieldInfoPtr_area;

		// Token: 0x04004D30 RID: 19760
		private static readonly IntPtr NativeFieldInfoPtr_borderEdgeCount;

		// Token: 0x04004D31 RID: 19761
		private static readonly IntPtr NativeFieldInfoPtr_closed;

		// Token: 0x04004D32 RID: 19762
		private static readonly IntPtr NativeFieldInfoPtr_nonManifold;

		// Token: 0x04004D33 RID: 19763
		[FieldOffset(0)]
		public float volume;

		// Token: 0x04004D34 RID: 19764
		[FieldOffset(4)]
		public float area;

		// Token: 0x04004D35 RID: 19765
		[FieldOffset(8)]
		public int borderEdgeCount;

		// Token: 0x04004D36 RID: 19766
		[FieldOffset(12)]
		[MarshalAs(UnmanagedType.U1)]
		public bool closed;

		// Token: 0x04004D37 RID: 19767
		[FieldOffset(13)]
		[MarshalAs(UnmanagedType.U1)]
		public bool nonManifold;
	}
}