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

namespace RootMotion.FinalIK
{
	// Token: 0x0200047B RID: 1147
	public class RotationLimitPolygonal : RotationLimit
	{
		// Token: 0x06008834 RID: 34868 RVA: 0x0022E7B4 File Offset: 0x0022C9B4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621494, XrefRangeEnd = 621497, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OpenUserManual()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_OpenUserManual_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008835 RID: 34869 RVA: 0x0022E7F8 File Offset: 0x0022C9F8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621497, XrefRangeEnd = 621500, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OpenScriptReference()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_OpenScriptReference_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008836 RID: 34870 RVA: 0x0022E83C File Offset: 0x0022CA3C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621500, XrefRangeEnd = 621503, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SupportGroup()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_SupportGroup_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008837 RID: 34871 RVA: 0x0022E880 File Offset: 0x0022CA80
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621503, XrefRangeEnd = 621506, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ASThread()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_ASThread_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008838 RID: 34872 RVA: 0x0022E8C4 File Offset: 0x0022CAC4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621506, XrefRangeEnd = 621513, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetLimitPoints(Il2CppReferenceArray<RotationLimitPolygonal.LimitPoint> points)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(points);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008839 RID: 34873 RVA: 0x0022E920 File Offset: 0x0022CB20
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621513, XrefRangeEnd = 621516, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override Quaternion LimitRotation(Quaternion rotation)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), RotationLimitPolygonal.NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x0600883A RID: 34874 RVA: 0x0022E990 File Offset: 0x0022CB90
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621551, RefRangeEnd = 621552, XrefRangeStart = 621516, XrefRangeEnd = 621551, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Start()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_Start_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600883B RID: 34875 RVA: 0x0022E9D4 File Offset: 0x0022CBD4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621593, RefRangeEnd = 621594, XrefRangeStart = 621552, XrefRangeEnd = 621593, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ResetToDefault()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_ResetToDefault_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600883C RID: 34876 RVA: 0x0022EA18 File Offset: 0x0022CC18
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 621625, RefRangeEnd = 621627, XrefRangeStart = 621594, XrefRangeEnd = 621625, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void BuildReachCones()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_BuildReachCones_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600883D RID: 34877 RVA: 0x0022EA5C File Offset: 0x0022CC5C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621644, RefRangeEnd = 621645, XrefRangeStart = 621627, XrefRangeEnd = 621644, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Il2CppStructArray<Vector3> SmoothPoints()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Il2CppStructArray<Vector3>(intPtr3) : null;
		}

		// Token: 0x0600883E RID: 34878 RVA: 0x0022EAB4 File Offset: 0x0022CCB4
		[CallerCount(0)]
		public unsafe float GetScalar(int k)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref k;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x0600883F RID: 34879 RVA: 0x0022EB18 File Offset: 0x0022CD18
		[CallerCount(0)]
		public unsafe Vector3 PointToTangentPlane(Vector3 p, float r)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref p;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref r;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06008840 RID: 34880 RVA: 0x0022EB90 File Offset: 0x0022CD90
		[CallerCount(0)]
		public unsafe Vector3 TangentPointToSphere(Vector3 q, float r)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref q;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref r;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06008841 RID: 34881 RVA: 0x0022EC08 File Offset: 0x0022CE08
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621661, RefRangeEnd = 621662, XrefRangeStart = 621645, XrefRangeEnd = 621661, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Quaternion LimitSwing(Quaternion rotation)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008842 RID: 34882 RVA: 0x0022EC6C File Offset: 0x0022CE6C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621664, RefRangeEnd = 621665, XrefRangeStart = 621662, XrefRangeEnd = 621664, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe int GetReachCone(Vector3 L)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref L;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008843 RID: 34883 RVA: 0x0022ECD0 File Offset: 0x0022CED0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621665, XrefRangeEnd = 621671, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe RotationLimitPolygonal()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008844 RID: 34884 RVA: 0x0022ED1C File Offset: 0x0022CF1C
		// Note: this type is marked as 'beforefieldinit'.
		static RotationLimitPolygonal()
		{
			Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "RotationLimitPolygonal");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr);
			RotationLimitPolygonal.NativeFieldInfoPtr_twistLimit = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "twistLimit");
			RotationLimitPolygonal.NativeFieldInfoPtr_smoothIterations = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "smoothIterations");
			RotationLimitPolygonal.NativeFieldInfoPtr_points = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "points");
			RotationLimitPolygonal.NativeFieldInfoPtr_P = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "P");
			RotationLimitPolygonal.NativeFieldInfoPtr_reachCones = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "reachCones");
			RotationLimitPolygonal.NativeMethodInfoPtr_OpenUserManual_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673690);
			RotationLimitPolygonal.NativeMethodInfoPtr_OpenScriptReference_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673691);
			RotationLimitPolygonal.NativeMethodInfoPtr_SupportGroup_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673692);
			RotationLimitPolygonal.NativeMethodInfoPtr_ASThread_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673693);
			RotationLimitPolygonal.NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673694);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673695);
			RotationLimitPolygonal.NativeMethodInfoPtr_Start_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673696);
			RotationLimitPolygonal.NativeMethodInfoPtr_ResetToDefault_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673697);
			RotationLimitPolygonal.NativeMethodInfoPtr_BuildReachCones_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673698);
			RotationLimitPolygonal.NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673699);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673700);
			RotationLimitPolygonal.NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673701);
			RotationLimitPolygonal.NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673702);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673703);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673704);
			RotationLimitPolygonal.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673705);
		}

		// Token: 0x06008845 RID: 34885 RVA: 0x0022E1E4 File Offset: 0x0022C3E4
		public RotationLimitPolygonal(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E59 RID: 11865
		// (get) Token: 0x06008846 RID: 34886 RVA: 0x0022EEF0 File Offset: 0x0022D0F0
		// (set) Token: 0x06008847 RID: 34887 RVA: 0x0022EF18 File Offset: 0x0022D118
		public unsafe float twistLimit
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_twistLimit);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_twistLimit)) = value;
			}
		}

		// Token: 0x17002E5A RID: 11866
		// (get) Token: 0x06008848 RID: 34888 RVA: 0x0022EF3C File Offset: 0x0022D13C
		// (set) Token: 0x06008849 RID: 34889 RVA: 0x0022EF64 File Offset: 0x0022D164
		public unsafe int smoothIterations
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_smoothIterations);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_smoothIterations)) = value;
			}
		}

		// Token: 0x17002E5B RID: 11867
		// (get) Token: 0x0600884A RID: 34890 RVA: 0x0022EF88 File Offset: 0x0022D188
		// (set) Token: 0x0600884B RID: 34891 RVA: 0x0022EFBC File Offset: 0x0022D1BC
		public unsafe Il2CppReferenceArray<RotationLimitPolygonal.LimitPoint> points
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_points);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<RotationLimitPolygonal.LimitPoint>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_points), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E5C RID: 11868
		// (get) Token: 0x0600884C RID: 34892 RVA: 0x0022EFE4 File Offset: 0x0022D1E4
		// (set) Token: 0x0600884D RID: 34893 RVA: 0x0022F018 File Offset: 0x0022D218
		public unsafe Il2CppStructArray<Vector3> P
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_P);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Vector3>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_P), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E5D RID: 11869
		// (get) Token: 0x0600884E RID: 34894 RVA: 0x0022F040 File Offset: 0x0022D240
		// (set) Token: 0x0600884F RID: 34895 RVA: 0x0022F074 File Offset: 0x0022D274
		public unsafe Il2CppReferenceArray<RotationLimitPolygonal.ReachCone> reachCones
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_reachCones);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<RotationLimitPolygonal.ReachCone>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.NativeFieldInfoPtr_reachCones), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04005AF0 RID: 23280
		private static readonly IntPtr NativeFieldInfoPtr_twistLimit;

		// Token: 0x04005AF1 RID: 23281
		private static readonly IntPtr NativeFieldInfoPtr_smoothIterations;

		// Token: 0x04005AF2 RID: 23282
		private static readonly IntPtr NativeFieldInfoPtr_points;

		// Token: 0x04005AF3 RID: 23283
		private static readonly IntPtr NativeFieldInfoPtr_P;

		// Token: 0x04005AF4 RID: 23284
		private static readonly IntPtr NativeFieldInfoPtr_reachCones;

		// Token: 0x04005AF5 RID: 23285
		private static readonly IntPtr NativeMethodInfoPtr_OpenUserManual_Private_Void_0;

		// Token: 0x04005AF6 RID: 23286
		private static readonly IntPtr NativeMethodInfoPtr_OpenScriptReference_Private_Void_0;

		// Token: 0x04005AF7 RID: 23287
		private static readonly IntPtr NativeMethodInfoPtr_SupportGroup_Private_Void_0;

		// Token: 0x04005AF8 RID: 23288
		private static readonly IntPtr NativeMethodInfoPtr_ASThread_Private_Void_0;

		// Token: 0x04005AF9 RID: 23289
		private static readonly IntPtr NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0;

		// Token: 0x04005AFA RID: 23290
		private static readonly IntPtr NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0;

		// Token: 0x04005AFB RID: 23291
		private static readonly IntPtr NativeMethodInfoPtr_Start_Private_Void_0;

		// Token: 0x04005AFC RID: 23292
		private static readonly IntPtr NativeMethodInfoPtr_ResetToDefault_Public_Void_0;

		// Token: 0x04005AFD RID: 23293
		private static readonly IntPtr NativeMethodInfoPtr_BuildReachCones_Public_Void_0;

		// Token: 0x04005AFE RID: 23294
		private static readonly IntPtr NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0;

		// Token: 0x04005AFF RID: 23295
		private static readonly IntPtr NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0;

		// Token: 0x04005B00 RID: 23296
		private static readonly IntPtr NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0;

		// Token: 0x04005B01 RID: 23297
		private static readonly IntPtr NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0;

		// Token: 0x04005B02 RID: 23298
		private static readonly IntPtr NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0;

		// Token: 0x04005B03 RID: 23299
		private static readonly IntPtr NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0;

		// Token: 0x04005B04 RID: 23300
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0200047C RID: 1148
		[Serializable]
		public class ReachCone : Il2CppSystem.Object
		{
			// Token: 0x17002E62 RID: 11874
			// (get) Token: 0x06008850 RID: 34896 RVA: 0x0022F09C File Offset: 0x0022D29C
			public unsafe Vector3 o
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_o_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002E63 RID: 11875
			// (get) Token: 0x06008851 RID: 34897 RVA: 0x0022F0EC File Offset: 0x0022D2EC
			public unsafe Vector3 a
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_a_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002E64 RID: 11876
			// (get) Token: 0x06008852 RID: 34898 RVA: 0x0022F13C File Offset: 0x0022D33C
			public unsafe Vector3 b
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_b_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002E65 RID: 11877
			// (get) Token: 0x06008853 RID: 34899 RVA: 0x0022F18C File Offset: 0x0022D38C
			public unsafe Vector3 c
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_c_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06008854 RID: 34900 RVA: 0x0022F1DC File Offset: 0x0022D3DC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 621482, RefRangeEnd = 621484, XrefRangeStart = 621475, XrefRangeEnd = 621482, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe ReachCone(Vector3 _o, Vector3 _a, Vector3 _b, Vector3 _c)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref _o;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref _a;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref _b;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref _c;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x17002E66 RID: 11878
			// (get) Token: 0x06008855 RID: 34901 RVA: 0x0022F274 File Offset: 0x0022D474
			public unsafe bool isValid
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621484, RefRangeEnd = 621485, XrefRangeStart = 621484, XrefRangeEnd = 621484, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06008856 RID: 34902 RVA: 0x0022F2C4 File Offset: 0x0022D4C4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 621490, RefRangeEnd = 621491, XrefRangeStart = 621485, XrefRangeEnd = 621490, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Calculate()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_Calculate_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008857 RID: 34903 RVA: 0x0022F308 File Offset: 0x0022D508
			// Note: this type is marked as 'beforefieldinit'.
			static ReachCone()
			{
				Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "ReachCone");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr);
				RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_tetrahedron = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, "tetrahedron");
				RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_volume = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, "volume");
				RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_S = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, "S");
				RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_B = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, "B");
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_o_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673706);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_a_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673707);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_b_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673708);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_c_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673709);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673710);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673711);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_Calculate_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673712);
			}

			// Token: 0x06008858 RID: 34904 RVA: 0x0000A74C File Offset: 0x0000894C
			public ReachCone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E5E RID: 11870
			// (get) Token: 0x06008859 RID: 34905 RVA: 0x0022F410 File Offset: 0x0022D610
			// (set) Token: 0x0600885A RID: 34906 RVA: 0x0022F444 File Offset: 0x0022D644
			public unsafe Il2CppStructArray<Vector3> tetrahedron
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_tetrahedron);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppStructArray<Vector3>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_tetrahedron), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002E5F RID: 11871
			// (get) Token: 0x0600885B RID: 34907 RVA: 0x0022F46C File Offset: 0x0022D66C
			// (set) Token: 0x0600885C RID: 34908 RVA: 0x0022F494 File Offset: 0x0022D694
			public unsafe float volume
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_volume);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_volume)) = value;
				}
			}

			// Token: 0x17002E60 RID: 11872
			// (get) Token: 0x0600885D RID: 34909 RVA: 0x0022F4B8 File Offset: 0x0022D6B8
			// (set) Token: 0x0600885E RID: 34910 RVA: 0x0022F4E0 File Offset: 0x0022D6E0
			public unsafe Vector3 S
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_S);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_S)) = value;
				}
			}

			// Token: 0x17002E61 RID: 11873
			// (get) Token: 0x0600885F RID: 34911 RVA: 0x0022F504 File Offset: 0x0022D704
			// (set) Token: 0x06008860 RID: 34912 RVA: 0x0022F52C File Offset: 0x0022D72C
			public unsafe Vector3 B
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_B);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.ReachCone.NativeFieldInfoPtr_B)) = value;
				}
			}

			// Token: 0x04005B05 RID: 23301
			private static readonly IntPtr NativeFieldInfoPtr_tetrahedron;

			// Token: 0x04005B06 RID: 23302
			private static readonly IntPtr NativeFieldInfoPtr_volume;

			// Token: 0x04005B07 RID: 23303
			private static readonly IntPtr NativeFieldInfoPtr_S;

			// Token: 0x04005B08 RID: 23304
			private static readonly IntPtr NativeFieldInfoPtr_B;

			// Token: 0x04005B09 RID: 23305
			private static readonly IntPtr NativeMethodInfoPtr_get_o_Public_get_Vector3_0;

			// Token: 0x04005B0A RID: 23306
			private static readonly IntPtr NativeMethodInfoPtr_get_a_Public_get_Vector3_0;

			// Token: 0x04005B0B RID: 23307
			private static readonly IntPtr NativeMethodInfoPtr_get_b_Public_get_Vector3_0;

			// Token: 0x04005B0C RID: 23308
			private static readonly IntPtr NativeMethodInfoPtr_get_c_Public_get_Vector3_0;

			// Token: 0x04005B0D RID: 23309
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0;

			// Token: 0x04005B0E RID: 23310
			private static readonly IntPtr NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0;

			// Token: 0x04005B0F RID: 23311
			private static readonly IntPtr NativeMethodInfoPtr_Calculate_Public_Void_0;
		}

		// Token: 0x0200047D RID: 1149
		[Serializable]
		public class LimitPoint : Il2CppSystem.Object
		{
			// Token: 0x06008861 RID: 34913 RVA: 0x0022F550 File Offset: 0x0022D750
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 621493, RefRangeEnd = 621494, XrefRangeStart = 621491, XrefRangeEnd = 621493, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe LimitPoint()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RotationLimitPolygonal.LimitPoint.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008862 RID: 34914 RVA: 0x0022F59C File Offset: 0x0022D79C
			// Note: this type is marked as 'beforefieldinit'.
			static LimitPoint()
			{
				Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, "LimitPoint");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr);
				RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_point = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr, "point");
				RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_tangentWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr, "tangentWeight");
				RotationLimitPolygonal.LimitPoint.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.LimitPoint>.NativeClassPtr, 100673713);
			}

			// Token: 0x06008863 RID: 34915 RVA: 0x0000A74C File Offset: 0x0000894C
			public LimitPoint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E67 RID: 11879
			// (get) Token: 0x06008864 RID: 34916 RVA: 0x0022F604 File Offset: 0x0022D804
			// (set) Token: 0x06008865 RID: 34917 RVA: 0x0022F62C File Offset: 0x0022D82C
			public unsafe Vector3 point
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_point);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_point)) = value;
				}
			}

			// Token: 0x17002E68 RID: 11880
			// (get) Token: 0x06008866 RID: 34918 RVA: 0x0022F650 File Offset: 0x0022D850
			// (set) Token: 0x06008867 RID: 34919 RVA: 0x0022F678 File Offset: 0x0022D878
			public unsafe float tangentWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_tangentWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(RotationLimitPolygonal.LimitPoint.NativeFieldInfoPtr_tangentWeight)) = value;
				}
			}

			// Token: 0x04005B10 RID: 23312
			private static readonly IntPtr NativeFieldInfoPtr_point;

			// Token: 0x04005B11 RID: 23313
			private static readonly IntPtr NativeFieldInfoPtr_tangentWeight;

			// Token: 0x04005B12 RID: 23314
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}
	}
}