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: 0x020003C9 RID: 969
public static class Oni : Il2CppSystem.Object
{
	// Token: 0x06007A98 RID: 31384 RVA: 0x001F21F0 File Offset: 0x001F03F0
	[CallerCount(43)]
	[CachedScanResults(RefRangeStart = 618603, RefRangeEnd = 618646, XrefRangeStart = 618602, XrefRangeEnd = 618603, 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: 0x06007A99 RID: 31385 RVA: 0x001F2248 File Offset: 0x001F0448
	[CallerCount(70)]
	[CachedScanResults(RefRangeStart = 618648, RefRangeEnd = 618718, XrefRangeStart = 618646, XrefRangeEnd = 618648, 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: 0x06007A9A RID: 31386 RVA: 0x001F2290 File Offset: 0x001F0490
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618720, RefRangeEnd = 618721, XrefRangeStart = 618718, XrefRangeEnd = 618720, 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: 0x06007A9B RID: 31387 RVA: 0x001F22D4 File Offset: 0x001F04D4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618723, RefRangeEnd = 618724, XrefRangeStart = 618721, XrefRangeEnd = 618723, 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: 0x06007A9C RID: 31388 RVA: 0x001F231C File Offset: 0x001F051C
	[CallerCount(14)]
	[CachedScanResults(RefRangeStart = 618726, RefRangeEnd = 618740, XrefRangeStart = 618724, XrefRangeEnd = 618726, 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: 0x06007A9D RID: 31389 RVA: 0x001F2370 File Offset: 0x001F0570
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618742, RefRangeEnd = 618744, XrefRangeStart = 618740, XrefRangeEnd = 618742, 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: 0x06007A9E RID: 31390 RVA: 0x001F23B8 File Offset: 0x001F05B8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618746, RefRangeEnd = 618747, XrefRangeStart = 618744, XrefRangeEnd = 618746, 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: 0x06007A9F RID: 31391 RVA: 0x001F23FC File Offset: 0x001F05FC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618749, RefRangeEnd = 618750, XrefRangeStart = 618747, XrefRangeEnd = 618749, 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: 0x06007AA0 RID: 31392 RVA: 0x001F2444 File Offset: 0x001F0644
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618752, RefRangeEnd = 618754, XrefRangeStart = 618750, XrefRangeEnd = 618752, 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: 0x06007AA1 RID: 31393 RVA: 0x001F24A0 File Offset: 0x001F06A0
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 618756, RefRangeEnd = 618766, XrefRangeStart = 618754, XrefRangeEnd = 618756, 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: 0x06007AA2 RID: 31394 RVA: 0x001F24FC File Offset: 0x001F06FC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618768, RefRangeEnd = 618770, XrefRangeStart = 618766, XrefRangeEnd = 618768, 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: 0x06007AA3 RID: 31395 RVA: 0x001F2558 File Offset: 0x001F0758
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618772, RefRangeEnd = 618773, XrefRangeStart = 618770, XrefRangeEnd = 618772, 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: 0x06007AA4 RID: 31396 RVA: 0x001F25B4 File Offset: 0x001F07B4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618775, RefRangeEnd = 618776, XrefRangeStart = 618773, XrefRangeEnd = 618775, 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: 0x06007AA5 RID: 31397 RVA: 0x001F260C File Offset: 0x001F080C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618778, RefRangeEnd = 618780, XrefRangeStart = 618776, XrefRangeEnd = 618778, 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: 0x06007AA6 RID: 31398 RVA: 0x001F2664 File Offset: 0x001F0864
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618782, RefRangeEnd = 618784, XrefRangeStart = 618780, XrefRangeEnd = 618782, 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: 0x06007AA7 RID: 31399 RVA: 0x001F26BC File Offset: 0x001F08BC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618786, RefRangeEnd = 618787, XrefRangeStart = 618784, XrefRangeEnd = 618786, 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: 0x06007AA8 RID: 31400 RVA: 0x001F2700 File Offset: 0x001F0900
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618789, RefRangeEnd = 618790, XrefRangeStart = 618787, XrefRangeEnd = 618789, 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: 0x06007AA9 RID: 31401 RVA: 0x001F2748 File Offset: 0x001F0948
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618792, RefRangeEnd = 618794, XrefRangeStart = 618790, XrefRangeEnd = 618792, 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: 0x06007AAA RID: 31402 RVA: 0x001F27A4 File Offset: 0x001F09A4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618796, RefRangeEnd = 618798, XrefRangeStart = 618794, XrefRangeEnd = 618796, 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: 0x06007AAB RID: 31403 RVA: 0x001F280C File Offset: 0x001F0A0C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618800, RefRangeEnd = 618802, XrefRangeStart = 618798, XrefRangeEnd = 618800, 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: 0x06007AAC RID: 31404 RVA: 0x001F2854 File Offset: 0x001F0A54
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 618804, RefRangeEnd = 618808, XrefRangeStart = 618802, XrefRangeEnd = 618804, 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: 0x06007AAD RID: 31405 RVA: 0x001F28AC File Offset: 0x001F0AAC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 618810, RefRangeEnd = 618814, XrefRangeStart = 618808, XrefRangeEnd = 618810, 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: 0x06007AAE RID: 31406 RVA: 0x001F2904 File Offset: 0x001F0B04
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618816, RefRangeEnd = 618817, XrefRangeStart = 618814, XrefRangeEnd = 618816, 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: 0x06007AAF RID: 31407 RVA: 0x001F2974 File Offset: 0x001F0B74
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618819, RefRangeEnd = 618820, XrefRangeStart = 618817, XrefRangeEnd = 618819, 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: 0x06007AB0 RID: 31408 RVA: 0x001F29C8 File Offset: 0x001F0BC8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618822, RefRangeEnd = 618823, XrefRangeStart = 618820, XrefRangeEnd = 618822, 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: 0x06007AB1 RID: 31409 RVA: 0x001F2A28 File Offset: 0x001F0C28
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618825, RefRangeEnd = 618827, XrefRangeStart = 618823, XrefRangeEnd = 618825, 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: 0x06007AB2 RID: 31410 RVA: 0x001F2A84 File Offset: 0x001F0C84
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618827, XrefRangeEnd = 618829, 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: 0x06007AB3 RID: 31411 RVA: 0x001F2AE0 File Offset: 0x001F0CE0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618831, RefRangeEnd = 618832, XrefRangeStart = 618829, XrefRangeEnd = 618831, 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: 0x06007AB4 RID: 31412 RVA: 0x001F2B60 File Offset: 0x001F0D60
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 618834, RefRangeEnd = 618837, XrefRangeStart = 618832, XrefRangeEnd = 618834, 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: 0x06007AB5 RID: 31413 RVA: 0x001F2BB8 File Offset: 0x001F0DB8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618839, RefRangeEnd = 618840, XrefRangeStart = 618837, XrefRangeEnd = 618839, 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: 0x06007AB6 RID: 31414 RVA: 0x001F2C00 File Offset: 0x001F0E00
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618842, RefRangeEnd = 618843, XrefRangeStart = 618840, XrefRangeEnd = 618842, 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: 0x06007AB7 RID: 31415 RVA: 0x001F2C58 File Offset: 0x001F0E58
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618845, RefRangeEnd = 618846, XrefRangeStart = 618843, XrefRangeEnd = 618845, 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: 0x06007AB8 RID: 31416 RVA: 0x001F2CB0 File Offset: 0x001F0EB0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618848, RefRangeEnd = 618849, XrefRangeStart = 618846, XrefRangeEnd = 618848, 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: 0x06007AB9 RID: 31417 RVA: 0x001F2CF8 File Offset: 0x001F0EF8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618849, XrefRangeEnd = 618851, 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: 0x06007ABA RID: 31418 RVA: 0x001F2D58 File Offset: 0x001F0F58
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618853, RefRangeEnd = 618855, XrefRangeStart = 618851, XrefRangeEnd = 618853, 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: 0x06007ABB RID: 31419 RVA: 0x001F2DB8 File Offset: 0x001F0FB8
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 618857, RefRangeEnd = 618861, XrefRangeStart = 618855, XrefRangeEnd = 618857, 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: 0x06007ABC RID: 31420 RVA: 0x001F2E20 File Offset: 0x001F1020
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618863, RefRangeEnd = 618865, XrefRangeStart = 618861, XrefRangeEnd = 618863, 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: 0x06007ABD RID: 31421 RVA: 0x001F2EA4 File Offset: 0x001F10A4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618865, XrefRangeEnd = 618867, 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: 0x06007ABE RID: 31422 RVA: 0x001F2F38 File Offset: 0x001F1138
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618869, RefRangeEnd = 618870, XrefRangeStart = 618867, XrefRangeEnd = 618869, 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: 0x06007ABF RID: 31423 RVA: 0x001F2FCC File Offset: 0x001F11CC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618872, RefRangeEnd = 618874, XrefRangeStart = 618870, XrefRangeEnd = 618872, 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: 0x06007AC0 RID: 31424 RVA: 0x001F3060 File Offset: 0x001F1260
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 618876, RefRangeEnd = 618885, XrefRangeStart = 618874, XrefRangeEnd = 618876, 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: 0x06007AC1 RID: 31425 RVA: 0x001F30F4 File Offset: 0x001F12F4
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 618887, RefRangeEnd = 618892, XrefRangeStart = 618885, XrefRangeEnd = 618887, 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: 0x06007AC2 RID: 31426 RVA: 0x001F3188 File Offset: 0x001F1388
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 618894, RefRangeEnd = 618901, XrefRangeStart = 618892, XrefRangeEnd = 618894, 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: 0x06007AC3 RID: 31427 RVA: 0x001F321C File Offset: 0x001F141C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618903, RefRangeEnd = 618905, XrefRangeStart = 618901, XrefRangeEnd = 618903, 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: 0x06007AC4 RID: 31428 RVA: 0x001F32B0 File Offset: 0x001F14B0
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 618907, RefRangeEnd = 618913, XrefRangeStart = 618905, XrefRangeEnd = 618907, 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: 0x06007AC5 RID: 31429 RVA: 0x001F3344 File Offset: 0x001F1544
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618915, RefRangeEnd = 618917, XrefRangeStart = 618913, XrefRangeEnd = 618915, 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: 0x06007AC6 RID: 31430 RVA: 0x001F33D8 File Offset: 0x001F15D8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618919, RefRangeEnd = 618920, XrefRangeStart = 618917, XrefRangeEnd = 618919, 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: 0x06007AC7 RID: 31431 RVA: 0x001F3460 File Offset: 0x001F1660
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618922, RefRangeEnd = 618923, XrefRangeStart = 618920, XrefRangeEnd = 618922, 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: 0x06007AC8 RID: 31432 RVA: 0x001F34E4 File Offset: 0x001F16E4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618925, RefRangeEnd = 618927, XrefRangeStart = 618923, XrefRangeEnd = 618925, 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: 0x06007AC9 RID: 31433 RVA: 0x001F3578 File Offset: 0x001F1778
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618929, RefRangeEnd = 618931, XrefRangeStart = 618927, XrefRangeEnd = 618929, 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: 0x06007ACA RID: 31434 RVA: 0x001F360C File Offset: 0x001F180C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618933, RefRangeEnd = 618934, XrefRangeStart = 618931, XrefRangeEnd = 618933, 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: 0x06007ACB RID: 31435 RVA: 0x001F3660 File Offset: 0x001F1860
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618936, RefRangeEnd = 618938, XrefRangeStart = 618934, XrefRangeEnd = 618936, 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: 0x06007ACC RID: 31436 RVA: 0x001F36E4 File Offset: 0x001F18E4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618940, RefRangeEnd = 618941, XrefRangeStart = 618938, XrefRangeEnd = 618940, 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: 0x06007ACD RID: 31437 RVA: 0x001F3760 File Offset: 0x001F1960
	[CallerCount(20)]
	[CachedScanResults(RefRangeStart = 618943, RefRangeEnd = 618963, XrefRangeStart = 618941, XrefRangeEnd = 618943, 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: 0x06007ACE RID: 31438 RVA: 0x001F37CC File Offset: 0x001F19CC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618963, XrefRangeEnd = 618965, 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: 0x06007ACF RID: 31439 RVA: 0x001F3838 File Offset: 0x001F1A38
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618967, RefRangeEnd = 618968, XrefRangeStart = 618965, XrefRangeEnd = 618967, 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: 0x06007AD0 RID: 31440 RVA: 0x001F38C0 File Offset: 0x001F1AC0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618970, RefRangeEnd = 618972, XrefRangeStart = 618968, XrefRangeEnd = 618970, 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: 0x06007AD1 RID: 31441 RVA: 0x001F3954 File Offset: 0x001F1B54
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618974, RefRangeEnd = 618976, XrefRangeStart = 618972, XrefRangeEnd = 618974, 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: 0x06007AD2 RID: 31442 RVA: 0x001F39D8 File Offset: 0x001F1BD8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 618978, RefRangeEnd = 618979, XrefRangeStart = 618976, XrefRangeEnd = 618978, 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: 0x06007AD3 RID: 31443 RVA: 0x001F3A6C File Offset: 0x001F1C6C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 618981, RefRangeEnd = 618986, XrefRangeStart = 618979, XrefRangeEnd = 618981, 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: 0x06007AD4 RID: 31444 RVA: 0x001F3B38 File Offset: 0x001F1D38
	[CallerCount(6)]
	[CachedScanResults(RefRangeStart = 618988, RefRangeEnd = 618994, XrefRangeStart = 618986, XrefRangeEnd = 618988, 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: 0x06007AD5 RID: 31445 RVA: 0x001F3B90 File Offset: 0x001F1D90
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 618996, RefRangeEnd = 618998, XrefRangeStart = 618994, XrefRangeEnd = 618996, 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: 0x06007AD6 RID: 31446 RVA: 0x001F3C4C File Offset: 0x001F1E4C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619000, RefRangeEnd = 619004, XrefRangeStart = 618998, XrefRangeEnd = 619000, 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: 0x06007AD7 RID: 31447 RVA: 0x001F3CB8 File Offset: 0x001F1EB8
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619006, RefRangeEnd = 619009, XrefRangeStart = 619004, XrefRangeEnd = 619006, 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: 0x06007AD8 RID: 31448 RVA: 0x001F3D18 File Offset: 0x001F1F18
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619011, RefRangeEnd = 619012, XrefRangeStart = 619009, XrefRangeEnd = 619011, 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: 0x06007AD9 RID: 31449 RVA: 0x001F3D84 File Offset: 0x001F1F84
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619012, XrefRangeEnd = 619014, 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: 0x06007ADA RID: 31450 RVA: 0x001F3DDC File Offset: 0x001F1FDC
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619016, RefRangeEnd = 619019, XrefRangeStart = 619014, XrefRangeEnd = 619016, 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: 0x06007ADB RID: 31451 RVA: 0x001F3ED0 File Offset: 0x001F20D0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619021, RefRangeEnd = 619023, XrefRangeStart = 619019, XrefRangeEnd = 619021, 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: 0x06007ADC RID: 31452 RVA: 0x001F3F58 File Offset: 0x001F2158
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619025, RefRangeEnd = 619027, XrefRangeStart = 619023, XrefRangeEnd = 619025, 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: 0x06007ADD RID: 31453 RVA: 0x001F3FB8 File Offset: 0x001F21B8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619029, RefRangeEnd = 619030, XrefRangeStart = 619027, XrefRangeEnd = 619029, 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: 0x06007ADE RID: 31454 RVA: 0x001F4000 File Offset: 0x001F2200
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 619032, RefRangeEnd = 619040, XrefRangeStart = 619030, XrefRangeEnd = 619032, 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: 0x06007ADF RID: 31455 RVA: 0x001F4068 File Offset: 0x001F2268
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619042, RefRangeEnd = 619046, XrefRangeStart = 619040, XrefRangeEnd = 619042, 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: 0x06007AE0 RID: 31456 RVA: 0x001F40B0 File Offset: 0x001F22B0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619048, RefRangeEnd = 619052, XrefRangeStart = 619046, XrefRangeEnd = 619048, 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: 0x06007AE1 RID: 31457 RVA: 0x001F412C File Offset: 0x001F232C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619054, RefRangeEnd = 619058, XrefRangeStart = 619052, XrefRangeEnd = 619054, 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: 0x06007AE2 RID: 31458 RVA: 0x001F4184 File Offset: 0x001F2384
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 619060, RefRangeEnd = 619068, XrefRangeStart = 619058, XrefRangeEnd = 619060, 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: 0x06007AE3 RID: 31459 RVA: 0x001F41EC File Offset: 0x001F23EC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619070, RefRangeEnd = 619074, XrefRangeStart = 619068, XrefRangeEnd = 619070, 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: 0x06007AE4 RID: 31460 RVA: 0x001F4240 File Offset: 0x001F2440
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619076, RefRangeEnd = 619078, XrefRangeStart = 619074, XrefRangeEnd = 619076, 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: 0x06007AE5 RID: 31461 RVA: 0x001F42D4 File Offset: 0x001F24D4
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619080, RefRangeEnd = 619084, XrefRangeStart = 619078, XrefRangeEnd = 619080, 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: 0x06007AE6 RID: 31462 RVA: 0x001F4328 File Offset: 0x001F2528
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619086, RefRangeEnd = 619090, XrefRangeStart = 619084, XrefRangeEnd = 619086, 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: 0x06007AE7 RID: 31463 RVA: 0x001F4388 File Offset: 0x001F2588
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619092, RefRangeEnd = 619096, XrefRangeStart = 619090, XrefRangeEnd = 619092, 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: 0x06007AE8 RID: 31464 RVA: 0x001F43F8 File Offset: 0x001F25F8
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619098, RefRangeEnd = 619102, XrefRangeStart = 619096, XrefRangeEnd = 619098, 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: 0x06007AE9 RID: 31465 RVA: 0x001F444C File Offset: 0x001F264C
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619104, RefRangeEnd = 619107, XrefRangeStart = 619102, XrefRangeEnd = 619104, 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: 0x06007AEA RID: 31466 RVA: 0x001F44CC File Offset: 0x001F26CC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619109, RefRangeEnd = 619111, XrefRangeStart = 619107, XrefRangeEnd = 619109, 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: 0x06007AEB RID: 31467 RVA: 0x001F456C File Offset: 0x001F276C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619113, RefRangeEnd = 619114, XrefRangeStart = 619111, XrefRangeEnd = 619113, 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: 0x06007AEC RID: 31468 RVA: 0x001F45FC File Offset: 0x001F27FC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619116, RefRangeEnd = 619118, XrefRangeStart = 619114, XrefRangeEnd = 619116, 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: 0x06007AED RID: 31469 RVA: 0x001F469C File Offset: 0x001F289C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619120, RefRangeEnd = 619121, XrefRangeStart = 619118, XrefRangeEnd = 619120, 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: 0x06007AEE RID: 31470 RVA: 0x001F472C File Offset: 0x001F292C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619123, RefRangeEnd = 619125, XrefRangeStart = 619121, XrefRangeEnd = 619123, 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: 0x06007AEF RID: 31471 RVA: 0x001F47FC File Offset: 0x001F29FC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619127, RefRangeEnd = 619129, XrefRangeStart = 619125, XrefRangeEnd = 619127, 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: 0x06007AF0 RID: 31472 RVA: 0x001F48BC File Offset: 0x001F2ABC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619131, RefRangeEnd = 619132, XrefRangeStart = 619129, XrefRangeEnd = 619131, 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: 0x06007AF1 RID: 31473 RVA: 0x001F4944 File Offset: 0x001F2B44
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619134, RefRangeEnd = 619135, XrefRangeStart = 619132, XrefRangeEnd = 619134, 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: 0x06007AF2 RID: 31474 RVA: 0x001F4A14 File Offset: 0x001F2C14
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619137, RefRangeEnd = 619139, XrefRangeStart = 619135, XrefRangeEnd = 619137, 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: 0x06007AF3 RID: 31475 RVA: 0x001F4AB4 File Offset: 0x001F2CB4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619141, RefRangeEnd = 619142, XrefRangeStart = 619139, XrefRangeEnd = 619141, 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: 0x06007AF4 RID: 31476 RVA: 0x001F4B44 File Offset: 0x001F2D44
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619144, RefRangeEnd = 619145, XrefRangeStart = 619142, XrefRangeEnd = 619144, 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: 0x06007AF5 RID: 31477 RVA: 0x001F4BFC File Offset: 0x001F2DFC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619147, RefRangeEnd = 619148, XrefRangeStart = 619145, XrefRangeEnd = 619147, 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: 0x06007AF6 RID: 31478 RVA: 0x001F4C84 File Offset: 0x001F2E84
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619150, RefRangeEnd = 619152, XrefRangeStart = 619148, XrefRangeEnd = 619150, 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: 0x06007AF7 RID: 31479 RVA: 0x001F4CF4 File Offset: 0x001F2EF4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619154, RefRangeEnd = 619155, XrefRangeStart = 619152, XrefRangeEnd = 619154, 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: 0x06007AF8 RID: 31480 RVA: 0x001F4D3C File Offset: 0x001F2F3C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619155, XrefRangeEnd = 619157, 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: 0x06007AF9 RID: 31481 RVA: 0x001F4DBC File Offset: 0x001F2FBC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619157, XrefRangeEnd = 619159, 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: 0x06007AFA RID: 31482 RVA: 0x001F4E50 File Offset: 0x001F3050
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619159, XrefRangeEnd = 619161, 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: 0x06007AFB RID: 31483 RVA: 0x001F4EA8 File Offset: 0x001F30A8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619163, RefRangeEnd = 619164, XrefRangeStart = 619161, XrefRangeEnd = 619163, 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: 0x06007AFC RID: 31484 RVA: 0x001F4EEC File Offset: 0x001F30EC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619166, RefRangeEnd = 619167, XrefRangeStart = 619164, XrefRangeEnd = 619166, 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: 0x06007AFD RID: 31485 RVA: 0x001F4F34 File Offset: 0x001F3134
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619169, RefRangeEnd = 619173, XrefRangeStart = 619167, XrefRangeEnd = 619169, 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: 0x06007AFE RID: 31486 RVA: 0x001F4FA0 File Offset: 0x001F31A0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619175, RefRangeEnd = 619178, XrefRangeStart = 619173, XrefRangeEnd = 619175, 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: 0x06007AFF RID: 31487 RVA: 0x001F500C File Offset: 0x001F320C
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619180, RefRangeEnd = 619183, XrefRangeStart = 619178, XrefRangeEnd = 619180, 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: 0x06007B00 RID: 31488 RVA: 0x001F5078 File Offset: 0x001F3278
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619185, RefRangeEnd = 619188, XrefRangeStart = 619183, XrefRangeEnd = 619185, 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: 0x06007B01 RID: 31489 RVA: 0x001F50D0 File Offset: 0x001F32D0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 619190, RefRangeEnd = 619193, XrefRangeStart = 619188, XrefRangeEnd = 619190, 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: 0x06007B02 RID: 31490 RVA: 0x001F5128 File Offset: 0x001F3328
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619195, RefRangeEnd = 619199, XrefRangeStart = 619193, XrefRangeEnd = 619195, 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: 0x06007B03 RID: 31491 RVA: 0x001F5180 File Offset: 0x001F3380
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619201, RefRangeEnd = 619205, XrefRangeStart = 619199, XrefRangeEnd = 619201, 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: 0x06007B04 RID: 31492 RVA: 0x001F51D8 File Offset: 0x001F33D8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619207, RefRangeEnd = 619209, XrefRangeStart = 619205, XrefRangeEnd = 619207, 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: 0x06007B05 RID: 31493 RVA: 0x001F522C File Offset: 0x001F342C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619211, RefRangeEnd = 619212, XrefRangeStart = 619209, XrefRangeEnd = 619211, 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: 0x06007B06 RID: 31494 RVA: 0x001F5280 File Offset: 0x001F3480
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619214, RefRangeEnd = 619215, XrefRangeStart = 619212, XrefRangeEnd = 619214, 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: 0x06007B07 RID: 31495 RVA: 0x001F52D4 File Offset: 0x001F34D4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619217, RefRangeEnd = 619218, XrefRangeStart = 619215, XrefRangeEnd = 619217, 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: 0x06007B08 RID: 31496 RVA: 0x001F533C File Offset: 0x001F353C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619220, RefRangeEnd = 619221, XrefRangeStart = 619218, XrefRangeEnd = 619220, 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: 0x06007B09 RID: 31497 RVA: 0x001F53D8 File Offset: 0x001F35D8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619223, RefRangeEnd = 619224, XrefRangeStart = 619221, XrefRangeEnd = 619223, 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: 0x06007B0A RID: 31498 RVA: 0x001F5488 File Offset: 0x001F3688
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 619226, RefRangeEnd = 619230, XrefRangeStart = 619224, XrefRangeEnd = 619226, 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: 0x06007B0B RID: 31499 RVA: 0x001F54F0 File Offset: 0x001F36F0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619232, RefRangeEnd = 619233, XrefRangeStart = 619230, XrefRangeEnd = 619232, 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: 0x06007B0C RID: 31500 RVA: 0x001F5544 File Offset: 0x001F3744
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619235, RefRangeEnd = 619236, XrefRangeStart = 619233, XrefRangeEnd = 619235, 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: 0x06007B0D RID: 31501 RVA: 0x001F559C File Offset: 0x001F379C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619238, RefRangeEnd = 619239, XrefRangeStart = 619236, XrefRangeEnd = 619238, 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: 0x06007B0E RID: 31502 RVA: 0x001F55E0 File Offset: 0x001F37E0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619239, XrefRangeEnd = 619241, 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: 0x06007B0F RID: 31503 RVA: 0x001F5628 File Offset: 0x001F3828
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619243, RefRangeEnd = 619244, XrefRangeStart = 619241, XrefRangeEnd = 619243, 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: 0x06007B10 RID: 31504 RVA: 0x001F56C4 File Offset: 0x001F38C4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619246, RefRangeEnd = 619247, XrefRangeStart = 619244, XrefRangeEnd = 619246, 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: 0x06007B11 RID: 31505 RVA: 0x001F5718 File Offset: 0x001F3918
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619249, RefRangeEnd = 619250, XrefRangeStart = 619247, XrefRangeEnd = 619249, 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: 0x06007B12 RID: 31506 RVA: 0x001F57D8 File Offset: 0x001F39D8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619252, RefRangeEnd = 619253, XrefRangeStart = 619250, XrefRangeEnd = 619252, 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: 0x06007B13 RID: 31507 RVA: 0x001F58A8 File Offset: 0x001F3AA8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619255, RefRangeEnd = 619256, XrefRangeStart = 619253, XrefRangeEnd = 619255, 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: 0x06007B14 RID: 31508 RVA: 0x001F58DC File Offset: 0x001F3ADC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619256, XrefRangeEnd = 619258, 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: 0x06007B15 RID: 31509 RVA: 0x001F5910 File Offset: 0x001F3B10
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619260, RefRangeEnd = 619261, XrefRangeStart = 619258, XrefRangeEnd = 619260, 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: 0x06007B16 RID: 31510 RVA: 0x001F5954 File Offset: 0x001F3B54
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 619263, RefRangeEnd = 619264, XrefRangeStart = 619261, XrefRangeEnd = 619263, 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: 0x06007B17 RID: 31511 RVA: 0x001F5988 File Offset: 0x001F3B88
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619266, RefRangeEnd = 619268, XrefRangeStart = 619264, XrefRangeEnd = 619266, 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: 0x06007B18 RID: 31512 RVA: 0x001F59CC File Offset: 0x001F3BCC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619270, RefRangeEnd = 619272, XrefRangeStart = 619268, XrefRangeEnd = 619270, 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: 0x06007B19 RID: 31513 RVA: 0x001F5A14 File Offset: 0x001F3C14
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619274, RefRangeEnd = 619276, XrefRangeStart = 619272, XrefRangeEnd = 619274, 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: 0x06007B1A RID: 31514 RVA: 0x001F5A58 File Offset: 0x001F3C58
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 619285, RefRangeEnd = 619287, XrefRangeStart = 619276, XrefRangeEnd = 619285, 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: 0x06007B1B RID: 31515 RVA: 0x001F5ACC File Offset: 0x001F3CCC
	// 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, 100672513);
		Oni.NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672514);
		Oni.NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672515);
		Oni.NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672516);
		Oni.NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672517);
		Oni.NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672518);
		Oni.NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672519);
		Oni.NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672520);
		Oni.NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672521);
		Oni.NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672522);
		Oni.NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672523);
		Oni.NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672524);
		Oni.NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672525);
		Oni.NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672526);
		Oni.NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672527);
		Oni.NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672528);
		Oni.NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672529);
		Oni.NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672530);
		Oni.NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672531);
		Oni.NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672532);
		Oni.NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672533);
		Oni.NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672534);
		Oni.NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672535);
		Oni.NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672536);
		Oni.NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672537);
		Oni.NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672538);
		Oni.NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672539);
		Oni.NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672540);
		Oni.NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672541);
		Oni.NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672542);
		Oni.NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672543);
		Oni.NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672544);
		Oni.NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672545);
		Oni.NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672546);
		Oni.NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672547);
		Oni.NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672548);
		Oni.NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672549);
		Oni.NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672550);
		Oni.NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672551);
		Oni.NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672552);
		Oni.NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672553);
		Oni.NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672554);
		Oni.NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672555);
		Oni.NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672556);
		Oni.NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672557);
		Oni.NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672558);
		Oni.NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672559);
		Oni.NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672560);
		Oni.NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672561);
		Oni.NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672562);
		Oni.NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672563);
		Oni.NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672564);
		Oni.NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672565);
		Oni.NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672566);
		Oni.NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672567);
		Oni.NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672568);
		Oni.NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672569);
		Oni.NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672570);
		Oni.NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672571);
		Oni.NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672572);
		Oni.NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672573);
		Oni.NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672574);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672575);
		Oni.NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672576);
		Oni.NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672577);
		Oni.NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672578);
		Oni.NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672579);
		Oni.NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672580);
		Oni.NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672581);
		Oni.NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672582);
		Oni.NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672583);
		Oni.NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672584);
		Oni.NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672585);
		Oni.NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672586);
		Oni.NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672587);
		Oni.NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672588);
		Oni.NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672589);
		Oni.NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672590);
		Oni.NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672591);
		Oni.NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672592);
		Oni.NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672593);
		Oni.NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672594);
		Oni.NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672595);
		Oni.NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672596);
		Oni.NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672597);
		Oni.NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672598);
		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, 100672599);
		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, 100672600);
		Oni.NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672601);
		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, 100672602);
		Oni.NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672603);
		Oni.NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672604);
		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, 100672605);
		Oni.NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672606);
		Oni.NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672607);
		Oni.NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672608);
		Oni.NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672609);
		Oni.NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672610);
		Oni.NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672611);
		Oni.NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672612);
		Oni.NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672613);
		Oni.NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672614);
		Oni.NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672615);
		Oni.NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672616);
		Oni.NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672617);
		Oni.NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672618);
		Oni.NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672619);
		Oni.NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672620);
		Oni.NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672621);
		Oni.NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672622);
		Oni.NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672623);
		Oni.NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672624);
		Oni.NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672625);
		Oni.NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672626);
		Oni.NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672627);
		Oni.NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672628);
		Oni.NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672629);
		Oni.NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672630);
		Oni.NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672631);
		Oni.NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672632);
		Oni.NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672633);
		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, 100672634);
		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, 100672635);
		Oni.NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672636);
		Oni.NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672637);
		Oni.NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672638);
		Oni.NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672639);
		Oni.NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672640);
		Oni.NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672641);
		Oni.NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672642);
		Oni.NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni>.NativeClassPtr, 100672643);
	}

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

	// Token: 0x0400516A RID: 20842
	private static readonly IntPtr NativeMethodInfoPtr_PinMemory_Public_Static_GCHandle_Object_0;

	// Token: 0x0400516B RID: 20843
	private static readonly IntPtr NativeMethodInfoPtr_UnpinMemory_Public_Static_Void_GCHandle_0;

	// Token: 0x0400516C RID: 20844
	private static readonly IntPtr NativeMethodInfoPtr_CreateCollider_Public_Static_IntPtr_0;

	// Token: 0x0400516D RID: 20845
	private static readonly IntPtr NativeMethodInfoPtr_DestroyCollider_Public_Static_Void_IntPtr_0;

	// Token: 0x0400516E RID: 20846
	private static readonly IntPtr NativeMethodInfoPtr_CreateShape_Public_Static_IntPtr_ShapeType_0;

	// Token: 0x0400516F RID: 20847
	private static readonly IntPtr NativeMethodInfoPtr_DestroyShape_Public_Static_Void_IntPtr_0;

	// Token: 0x04005170 RID: 20848
	private static readonly IntPtr NativeMethodInfoPtr_CreateRigidbody_Public_Static_IntPtr_0;

	// Token: 0x04005171 RID: 20849
	private static readonly IntPtr NativeMethodInfoPtr_DestroyRigidbody_Public_Static_Void_IntPtr_0;

	// Token: 0x04005172 RID: 20850
	private static readonly IntPtr NativeMethodInfoPtr_UpdateCollider_Public_Static_Void_IntPtr_byref_Collider_0;

	// Token: 0x04005173 RID: 20851
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShape_Public_Static_Void_IntPtr_byref_Shape_0;

	// Token: 0x04005174 RID: 20852
	private static readonly IntPtr NativeMethodInfoPtr_UpdateRigidbody_Public_Static_Void_IntPtr_byref_Rigidbody_0;

	// Token: 0x04005175 RID: 20853
	private static readonly IntPtr NativeMethodInfoPtr_GetRigidbodyVelocity_Public_Static_Void_IntPtr_byref_RigidbodyVelocities_0;

	// Token: 0x04005176 RID: 20854
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderShape_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04005177 RID: 20855
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderRigidbody_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04005178 RID: 20856
	private static readonly IntPtr NativeMethodInfoPtr_SetColliderMaterial_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04005179 RID: 20857
	private static readonly IntPtr NativeMethodInfoPtr_CreateCollisionMaterial_Public_Static_IntPtr_0;

	// Token: 0x0400517A RID: 20858
	private static readonly IntPtr NativeMethodInfoPtr_DestroyCollisionMaterial_Public_Static_Void_IntPtr_0;

	// Token: 0x0400517B RID: 20859
	private static readonly IntPtr NativeMethodInfoPtr_UpdateCollisionMaterial_Public_Static_Void_IntPtr_byref_CollisionMaterial_0;

	// Token: 0x0400517C RID: 20860
	private static readonly IntPtr NativeMethodInfoPtr_CreateSolver_Public_Static_IntPtr_Int32_Int32_0;

	// Token: 0x0400517D RID: 20861
	private static readonly IntPtr NativeMethodInfoPtr_DestroySolver_Public_Static_Void_IntPtr_0;

	// Token: 0x0400517E RID: 20862
	private static readonly IntPtr NativeMethodInfoPtr_AddCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x0400517F RID: 20863
	private static readonly IntPtr NativeMethodInfoPtr_RemoveCollider_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x04005180 RID: 20864
	private static readonly IntPtr NativeMethodInfoPtr_GetBounds_Public_Static_Void_IntPtr_byref_Vector3_byref_Vector3_0;

	// Token: 0x04005181 RID: 20865
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGridSize_Public_Static_Int32_IntPtr_0;

	// Token: 0x04005182 RID: 20866
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleGrid_Public_Static_Void_IntPtr_Il2CppStructArray_1_GridCell_0;

	// Token: 0x04005183 RID: 20867
	private static readonly IntPtr NativeMethodInfoPtr_SetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04005184 RID: 20868
	private static readonly IntPtr NativeMethodInfoPtr_GetSolverParameters_Public_Static_Void_IntPtr_byref_SolverParameters_0;

	// Token: 0x04005185 RID: 20869
	private static readonly IntPtr NativeMethodInfoPtr_SetActiveParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04005186 RID: 20870
	private static readonly IntPtr NativeMethodInfoPtr_AddSimulationTime_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04005187 RID: 20871
	private static readonly IntPtr NativeMethodInfoPtr_ResetSimulationTime_Public_Static_Void_IntPtr_0;

	// Token: 0x04005188 RID: 20872
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSolver_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x04005189 RID: 20873
	private static readonly IntPtr NativeMethodInfoPtr_ApplyPositionInterpolation_Public_Static_Void_IntPtr_Single_0;

	// Token: 0x0400518A RID: 20874
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSkeletalAnimation_Public_Static_Void_IntPtr_0;

	// Token: 0x0400518B RID: 20875
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x0400518C RID: 20876
	private static readonly IntPtr NativeMethodInfoPtr_SetConstraintsOrder_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x0400518D RID: 20877
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintCount_Public_Static_Int32_IntPtr_Int32_0;

	// Token: 0x0400518E RID: 20878
	private static readonly IntPtr NativeMethodInfoPtr_GetActiveConstraintIndices_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x0400518F RID: 20879
	private static readonly IntPtr NativeMethodInfoPtr_SetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005190 RID: 20880
	private static readonly IntPtr NativeMethodInfoPtr_GetRenderableParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005191 RID: 20881
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePhases_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x04005192 RID: 20882
	private static readonly IntPtr NativeMethodInfoPtr_SetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005193 RID: 20883
	private static readonly IntPtr NativeMethodInfoPtr_GetParticlePositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005194 RID: 20884
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleInverseMasses_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04005195 RID: 20885
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleSolidRadii_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x04005196 RID: 20886
	private static readonly IntPtr NativeMethodInfoPtr_SetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005197 RID: 20887
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x04005198 RID: 20888
	private static readonly IntPtr NativeMethodInfoPtr_AddParticleExternalForces_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector4_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x04005199 RID: 20889
	private static readonly IntPtr NativeMethodInfoPtr_AddParticleExternalForce_Public_Static_Void_IntPtr_byref_Vector4_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x0400519A RID: 20890
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleVorticities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x0400519B RID: 20891
	private static readonly IntPtr NativeMethodInfoPtr_GetParticleDensities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x0400519C RID: 20892
	private static readonly IntPtr NativeMethodInfoPtr_GetDeformableTriangleCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x0400519D RID: 20893
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableTriangles_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x0400519E RID: 20894
	private static readonly IntPtr NativeMethodInfoPtr_RemoveDeformableTriangles_Public_Static_Int32_IntPtr_Int32_Int32_0;

	// Token: 0x0400519F RID: 20895
	private static readonly IntPtr NativeMethodInfoPtr_SetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0;

	// Token: 0x040051A0 RID: 20896
	private static readonly IntPtr NativeMethodInfoPtr_GetConstraintGroupParameters_Public_Static_Void_IntPtr_Int32_byref_ConstraintParameters_0;

	// Token: 0x040051A1 RID: 20897
	private static readonly IntPtr NativeMethodInfoPtr_SetCollisionMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x040051A2 RID: 20898
	private static readonly IntPtr NativeMethodInfoPtr_SetRestPositions_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x040051A3 RID: 20899
	private static readonly IntPtr NativeMethodInfoPtr_SetFluidMaterials_Public_Static_Void_IntPtr_Il2CppStructArray_1_FluidMaterial_Int32_Int32_0;

	// Token: 0x040051A4 RID: 20900
	private static readonly IntPtr NativeMethodInfoPtr_SetFluidMaterialIndices_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x040051A5 RID: 20901
	private static readonly IntPtr NativeMethodInfoPtr_CreateDeformableMesh_Public_Static_IntPtr_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_Single_IntPtr_Int32_Int32_0;

	// Token: 0x040051A6 RID: 20902
	private static readonly IntPtr NativeMethodInfoPtr_DestroyDeformableMesh_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051A7 RID: 20903
	private static readonly IntPtr NativeMethodInfoPtr_TearDeformableMeshAtVertex_Public_Static_Boolean_IntPtr_Int32_byref_Vector3_byref_Vector3_Il2CppStructArray_1_Int32_byref_Int32_0;

	// Token: 0x040051A8 RID: 20904
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshTBNUpdate_Public_Static_Void_IntPtr_NormalsUpdate_Boolean_0;

	// Token: 0x040051A9 RID: 20905
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshTransform_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0;

	// Token: 0x040051AA RID: 20906
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshSkinMap_Public_Static_Void_IntPtr_IntPtr_IntPtr_0;

	// Token: 0x040051AB RID: 20907
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshParticleIndices_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051AC RID: 20908
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshData_Public_Static_Void_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_0;

	// Token: 0x040051AD RID: 20909
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshAnimationData_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_Il2CppStructArray_1_BoneWeights_Int32_0;

	// Token: 0x040051AE RID: 20910
	private static readonly IntPtr NativeMethodInfoPtr_SetDeformableMeshBoneTransforms_Public_Static_Void_IntPtr_Il2CppStructArray_1_Single_0;

	// Token: 0x040051AF RID: 20911
	private static readonly IntPtr NativeMethodInfoPtr_ForceDeformableMeshSkeletalSkinning_Public_Static_Void_IntPtr_0;

	// Token: 0x040051B0 RID: 20912
	private static readonly IntPtr NativeMethodInfoPtr_CreateBatch_Public_Static_IntPtr_Int32_Boolean_0;

	// Token: 0x040051B1 RID: 20913
	private static readonly IntPtr NativeMethodInfoPtr_DestroyBatch_Public_Static_Void_IntPtr_0;

	// Token: 0x040051B2 RID: 20914
	private static readonly IntPtr NativeMethodInfoPtr_AddBatch_Public_Static_IntPtr_IntPtr_IntPtr_Boolean_0;

	// Token: 0x040051B3 RID: 20915
	private static readonly IntPtr NativeMethodInfoPtr_RemoveBatch_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051B4 RID: 20916
	private static readonly IntPtr NativeMethodInfoPtr_EnableBatch_Public_Static_Boolean_IntPtr_Boolean_0;

	// Token: 0x040051B5 RID: 20917
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051B6 RID: 20918
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchConstraintForces_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Single_Int32_Int32_0;

	// Token: 0x040051B7 RID: 20919
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051B8 RID: 20920
	private static readonly IntPtr NativeMethodInfoPtr_GetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_0;

	// Token: 0x040051B9 RID: 20921
	private static readonly IntPtr NativeMethodInfoPtr_SetBatchPhaseSizes_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x040051BA RID: 20922
	private static readonly IntPtr NativeMethodInfoPtr_CookBatch_Public_Static_Boolean_IntPtr_0;

	// Token: 0x040051BB RID: 20923
	private static readonly IntPtr NativeMethodInfoPtr_SetActiveConstraints_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Int32_Int32_0;

	// Token: 0x040051BC RID: 20924
	private static readonly IntPtr NativeMethodInfoPtr_SetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x040051BD RID: 20925
	private static readonly IntPtr NativeMethodInfoPtr_GetDistanceConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0;

	// Token: 0x040051BE RID: 20926
	private static readonly IntPtr NativeMethodInfoPtr_SetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_Int32_0;

	// Token: 0x040051BF RID: 20927
	private static readonly IntPtr NativeMethodInfoPtr_GetBendingConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Il2CppStructArray_1_Vector2_0;

	// Token: 0x040051C0 RID: 20928
	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: 0x040051C1 RID: 20929
	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: 0x040051C2 RID: 20930
	private static readonly IntPtr NativeMethodInfoPtr_SetAerodynamicConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x040051C3 RID: 20931
	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: 0x040051C4 RID: 20932
	private static readonly IntPtr NativeMethodInfoPtr_SetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x040051C5 RID: 20933
	private static readonly IntPtr NativeMethodInfoPtr_GetTetherConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Vector2_Il2CppStructArray_1_Single_0;

	// Token: 0x040051C6 RID: 20934
	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: 0x040051C7 RID: 20935
	private static readonly IntPtr NativeMethodInfoPtr_SetStitchConstraints_Public_Static_Void_IntPtr_Il2CppStructArray_1_Int32_Il2CppStructArray_1_Single_Int32_0;

	// Token: 0x040051C8 RID: 20936
	private static readonly IntPtr NativeMethodInfoPtr_GetCollisionContacts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Contact_Int32_0;

	// Token: 0x040051C9 RID: 20937
	private static readonly IntPtr NativeMethodInfoPtr_ClearDiffuseParticles_Public_Static_Void_IntPtr_0;

	// Token: 0x040051CA RID: 20938
	private static readonly IntPtr NativeMethodInfoPtr_SetDiffuseParticles_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_0;

	// Token: 0x040051CB RID: 20939
	private static readonly IntPtr NativeMethodInfoPtr_GetDiffuseParticleVelocities_Public_Static_Int32_IntPtr_Il2CppStructArray_1_Vector4_Int32_Int32_0;

	// Token: 0x040051CC RID: 20940
	private static readonly IntPtr NativeMethodInfoPtr_SetDiffuseParticleNeighbourCounts_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051CD RID: 20941
	private static readonly IntPtr NativeMethodInfoPtr_CreateHalfEdgeMesh_Public_Static_IntPtr_0;

	// Token: 0x040051CE RID: 20942
	private static readonly IntPtr NativeMethodInfoPtr_DestroyHalfEdgeMesh_Public_Static_Void_IntPtr_0;

	// Token: 0x040051CF RID: 20943
	private static readonly IntPtr NativeMethodInfoPtr_SetVertices_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x040051D0 RID: 20944
	private static readonly IntPtr NativeMethodInfoPtr_SetHalfEdges_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x040051D1 RID: 20945
	private static readonly IntPtr NativeMethodInfoPtr_SetFaces_Public_Static_Void_IntPtr_IntPtr_Int32_0;

	// Token: 0x040051D2 RID: 20946
	private static readonly IntPtr NativeMethodInfoPtr_SetNormals_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051D3 RID: 20947
	private static readonly IntPtr NativeMethodInfoPtr_SetTangents_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051D4 RID: 20948
	private static readonly IntPtr NativeMethodInfoPtr_SetInverseOrientations_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051D5 RID: 20949
	private static readonly IntPtr NativeMethodInfoPtr_SetVisualMap_Public_Static_Void_IntPtr_IntPtr_0;

	// Token: 0x040051D6 RID: 20950
	private static readonly IntPtr NativeMethodInfoPtr_GetVertexCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051D7 RID: 20951
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051D8 RID: 20952
	private static readonly IntPtr NativeMethodInfoPtr_GetFaceCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051D9 RID: 20953
	private static readonly IntPtr NativeMethodInfoPtr_GetHalfEdgeMeshInfo_Public_Static_Int32_IntPtr_byref_MeshInformation_0;

	// Token: 0x040051DA RID: 20954
	private static readonly IntPtr NativeMethodInfoPtr_CalculatePrimitiveCounts_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_0;

	// Token: 0x040051DB RID: 20955
	private static readonly IntPtr NativeMethodInfoPtr_Generate_Public_Static_Void_IntPtr_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Int32_Int32_Int32_byref_Vector3_0;

	// Token: 0x040051DC RID: 20956
	private static readonly IntPtr NativeMethodInfoPtr_MakePhase_Public_Static_Int32_Int32_ParticlePhase_0;

	// Token: 0x040051DD RID: 20957
	private static readonly IntPtr NativeMethodInfoPtr_GetGroupFromPhase_Public_Static_Int32_Int32_0;

	// Token: 0x040051DE RID: 20958
	private static readonly IntPtr NativeMethodInfoPtr_BendingConstraintRest_Public_Static_Single_Il2CppStructArray_1_Single_0;

	// Token: 0x040051DF RID: 20959
	private static readonly IntPtr NativeMethodInfoPtr_CreateTriangleSkinMap_Public_Static_IntPtr_0;

	// Token: 0x040051E0 RID: 20960
	private static readonly IntPtr NativeMethodInfoPtr_DestroyTriangleSkinMap_Public_Static_Void_IntPtr_0;

	// Token: 0x040051E1 RID: 20961
	private static readonly IntPtr NativeMethodInfoPtr_Bind_Public_Static_Void_IntPtr_IntPtr_IntPtr_Il2CppStructArray_1_UInt32_Il2CppStructArray_1_UInt32_0;

	// Token: 0x040051E2 RID: 20962
	private static readonly IntPtr NativeMethodInfoPtr_GetSkinnedVertexCount_Public_Static_Int32_IntPtr_0;

	// Token: 0x040051E3 RID: 20963
	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: 0x040051E4 RID: 20964
	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: 0x040051E5 RID: 20965
	private static readonly IntPtr NativeMethodInfoPtr_WaitForAllTasks_Public_Static_Void_0;

	// Token: 0x040051E6 RID: 20966
	private static readonly IntPtr NativeMethodInfoPtr_ClearTasks_Public_Static_Void_0;

	// Token: 0x040051E7 RID: 20967
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxSystemConcurrency_Public_Static_Int32_0;

	// Token: 0x040051E8 RID: 20968
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameStart_Public_Static_Void_0;

	// Token: 0x040051E9 RID: 20969
	private static readonly IntPtr NativeMethodInfoPtr_SignalFrameEnd_Public_Static_Double_0;

	// Token: 0x040051EA RID: 20970
	private static readonly IntPtr NativeMethodInfoPtr_EnableProfiler_Public_Static_Void_Boolean_0;

	// Token: 0x040051EB RID: 20971
	private static readonly IntPtr NativeMethodInfoPtr_GetProfilingInfoCount_Public_Static_Int32_0;

	// Token: 0x040051EC RID: 20972
	private static readonly IntPtr NativeMethodInfoPtr_GetProfilingInfo_Public_Static_Void_Il2CppReferenceArray_1_ProfileInfo_Int32_0;

	// Token: 0x020003CA RID: 970
	public enum ConstraintType
	{
		// Token: 0x040051EE RID: 20974
		Tether,
		// Token: 0x040051EF RID: 20975
		Pin,
		// Token: 0x040051F0 RID: 20976
		Volume,
		// Token: 0x040051F1 RID: 20977
		Bending,
		// Token: 0x040051F2 RID: 20978
		Distance,
		// Token: 0x040051F3 RID: 20979
		ParticleCollision,
		// Token: 0x040051F4 RID: 20980
		Density,
		// Token: 0x040051F5 RID: 20981
		Collision,
		// Token: 0x040051F6 RID: 20982
		Skin,
		// Token: 0x040051F7 RID: 20983
		Aerodynamics,
		// Token: 0x040051F8 RID: 20984
		Stitch,
		// Token: 0x040051F9 RID: 20985
		ShapeMatching
	}

	// Token: 0x020003CB RID: 971
	public enum ParticlePhase
	{
		// Token: 0x040051FB RID: 20987
		SelfCollide = 16777216,
		// Token: 0x040051FC RID: 20988
		Fluid = 33554432
	}

	// Token: 0x020003CC RID: 972
	public enum ShapeType
	{
		// Token: 0x040051FE RID: 20990
		Sphere,
		// Token: 0x040051FF RID: 20991
		Box,
		// Token: 0x04005200 RID: 20992
		Capsule,
		// Token: 0x04005201 RID: 20993
		Heightmap,
		// Token: 0x04005202 RID: 20994
		TriangleMesh,
		// Token: 0x04005203 RID: 20995
		EdgeMesh
	}

	// Token: 0x020003CD RID: 973
	public enum MaterialCombineMode
	{
		// Token: 0x04005205 RID: 20997
		Average,
		// Token: 0x04005206 RID: 20998
		Minimium,
		// Token: 0x04005207 RID: 20999
		Multiply,
		// Token: 0x04005208 RID: 21000
		Maximum
	}

	// Token: 0x020003CE RID: 974
	public enum NormalsUpdate
	{
		// Token: 0x0400520A RID: 21002
		Recalculate,
		// Token: 0x0400520B RID: 21003
		Skin
	}

	// Token: 0x020003CF RID: 975
	public sealed class ProfileInfo : ValueType
	{
		// Token: 0x06007B1D RID: 31517 RVA: 0x001F6538 File Offset: 0x001F4738
		// 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: 0x06007B1E RID: 31518 RVA: 0x001295E7 File Offset: 0x001277E7
		public ProfileInfo(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x06007B1F RID: 31519 RVA: 0x001F65DC File Offset: 0x001F47DC
		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: 0x170029FA RID: 10746
		// (get) Token: 0x06007B20 RID: 31520 RVA: 0x001F660C File Offset: 0x001F480C
		// (set) Token: 0x06007B21 RID: 31521 RVA: 0x001F6634 File Offset: 0x001F4834
		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: 0x170029FB RID: 10747
		// (get) Token: 0x06007B22 RID: 31522 RVA: 0x001F6658 File Offset: 0x001F4858
		// (set) Token: 0x06007B23 RID: 31523 RVA: 0x001F6680 File Offset: 0x001F4880
		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: 0x170029FC RID: 10748
		// (get) Token: 0x06007B24 RID: 31524 RVA: 0x001F66A4 File Offset: 0x001F48A4
		// (set) Token: 0x06007B25 RID: 31525 RVA: 0x001F66CC File Offset: 0x001F48CC
		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: 0x170029FD RID: 10749
		// (get) Token: 0x06007B26 RID: 31526 RVA: 0x001F66F0 File Offset: 0x001F48F0
		// (set) Token: 0x06007B27 RID: 31527 RVA: 0x001F6718 File Offset: 0x001F4918
		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: 0x170029FE RID: 10750
		// (get) Token: 0x06007B28 RID: 31528 RVA: 0x001F673C File Offset: 0x001F493C
		// (set) Token: 0x06007B29 RID: 31529 RVA: 0x001F6764 File Offset: 0x001F4964
		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: 0x170029FF RID: 10751
		// (get) Token: 0x06007B2A RID: 31530 RVA: 0x001F6788 File Offset: 0x001F4988
		// (set) Token: 0x06007B2B RID: 31531 RVA: 0x001F67B1 File Offset: 0x001F49B1
		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: 0x0400520C RID: 21004
		private static readonly IntPtr NativeFieldInfoPtr_start;

		// Token: 0x0400520D RID: 21005
		private static readonly IntPtr NativeFieldInfoPtr_end;

		// Token: 0x0400520E RID: 21006
		private static readonly IntPtr NativeFieldInfoPtr_childDuration;

		// Token: 0x0400520F RID: 21007
		private static readonly IntPtr NativeFieldInfoPtr_threadID;

		// Token: 0x04005210 RID: 21008
		private static readonly IntPtr NativeFieldInfoPtr_level;

		// Token: 0x04005211 RID: 21009
		private static readonly IntPtr NativeFieldInfoPtr_name;
	}

	// Token: 0x020003D0 RID: 976
	[StructLayout(2)]
	public struct GridCell
	{
		// Token: 0x06007B2C RID: 31532 RVA: 0x001F67D8 File Offset: 0x001F49D8
		// 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: 0x06007B2D RID: 31533 RVA: 0x001F683F File Offset: 0x001F4A3F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.GridCell>.NativeClassPtr, ref this));
		}

		// Token: 0x04005212 RID: 21010
		private static readonly IntPtr NativeFieldInfoPtr_center;

		// Token: 0x04005213 RID: 21011
		private static readonly IntPtr NativeFieldInfoPtr_size;

		// Token: 0x04005214 RID: 21012
		private static readonly IntPtr NativeFieldInfoPtr_count;

		// Token: 0x04005215 RID: 21013
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04005216 RID: 21014
		[FieldOffset(12)]
		public Vector3 size;

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

	// Token: 0x020003D1 RID: 977
	[Serializable]
	[StructLayout(2)]
	public struct SolverParameters
	{
		// Token: 0x06007B2E RID: 31534 RVA: 0x001F6854 File Offset: 0x001F4A54
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618421, RefRangeEnd = 618422, XrefRangeStart = 618420, XrefRangeEnd = 618421, 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: 0x06007B2F RID: 31535 RVA: 0x001F68AC File Offset: 0x001F4AAC
		// 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, 100672644);
		}

		// Token: 0x06007B30 RID: 31536 RVA: 0x001F6977 File Offset: 0x001F4B77
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.SolverParameters>.NativeClassPtr, ref this));
		}

		// Token: 0x04005218 RID: 21016
		private static readonly IntPtr NativeFieldInfoPtr_mode;

		// Token: 0x04005219 RID: 21017
		private static readonly IntPtr NativeFieldInfoPtr_interpolation;

		// Token: 0x0400521A RID: 21018
		private static readonly IntPtr NativeFieldInfoPtr_gravity;

		// Token: 0x0400521B RID: 21019
		private static readonly IntPtr NativeFieldInfoPtr_damping;

		// Token: 0x0400521C RID: 21020
		private static readonly IntPtr NativeFieldInfoPtr_fluidDenoising;

		// Token: 0x0400521D RID: 21021
		private static readonly IntPtr NativeFieldInfoPtr_advectionRadius;

		// Token: 0x0400521E RID: 21022
		private static readonly IntPtr NativeFieldInfoPtr_sleepThreshold;

		// Token: 0x0400521F RID: 21023
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Interpolation_Vector4_0;

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

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

		// Token: 0x04005222 RID: 21026
		[FieldOffset(8)]
		public Vector3 gravity;

		// Token: 0x04005223 RID: 21027
		[FieldOffset(20)]
		public float damping;

		// Token: 0x04005224 RID: 21028
		[FieldOffset(24)]
		public float fluidDenoising;

		// Token: 0x04005225 RID: 21029
		[FieldOffset(28)]
		public float advectionRadius;

		// Token: 0x04005226 RID: 21030
		[FieldOffset(32)]
		public float sleepThreshold;

		// Token: 0x020003D2 RID: 978
		public enum Interpolation
		{
			// Token: 0x04005228 RID: 21032
			None,
			// Token: 0x04005229 RID: 21033
			Interpolate
		}

		// Token: 0x020003D3 RID: 979
		public enum Mode
		{
			// Token: 0x0400522B RID: 21035
			Mode3D,
			// Token: 0x0400522C RID: 21036
			Mode2D
		}
	}

	// Token: 0x020003D4 RID: 980
	[Serializable]
	[StructLayout(2)]
	public struct ConstraintParameters
	{
		// Token: 0x06007B31 RID: 31537 RVA: 0x001F698C File Offset: 0x001F4B8C
		[CallerCount(10)]
		[CachedScanResults(RefRangeStart = 618422, RefRangeEnd = 618432, XrefRangeStart = 618422, XrefRangeEnd = 618422, 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: 0x06007B32 RID: 31538 RVA: 0x001F69F8 File Offset: 0x001F4BF8
		// 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, 100672645);
		}

		// Token: 0x06007B33 RID: 31539 RVA: 0x001F6A87 File Offset: 0x001F4C87
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.ConstraintParameters>.NativeClassPtr, ref this));
		}

		// Token: 0x0400522D RID: 21037
		private static readonly IntPtr NativeFieldInfoPtr_enabled;

		// Token: 0x0400522E RID: 21038
		private static readonly IntPtr NativeFieldInfoPtr_evaluationOrder;

		// Token: 0x0400522F RID: 21039
		private static readonly IntPtr NativeFieldInfoPtr_iterations;

		// Token: 0x04005230 RID: 21040
		private static readonly IntPtr NativeFieldInfoPtr_SORFactor;

		// Token: 0x04005231 RID: 21041
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Boolean_EvaluationOrder_Int32_0;

		// Token: 0x04005232 RID: 21042
		[FieldOffset(0)]
		[MarshalAs(4)]
		public bool enabled;

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

		// Token: 0x04005234 RID: 21044
		[FieldOffset(5)]
		public int iterations;

		// Token: 0x04005235 RID: 21045
		[FieldOffset(9)]
		public float SORFactor;

		// Token: 0x020003D5 RID: 981
		public enum EvaluationOrder
		{
			// Token: 0x04005237 RID: 21047
			Sequential,
			// Token: 0x04005238 RID: 21048
			Parallel
		}
	}

	// Token: 0x020003D6 RID: 982
	[StructLayout(2)]
	public struct Contact
	{
		// Token: 0x06007B34 RID: 31540 RVA: 0x001F6A9C File Offset: 0x001F4C9C
		// 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: 0x06007B35 RID: 31541 RVA: 0x001F6BA3 File Offset: 0x001F4DA3
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Contact>.NativeClassPtr, ref this));
		}

		// Token: 0x04005239 RID: 21049
		private static readonly IntPtr NativeFieldInfoPtr_point;

		// Token: 0x0400523A RID: 21050
		private static readonly IntPtr NativeFieldInfoPtr_normal;

		// Token: 0x0400523B RID: 21051
		private static readonly IntPtr NativeFieldInfoPtr_tangent;

		// Token: 0x0400523C RID: 21052
		private static readonly IntPtr NativeFieldInfoPtr_bitangent;

		// Token: 0x0400523D RID: 21053
		private static readonly IntPtr NativeFieldInfoPtr_distance;

		// Token: 0x0400523E RID: 21054
		private static readonly IntPtr NativeFieldInfoPtr_normalImpulse;

		// Token: 0x0400523F RID: 21055
		private static readonly IntPtr NativeFieldInfoPtr_tangentImpulse;

		// Token: 0x04005240 RID: 21056
		private static readonly IntPtr NativeFieldInfoPtr_bitangentImpulse;

		// Token: 0x04005241 RID: 21057
		private static readonly IntPtr NativeFieldInfoPtr_stickImpulse;

		// Token: 0x04005242 RID: 21058
		private static readonly IntPtr NativeFieldInfoPtr_particle;

		// Token: 0x04005243 RID: 21059
		private static readonly IntPtr NativeFieldInfoPtr_other;

		// Token: 0x04005244 RID: 21060
		[FieldOffset(0)]
		public Vector4 point;

		// Token: 0x04005245 RID: 21061
		[FieldOffset(16)]
		public Vector4 normal;

		// Token: 0x04005246 RID: 21062
		[FieldOffset(32)]
		public Vector4 tangent;

		// Token: 0x04005247 RID: 21063
		[FieldOffset(48)]
		public Vector4 bitangent;

		// Token: 0x04005248 RID: 21064
		[FieldOffset(64)]
		public float distance;

		// Token: 0x04005249 RID: 21065
		[FieldOffset(68)]
		public float normalImpulse;

		// Token: 0x0400524A RID: 21066
		[FieldOffset(72)]
		public float tangentImpulse;

		// Token: 0x0400524B RID: 21067
		[FieldOffset(76)]
		public float bitangentImpulse;

		// Token: 0x0400524C RID: 21068
		[FieldOffset(80)]
		public float stickImpulse;

		// Token: 0x0400524D RID: 21069
		[FieldOffset(84)]
		public int particle;

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

	// Token: 0x020003D7 RID: 983
	[StructLayout(2)]
	public struct BoneWeights
	{
		// Token: 0x06007B36 RID: 31542 RVA: 0x001F6BB8 File Offset: 0x001F4DB8
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618440, RefRangeEnd = 618442, XrefRangeStart = 618432, XrefRangeEnd = 618440, 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: 0x06007B37 RID: 31543 RVA: 0x001F6C00 File Offset: 0x001F4E00
		// 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, 100672646);
		}

		// Token: 0x06007B38 RID: 31544 RVA: 0x001F6CDF File Offset: 0x001F4EDF
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.BoneWeights>.NativeClassPtr, ref this));
		}

		// Token: 0x0400524F RID: 21071
		private static readonly IntPtr NativeFieldInfoPtr_bone0;

		// Token: 0x04005250 RID: 21072
		private static readonly IntPtr NativeFieldInfoPtr_bone1;

		// Token: 0x04005251 RID: 21073
		private static readonly IntPtr NativeFieldInfoPtr_bone2;

		// Token: 0x04005252 RID: 21074
		private static readonly IntPtr NativeFieldInfoPtr_bone3;

		// Token: 0x04005253 RID: 21075
		private static readonly IntPtr NativeFieldInfoPtr_weight0;

		// Token: 0x04005254 RID: 21076
		private static readonly IntPtr NativeFieldInfoPtr_weight1;

		// Token: 0x04005255 RID: 21077
		private static readonly IntPtr NativeFieldInfoPtr_weight2;

		// Token: 0x04005256 RID: 21078
		private static readonly IntPtr NativeFieldInfoPtr_weight3;

		// Token: 0x04005257 RID: 21079
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_BoneWeight_0;

		// Token: 0x04005258 RID: 21080
		[FieldOffset(0)]
		public int bone0;

		// Token: 0x04005259 RID: 21081
		[FieldOffset(4)]
		public int bone1;

		// Token: 0x0400525A RID: 21082
		[FieldOffset(8)]
		public int bone2;

		// Token: 0x0400525B RID: 21083
		[FieldOffset(12)]
		public int bone3;

		// Token: 0x0400525C RID: 21084
		[FieldOffset(16)]
		public float weight0;

		// Token: 0x0400525D RID: 21085
		[FieldOffset(20)]
		public float weight1;

		// Token: 0x0400525E RID: 21086
		[FieldOffset(24)]
		public float weight2;

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

	// Token: 0x020003D8 RID: 984
	[Serializable]
	[StructLayout(2)]
	public struct Rigidbody
	{
		// Token: 0x06007B39 RID: 31545 RVA: 0x001F6CF4 File Offset: 0x001F4EF4
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618469, RefRangeEnd = 618471, XrefRangeStart = 618442, XrefRangeEnd = 618469, 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: 0x06007B3A RID: 31546 RVA: 0x001F6D54 File Offset: 0x001F4F54
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618471, XrefRangeEnd = 618492, 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: 0x06007B3B RID: 31547 RVA: 0x001F6DB4 File Offset: 0x001F4FB4
		// 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, 100672647);
			Oni.Rigidbody.NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, 100672648);
		}

		// Token: 0x06007B3C RID: 31548 RVA: 0x001F6E7F File Offset: 0x001F507F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Rigidbody>.NativeClassPtr, ref this));
		}

		// Token: 0x04005260 RID: 21088
		private static readonly IntPtr NativeFieldInfoPtr_rotation;

		// Token: 0x04005261 RID: 21089
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x04005262 RID: 21090
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

		// Token: 0x04005263 RID: 21091
		private static readonly IntPtr NativeFieldInfoPtr_centerOfMass;

		// Token: 0x04005264 RID: 21092
		private static readonly IntPtr NativeFieldInfoPtr_inertiaTensor;

		// Token: 0x04005265 RID: 21093
		private static readonly IntPtr NativeFieldInfoPtr_inverseMass;

		// Token: 0x04005266 RID: 21094
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Rigidbody_Boolean_0;

		// Token: 0x04005267 RID: 21095
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Rigidbody2D_Boolean_0;

		// Token: 0x04005268 RID: 21096
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x04005269 RID: 21097
		[FieldOffset(16)]
		public Vector3 linearVelocity;

		// Token: 0x0400526A RID: 21098
		[FieldOffset(28)]
		public Vector3 angularVelocity;

		// Token: 0x0400526B RID: 21099
		[FieldOffset(40)]
		public Vector3 centerOfMass;

		// Token: 0x0400526C RID: 21100
		[FieldOffset(52)]
		public Vector3 inertiaTensor;

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

	// Token: 0x020003D9 RID: 985
	[Serializable]
	[StructLayout(2)]
	public struct RigidbodyVelocities
	{
		// Token: 0x06007B3D RID: 31549 RVA: 0x001F6E94 File Offset: 0x001F5094
		// 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: 0x06007B3E RID: 31550 RVA: 0x001F6EE7 File Offset: 0x001F50E7
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.RigidbodyVelocities>.NativeClassPtr, ref this));
		}

		// Token: 0x0400526E RID: 21102
		private static readonly IntPtr NativeFieldInfoPtr_linearVelocity;

		// Token: 0x0400526F RID: 21103
		private static readonly IntPtr NativeFieldInfoPtr_angularVelocity;

		// Token: 0x04005270 RID: 21104
		[FieldOffset(0)]
		public Vector3 linearVelocity;

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

	// Token: 0x020003DA RID: 986
	[Serializable]
	[StructLayout(2)]
	public struct Collider
	{
		// Token: 0x06007B3F RID: 31551 RVA: 0x001F6EFC File Offset: 0x001F50FC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618514, RefRangeEnd = 618515, XrefRangeStart = 618492, XrefRangeEnd = 618514, 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: 0x06007B40 RID: 31552 RVA: 0x001F6F6C File Offset: 0x001F516C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618535, RefRangeEnd = 618536, XrefRangeStart = 618515, XrefRangeEnd = 618535, 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: 0x06007B41 RID: 31553 RVA: 0x001F6FDC File Offset: 0x001F51DC
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618591, RefRangeEnd = 618593, XrefRangeStart = 618536, XrefRangeEnd = 618591, 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: 0x06007B42 RID: 31554 RVA: 0x001F7028 File Offset: 0x001F5228
		// 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, 100672649);
			Oni.Collider.NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100672650);
			Oni.Collider.NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, 100672651);
		}

		// Token: 0x06007B43 RID: 31555 RVA: 0x001F7143 File Offset: 0x001F5343
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Collider>.NativeClassPtr, ref this));
		}

		// Token: 0x04005272 RID: 21106
		private static readonly IntPtr NativeFieldInfoPtr_rotation;

		// Token: 0x04005273 RID: 21107
		private static readonly IntPtr NativeFieldInfoPtr_translation;

		// Token: 0x04005274 RID: 21108
		private static readonly IntPtr NativeFieldInfoPtr_scale;

		// Token: 0x04005275 RID: 21109
		private static readonly IntPtr NativeFieldInfoPtr_boundsMin;

		// Token: 0x04005276 RID: 21110
		private static readonly IntPtr NativeFieldInfoPtr_boundsMax;

		// Token: 0x04005277 RID: 21111
		private static readonly IntPtr NativeFieldInfoPtr_id;

		// Token: 0x04005278 RID: 21112
		private static readonly IntPtr NativeFieldInfoPtr_contactOffset;

		// Token: 0x04005279 RID: 21113
		private static readonly IntPtr NativeFieldInfoPtr_collisionGroup;

		// Token: 0x0400527A RID: 21114
		private static readonly IntPtr NativeFieldInfoPtr_trigger;

		// Token: 0x0400527B RID: 21115
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider_Int32_Single_0;

		// Token: 0x0400527C RID: 21116
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Collider2D_Int32_Single_0;

		// Token: 0x0400527D RID: 21117
		private static readonly IntPtr NativeMethodInfoPtr_SetSpaceTransform_Public_Void_Transform_0;

		// Token: 0x0400527E RID: 21118
		[FieldOffset(0)]
		public Quaternion rotation;

		// Token: 0x0400527F RID: 21119
		[FieldOffset(16)]
		public Vector3 translation;

		// Token: 0x04005280 RID: 21120
		[FieldOffset(28)]
		public Vector3 scale;

		// Token: 0x04005281 RID: 21121
		[FieldOffset(40)]
		public Vector3 boundsMin;

		// Token: 0x04005282 RID: 21122
		[FieldOffset(52)]
		public Vector3 boundsMax;

		// Token: 0x04005283 RID: 21123
		[FieldOffset(64)]
		public int id;

		// Token: 0x04005284 RID: 21124
		[FieldOffset(68)]
		public float contactOffset;

		// Token: 0x04005285 RID: 21125
		[FieldOffset(72)]
		public int collisionGroup;

		// Token: 0x04005286 RID: 21126
		[FieldOffset(76)]
		[MarshalAs(4)]
		public bool trigger;
	}

	// Token: 0x020003DB RID: 987
	[Serializable]
	[StructLayout(2)]
	public struct Shape
	{
		// Token: 0x06007B44 RID: 31556 RVA: 0x001F7158 File Offset: 0x001F5358
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618594, RefRangeEnd = 618596, XrefRangeStart = 618593, XrefRangeEnd = 618594, 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: 0x06007B45 RID: 31557 RVA: 0x001F71B0 File Offset: 0x001F53B0
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 368804, RefRangeEnd = 368809, XrefRangeStart = 368804, XrefRangeEnd = 368809, 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: 0x06007B46 RID: 31558 RVA: 0x001F7208 File Offset: 0x001F5408
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 618596, RefRangeEnd = 618599, XrefRangeStart = 618596, XrefRangeEnd = 618596, 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: 0x06007B47 RID: 31559 RVA: 0x001F7288 File Offset: 0x001F5488
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618599, RefRangeEnd = 618600, XrefRangeStart = 618599, XrefRangeEnd = 618599, 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: 0x06007B48 RID: 31560 RVA: 0x001F7308 File Offset: 0x001F5508
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618600, RefRangeEnd = 618602, XrefRangeStart = 618600, XrefRangeEnd = 618600, 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: 0x06007B49 RID: 31561 RVA: 0x001F7388 File Offset: 0x001F5588
		// 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, 100672652);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100672653);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100672654);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100672655);
			Oni.Shape.NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, 100672656);
		}

		// Token: 0x06007B4A RID: 31562 RVA: 0x001F74CB File Offset: 0x001F56CB
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Shape>.NativeClassPtr, ref this));
		}

		// Token: 0x04005287 RID: 21127
		private static readonly IntPtr NativeFieldInfoPtr_center;

		// Token: 0x04005288 RID: 21128
		private static readonly IntPtr NativeFieldInfoPtr_size;

		// Token: 0x04005289 RID: 21129
		private static readonly IntPtr NativeFieldInfoPtr_data;

		// Token: 0x0400528A RID: 21130
		private static readonly IntPtr NativeFieldInfoPtr_indices;

		// Token: 0x0400528B RID: 21131
		private static readonly IntPtr NativeFieldInfoPtr_dataCount;

		// Token: 0x0400528C RID: 21132
		private static readonly IntPtr NativeFieldInfoPtr_indexCount;

		// Token: 0x0400528D RID: 21133
		private static readonly IntPtr NativeFieldInfoPtr_resolutionU;

		// Token: 0x0400528E RID: 21134
		private static readonly IntPtr NativeFieldInfoPtr_resolutionV;

		// Token: 0x0400528F RID: 21135
		private static readonly IntPtr NativeFieldInfoPtr_is2D;

		// Token: 0x04005290 RID: 21136
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_0;

		// Token: 0x04005291 RID: 21137
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Vector3_0;

		// Token: 0x04005292 RID: 21138
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Single_Single_Int32_0;

		// Token: 0x04005293 RID: 21139
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_Vector3_Int32_Int32_IntPtr_0;

		// Token: 0x04005294 RID: 21140
		private static readonly IntPtr NativeMethodInfoPtr_Set_Public_Void_IntPtr_IntPtr_Int32_Int32_0;

		// Token: 0x04005295 RID: 21141
		[FieldOffset(0)]
		public Vector3 center;

		// Token: 0x04005296 RID: 21142
		[FieldOffset(12)]
		public Vector3 size;

		// Token: 0x04005297 RID: 21143
		[FieldOffset(24)]
		public IntPtr data;

		// Token: 0x04005298 RID: 21144
		[FieldOffset(32)]
		public IntPtr indices;

		// Token: 0x04005299 RID: 21145
		[FieldOffset(40)]
		public int dataCount;

		// Token: 0x0400529A RID: 21146
		[FieldOffset(44)]
		public int indexCount;

		// Token: 0x0400529B RID: 21147
		[FieldOffset(48)]
		public int resolutionU;

		// Token: 0x0400529C RID: 21148
		[FieldOffset(52)]
		public int resolutionV;

		// Token: 0x0400529D RID: 21149
		[FieldOffset(56)]
		[MarshalAs(4)]
		public bool is2D;
	}

	// Token: 0x020003DC RID: 988
	[Serializable]
	[StructLayout(2)]
	public struct CollisionMaterial
	{
		// Token: 0x06007B4B RID: 31563 RVA: 0x001F74E0 File Offset: 0x001F56E0
		// 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: 0x06007B4C RID: 31564 RVA: 0x001F756F File Offset: 0x001F576F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.CollisionMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x0400529E RID: 21150
		private static readonly IntPtr NativeFieldInfoPtr_friction;

		// Token: 0x0400529F RID: 21151
		private static readonly IntPtr NativeFieldInfoPtr_stickiness;

		// Token: 0x040052A0 RID: 21152
		private static readonly IntPtr NativeFieldInfoPtr_stickDistance;

		// Token: 0x040052A1 RID: 21153
		private static readonly IntPtr NativeFieldInfoPtr_frictionCombine;

		// Token: 0x040052A2 RID: 21154
		private static readonly IntPtr NativeFieldInfoPtr_stickinessCombine;

		// Token: 0x040052A3 RID: 21155
		[FieldOffset(0)]
		public float friction;

		// Token: 0x040052A4 RID: 21156
		[FieldOffset(4)]
		public float stickiness;

		// Token: 0x040052A5 RID: 21157
		[FieldOffset(8)]
		public float stickDistance;

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

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

	// Token: 0x020003DD RID: 989
	[Serializable]
	[StructLayout(2)]
	public struct FluidMaterial
	{
		// Token: 0x06007B4D RID: 31565 RVA: 0x001F7584 File Offset: 0x001F5784
		// 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: 0x06007B4E RID: 31566 RVA: 0x001F768B File Offset: 0x001F588B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.FluidMaterial>.NativeClassPtr, ref this));
		}

		// Token: 0x040052A8 RID: 21160
		private static readonly IntPtr NativeFieldInfoPtr_smoothingRadius;

		// Token: 0x040052A9 RID: 21161
		private static readonly IntPtr NativeFieldInfoPtr_restDensity;

		// Token: 0x040052AA RID: 21162
		private static readonly IntPtr NativeFieldInfoPtr_viscosity;

		// Token: 0x040052AB RID: 21163
		private static readonly IntPtr NativeFieldInfoPtr_surfaceTension;

		// Token: 0x040052AC RID: 21164
		private static readonly IntPtr NativeFieldInfoPtr_buoyancy;

		// Token: 0x040052AD RID: 21165
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericDrag;

		// Token: 0x040052AE RID: 21166
		private static readonly IntPtr NativeFieldInfoPtr_atmosphericPressure;

		// Token: 0x040052AF RID: 21167
		private static readonly IntPtr NativeFieldInfoPtr_vorticity;

		// Token: 0x040052B0 RID: 21168
		private static readonly IntPtr NativeFieldInfoPtr_elasticRange;

		// Token: 0x040052B1 RID: 21169
		private static readonly IntPtr NativeFieldInfoPtr_plasticCreep;

		// Token: 0x040052B2 RID: 21170
		private static readonly IntPtr NativeFieldInfoPtr_plasticThreshold;

		// Token: 0x040052B3 RID: 21171
		[FieldOffset(0)]
		public float smoothingRadius;

		// Token: 0x040052B4 RID: 21172
		[FieldOffset(4)]
		public float restDensity;

		// Token: 0x040052B5 RID: 21173
		[FieldOffset(8)]
		public float viscosity;

		// Token: 0x040052B6 RID: 21174
		[FieldOffset(12)]
		public float surfaceTension;

		// Token: 0x040052B7 RID: 21175
		[FieldOffset(16)]
		public float buoyancy;

		// Token: 0x040052B8 RID: 21176
		[FieldOffset(20)]
		public float atmosphericDrag;

		// Token: 0x040052B9 RID: 21177
		[FieldOffset(24)]
		public float atmosphericPressure;

		// Token: 0x040052BA RID: 21178
		[FieldOffset(28)]
		public float vorticity;

		// Token: 0x040052BB RID: 21179
		[FieldOffset(32)]
		public float elasticRange;

		// Token: 0x040052BC RID: 21180
		[FieldOffset(36)]
		public float plasticCreep;

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

	// Token: 0x020003DE RID: 990
	[Serializable]
	[StructLayout(2)]
	public struct HalfEdge
	{
		// Token: 0x06007B4F RID: 31567 RVA: 0x001F76A0 File Offset: 0x001F58A0
		[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: 0x06007B50 RID: 31568 RVA: 0x001F76E8 File Offset: 0x001F58E8
		// 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, 100672657);
		}

		// Token: 0x06007B51 RID: 31569 RVA: 0x001F779F File Offset: 0x001F599F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.HalfEdge>.NativeClassPtr, ref this));
		}

		// Token: 0x040052BE RID: 21182
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x040052BF RID: 21183
		private static readonly IntPtr NativeFieldInfoPtr_indexInFace;

		// Token: 0x040052C0 RID: 21184
		private static readonly IntPtr NativeFieldInfoPtr_face;

		// Token: 0x040052C1 RID: 21185
		private static readonly IntPtr NativeFieldInfoPtr_nextHalfEdge;

		// Token: 0x040052C2 RID: 21186
		private static readonly IntPtr NativeFieldInfoPtr_pair;

		// Token: 0x040052C3 RID: 21187
		private static readonly IntPtr NativeFieldInfoPtr_endVertex;

		// Token: 0x040052C4 RID: 21188
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x040052C5 RID: 21189
		[FieldOffset(0)]
		public int index;

		// Token: 0x040052C6 RID: 21190
		[FieldOffset(4)]
		public int indexInFace;

		// Token: 0x040052C7 RID: 21191
		[FieldOffset(8)]
		public int face;

		// Token: 0x040052C8 RID: 21192
		[FieldOffset(12)]
		public int nextHalfEdge;

		// Token: 0x040052C9 RID: 21193
		[FieldOffset(16)]
		public int pair;

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

	// Token: 0x020003DF RID: 991
	[Serializable]
	[StructLayout(2)]
	public struct Vertex
	{
		// Token: 0x06007B52 RID: 31570 RVA: 0x001F77B4 File Offset: 0x001F59B4
		[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: 0x06007B53 RID: 31571 RVA: 0x001F7820 File Offset: 0x001F5A20
		// 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, 100672658);
		}

		// Token: 0x06007B54 RID: 31572 RVA: 0x001F789B File Offset: 0x001F5A9B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Vertex>.NativeClassPtr, ref this));
		}

		// Token: 0x040052CB RID: 21195
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x040052CC RID: 21196
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x040052CD RID: 21197
		private static readonly IntPtr NativeFieldInfoPtr_position;

		// Token: 0x040052CE RID: 21198
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Int32_Int32_0;

		// Token: 0x040052CF RID: 21199
		[FieldOffset(0)]
		public int index;

		// Token: 0x040052D0 RID: 21200
		[FieldOffset(4)]
		public int halfEdge;

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

	// Token: 0x020003E0 RID: 992
	[Serializable]
	[StructLayout(2)]
	public struct Face
	{
		// Token: 0x06007B55 RID: 31573 RVA: 0x001F78B0 File Offset: 0x001F5AB0
		[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: 0x06007B56 RID: 31574 RVA: 0x001F78F8 File Offset: 0x001F5AF8
		// 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, 100672659);
		}

		// Token: 0x06007B57 RID: 31575 RVA: 0x001F795F File Offset: 0x001F5B5F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.Face>.NativeClassPtr, ref this));
		}

		// Token: 0x040052D2 RID: 21202
		private static readonly IntPtr NativeFieldInfoPtr_index;

		// Token: 0x040052D3 RID: 21203
		private static readonly IntPtr NativeFieldInfoPtr_halfEdge;

		// Token: 0x040052D4 RID: 21204
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_0;

		// Token: 0x040052D5 RID: 21205
		[FieldOffset(0)]
		public int index;

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

	// Token: 0x020003E1 RID: 993
	[Serializable]
	[StructLayout(2)]
	public struct MeshInformation
	{
		// Token: 0x06007B58 RID: 31576 RVA: 0x001F7974 File Offset: 0x001F5B74
		// 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: 0x06007B59 RID: 31577 RVA: 0x001F7A03 File Offset: 0x001F5C03
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<Oni.MeshInformation>.NativeClassPtr, ref this));
		}

		// Token: 0x040052D7 RID: 21207
		private static readonly IntPtr NativeFieldInfoPtr_volume;

		// Token: 0x040052D8 RID: 21208
		private static readonly IntPtr NativeFieldInfoPtr_area;

		// Token: 0x040052D9 RID: 21209
		private static readonly IntPtr NativeFieldInfoPtr_borderEdgeCount;

		// Token: 0x040052DA RID: 21210
		private static readonly IntPtr NativeFieldInfoPtr_closed;

		// Token: 0x040052DB RID: 21211
		private static readonly IntPtr NativeFieldInfoPtr_nonManifold;

		// Token: 0x040052DC RID: 21212
		[FieldOffset(0)]
		public float volume;

		// Token: 0x040052DD RID: 21213
		[FieldOffset(4)]
		public float area;

		// Token: 0x040052DE RID: 21214
		[FieldOffset(8)]
		public int borderEdgeCount;

		// Token: 0x040052DF RID: 21215
		[FieldOffset(12)]
		[MarshalAs(4)]
		public bool closed;

		// Token: 0x040052E0 RID: 21216
		[FieldOffset(13)]
		[MarshalAs(4)]
		public bool nonManifold;
	}
}
