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

namespace RootMotion.FinalIK
{
	// Token: 0x02000472 RID: 1138
	public class RotationLimitPolygonal : RotationLimit
	{
		// Token: 0x06008784 RID: 34692 RVA: 0x0022BBB0 File Offset: 0x00229DB0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603763, XrefRangeEnd = 603766, 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: 0x06008785 RID: 34693 RVA: 0x0022BBF4 File Offset: 0x00229DF4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603766, XrefRangeEnd = 603769, 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: 0x06008786 RID: 34694 RVA: 0x0022BC38 File Offset: 0x00229E38
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603769, XrefRangeEnd = 603772, 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: 0x06008787 RID: 34695 RVA: 0x0022BC7C File Offset: 0x00229E7C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603772, XrefRangeEnd = 603775, 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: 0x06008788 RID: 34696 RVA: 0x0022BCC0 File Offset: 0x00229EC0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603775, XrefRangeEnd = 603782, 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: 0x06008789 RID: 34697 RVA: 0x0022BD1C File Offset: 0x00229F1C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603782, XrefRangeEnd = 603785, 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: 0x0600878A RID: 34698 RVA: 0x0022BD8C File Offset: 0x00229F8C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603820, RefRangeEnd = 603821, XrefRangeStart = 603785, XrefRangeEnd = 603820, 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: 0x0600878B RID: 34699 RVA: 0x0022BDD0 File Offset: 0x00229FD0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603862, RefRangeEnd = 603863, XrefRangeStart = 603821, XrefRangeEnd = 603862, 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: 0x0600878C RID: 34700 RVA: 0x0022BE14 File Offset: 0x0022A014
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 603894, RefRangeEnd = 603896, XrefRangeStart = 603863, XrefRangeEnd = 603894, 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: 0x0600878D RID: 34701 RVA: 0x0022BE58 File Offset: 0x0022A058
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603913, RefRangeEnd = 603914, XrefRangeStart = 603896, XrefRangeEnd = 603913, 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: 0x0600878E RID: 34702 RVA: 0x0022BEB0 File Offset: 0x0022A0B0
		[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: 0x0600878F RID: 34703 RVA: 0x0022BF14 File Offset: 0x0022A114
		[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: 0x06008790 RID: 34704 RVA: 0x0022BF8C File Offset: 0x0022A18C
		[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: 0x06008791 RID: 34705 RVA: 0x0022C004 File Offset: 0x0022A204
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603930, RefRangeEnd = 603931, XrefRangeStart = 603914, XrefRangeEnd = 603930, 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: 0x06008792 RID: 34706 RVA: 0x0022C068 File Offset: 0x0022A268
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 603933, RefRangeEnd = 603934, XrefRangeStart = 603931, XrefRangeEnd = 603933, 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: 0x06008793 RID: 34707 RVA: 0x0022C0CC File Offset: 0x0022A2CC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 603934, XrefRangeEnd = 603940, 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: 0x06008794 RID: 34708 RVA: 0x0022C118 File Offset: 0x0022A318
		// 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, 100673640);
			RotationLimitPolygonal.NativeMethodInfoPtr_OpenScriptReference_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673641);
			RotationLimitPolygonal.NativeMethodInfoPtr_SupportGroup_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673642);
			RotationLimitPolygonal.NativeMethodInfoPtr_ASThread_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673643);
			RotationLimitPolygonal.NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673644);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673645);
			RotationLimitPolygonal.NativeMethodInfoPtr_Start_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673646);
			RotationLimitPolygonal.NativeMethodInfoPtr_ResetToDefault_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673647);
			RotationLimitPolygonal.NativeMethodInfoPtr_BuildReachCones_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673648);
			RotationLimitPolygonal.NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673649);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673650);
			RotationLimitPolygonal.NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673651);
			RotationLimitPolygonal.NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673652);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673653);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673654);
			RotationLimitPolygonal.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100673655);
		}

		// Token: 0x06008795 RID: 34709 RVA: 0x0022B5E0 File Offset: 0x002297E0
		public RotationLimitPolygonal(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E27 RID: 11815
		// (get) Token: 0x06008796 RID: 34710 RVA: 0x0022C2EC File Offset: 0x0022A4EC
		// (set) Token: 0x06008797 RID: 34711 RVA: 0x0022C314 File Offset: 0x0022A514
		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: 0x17002E28 RID: 11816
		// (get) Token: 0x06008798 RID: 34712 RVA: 0x0022C338 File Offset: 0x0022A538
		// (set) Token: 0x06008799 RID: 34713 RVA: 0x0022C360 File Offset: 0x0022A560
		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: 0x17002E29 RID: 11817
		// (get) Token: 0x0600879A RID: 34714 RVA: 0x0022C384 File Offset: 0x0022A584
		// (set) Token: 0x0600879B RID: 34715 RVA: 0x0022C3B8 File Offset: 0x0022A5B8
		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: 0x17002E2A RID: 11818
		// (get) Token: 0x0600879C RID: 34716 RVA: 0x0022C3E0 File Offset: 0x0022A5E0
		// (set) Token: 0x0600879D RID: 34717 RVA: 0x0022C414 File Offset: 0x0022A614
		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: 0x17002E2B RID: 11819
		// (get) Token: 0x0600879E RID: 34718 RVA: 0x0022C43C File Offset: 0x0022A63C
		// (set) Token: 0x0600879F RID: 34719 RVA: 0x0022C470 File Offset: 0x0022A670
		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: 0x04005A7C RID: 23164
		private static readonly IntPtr NativeFieldInfoPtr_twistLimit;

		// Token: 0x04005A7D RID: 23165
		private static readonly IntPtr NativeFieldInfoPtr_smoothIterations;

		// Token: 0x04005A7E RID: 23166
		private static readonly IntPtr NativeFieldInfoPtr_points;

		// Token: 0x04005A7F RID: 23167
		private static readonly IntPtr NativeFieldInfoPtr_P;

		// Token: 0x04005A80 RID: 23168
		private static readonly IntPtr NativeFieldInfoPtr_reachCones;

		// Token: 0x04005A81 RID: 23169
		private static readonly IntPtr NativeMethodInfoPtr_OpenUserManual_Private_Void_0;

		// Token: 0x04005A82 RID: 23170
		private static readonly IntPtr NativeMethodInfoPtr_OpenScriptReference_Private_Void_0;

		// Token: 0x04005A83 RID: 23171
		private static readonly IntPtr NativeMethodInfoPtr_SupportGroup_Private_Void_0;

		// Token: 0x04005A84 RID: 23172
		private static readonly IntPtr NativeMethodInfoPtr_ASThread_Private_Void_0;

		// Token: 0x04005A85 RID: 23173
		private static readonly IntPtr NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0;

		// Token: 0x04005A86 RID: 23174
		private static readonly IntPtr NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0;

		// Token: 0x04005A87 RID: 23175
		private static readonly IntPtr NativeMethodInfoPtr_Start_Private_Void_0;

		// Token: 0x04005A88 RID: 23176
		private static readonly IntPtr NativeMethodInfoPtr_ResetToDefault_Public_Void_0;

		// Token: 0x04005A89 RID: 23177
		private static readonly IntPtr NativeMethodInfoPtr_BuildReachCones_Public_Void_0;

		// Token: 0x04005A8A RID: 23178
		private static readonly IntPtr NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0;

		// Token: 0x04005A8B RID: 23179
		private static readonly IntPtr NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0;

		// Token: 0x04005A8C RID: 23180
		private static readonly IntPtr NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0;

		// Token: 0x04005A8D RID: 23181
		private static readonly IntPtr NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0;

		// Token: 0x04005A8E RID: 23182
		private static readonly IntPtr NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0;

		// Token: 0x04005A8F RID: 23183
		private static readonly IntPtr NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0;

		// Token: 0x04005A90 RID: 23184
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000473 RID: 1139
		[Serializable]
		public class ReachCone : Il2CppSystem.Object
		{
			// Token: 0x17002E30 RID: 11824
			// (get) Token: 0x060087A0 RID: 34720 RVA: 0x0022C498 File Offset: 0x0022A698
			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: 0x17002E31 RID: 11825
			// (get) Token: 0x060087A1 RID: 34721 RVA: 0x0022C4E8 File Offset: 0x0022A6E8
			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: 0x17002E32 RID: 11826
			// (get) Token: 0x060087A2 RID: 34722 RVA: 0x0022C538 File Offset: 0x0022A738
			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: 0x17002E33 RID: 11827
			// (get) Token: 0x060087A3 RID: 34723 RVA: 0x0022C588 File Offset: 0x0022A788
			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: 0x060087A4 RID: 34724 RVA: 0x0022C5D8 File Offset: 0x0022A7D8
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 603751, RefRangeEnd = 603753, XrefRangeStart = 603744, XrefRangeEnd = 603751, 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: 0x17002E34 RID: 11828
			// (get) Token: 0x060087A5 RID: 34725 RVA: 0x0022C670 File Offset: 0x0022A870
			public unsafe bool isValid
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 603753, RefRangeEnd = 603754, XrefRangeStart = 603753, XrefRangeEnd = 603753, 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: 0x060087A6 RID: 34726 RVA: 0x0022C6C0 File Offset: 0x0022A8C0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 603759, RefRangeEnd = 603760, XrefRangeStart = 603754, XrefRangeEnd = 603759, 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: 0x060087A7 RID: 34727 RVA: 0x0022C704 File Offset: 0x0022A904
			// 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, 100673656);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_a_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673657);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_b_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673658);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_c_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673659);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673660);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673661);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_Calculate_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100673662);
			}

			// Token: 0x060087A8 RID: 34728 RVA: 0x0000A688 File Offset: 0x00008888
			public ReachCone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E2C RID: 11820
			// (get) Token: 0x060087A9 RID: 34729 RVA: 0x0022C80C File Offset: 0x0022AA0C
			// (set) Token: 0x060087AA RID: 34730 RVA: 0x0022C840 File Offset: 0x0022AA40
			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: 0x17002E2D RID: 11821
			// (get) Token: 0x060087AB RID: 34731 RVA: 0x0022C868 File Offset: 0x0022AA68
			// (set) Token: 0x060087AC RID: 34732 RVA: 0x0022C890 File Offset: 0x0022AA90
			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: 0x17002E2E RID: 11822
			// (get) Token: 0x060087AD RID: 34733 RVA: 0x0022C8B4 File Offset: 0x0022AAB4
			// (set) Token: 0x060087AE RID: 34734 RVA: 0x0022C8DC File Offset: 0x0022AADC
			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: 0x17002E2F RID: 11823
			// (get) Token: 0x060087AF RID: 34735 RVA: 0x0022C900 File Offset: 0x0022AB00
			// (set) Token: 0x060087B0 RID: 34736 RVA: 0x0022C928 File Offset: 0x0022AB28
			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: 0x04005A91 RID: 23185
			private static readonly IntPtr NativeFieldInfoPtr_tetrahedron;

			// Token: 0x04005A92 RID: 23186
			private static readonly IntPtr NativeFieldInfoPtr_volume;

			// Token: 0x04005A93 RID: 23187
			private static readonly IntPtr NativeFieldInfoPtr_S;

			// Token: 0x04005A94 RID: 23188
			private static readonly IntPtr NativeFieldInfoPtr_B;

			// Token: 0x04005A95 RID: 23189
			private static readonly IntPtr NativeMethodInfoPtr_get_o_Public_get_Vector3_0;

			// Token: 0x04005A96 RID: 23190
			private static readonly IntPtr NativeMethodInfoPtr_get_a_Public_get_Vector3_0;

			// Token: 0x04005A97 RID: 23191
			private static readonly IntPtr NativeMethodInfoPtr_get_b_Public_get_Vector3_0;

			// Token: 0x04005A98 RID: 23192
			private static readonly IntPtr NativeMethodInfoPtr_get_c_Public_get_Vector3_0;

			// Token: 0x04005A99 RID: 23193
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0;

			// Token: 0x04005A9A RID: 23194
			private static readonly IntPtr NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0;

			// Token: 0x04005A9B RID: 23195
			private static readonly IntPtr NativeMethodInfoPtr_Calculate_Public_Void_0;
		}

		// Token: 0x02000474 RID: 1140
		[Serializable]
		public class LimitPoint : Il2CppSystem.Object
		{
			// Token: 0x060087B1 RID: 34737 RVA: 0x0022C94C File Offset: 0x0022AB4C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 603762, RefRangeEnd = 603763, XrefRangeStart = 603760, XrefRangeEnd = 603762, 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: 0x060087B2 RID: 34738 RVA: 0x0022C998 File Offset: 0x0022AB98
			// 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, 100673663);
			}

			// Token: 0x060087B3 RID: 34739 RVA: 0x0000A688 File Offset: 0x00008888
			public LimitPoint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E35 RID: 11829
			// (get) Token: 0x060087B4 RID: 34740 RVA: 0x0022CA00 File Offset: 0x0022AC00
			// (set) Token: 0x060087B5 RID: 34741 RVA: 0x0022CA28 File Offset: 0x0022AC28
			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: 0x17002E36 RID: 11830
			// (get) Token: 0x060087B6 RID: 34742 RVA: 0x0022CA4C File Offset: 0x0022AC4C
			// (set) Token: 0x060087B7 RID: 34743 RVA: 0x0022CA74 File Offset: 0x0022AC74
			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: 0x04005A9C RID: 23196
			private static readonly IntPtr NativeFieldInfoPtr_point;

			// Token: 0x04005A9D RID: 23197
			private static readonly IntPtr NativeFieldInfoPtr_tangentWeight;

			// Token: 0x04005A9E RID: 23198
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}
	}
}