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: 0x0200037A RID: 890
public static class Oni : Il2CppSystem.Object
{
	// Token: 0x060072F5 RID: 29429 RVA: 0x001D20B8 File Offset: 0x001D02B8
	[CallerCount(43)]
	[CachedScanResults(RefRangeStart = 603913, RefRangeEnd = 603956, XrefRangeStart = 603912, XrefRangeEnd = 603913, 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: 0x060072F6 RID: 29430 RVA: 0x001D2110 File Offset: 0x001D0310
	[CallerCount(70)]
	[CachedScanResults(RefRangeStart = 603958, RefRangeEnd = 604028, XrefRangeStart = 603956, XrefRangeEnd = 603958, 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: 0x060072F7 RID: 29431 RVA: 0x001D2158 File Offset: 0x001D0358
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604030, RefRangeEnd = 604031, XrefRangeStart = 604028, XrefRangeEnd = 604030, 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: 0x060072F8 RID: 29432 RVA: 0x001D219C File Offset: 0x001D039C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604033, RefRangeEnd = 604034, XrefRangeStart = 604031, XrefRangeEnd = 604033, 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: 0x060072F9 RID: 29433 RVA: 0x001D21E4 File Offset: 0x001D03E4
	[CallerCount(14)]
	[CachedScanResults(RefRangeStart = 604036, RefRangeEnd = 604050, XrefRangeStart = 604034, XrefRangeEnd = 604036, 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: 0x060072FA RID: 29434 RVA: 0x001D2238 File Offset: 0x001D0438
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604052, RefRangeEnd = 604054, XrefRangeStart = 604050, XrefRangeEnd = 604052, 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: 0x060072FB RID: 29435 RVA: 0x001D2280 File Offset: 0x001D0480
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604056, RefRangeEnd = 604057, XrefRangeStart = 604054, XrefRangeEnd = 604056, 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: 0x060072FC RID: 29436 RVA: 0x001D22C4 File Offset: 0x001D04C4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604059, RefRangeEnd = 604060, XrefRangeStart = 604057, XrefRangeEnd = 604059, 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: 0x060072FD RID: 29437 RVA: 0x001D230C File Offset: 0x001D050C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604062, RefRangeEnd = 604064, XrefRangeStart = 604060, XrefRangeEnd = 604062, 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: 0x060072FE RID: 29438 RVA: 0x001D2368 File Offset: 0x001D0568
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 604066, RefRangeEnd = 604076, XrefRangeStart = 604064, XrefRangeEnd = 604066, 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: 0x060072FF RID: 29439 RVA: 0x001D23C4 File Offset: 0x001D05C4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604078, RefRangeEnd = 604080, XrefRangeStart = 604076, XrefRangeEnd = 604078, 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: 0x06007300 RID: 29440 RVA: 0x001D2420 File Offset: 0x001D0620
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604082, RefRangeEnd = 604083, XrefRangeStart = 604080, XrefRangeEnd = 604082, 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: 0x06007301 RID: 29441 RVA: 0x001D247C File Offset: 0x001D067C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604085, RefRangeEnd = 604086, XrefRangeStart = 604083, XrefRangeEnd = 604085, 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: 0x06007302 RID: 29442 RVA: 0x001D24D4 File Offset: 0x001D06D4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604088, RefRangeEnd = 604090, XrefRangeStart = 604086, XrefRangeEnd = 604088, 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: 0x06007303 RID: 29443 RVA: 0x001D252C File Offset: 0x001D072C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604092, RefRangeEnd = 604094, XrefRangeStart = 604090, XrefRangeEnd = 604092, 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: 0x06007304 RID: 29444 RVA: 0x001D2584 File Offset: 0x001D0784
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604096, RefRangeEnd = 604097, XrefRangeStart = 604094, XrefRangeEnd = 604096, 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: 0x06007305 RID: 29445 RVA: 0x001D25C8 File Offset: 0x001D07C8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604099, RefRangeEnd = 604100, XrefRangeStart = 604097, XrefRangeEnd = 604099, 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: 0x06007306 RID: 29446 RVA: 0x001D2610 File Offset: 0x001D0810
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604102, RefRangeEnd = 604104, XrefRangeStart = 604100, XrefRangeEnd = 604102, 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: 0x06007307 RID: 29447 RVA: 0x001D266C File Offset: 0x001D086C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604106, RefRangeEnd = 604108, XrefRangeStart = 604104, XrefRangeEnd = 604106, 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: 0x06007308 RID: 29448 RVA: 0x001D26D4 File Offset: 0x001D08D4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604110, RefRangeEnd = 604112, XrefRangeStart = 604108, XrefRangeEnd = 604110, 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: 0x06007309 RID: 29449 RVA: 0x001D271C File Offset: 0x001D091C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604114, RefRangeEnd = 604118, XrefRangeStart = 604112, XrefRangeEnd = 604114, 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: 0x0600730A RID: 29450 RVA: 0x001D2774 File Offset: 0x001D0974
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604120, RefRangeEnd = 604124, XrefRangeStart = 604118, XrefRangeEnd = 604120, 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: 0x0600730B RID: 29451 RVA: 0x001D27CC File Offset: 0x001D09CC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604126, RefRangeEnd = 604127, XrefRangeStart = 604124, XrefRangeEnd = 604126, 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: 0x0600730C RID: 29452 RVA: 0x001D283C File Offset: 0x001D0A3C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604129, RefRangeEnd = 604130, XrefRangeStart = 604127, XrefRangeEnd = 604129, 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: 0x0600730D RID: 29453 RVA: 0x001D2890 File Offset: 0x001D0A90
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604132, RefRangeEnd = 604133, XrefRangeStart = 604130, XrefRangeEnd = 604132, 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: 0x0600730E RID: 29454 RVA: 0x001D28F0 File Offset: 0x001D0AF0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604135, RefRangeEnd = 604137, XrefRangeStart = 604133, XrefRangeEnd = 604135, 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: 0x0600730F RID: 29455 RVA: 0x001D294C File Offset: 0x001D0B4C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604137, XrefRangeEnd = 604139, 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: 0x06007310 RID: 29456 RVA: 0x001D29A8 File Offset: 0x001D0BA8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604141, RefRangeEnd = 604142, XrefRangeStart = 604139, XrefRangeEnd = 604141, 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: 0x06007311 RID: 29457 RVA: 0x001D2A28 File Offset: 0x001D0C28
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604144, RefRangeEnd = 604147, XrefRangeStart = 604142, XrefRangeEnd = 604144, 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: 0x06007312 RID: 29458 RVA: 0x001D2A80 File Offset: 0x001D0C80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604149, RefRangeEnd = 604150, XrefRangeStart = 604147, XrefRangeEnd = 604149, 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: 0x06007313 RID: 29459 RVA: 0x001D2AC8 File Offset: 0x001D0CC8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604152, RefRangeEnd = 604153, XrefRangeStart = 604150, XrefRangeEnd = 604152, 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: 0x06007314 RID: 29460 RVA: 0x001D2B20 File Offset: 0x001D0D20
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604155, RefRangeEnd = 604156, XrefRangeStart = 604153, XrefRangeEnd = 604155, 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: 0x06007315 RID: 29461 RVA: 0x001D2B78 File Offset: 0x001D0D78
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604158, RefRangeEnd = 604159, XrefRangeStart = 604156, XrefRangeEnd = 604158, 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: 0x06007316 RID: 29462 RVA: 0x001D2BC0 File Offset: 0x001D0DC0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604159, XrefRangeEnd = 604161, 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: 0x06007317 RID: 29463 RVA: 0x001D2C20 File Offset: 0x001D0E20
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604163, RefRangeEnd = 604165, XrefRangeStart = 604161, XrefRangeEnd = 604163, 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: 0x06007318 RID: 29464 RVA: 0x001D2C80 File Offset: 0x001D0E80
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604167, RefRangeEnd = 604171, XrefRangeStart = 604165, XrefRangeEnd = 604167, 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: 0x06007319 RID: 29465 RVA: 0x001D2CE8 File Offset: 0x001D0EE8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604173, RefRangeEnd = 604175, XrefRangeStart = 604171, XrefRangeEnd = 604173, 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: 0x0600731A RID: 29466 RVA: 0x001D2D6C File Offset: 0x001D0F6C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604175, XrefRangeEnd = 604177, 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: 0x0600731B RID: 29467 RVA: 0x001D2E00 File Offset: 0x001D1000
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604179, RefRangeEnd = 604180, XrefRangeStart = 604177, XrefRangeEnd = 604179, 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: 0x0600731C RID: 29468 RVA: 0x001D2E94 File Offset: 0x001D1094
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604182, RefRangeEnd = 604184, XrefRangeStart = 604180, XrefRangeEnd = 604182, 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: 0x0600731D RID: 29469 RVA: 0x001D2F28 File Offset: 0x001D1128
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 604186, RefRangeEnd = 604195, XrefRangeStart = 604184, XrefRangeEnd = 604186, 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: 0x0600731E RID: 29470 RVA: 0x001D2FBC File Offset: 0x001D11BC
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 604197, RefRangeEnd = 604202, XrefRangeStart = 604195, XrefRangeEnd = 604197, 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: 0x0600731F RID: 29471 RVA: 0x001D3050 File Offset: 0x001D1250
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 604204, RefRangeEnd = 604211, XrefRangeStart = 604202, XrefRangeEnd = 604204, 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: 0x06007320 RID: 29472 RVA: 0x001D30E4 File Offset: 0x001D12E4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604213, RefRangeEnd = 604215, XrefRangeStart = 604211, XrefRangeEnd = 604213, 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: 0x06007321 RID: 29473 RVA: 0x001D3178 File Offset: 0x001D1378
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 604217, RefRangeEnd = 604223, XrefRangeStart = 604215, XrefRangeEnd = 604217, 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: 0x06007322 RID: 29474 RVA: 0x001D320C File Offset: 0x001D140C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604225, RefRangeEnd = 604227, XrefRangeStart = 604223, XrefRangeEnd = 604225, 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: 0x06007323 RID: 29475 RVA: 0x001D32A0 File Offset: 0x001D14A0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604229, RefRangeEnd = 604230, XrefRangeStart = 604227, XrefRangeEnd = 604229, 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: 0x06007324 RID: 29476 RVA: 0x001D3328 File Offset: 0x001D1528
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604232, RefRangeEnd = 604233, XrefRangeStart = 604230, XrefRangeEnd = 604232, 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: 0x06007325 RID: 29477 RVA: 0x001D33AC File Offset: 0x001D15AC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604235, RefRangeEnd = 604237, XrefRangeStart = 604233, XrefRangeEnd = 604235, 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: 0x06007326 RID: 29478 RVA: 0x001D3440 File Offset: 0x001D1640
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604239, RefRangeEnd = 604241, XrefRangeStart = 604237, XrefRangeEnd = 604239, 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: 0x06007327 RID: 29479 RVA: 0x001D34D4 File Offset: 0x001D16D4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604243, RefRangeEnd = 604244, XrefRangeStart = 604241, XrefRangeEnd = 604243, 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: 0x06007328 RID: 29480 RVA: 0x001D3528 File Offset: 0x001D1728
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604246, RefRangeEnd = 604248, XrefRangeStart = 604244, XrefRangeEnd = 604246, 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: 0x06007329 RID: 29481 RVA: 0x001D35AC File Offset: 0x001D17AC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604250, RefRangeEnd = 604251, XrefRangeStart = 604248, XrefRangeEnd = 604250, 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: 0x0600732A RID: 29482 RVA: 0x001D3628 File Offset: 0x001D1828
	[CallerCount(20)]
	[CachedScanResults(RefRangeStart = 604253, RefRangeEnd = 604273, XrefRangeStart = 604251, XrefRangeEnd = 604253, 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: 0x0600732B RID: 29483 RVA: 0x001D3694 File Offset: 0x001D1894
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604273, XrefRangeEnd = 604275, 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: 0x0600732C RID: 29484 RVA: 0x001D3700 File Offset: 0x001D1900
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604277, RefRangeEnd = 604278, XrefRangeStart = 604275, XrefRangeEnd = 604277, 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: 0x0600732D RID: 29485 RVA: 0x001D3788 File Offset: 0x001D1988
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604280, RefRangeEnd = 604282, XrefRangeStart = 604278, XrefRangeEnd = 604280, 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: 0x0600732E RID: 29486 RVA: 0x001D381C File Offset: 0x001D1A1C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604284, RefRangeEnd = 604286, XrefRangeStart = 604282, XrefRangeEnd = 604284, 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: 0x0600732F RID: 29487 RVA: 0x001D38A0 File Offset: 0x001D1AA0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604288, RefRangeEnd = 604289, XrefRangeStart = 604286, XrefRangeEnd = 604288, 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: 0x06007330 RID: 29488 RVA: 0x001D3934 File Offset: 0x001D1B34
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 604291, RefRangeEnd = 604296, XrefRangeStart = 604289, XrefRangeEnd = 604291, 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: 0x06007331 RID: 29489 RVA: 0x001D3A00 File Offset: 0x001D1C00
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 604298, RefRangeEnd = 604304, XrefRangeStart = 604296, XrefRangeEnd = 604298, 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: 0x06007332 RID: 29490 RVA: 0x001D3A58 File Offset: 0x001D1C58
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604306, RefRangeEnd = 604308, XrefRangeStart = 604304, XrefRangeEnd = 604306, 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: 0x06007333 RID: 29491 RVA: 0x001D3B14 File Offset: 0x001D1D14
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604310, RefRangeEnd = 604314, XrefRangeStart = 604308, XrefRangeEnd = 604310, 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: 0x06007334 RID: 29492 RVA: 0x001D3B80 File Offset: 0x001D1D80
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604316, RefRangeEnd = 604319, XrefRangeStart = 604314, XrefRangeEnd = 604316, 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: 0x06007335 RID: 29493 RVA: 0x001D3BE0 File Offset: 0x001D1DE0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604321, RefRangeEnd = 604322, XrefRangeStart = 604319, XrefRangeEnd = 604321, 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: 0x06007336 RID: 29494 RVA: 0x001D3C4C File Offset: 0x001D1E4C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604322, XrefRangeEnd = 604324, 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: 0x06007337 RID: 29495 RVA: 0x001D3CA4 File Offset: 0x001D1EA4
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604326, RefRangeEnd = 604329, XrefRangeStart = 604324, XrefRangeEnd = 604326, 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: 0x06007338 RID: 29496 RVA: 0x001D3D98 File Offset: 0x001D1F98
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604331, RefRangeEnd = 604333, XrefRangeStart = 604329, XrefRangeEnd = 604331, 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: 0x06007339 RID: 29497 RVA: 0x001D3E20 File Offset: 0x001D2020
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604335, RefRangeEnd = 604337, XrefRangeStart = 604333, XrefRangeEnd = 604335, 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: 0x0600733A RID: 29498 RVA: 0x001D3E80 File Offset: 0x001D2080
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604339, RefRangeEnd = 604340, XrefRangeStart = 604337, XrefRangeEnd = 604339, 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: 0x0600733B RID: 29499 RVA: 0x001D3EC8 File Offset: 0x001D20C8
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 604342, RefRangeEnd = 604350, XrefRangeStart = 604340, XrefRangeEnd = 604342, 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: 0x0600733C RID: 29500 RVA: 0x001D3F30 File Offset: 0x001D2130
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604352, RefRangeEnd = 604356, XrefRangeStart = 604350, XrefRangeEnd = 604352, 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: 0x0600733D RID: 29501 RVA: 0x001D3F78 File Offset: 0x001D2178
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604358, RefRangeEnd = 604362, XrefRangeStart = 604356, XrefRangeEnd = 604358, 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: 0x0600733E RID: 29502 RVA: 0x001D3FF4 File Offset: 0x001D21F4
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604364, RefRangeEnd = 604368, XrefRangeStart = 604362, XrefRangeEnd = 604364, 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: 0x0600733F RID: 29503 RVA: 0x001D404C File Offset: 0x001D224C
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 604370, RefRangeEnd = 604378, XrefRangeStart = 604368, XrefRangeEnd = 604370, 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: 0x06007340 RID: 29504 RVA: 0x001D40B4 File Offset: 0x001D22B4
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604380, RefRangeEnd = 604384, XrefRangeStart = 604378, XrefRangeEnd = 604380, 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: 0x06007341 RID: 29505 RVA: 0x001D4108 File Offset: 0x001D2308
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604386, RefRangeEnd = 604388, XrefRangeStart = 604384, XrefRangeEnd = 604386, 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: 0x06007342 RID: 29506 RVA: 0x001D419C File Offset: 0x001D239C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604390, RefRangeEnd = 604394, XrefRangeStart = 604388, XrefRangeEnd = 604390, 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: 0x06007343 RID: 29507 RVA: 0x001D41F0 File Offset: 0x001D23F0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604396, RefRangeEnd = 604400, XrefRangeStart = 604394, XrefRangeEnd = 604396, 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: 0x06007344 RID: 29508 RVA: 0x001D4250 File Offset: 0x001D2450
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604402, RefRangeEnd = 604406, XrefRangeStart = 604400, XrefRangeEnd = 604402, 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: 0x06007345 RID: 29509 RVA: 0x001D42C0 File Offset: 0x001D24C0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604408, RefRangeEnd = 604412, XrefRangeStart = 604406, XrefRangeEnd = 604408, 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: 0x06007346 RID: 29510 RVA: 0x001D4314 File Offset: 0x001D2514
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604414, RefRangeEnd = 604417, XrefRangeStart = 604412, XrefRangeEnd = 604414, 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: 0x06007347 RID: 29511 RVA: 0x001D4394 File Offset: 0x001D2594
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604419, RefRangeEnd = 604421, XrefRangeStart = 604417, XrefRangeEnd = 604419, 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: 0x06007348 RID: 29512 RVA: 0x001D4434 File Offset: 0x001D2634
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604423, RefRangeEnd = 604424, XrefRangeStart = 604421, XrefRangeEnd = 604423, 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: 0x06007349 RID: 29513 RVA: 0x001D44C4 File Offset: 0x001D26C4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604426, RefRangeEnd = 604428, XrefRangeStart = 604424, XrefRangeEnd = 604426, 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: 0x0600734A RID: 29514 RVA: 0x001D4564 File Offset: 0x001D2764
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604430, RefRangeEnd = 604431, XrefRangeStart = 604428, XrefRangeEnd = 604430, 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: 0x0600734B RID: 29515 RVA: 0x001D45F4 File Offset: 0x001D27F4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604433, RefRangeEnd = 604435, XrefRangeStart = 604431, XrefRangeEnd = 604433, 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: 0x0600734C RID: 29516 RVA: 0x001D46C4 File Offset: 0x001D28C4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604437, RefRangeEnd = 604439, XrefRangeStart = 604435, XrefRangeEnd = 604437, 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: 0x0600734D RID: 29517 RVA: 0x001D4784 File Offset: 0x001D2984
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604441, RefRangeEnd = 604442, XrefRangeStart = 604439, XrefRangeEnd = 604441, 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: 0x0600734E RID: 29518 RVA: 0x001D480C File Offset: 0x001D2A0C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604444, RefRangeEnd = 604445, XrefRangeStart = 604442, XrefRangeEnd = 604444, 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: 0x0600734F RID: 29519 RVA: 0x001D48DC File Offset: 0x001D2ADC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604447, RefRangeEnd = 604449, XrefRangeStart = 604445, XrefRangeEnd = 604447, 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: 0x06007350 RID: 29520 RVA: 0x001D497C File Offset: 0x001D2B7C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604451, RefRangeEnd = 604452, XrefRangeStart = 604449, XrefRangeEnd = 604451, 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: 0x06007351 RID: 29521 RVA: 0x001D4A0C File Offset: 0x001D2C0C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604454, RefRangeEnd = 604455, XrefRangeStart = 604452, XrefRangeEnd = 604454, 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: 0x06007352 RID: 29522 RVA: 0x001D4AC4 File Offset: 0x001D2CC4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604457, RefRangeEnd = 604458, XrefRangeStart = 604455, XrefRangeEnd = 604457, 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: 0x06007353 RID: 29523 RVA: 0x001D4B4C File Offset: 0x001D2D4C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604460, RefRangeEnd = 604462, XrefRangeStart = 604458, XrefRangeEnd = 604460, 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: 0x06007354 RID: 29524 RVA: 0x001D4BBC File Offset: 0x001D2DBC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604464, RefRangeEnd = 604465, XrefRangeStart = 604462, XrefRangeEnd = 604464, 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: 0x06007355 RID: 29525 RVA: 0x001D4C04 File Offset: 0x001D2E04
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604465, XrefRangeEnd = 604467, 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: 0x06007356 RID: 29526 RVA: 0x001D4C84 File Offset: 0x001D2E84
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604467, XrefRangeEnd = 604469, 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: 0x06007357 RID: 29527 RVA: 0x001D4D18 File Offset: 0x001D2F18
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604469, XrefRangeEnd = 604471, 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: 0x06007358 RID: 29528 RVA: 0x001D4D70 File Offset: 0x001D2F70
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604473, RefRangeEnd = 604474, XrefRangeStart = 604471, XrefRangeEnd = 604473, 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: 0x06007359 RID: 29529 RVA: 0x001D4DB4 File Offset: 0x001D2FB4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604476, RefRangeEnd = 604477, XrefRangeStart = 604474, XrefRangeEnd = 604476, 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: 0x0600735A RID: 29530 RVA: 0x001D4DFC File Offset: 0x001D2FFC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604479, RefRangeEnd = 604483, XrefRangeStart = 604477, XrefRangeEnd = 604479, 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: 0x0600735B RID: 29531 RVA: 0x001D4E68 File Offset: 0x001D3068
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604485, RefRangeEnd = 604488, XrefRangeStart = 604483, XrefRangeEnd = 604485, 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: 0x0600735C RID: 29532 RVA: 0x001D4ED4 File Offset: 0x001D30D4
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604490, RefRangeEnd = 604493, XrefRangeStart = 604488, XrefRangeEnd = 604490, 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: 0x0600735D RID: 29533 RVA: 0x001D4F40 File Offset: 0x001D3140
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604495, RefRangeEnd = 604498, XrefRangeStart = 604493, XrefRangeEnd = 604495, 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: 0x0600735E RID: 29534 RVA: 0x001D4F98 File Offset: 0x001D3198
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 604500, RefRangeEnd = 604503, XrefRangeStart = 604498, XrefRangeEnd = 604500, 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: 0x0600735F RID: 29535 RVA: 0x001D4FF0 File Offset: 0x001D31F0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604505, RefRangeEnd = 604509, XrefRangeStart = 604503, XrefRangeEnd = 604505, 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: 0x06007360 RID: 29536 RVA: 0x001D5048 File Offset: 0x001D3248
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604511, RefRangeEnd = 604515, XrefRangeStart = 604509, XrefRangeEnd = 604511, 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: 0x06007361 RID: 29537 RVA: 0x001D50A0 File Offset: 0x001D32A0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604517, RefRangeEnd = 604519, XrefRangeStart = 604515, XrefRangeEnd = 604517, 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: 0x06007362 RID: 29538 RVA: 0x001D50F4 File Offset: 0x001D32F4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604521, RefRangeEnd = 604522, XrefRangeStart = 604519, XrefRangeEnd = 604521, 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: 0x06007363 RID: 29539 RVA: 0x001D5148 File Offset: 0x001D3348
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604524, RefRangeEnd = 604525, XrefRangeStart = 604522, XrefRangeEnd = 604524, 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: 0x06007364 RID: 29540 RVA: 0x001D519C File Offset: 0x001D339C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604527, RefRangeEnd = 604528, XrefRangeStart = 604525, XrefRangeEnd = 604527, 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: 0x06007365 RID: 29541 RVA: 0x001D5204 File Offset: 0x001D3404
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604530, RefRangeEnd = 604531, XrefRangeStart = 604528, XrefRangeEnd = 604530, 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: 0x06007366 RID: 29542 RVA: 0x001D52A0 File Offset: 0x001D34A0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604533, RefRangeEnd = 604534, XrefRangeStart = 604531, XrefRangeEnd = 604533, 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: 0x06007367 RID: 29543 RVA: 0x001D5350 File Offset: 0x001D3550
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 604536, RefRangeEnd = 604540, XrefRangeStart = 604534, XrefRangeEnd = 604536, 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: 0x06007368 RID: 29544 RVA: 0x001D53B8 File Offset: 0x001D35B8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604542, RefRangeEnd = 604543, XrefRangeStart = 604540, XrefRangeEnd = 604542, 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: 0x06007369 RID: 29545 RVA: 0x001D540C File Offset: 0x001D360C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604545, RefRangeEnd = 604546, XrefRangeStart = 604543, XrefRangeEnd = 604545, 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: 0x0600736A RID: 29546 RVA: 0x001D5464 File Offset: 0x001D3664
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604548, RefRangeEnd = 604549, XrefRangeStart = 604546, XrefRangeEnd = 604548, 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: 0x0600736B RID: 29547 RVA: 0x001D54A8 File Offset: 0x001D36A8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604549, XrefRangeEnd = 604551, 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: 0x0600736C RID: 29548 RVA: 0x001D54F0 File Offset: 0x001D36F0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604553, RefRangeEnd = 604554, XrefRangeStart = 604551, XrefRangeEnd = 604553, 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: 0x0600736D RID: 29549 RVA: 0x001D558C File Offset: 0x001D378C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604556, RefRangeEnd = 604557, XrefRangeStart = 604554, XrefRangeEnd = 604556, 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: 0x0600736E RID: 29550 RVA: 0x001D55E0 File Offset: 0x001D37E0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604559, RefRangeEnd = 604560, XrefRangeStart = 604557, XrefRangeEnd = 604559, 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: 0x0600736F RID: 29551 RVA: 0x001D56A0 File Offset: 0x001D38A0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604562, RefRangeEnd = 604563, XrefRangeStart = 604560, XrefRangeEnd = 604562, 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: 0x06007370 RID: 29552 RVA: 0x001D5770 File Offset: 0x001D3970
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604565, RefRangeEnd = 604566, XrefRangeStart = 604563, XrefRangeEnd = 604565, 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: 0x06007371 RID: 29553 RVA: 0x001D57A4 File Offset: 0x001D39A4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604566, XrefRangeEnd = 604568, 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: 0x06007372 RID: 29554 RVA: 0x001D57D8 File Offset: 0x001D39D8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604570, RefRangeEnd = 604571, XrefRangeStart = 604568, XrefRangeEnd = 604570, 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: 0x06007373 RID: 29555 RVA: 0x001D581C File Offset: 0x001D3A1C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 604573, RefRangeEnd = 604574, XrefRangeStart = 604571, XrefRangeEnd = 604573, 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: 0x06007374 RID: 29556 RVA: 0x001D5850 File Offset: 0x001D3A50
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604576, RefRangeEnd = 604578, XrefRangeStart = 604574, XrefRangeEnd = 604576, 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: 0x06007375 RID: 29557 RVA: 0x001D5894 File Offset: 0x001D3A94
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604580, RefRangeEnd = 604582, XrefRangeStart = 604578, XrefRangeEnd = 604580, 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: 0x06007376 RID: 29558 RVA: 0x001D58DC File Offset: 0x001D3ADC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604584, RefRangeEnd = 604586, XrefRangeStart = 604582, XrefRangeEnd = 604584, 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: 0x06007377 RID: 29559 RVA: 0x001D5920 File Offset: 0x001D3B20
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 604595, RefRangeEnd = 604597, XrefRangeStart = 604586, XrefRangeEnd = 604595, 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: 0x06007378 RID: 29560 RVA: 0x001D5994 File Offset: 0x001D3B94
	// 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, 100671850);
		Oni.NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671851);
		Oni.NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671852);
		Oni.NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671853);
		Oni.NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671854);
		Oni.NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671855);
		Oni.NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671856);
		Oni.NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671857);
		Oni.NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671858);
		Oni.NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671859);
		Oni.NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671860);
		Oni.NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671861);
		Oni.NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671862);
		Oni.NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671863);
		Oni.NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671864);
		Oni.NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671865);
		Oni.NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671866);
		Oni.NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671867);
		Oni.NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671868);
		Oni.NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671869);
		Oni.NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671870);
		Oni.NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671871);
		Oni.NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671872);
		Oni.NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671873);
		Oni.NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671874);
		Oni.NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671875);
		Oni.NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671876);
		Oni.NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671877);
		Oni.NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671878);
		Oni.NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671879);
		Oni.NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671880);
		Oni.NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671881);
		Oni.NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671882);
		Oni.NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671883);
		Oni.NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671884);
		Oni.NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671885);
		Oni.NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671886);
		Oni.NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671887);
		Oni.NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671888);
		Oni.NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671889);
		Oni.NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671890);
		Oni.NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671891);
		Oni.NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671892);
		Oni.NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671893);
		Oni.NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671894);
		Oni.NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671895);
		Oni.NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671896);
		Oni.NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671897);
		Oni.NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671898);
		Oni.NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671899);
		Oni.NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671900);
		Oni.NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671901);
		Oni.NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671902);
		Oni.NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671903);
		Oni.NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671904);
		Oni.NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671905);
		Oni.NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671906);
		Oni.NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671907);
		Oni.NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671908);
		Oni.NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671909);
		Oni.NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671910);
		Oni.NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671911);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671912);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671913);
		Oni.NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671914);
		Oni.NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671915);
		Oni.NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671916);
		Oni.NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671917);
		Oni.NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671918);
		Oni.NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671919);
		Oni.NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671920);
		Oni.NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671921);
		Oni.NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671922);
		Oni.NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671923);
		Oni.NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671924);
		Oni.NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671925);
		Oni.NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671926);
		Oni.NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671927);
		Oni.NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671928);
		Oni.NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671929);
		Oni.NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671930);
		Oni.NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671931);
		Oni.NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671932);
		Oni.NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671933);
		Oni.NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671934);
		Oni.NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671935);
		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, 100671936);
		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, 100671937);
		Oni.NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671938);
		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, 100671939);
		Oni.NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671940);
		Oni.NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671941);
		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, 100671942);
		Oni.NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671943);
		Oni.NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671944);
		Oni.NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671945);
		Oni.NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671946);
		Oni.NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671947);
		Oni.NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671948);
		Oni.NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671949);
		Oni.NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671950);
		Oni.NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671951);
		Oni.NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671952);
		Oni.NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671953);
		Oni.NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671954);
		Oni.NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671955);
		Oni.NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671956);
		Oni.NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671957);
		Oni.NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671958);
		Oni.NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671959);
		Oni.NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671960);
		Oni.NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671961);
		Oni.NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671962);
		Oni.NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671963);
		Oni.NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671964);
		Oni.NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671965);
		Oni.NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671966);
		Oni.NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671967);
		Oni.NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671968);
		Oni.NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671969);
		Oni.NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671970);
		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, 100671971);
		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, 100671972);
		Oni.NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671973);
		Oni.NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671974);
		Oni.NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671975);
		Oni.NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671976);
		Oni.NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671977);
		Oni.NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671978);
		Oni.NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671979);
		Oni.NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100671980);
	}

	// Token: 0x06007379 RID: 29561 RVA: 0x0000A74C File Offset: 0x0000894C
	public Oni(IntPtr pointer)
		: base(pointer)
	{
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// Token: 0x04004C44 RID: 19524
	private static readonly IntPtr NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0;

	// Token: 0x04004C45 RID: 19525
	private static readonly IntPtr NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C46 RID: 19526
	private static readonly IntPtr NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0;

	// Token: 0x04004C47 RID: 19527
	private static readonly IntPtr NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0;

	// Token: 0x04004C48 RID: 19528
	private static readonly IntPtr NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C49 RID: 19529
	private static readonly IntPtr NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C4A RID: 19530
	private static readonly IntPtr NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C4B RID: 19531
	private static readonly IntPtr NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0;

	// Token: 0x04004C4C RID: 19532
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C4D RID: 19533
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0;

	// Token: 0x04004C4E RID: 19534
	private static readonly IntPtr NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04004C4F RID: 19535
	private static readonly IntPtr NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04004C50 RID: 19536
	private static readonly IntPtr NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004C51 RID: 19537
	private static readonly IntPtr NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004C52 RID: 19538
	private static readonly IntPtr NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C53 RID: 19539
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004C54 RID: 19540
	private static readonly IntPtr NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04004C55 RID: 19541
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C56 RID: 19542
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x04004C57 RID: 19543
	private static readonly IntPtr NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x04004C58 RID: 19544
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0;

	// Token: 0x04004C59 RID: 19545
	private static readonly IntPtr NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004C5A RID: 19546
	private static readonly IntPtr NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C5B RID: 19547
	private static readonly IntPtr NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C5C RID: 19548
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04004C5D RID: 19549
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C5E RID: 19550
	private static readonly IntPtr NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C5F RID: 19551
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004C60 RID: 19552
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004C61 RID: 19553
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C62 RID: 19554
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

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

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

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

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

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

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

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

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

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

	// Token: 0x04004C6C RID: 19564
	private static readonly IntPtr NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04004C6D RID: 19565
	private static readonly IntPtr NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04004C6E RID: 19566
	private static readonly IntPtr NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0;

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

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

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

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

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

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

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

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

	// Token: 0x04004C77 RID: 19575
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0;

	// Token: 0x04004C78 RID: 19576
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0;

	// Token: 0x04004C79 RID: 19577
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0;

	// Token: 0x04004C7A RID: 19578
	private static readonly IntPtr NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C7B RID: 19579
	private static readonly IntPtr NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0;

	// Token: 0x04004C7C RID: 19580
	private static readonly IntPtr NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0;

	// Token: 0x04004C7D RID: 19581
	private static readonly IntPtr NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0;

	// Token: 0x04004C7E RID: 19582
	private static readonly IntPtr NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C7F RID: 19583
	private static readonly IntPtr NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0;

	// Token: 0x04004C80 RID: 19584
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C81 RID: 19585
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04004C82 RID: 19586
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004C83 RID: 19587
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

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

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

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

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

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

	// Token: 0x04004C89 RID: 19593
	private static readonly IntPtr NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x04004C8A RID: 19594
	private static readonly IntPtr NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0;

	// Token: 0x04004C8B RID: 19595
	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: 0x04004C8C RID: 19596
	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: 0x04004C8D RID: 19597
	private static readonly IntPtr NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x04004C8E RID: 19598
	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: 0x04004C8F RID: 19599
	private static readonly IntPtr NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0;

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

	// Token: 0x04004C91 RID: 19601
	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: 0x04004C92 RID: 19602
	private static readonly IntPtr NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

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

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

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

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

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

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

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

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

	// Token: 0x04004C9B RID: 19611
	private static readonly IntPtr NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x04004C9C RID: 19612
	private static readonly IntPtr NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x04004C9D RID: 19613
	private static readonly IntPtr NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C9E RID: 19614
	private static readonly IntPtr NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004C9F RID: 19615
	private static readonly IntPtr NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004CA0 RID: 19616
	private static readonly IntPtr NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04004CA1 RID: 19617
	private static readonly IntPtr NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004CA2 RID: 19618
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004CA3 RID: 19619
	private static readonly IntPtr NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x04004CA4 RID: 19620
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0;

	// Token: 0x04004CA5 RID: 19621
	private static readonly IntPtr NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0;

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

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

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

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

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

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

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

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

	// Token: 0x04004CAE RID: 19630
	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: 0x04004CAF RID: 19631
	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: 0x04004CB0 RID: 19632
	private static readonly IntPtr NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0;

	// Token: 0x04004CB1 RID: 19633
	private static readonly IntPtr NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0;

	// Token: 0x04004CB2 RID: 19634
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0;

	// Token: 0x04004CB3 RID: 19635
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0;

	// Token: 0x04004CB4 RID: 19636
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0;

	// Token: 0x04004CB5 RID: 19637
	private static readonly IntPtr NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0;

	// Token: 0x04004CB6 RID: 19638
	private static readonly IntPtr NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0;

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

	// Token: 0x0200037B RID: 891
	public enum ConstraintType
	{
		// Token: 0x04004CB9 RID: 19641
		Tether,
		// Token: 0x04004CBA RID: 19642
		Pin,
		// Token: 0x04004CBB RID: 19643
		Volume,
		// Token: 0x04004CBC RID: 19644
		Bending,
		// Token: 0x04004CBD RID: 19645
		Distance,
		// Token: 0x04004CBE RID: 19646
		ParticleCollision,
		// Token: 0x04004CBF RID: 19647
		Density,
		// Token: 0x04004CC0 RID: 19648
		Collision,
		// Token: 0x04004CC1 RID: 19649
		Skin,
		// Token: 0x04004CC2 RID: 19650
		Aerodynamics,
		// Token: 0x04004CC3 RID: 19651
		Stitch,
		// Token: 0x04004CC4 RID: 19652
		ShapeMatching
	}

	// Token: 0x0200037C RID: 892
	public enum ParticlePhase
	{
		// Token: 0x04004CC6 RID: 19654
		SelfCollide = 16777216,
		// Token: 0x04004CC7 RID: 19655
		Fluid = 33554432
	}

	// Token: 0x0200037D RID: 893
	public enum ShapeType
	{
		// Token: 0x04004CC9 RID: 19657
		Sphere,
		// Token: 0x04004CCA RID: 19658
		Box,
		// Token: 0x04004CCB RID: 19659
		Capsule,
		// Token: 0x04004CCC RID: 19660
		Heightmap,
		// Token: 0x04004CCD RID: 19661
		TriangleMesh,
		// Token: 0x04004CCE RID: 19662
		EdgeMesh
	}

	// Token: 0x0200037E RID: 894
	public enum MaterialCombineMode
	{
		// Token: 0x04004CD0 RID: 19664
		Average,
		// Token: 0x04004CD1 RID: 19665
		Minimium,
		// Token: 0x04004CD2 RID: 19666
		Multiply,
		// Token: 0x04004CD3 RID: 19667
		Maximum
	}

	// Token: 0x0200037F RID: 895
	public enum NormalsUpdate
	{
		// Token: 0x04004CD5 RID: 19669
		Recalculate,
		// Token: 0x04004CD6 RID: 19670
		Skin
	}

	// Token: 0x02000380 RID: 896
	public sealed class ProfileInfo : ValueType
	{
		// Token: 0x0600737A RID: 29562 RVA: 0x001D6400 File Offset: 0x001D4600
		// 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: 0x0600737B RID: 29563 RVA: 0x00117D17 File Offset: 0x00115F17
		public ProfileInfo(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x0600737C RID: 29564 RVA: 0x001D64A4 File Offset: 0x001D46A4
		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: 0x17002791 RID: 10129
		// (get) Token: 0x0600737D RID: 29565 RVA: 0x001D64D4 File Offset: 0x001D46D4
		// (set) Token: 0x0600737E RID: 29566 RVA: 0x001D64FC File Offset: 0x001D46FC
		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: 0x17002792 RID: 10130
		// (get) Token: 0x0600737F RID: 29567 RVA: 0x001D6520 File Offset: 0x001D4720
		// (set) Token: 0x06007380 RID: 29568 RVA: 0x001D6548 File Offset: 0x001D4748
		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: 0x17002793 RID: 10131
		// (get) Token: 0x06007381 RID: 29569 RVA: 0x001D656C File Offset: 0x001D476C
		// (set) Token: 0x06007382 RID: 29570 RVA: 0x001D6594 File Offset: 0x001D4794
		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: 0x17002794 RID: 10132
		// (get) Token: 0x06007383 RID: 29571 RVA: 0x001D65B8 File Offset: 0x001D47B8
		// (set) Token: 0x06007384 RID: 29572 RVA: 0x001D65E0 File Offset: 0x001D47E0
		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: 0x17002795 RID: 10133
		// (get) Token: 0x06007385 RID: 29573 RVA: 0x001D6604 File Offset: 0x001D4804
		// (set) Token: 0x06007386 RID: 29574 RVA: 0x001D662C File Offset: 0x001D482C
		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: 0x17002796 RID: 10134
		// (get) Token: 0x06007387 RID: 29575 RVA: 0x001D6650 File Offset: 0x001D4850
		// (set) Token: 0x06007388 RID: 29576 RVA: 0x001D6679 File Offset: 0x001D4879
		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: 0x04004CD7 RID: 19671
		private static readonly IntPtr NativeFieldInfoPtr_start;

		// Token: 0x04004CD8 RID: 19672
		private static readonly IntPtr NativeFieldInfoPtr_end;

		// Token: 0x04004CD9 RID: 19673
		private static readonly IntPtr NativeFieldInfoPtr_childDuration;

		// Token: 0x04004CDA RID: 19674
		private static readonly IntPtr NativeFieldInfoPtr_threadID;

		// Token: 0x04004CDB RID: 19675
		private static readonly IntPtr NativeFieldInfoPtr_level;

		// Token: 0x04004CDC RID: 19676
		private static readonly IntPtr NativeFieldInfoPtr_name;
	}

	// Token: 0x02000381 RID: 897
	[StructLayout(LayoutKind.Explicit)]
	public struct GridCell
	{
		// Token: 0x06007389 RID: 29577 RVA: 0x001D66A0 File Offset: 0x001D48A0
		// 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: 0x0600738A RID: 29578 RVA: 0x001D6707 File Offset: 0x001D4907
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, ref this));
		}

		// Token: 0x04004CDD RID: 19677
		private static readonly IntPtr NativeFieldInfoPtr_center;

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

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

		// Token: 0x04004CE0 RID: 19680
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04004CE1 RID: 19681
		[FieldOffset(12)]
		public Vector3 size;

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

	// Token: 0x02000382 RID: 898
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct SolverParameters
	{
		// Token: 0x0600738B RID: 29579 RVA: 0x001D671C File Offset: 0x001D491C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603731, RefRangeEnd = 603732, XrefRangeStart = 603730, XrefRangeEnd = 603731, 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: 0x0600738C RID: 29580 RVA: 0x001D6774 File Offset: 0x001D4974
		// 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, 100671981);
		}

		// Token: 0x0600738D RID: 29581 RVA: 0x001D683F File Offset: 0x001D4A3F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, ref this));
		}

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

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

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

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

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

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

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

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

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

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

		// Token: 0x04004CED RID: 19693
		[FieldOffset(8)]
		public Vector3 gravity;

		// Token: 0x04004CEE RID: 19694
		[FieldOffset(20)]
		public float damping;

		// Token: 0x04004CEF RID: 19695
		[FieldOffset(24)]
		public float fluidDenoising;

		// Token: 0x04004CF0 RID: 19696
		[FieldOffset(28)]
		public float advectionRadius;

		// Token: 0x04004CF1 RID: 19697
		[FieldOffset(32)]
		public float sleepThreshold;

		// Token: 0x02000383 RID: 899
		public enum Interpolation
		{
			// Token: 0x04004CF3 RID: 19699
			None,
			// Token: 0x04004CF4 RID: 19700
			Interpolate
		}

		// Token: 0x02000384 RID: 900
		public enum Mode
		{
			// Token: 0x04004CF6 RID: 19702
			Mode3D,
			// Token: 0x04004CF7 RID: 19703
			Mode2D
		}
	}

	// Token: 0x02000385 RID: 901
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct ConstraintParameters
	{
		// Token: 0x0600738E RID: 29582 RVA: 0x001D6854 File Offset: 0x001D4A54
		[CallerCount(10)]
		[CachedScanResults(RefRangeStart = 603732, RefRangeEnd = 603742, XrefRangeStart = 603732, XrefRangeEnd = 603732, 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: 0x0600738F RID: 29583 RVA: 0x001D68C0 File Offset: 0x001D4AC0
		// 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, 100671982);
		}

		// Token: 0x06007390 RID: 29584 RVA: 0x001D694F File Offset: 0x001D4B4F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, ref this));
		}

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

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

		// Token: 0x04004CFA RID: 19706
		private static readonly IntPtr NativeFieldInfoPtr_iterations;

		// Token: 0x04004CFB RID: 19707
		private static readonly IntPtr NativeFieldInfoPtr_SORFactor;

		// Token: 0x04004CFC RID: 19708
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Boolean_EvaluationOrder_Int32_0;

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

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

		// Token: 0x04004CFF RID: 19711
		[FieldOffset(5)]
		public int iterations;

		// Token: 0x04004D00 RID: 19712
		[FieldOffset(9)]
		public float SORFactor;

		// Token: 0x02000386 RID: 902
		public enum EvaluationOrder
		{
			// Token: 0x04004D02 RID: 19714
			Sequential,
			// Token: 0x04004D03 RID: 19715
			Parallel
		}
	}

	// Token: 0x02000387 RID: 903
	[StructLayout(LayoutKind.Explicit)]
	public struct Contact
	{
		// Token: 0x06007391 RID: 29585 RVA: 0x001D6964 File Offset: 0x001D4B64
		// 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: 0x06007392 RID: 29586 RVA: 0x001D6A6B File Offset: 0x001D4C6B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, ref this));
		}

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

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

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

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

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

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

		// Token: 0x04004D0A RID: 19722
		private static readonly IntPtr NativeFieldInfoPtr_tangentImpulse;

		// Token: 0x04004D0B RID: 19723
		private static readonly IntPtr NativeFieldInfoPtr_bitangentImpulse;

		// Token: 0x04004D0C RID: 19724
		private static readonly IntPtr NativeFieldInfoPtr_stickImpulse;

		// Token: 0x04004D0D RID: 19725
		private static readonly IntPtr NativeFieldInfoPtr_particle;

		// Token: 0x04004D0E RID: 19726
		private static readonly IntPtr NativeFieldInfoPtr_other;

		// Token: 0x04004D0F RID: 19727
		[FieldOffset(0)]
		public Vector4 point;

		// Token: 0x04004D10 RID: 19728
		[FieldOffset(16)]
		public Vector4 normal;

		// Token: 0x04004D11 RID: 19729
		[FieldOffset(32)]
		public Vector4 tangent;

		// Token: 0x04004D12 RID: 19730
		[FieldOffset(48)]
		public Vector4 bitangent;

		// Token: 0x04004D13 RID: 19731
		[FieldOffset(64)]
		public float distance;

		// Token: 0x04004D14 RID: 19732
		[FieldOffset(68)]
		public float normalImpulse;

		// Token: 0x04004D15 RID: 19733
		[FieldOffset(72)]
		public float tangentImpulse;

		// Token: 0x04004D16 RID: 19734
		[FieldOffset(76)]
		public float bitangentImpulse;

		// Token: 0x04004D17 RID: 19735
		[FieldOffset(80)]
		public float stickImpulse;

		// Token: 0x04004D18 RID: 19736
		[FieldOffset(84)]
		public int particle;

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

	// Token: 0x02000388 RID: 904
	[StructLayout(LayoutKind.Explicit)]
	public struct BoneWeights
	{
		// Token: 0x06007393 RID: 29587 RVA: 0x001D6A80 File Offset: 0x001D4C80
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603750, RefRangeEnd = 603752, XrefRangeStart = 603742, XrefRangeEnd = 603750, 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: 0x06007394 RID: 29588 RVA: 0x001D6AC8 File Offset: 0x001D4CC8
		// 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, 100671983);
		}

		// Token: 0x06007395 RID: 29589 RVA: 0x001D6BA7 File Offset: 0x001D4DA7
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, ref this));
		}

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

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

		// Token: 0x04004D1C RID: 19740
		private static readonly IntPtr NativeFieldInfoPtr_bone2;

		// Token: 0x04004D1D RID: 19741
		private static readonly IntPtr NativeFieldInfoPtr_bone3;

		// Token: 0x04004D1E RID: 19742
		private static readonly IntPtr NativeFieldInfoPtr_weight0;

		// Token: 0x04004D1F RID: 19743
		private static readonly IntPtr NativeFieldInfoPtr_weight1;

		// Token: 0x04004D20 RID: 19744
		private static readonly IntPtr NativeFieldInfoPtr_weight2;

		// Token: 0x04004D21 RID: 19745
		private static readonly IntPtr NativeFieldInfoPtr_weight3;

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

		// Token: 0x04004D23 RID: 19747
		[FieldOffset(0)]
		public int bone0;

		// Token: 0x04004D24 RID: 19748
		[FieldOffset(4)]
		public int bone1;

		// Token: 0x04004D25 RID: 19749
		[FieldOffset(8)]
		public int bone2;

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

		// Token: 0x04004D27 RID: 19751
		[FieldOffset(16)]
		public float weight0;

		// Token: 0x04004D28 RID: 19752
		[FieldOffset(20)]
		public float weight1;

		// Token: 0x04004D29 RID: 19753
		[FieldOffset(24)]
		public float weight2;

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

	// Token: 0x02000389 RID: 905
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Rigidbody
	{
		// Token: 0x06007396 RID: 29590 RVA: 0x001D6BBC File Offset: 0x001D4DBC
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603779, RefRangeEnd = 603781, XrefRangeStart = 603752, XrefRangeEnd = 603779, 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: 0x06007397 RID: 29591 RVA: 0x001D6C1C File Offset: 0x001D4E1C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603781, XrefRangeEnd = 603802, 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: 0x06007398 RID: 29592 RVA: 0x001D6C7C File Offset: 0x001D4E7C
		// 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, 100671984);
			Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, 100671985);
		}

		// Token: 0x06007399 RID: 29593 RVA: 0x001D6D47 File Offset: 0x001D4F47
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, ref this));
		}

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

		// Token: 0x04004D2C RID: 19756
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x04004D2D RID: 19757
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

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

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

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

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

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

		// Token: 0x04004D33 RID: 19763
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x04004D34 RID: 19764
		[FieldOffset(16)]
		public Vector3 linearVelocity;

		// Token: 0x04004D35 RID: 19765
		[FieldOffset(28)]
		public Vector3 angularVelocity;

		// Token: 0x04004D36 RID: 19766
		[FieldOffset(40)]
		public Vector3 centerOfMass;

		// Token: 0x04004D37 RID: 19767
		[FieldOffset(52)]
		public Vector3 inertiaTensor;

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

	// Token: 0x0200038A RID: 906
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct RigidbodyVelocities
	{
		// Token: 0x0600739A RID: 29594 RVA: 0x001D6D5C File Offset: 0x001D4F5C
		// 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: 0x0600739B RID: 29595 RVA: 0x001D6DAF File Offset: 0x001D4FAF
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D39 RID: 19769
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x04004D3A RID: 19770
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

		// Token: 0x04004D3B RID: 19771
		[FieldOffset(0)]
		public Vector3 linearVelocity;

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

	// Token: 0x0200038B RID: 907
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Collider
	{
		// Token: 0x0600739C RID: 29596 RVA: 0x001D6DC4 File Offset: 0x001D4FC4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603824, RefRangeEnd = 603825, XrefRangeStart = 603802, XrefRangeEnd = 603824, 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: 0x0600739D RID: 29597 RVA: 0x001D6E34 File Offset: 0x001D5034
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603845, RefRangeEnd = 603846, XrefRangeStart = 603825, XrefRangeEnd = 603845, 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: 0x0600739E RID: 29598 RVA: 0x001D6EA4 File Offset: 0x001D50A4
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603901, RefRangeEnd = 603903, XrefRangeStart = 603846, XrefRangeEnd = 603901, 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: 0x0600739F RID: 29599 RVA: 0x001D6EF0 File Offset: 0x001D50F0
		// 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, 100671986);
			Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100671987);
			Oni.Collider.NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100671988);
		}

		// Token: 0x060073A0 RID: 29600 RVA: 0x001D700B File Offset: 0x001D520B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D3D RID: 19773
		private static readonly IntPtr NativeFieldInfoPtr_rotation;

		// Token: 0x04004D3E RID: 19774
		private static readonly IntPtr NativeFieldInfoPtr_translation;

		// Token: 0x04004D3F RID: 19775
		private static readonly IntPtr NativeFieldInfoPtr_scale;

		// Token: 0x04004D40 RID: 19776
		private static readonly IntPtr NativeFieldInfoPtr_boundsMin;

		// Token: 0x04004D41 RID: 19777
		private static readonly IntPtr NativeFieldInfoPtr_boundsMax;

		// Token: 0x04004D42 RID: 19778
		private static readonly IntPtr NativeFieldInfoPtr_id;

		// Token: 0x04004D43 RID: 19779
		private static readonly IntPtr NativeFieldInfoPtr_contactOffset;

		// Token: 0x04004D44 RID: 19780
		private static readonly IntPtr NativeFieldInfoPtr_collisionGroup;

		// Token: 0x04004D45 RID: 19781
		private static readonly IntPtr NativeFieldInfoPtr_trigger;

		// Token: 0x04004D46 RID: 19782
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider_Int32_Single_0;

		// Token: 0x04004D47 RID: 19783
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0;

		// Token: 0x04004D48 RID: 19784
		private static readonly IntPtr NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0;

		// Token: 0x04004D49 RID: 19785
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x04004D4A RID: 19786
		[FieldOffset(16)]
		public Vector3 translation;

		// Token: 0x04004D4B RID: 19787
		[FieldOffset(28)]
		public Vector3 scale;

		// Token: 0x04004D4C RID: 19788
		[FieldOffset(40)]
		public Vector3 boundsMin;

		// Token: 0x04004D4D RID: 19789
		[FieldOffset(52)]
		public Vector3 boundsMax;

		// Token: 0x04004D4E RID: 19790
		[FieldOffset(64)]
		public int id;

		// Token: 0x04004D4F RID: 19791
		[FieldOffset(68)]
		public float contactOffset;

		// Token: 0x04004D50 RID: 19792
		[FieldOffset(72)]
		public int collisionGroup;

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

	// Token: 0x0200038C RID: 908
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Shape
	{
		// Token: 0x060073A1 RID: 29601 RVA: 0x001D7020 File Offset: 0x001D5220
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603904, RefRangeEnd = 603906, XrefRangeStart = 603903, XrefRangeEnd = 603904, 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: 0x060073A2 RID: 29602 RVA: 0x001D7078 File Offset: 0x001D5278
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 365882, RefRangeEnd = 365887, XrefRangeStart = 365882, XrefRangeEnd = 365887, 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: 0x060073A3 RID: 29603 RVA: 0x001D70D0 File Offset: 0x001D52D0
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 603906, RefRangeEnd = 603909, XrefRangeStart = 603906, XrefRangeEnd = 603906, 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: 0x060073A4 RID: 29604 RVA: 0x001D7150 File Offset: 0x001D5350
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603909, RefRangeEnd = 603910, XrefRangeStart = 603909, XrefRangeEnd = 603909, 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: 0x060073A5 RID: 29605 RVA: 0x001D71D0 File Offset: 0x001D53D0
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603910, RefRangeEnd = 603912, XrefRangeStart = 603910, XrefRangeEnd = 603910, 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: 0x060073A6 RID: 29606 RVA: 0x001D7250 File Offset: 0x001D5450
		// 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, 100671989);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671990);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671991);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671992);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100671993);
		}

		// Token: 0x060073A7 RID: 29607 RVA: 0x001D7393 File Offset: 0x001D5593
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D52 RID: 19794
		private static readonly IntPtr NativeFieldInfoPtr_center;

		// Token: 0x04004D53 RID: 19795
		private static readonly IntPtr NativeFieldInfoPtr_size;

		// Token: 0x04004D54 RID: 19796
		private static readonly IntPtr NativeFieldInfoPtr_data;

		// Token: 0x04004D55 RID: 19797
		private static readonly IntPtr NativeFieldInfoPtr_indices;

		// Token: 0x04004D56 RID: 19798
		private static readonly IntPtr NativeFieldInfoPtr_dataCount;

		// Token: 0x04004D57 RID: 19799
		private static readonly IntPtr NativeFieldInfoPtr_indexCount;

		// Token: 0x04004D58 RID: 19800
		private static readonly IntPtr NativeFieldInfoPtr_resolutionU;

		// Token: 0x04004D59 RID: 19801
		private static readonly IntPtr NativeFieldInfoPtr_resolutionV;

		// Token: 0x04004D5A RID: 19802
		private static readonly IntPtr NativeFieldInfoPtr_is2D;

		// Token: 0x04004D5B RID: 19803
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_0;

		// Token: 0x04004D5C RID: 19804
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0;

		// Token: 0x04004D5D RID: 19805
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0;

		// Token: 0x04004D5E RID: 19806
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0;

		// Token: 0x04004D5F RID: 19807
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0;

		// Token: 0x04004D60 RID: 19808
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04004D61 RID: 19809
		[FieldOffset(12)]
		public Vector3 size;

		// Token: 0x04004D62 RID: 19810
		[FieldOffset(24)]
		public IntPtr data;

		// Token: 0x04004D63 RID: 19811
		[FieldOffset(32)]
		public IntPtr indices;

		// Token: 0x04004D64 RID: 19812
		[FieldOffset(40)]
		public int dataCount;

		// Token: 0x04004D65 RID: 19813
		[FieldOffset(44)]
		public int indexCount;

		// Token: 0x04004D66 RID: 19814
		[FieldOffset(48)]
		public int resolutionU;

		// Token: 0x04004D67 RID: 19815
		[FieldOffset(52)]
		public int resolutionV;

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

	// Token: 0x0200038D RID: 909
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct CollisionMaterial
	{
		// Token: 0x060073A8 RID: 29608 RVA: 0x001D73A8 File Offset: 0x001D55A8
		// 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: 0x060073A9 RID: 29609 RVA: 0x001D7437 File Offset: 0x001D5637
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D69 RID: 19817
		private static readonly IntPtr NativeFieldInfoPtr_friction;

		// Token: 0x04004D6A RID: 19818
		private static readonly IntPtr NativeFieldInfoPtr_stickiness;

		// Token: 0x04004D6B RID: 19819
		private static readonly IntPtr NativeFieldInfoPtr_stickDistance;

		// Token: 0x04004D6C RID: 19820
		private static readonly IntPtr NativeFieldInfoPtr_frictionCombine;

		// Token: 0x04004D6D RID: 19821
		private static readonly IntPtr NativeFieldInfoPtr_stickinessCombine;

		// Token: 0x04004D6E RID: 19822
		[FieldOffset(0)]
		public float friction;

		// Token: 0x04004D6F RID: 19823
		[FieldOffset(4)]
		public float stickiness;

		// Token: 0x04004D70 RID: 19824
		[FieldOffset(8)]
		public float stickDistance;

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

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

	// Token: 0x0200038E RID: 910
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct FluidMaterial
	{
		// Token: 0x060073AA RID: 29610 RVA: 0x001D744C File Offset: 0x001D564C
		// 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: 0x060073AB RID: 29611 RVA: 0x001D7553 File Offset: 0x001D5753
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D73 RID: 19827
		private static readonly IntPtr NativeFieldInfoPtr_smoothingRadius;

		// Token: 0x04004D74 RID: 19828
		private static readonly IntPtr NativeFieldInfoPtr_restDensity;

		// Token: 0x04004D75 RID: 19829
		private static readonly IntPtr NativeFieldInfoPtr_viscosity;

		// Token: 0x04004D76 RID: 19830
		private static readonly IntPtr NativeFieldInfoPtr_surfaceTension;

		// Token: 0x04004D77 RID: 19831
		private static readonly IntPtr NativeFieldInfoPtr_buoyancy;

		// Token: 0x04004D78 RID: 19832
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericDrag;

		// Token: 0x04004D79 RID: 19833
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericPressure;

		// Token: 0x04004D7A RID: 19834
		private static readonly IntPtr NativeFieldInfoPtr_vorticity;

		// Token: 0x04004D7B RID: 19835
		private static readonly IntPtr NativeFieldInfoPtr_elasticRange;

		// Token: 0x04004D7C RID: 19836
		private static readonly IntPtr NativeFieldInfoPtr_plasticCreep;

		// Token: 0x04004D7D RID: 19837
		private static readonly IntPtr NativeFieldInfoPtr_plasticThreshold;

		// Token: 0x04004D7E RID: 19838
		[FieldOffset(0)]
		public float smoothingRadius;

		// Token: 0x04004D7F RID: 19839
		[FieldOffset(4)]
		public float restDensity;

		// Token: 0x04004D80 RID: 19840
		[FieldOffset(8)]
		public float viscosity;

		// Token: 0x04004D81 RID: 19841
		[FieldOffset(12)]
		public float surfaceTension;

		// Token: 0x04004D82 RID: 19842
		[FieldOffset(16)]
		public float buoyancy;

		// Token: 0x04004D83 RID: 19843
		[FieldOffset(20)]
		public float atmosphericDrag;

		// Token: 0x04004D84 RID: 19844
		[FieldOffset(24)]
		public float atmosphericPressure;

		// Token: 0x04004D85 RID: 19845
		[FieldOffset(28)]
		public float vorticity;

		// Token: 0x04004D86 RID: 19846
		[FieldOffset(32)]
		public float elasticRange;

		// Token: 0x04004D87 RID: 19847
		[FieldOffset(36)]
		public float plasticCreep;

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

	// Token: 0x0200038F RID: 911
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct HalfEdge
	{
		// Token: 0x060073AC RID: 29612 RVA: 0x001D7568 File Offset: 0x001D5768
		[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: 0x060073AD RID: 29613 RVA: 0x001D75B0 File Offset: 0x001D57B0
		// 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, 100671994);
		}

		// Token: 0x060073AE RID: 29614 RVA: 0x001D7667 File Offset: 0x001D5867
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D89 RID: 19849
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D8A RID: 19850
		private static readonly IntPtr NativeFieldInfoPtr_indexInFace;

		// Token: 0x04004D8B RID: 19851
		private static readonly IntPtr NativeFieldInfoPtr_face;

		// Token: 0x04004D8C RID: 19852
		private static readonly IntPtr NativeFieldInfoPtr_nextHalfEdge;

		// Token: 0x04004D8D RID: 19853
		private static readonly IntPtr NativeFieldInfoPtr_pair;

		// Token: 0x04004D8E RID: 19854
		private static readonly IntPtr NativeFieldInfoPtr_endVertex;

		// Token: 0x04004D8F RID: 19855
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x04004D90 RID: 19856
		[FieldOffset(0)]
		public int index;

		// Token: 0x04004D91 RID: 19857
		[FieldOffset(4)]
		public int indexInFace;

		// Token: 0x04004D92 RID: 19858
		[FieldOffset(8)]
		public int face;

		// Token: 0x04004D93 RID: 19859
		[FieldOffset(12)]
		public int nextHalfEdge;

		// Token: 0x04004D94 RID: 19860
		[FieldOffset(16)]
		public int pair;

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

	// Token: 0x02000390 RID: 912
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Vertex
	{
		// Token: 0x060073AF RID: 29615 RVA: 0x001D767C File Offset: 0x001D587C
		[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: 0x060073B0 RID: 29616 RVA: 0x001D76E8 File Offset: 0x001D58E8
		// 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, 100671995);
		}

		// Token: 0x060073B1 RID: 29617 RVA: 0x001D7763 File Offset: 0x001D5963
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D96 RID: 19862
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D97 RID: 19863
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x04004D98 RID: 19864
		private static readonly IntPtr NativeFieldInfoPtr_position;

		// Token: 0x04004D99 RID: 19865
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Int32_Int32_0;

		// Token: 0x04004D9A RID: 19866
		[FieldOffset(0)]
		public int index;

		// Token: 0x04004D9B RID: 19867
		[FieldOffset(4)]
		public int halfEdge;

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

	// Token: 0x02000391 RID: 913
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct Face
	{
		// Token: 0x060073B2 RID: 29618 RVA: 0x001D7778 File Offset: 0x001D5978
		[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: 0x060073B3 RID: 29619 RVA: 0x001D77C0 File Offset: 0x001D59C0
		// 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, 100671996);
		}

		// Token: 0x060073B4 RID: 29620 RVA: 0x001D7827 File Offset: 0x001D5A27
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, ref this));
		}

		// Token: 0x04004D9D RID: 19869
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x04004D9E RID: 19870
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x04004D9F RID: 19871
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x04004DA0 RID: 19872
		[FieldOffset(0)]
		public int index;

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

	// Token: 0x02000392 RID: 914
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	public struct MeshInformation
	{
		// Token: 0x060073B5 RID: 29621 RVA: 0x001D783C File Offset: 0x001D5A3C
		// 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: 0x060073B6 RID: 29622 RVA: 0x001D78CB File Offset: 0x001D5ACB
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, ref this));
		}

		// Token: 0x04004DA2 RID: 19874
		private static readonly IntPtr NativeFieldInfoPtr_volume;

		// Token: 0x04004DA3 RID: 19875
		private static readonly IntPtr NativeFieldInfoPtr_area;

		// Token: 0x04004DA4 RID: 19876
		private static readonly IntPtr NativeFieldInfoPtr_borderEdgeCount;

		// Token: 0x04004DA5 RID: 19877
		private static readonly IntPtr NativeFieldInfoPtr_closed;

		// Token: 0x04004DA6 RID: 19878
		private static readonly IntPtr NativeFieldInfoPtr_nonManifold;

		// Token: 0x04004DA7 RID: 19879
		[FieldOffset(0)]
		public float volume;

		// Token: 0x04004DA8 RID: 19880
		[FieldOffset(4)]
		public float area;

		// Token: 0x04004DA9 RID: 19881
		[FieldOffset(8)]
		public int borderEdgeCount;

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

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