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

namespace RootMotion.FinalIK
{
	// Token: 0x020004CA RID: 1226
	public class RotationLimitPolygonal : RotationLimit
	{
		// Token: 0x06008FD7 RID: 36823 RVA: 0x0024E8EC File Offset: 0x0024CAEC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636072, XrefRangeEnd = 636075, 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: 0x06008FD8 RID: 36824 RVA: 0x0024E930 File Offset: 0x0024CB30
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636075, XrefRangeEnd = 636078, 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: 0x06008FD9 RID: 36825 RVA: 0x0024E974 File Offset: 0x0024CB74
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636078, XrefRangeEnd = 636081, 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: 0x06008FDA RID: 36826 RVA: 0x0024E9B8 File Offset: 0x0024CBB8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636081, XrefRangeEnd = 636084, 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: 0x06008FDB RID: 36827 RVA: 0x0024E9FC File Offset: 0x0024CBFC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636084, XrefRangeEnd = 636091, 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: 0x06008FDC RID: 36828 RVA: 0x0024EA58 File Offset: 0x0024CC58
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636091, XrefRangeEnd = 636094, 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: 0x06008FDD RID: 36829 RVA: 0x0024EAC8 File Offset: 0x0024CCC8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636129, RefRangeEnd = 636130, XrefRangeStart = 636094, XrefRangeEnd = 636129, 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: 0x06008FDE RID: 36830 RVA: 0x0024EB0C File Offset: 0x0024CD0C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636171, RefRangeEnd = 636172, XrefRangeStart = 636130, XrefRangeEnd = 636171, 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: 0x06008FDF RID: 36831 RVA: 0x0024EB50 File Offset: 0x0024CD50
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 636203, RefRangeEnd = 636205, XrefRangeStart = 636172, XrefRangeEnd = 636203, 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: 0x06008FE0 RID: 36832 RVA: 0x0024EB94 File Offset: 0x0024CD94
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636222, RefRangeEnd = 636223, XrefRangeStart = 636205, XrefRangeEnd = 636222, 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: 0x06008FE1 RID: 36833 RVA: 0x0024EBEC File Offset: 0x0024CDEC
		[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: 0x06008FE2 RID: 36834 RVA: 0x0024EC50 File Offset: 0x0024CE50
		[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: 0x06008FE3 RID: 36835 RVA: 0x0024ECC8 File Offset: 0x0024CEC8
		[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: 0x06008FE4 RID: 36836 RVA: 0x0024ED40 File Offset: 0x0024CF40
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636239, RefRangeEnd = 636240, XrefRangeStart = 636223, XrefRangeEnd = 636239, 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: 0x06008FE5 RID: 36837 RVA: 0x0024EDA4 File Offset: 0x0024CFA4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636242, RefRangeEnd = 636243, XrefRangeStart = 636240, XrefRangeEnd = 636242, 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: 0x06008FE6 RID: 36838 RVA: 0x0024EE08 File Offset: 0x0024D008
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636243, XrefRangeEnd = 636249, 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: 0x06008FE7 RID: 36839 RVA: 0x0024EE54 File Offset: 0x0024D054
		// 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, 100674353);
			RotationLimitPolygonal.NativeMethodInfoPtr_OpenScriptReference_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674354);
			RotationLimitPolygonal.NativeMethodInfoPtr_SupportGroup_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674355);
			RotationLimitPolygonal.NativeMethodInfoPtr_ASThread_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674356);
			RotationLimitPolygonal.NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674357);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674358);
			RotationLimitPolygonal.NativeMethodInfoPtr_Start_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674359);
			RotationLimitPolygonal.NativeMethodInfoPtr_ResetToDefault_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674360);
			RotationLimitPolygonal.NativeMethodInfoPtr_BuildReachCones_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674361);
			RotationLimitPolygonal.NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674362);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674363);
			RotationLimitPolygonal.NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674364);
			RotationLimitPolygonal.NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674365);
			RotationLimitPolygonal.NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674366);
			RotationLimitPolygonal.NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674367);
			RotationLimitPolygonal.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal>.NativeClassPtr, 100674368);
		}

		// Token: 0x06008FE8 RID: 36840 RVA: 0x0024E31C File Offset: 0x0024C51C
		public RotationLimitPolygonal(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x170030C2 RID: 12482
		// (get) Token: 0x06008FE9 RID: 36841 RVA: 0x0024F028 File Offset: 0x0024D228
		// (set) Token: 0x06008FEA RID: 36842 RVA: 0x0024F050 File Offset: 0x0024D250
		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: 0x170030C3 RID: 12483
		// (get) Token: 0x06008FEB RID: 36843 RVA: 0x0024F074 File Offset: 0x0024D274
		// (set) Token: 0x06008FEC RID: 36844 RVA: 0x0024F09C File Offset: 0x0024D29C
		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: 0x170030C4 RID: 12484
		// (get) Token: 0x06008FED RID: 36845 RVA: 0x0024F0C0 File Offset: 0x0024D2C0
		// (set) Token: 0x06008FEE RID: 36846 RVA: 0x0024F0F4 File Offset: 0x0024D2F4
		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: 0x170030C5 RID: 12485
		// (get) Token: 0x06008FEF RID: 36847 RVA: 0x0024F11C File Offset: 0x0024D31C
		// (set) Token: 0x06008FF0 RID: 36848 RVA: 0x0024F150 File Offset: 0x0024D350
		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: 0x170030C6 RID: 12486
		// (get) Token: 0x06008FF1 RID: 36849 RVA: 0x0024F178 File Offset: 0x0024D378
		// (set) Token: 0x06008FF2 RID: 36850 RVA: 0x0024F1AC File Offset: 0x0024D3AC
		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: 0x04006025 RID: 24613
		private static readonly IntPtr NativeFieldInfoPtr_twistLimit;

		// Token: 0x04006026 RID: 24614
		private static readonly IntPtr NativeFieldInfoPtr_smoothIterations;

		// Token: 0x04006027 RID: 24615
		private static readonly IntPtr NativeFieldInfoPtr_points;

		// Token: 0x04006028 RID: 24616
		private static readonly IntPtr NativeFieldInfoPtr_P;

		// Token: 0x04006029 RID: 24617
		private static readonly IntPtr NativeFieldInfoPtr_reachCones;

		// Token: 0x0400602A RID: 24618
		private static readonly IntPtr NativeMethodInfoPtr_OpenUserManual_Private_Void_0;

		// Token: 0x0400602B RID: 24619
		private static readonly IntPtr NativeMethodInfoPtr_OpenScriptReference_Private_Void_0;

		// Token: 0x0400602C RID: 24620
		private static readonly IntPtr NativeMethodInfoPtr_SupportGroup_Private_Void_0;

		// Token: 0x0400602D RID: 24621
		private static readonly IntPtr NativeMethodInfoPtr_ASThread_Private_Void_0;

		// Token: 0x0400602E RID: 24622
		private static readonly IntPtr NativeMethodInfoPtr_SetLimitPoints_Public_Void_Il2CppReferenceArray_1_LimitPoint_0;

		// Token: 0x0400602F RID: 24623
		private static readonly IntPtr NativeMethodInfoPtr_LimitRotation_Protected_Virtual_Quaternion_Quaternion_0;

		// Token: 0x04006030 RID: 24624
		private static readonly IntPtr NativeMethodInfoPtr_Start_Private_Void_0;

		// Token: 0x04006031 RID: 24625
		private static readonly IntPtr NativeMethodInfoPtr_ResetToDefault_Public_Void_0;

		// Token: 0x04006032 RID: 24626
		private static readonly IntPtr NativeMethodInfoPtr_BuildReachCones_Public_Void_0;

		// Token: 0x04006033 RID: 24627
		private static readonly IntPtr NativeMethodInfoPtr_SmoothPoints_Private_Il2CppStructArray_1_Vector3_0;

		// Token: 0x04006034 RID: 24628
		private static readonly IntPtr NativeMethodInfoPtr_GetScalar_Private_Single_Int32_0;

		// Token: 0x04006035 RID: 24629
		private static readonly IntPtr NativeMethodInfoPtr_PointToTangentPlane_Private_Vector3_Vector3_Single_0;

		// Token: 0x04006036 RID: 24630
		private static readonly IntPtr NativeMethodInfoPtr_TangentPointToSphere_Private_Vector3_Vector3_Single_0;

		// Token: 0x04006037 RID: 24631
		private static readonly IntPtr NativeMethodInfoPtr_LimitSwing_Private_Quaternion_Quaternion_0;

		// Token: 0x04006038 RID: 24632
		private static readonly IntPtr NativeMethodInfoPtr_GetReachCone_Private_Int32_Vector3_0;

		// Token: 0x04006039 RID: 24633
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004CB RID: 1227
		[Serializable]
		public class ReachCone : Il2CppSystem.Object
		{
			// Token: 0x170030CB RID: 12491
			// (get) Token: 0x06008FF3 RID: 36851 RVA: 0x0024F1D4 File Offset: 0x0024D3D4
			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: 0x170030CC RID: 12492
			// (get) Token: 0x06008FF4 RID: 36852 RVA: 0x0024F224 File Offset: 0x0024D424
			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: 0x170030CD RID: 12493
			// (get) Token: 0x06008FF5 RID: 36853 RVA: 0x0024F274 File Offset: 0x0024D474
			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: 0x170030CE RID: 12494
			// (get) Token: 0x06008FF6 RID: 36854 RVA: 0x0024F2C4 File Offset: 0x0024D4C4
			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: 0x06008FF7 RID: 36855 RVA: 0x0024F314 File Offset: 0x0024D514
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 636060, RefRangeEnd = 636062, XrefRangeStart = 636053, XrefRangeEnd = 636060, 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: 0x170030CF RID: 12495
			// (get) Token: 0x06008FF8 RID: 36856 RVA: 0x0024F3AC File Offset: 0x0024D5AC
			public unsafe bool isValid
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636062, RefRangeEnd = 636063, XrefRangeStart = 636062, XrefRangeEnd = 636062, 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: 0x06008FF9 RID: 36857 RVA: 0x0024F3FC File Offset: 0x0024D5FC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 636068, RefRangeEnd = 636069, XrefRangeStart = 636063, XrefRangeEnd = 636068, 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: 0x06008FFA RID: 36858 RVA: 0x0024F440 File Offset: 0x0024D640
			// 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, 100674369);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_a_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674370);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_b_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674371);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_c_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674372);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674373);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674374);
				RotationLimitPolygonal.ReachCone.NativeMethodInfoPtr_Calculate_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RotationLimitPolygonal.ReachCone>.NativeClassPtr, 100674375);
			}

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

			// Token: 0x170030C7 RID: 12487
			// (get) Token: 0x06008FFC RID: 36860 RVA: 0x0024F548 File Offset: 0x0024D748
			// (set) Token: 0x06008FFD RID: 36861 RVA: 0x0024F57C File Offset: 0x0024D77C
			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: 0x170030C8 RID: 12488
			// (get) Token: 0x06008FFE RID: 36862 RVA: 0x0024F5A4 File Offset: 0x0024D7A4
			// (set) Token: 0x06008FFF RID: 36863 RVA: 0x0024F5CC File Offset: 0x0024D7CC
			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: 0x170030C9 RID: 12489
			// (get) Token: 0x06009000 RID: 36864 RVA: 0x0024F5F0 File Offset: 0x0024D7F0
			// (set) Token: 0x06009001 RID: 36865 RVA: 0x0024F618 File Offset: 0x0024D818
			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: 0x170030CA RID: 12490
			// (get) Token: 0x06009002 RID: 36866 RVA: 0x0024F63C File Offset: 0x0024D83C
			// (set) Token: 0x06009003 RID: 36867 RVA: 0x0024F664 File Offset: 0x0024D864
			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: 0x0400603A RID: 24634
			private static readonly IntPtr NativeFieldInfoPtr_tetrahedron;

			// Token: 0x0400603B RID: 24635
			private static readonly IntPtr NativeFieldInfoPtr_volume;

			// Token: 0x0400603C RID: 24636
			private static readonly IntPtr NativeFieldInfoPtr_S;

			// Token: 0x0400603D RID: 24637
			private static readonly IntPtr NativeFieldInfoPtr_B;

			// Token: 0x0400603E RID: 24638
			private static readonly IntPtr NativeMethodInfoPtr_get_o_Public_get_Vector3_0;

			// Token: 0x0400603F RID: 24639
			private static readonly IntPtr NativeMethodInfoPtr_get_a_Public_get_Vector3_0;

			// Token: 0x04006040 RID: 24640
			private static readonly IntPtr NativeMethodInfoPtr_get_b_Public_get_Vector3_0;

			// Token: 0x04006041 RID: 24641
			private static readonly IntPtr NativeMethodInfoPtr_get_c_Public_get_Vector3_0;

			// Token: 0x04006042 RID: 24642
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Vector3_Vector3_Vector3_0;

			// Token: 0x04006043 RID: 24643
			private static readonly IntPtr NativeMethodInfoPtr_get_isValid_Public_get_Boolean_0;

			// Token: 0x04006044 RID: 24644
			private static readonly IntPtr NativeMethodInfoPtr_Calculate_Public_Void_0;
		}

		// Token: 0x020004CC RID: 1228
		[Serializable]
		public class LimitPoint : Il2CppSystem.Object
		{
			// Token: 0x06009004 RID: 36868 RVA: 0x0024F688 File Offset: 0x0024D888
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 636071, RefRangeEnd = 636072, XrefRangeStart = 636069, XrefRangeEnd = 636071, 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: 0x06009005 RID: 36869 RVA: 0x0024F6D4 File Offset: 0x0024D8D4
			// 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, 100674376);
			}

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

			// Token: 0x170030D0 RID: 12496
			// (get) Token: 0x06009007 RID: 36871 RVA: 0x0024F73C File Offset: 0x0024D93C
			// (set) Token: 0x06009008 RID: 36872 RVA: 0x0024F764 File Offset: 0x0024D964
			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: 0x170030D1 RID: 12497
			// (get) Token: 0x06009009 RID: 36873 RVA: 0x0024F788 File Offset: 0x0024D988
			// (set) Token: 0x0600900A RID: 36874 RVA: 0x0024F7B0 File Offset: 0x0024D9B0
			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: 0x04006045 RID: 24645
			private static readonly IntPtr NativeFieldInfoPtr_point;

			// Token: 0x04006046 RID: 24646
			private static readonly IntPtr NativeFieldInfoPtr_tangentWeight;

			// Token: 0x04006047 RID: 24647
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}
	}
}