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

namespace RootMotion.FinalIK
{
	// Token: 0x0200047E RID: 1150
	[Serializable]
	public class FBIKChain : Il2CppSystem.Object
	{
		// Token: 0x0600873F RID: 34623 RVA: 0x0022808C File Offset: 0x0022628C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628757, RefRangeEnd = 628758, XrefRangeStart = 628739, XrefRangeEnd = 628757, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe FBIKChain()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008740 RID: 34624 RVA: 0x002280D8 File Offset: 0x002262D8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 628758, XrefRangeEnd = 628797, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe FBIKChain(float pin, float pull, Il2CppReferenceArray<Transform> nodeTransforms = null)
		{
			if (nodeTransforms == null)
			{
				nodeTransforms = new Il2CppReferenceArray<Transform>(0L);
			}
			this..ctor(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr));
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref pin;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pull;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(nodeTransforms);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008741 RID: 34625 RVA: 0x00228178 File Offset: 0x00226378
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 628808, RefRangeEnd = 628813, XrefRangeStart = 628797, XrefRangeEnd = 628808, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetNodes(Il2CppReferenceArray<Transform> boneTransforms = null)
		{
			if (boneTransforms == null)
			{
				boneTransforms = new Il2CppReferenceArray<Transform>(0L);
			}
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(boneTransforms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008742 RID: 34626 RVA: 0x002281E8 File Offset: 0x002263E8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628818, RefRangeEnd = 628819, XrefRangeStart = 628813, XrefRangeEnd = 628818, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe int GetNodeIndex(Transform boneTransform)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(boneTransform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008743 RID: 34627 RVA: 0x00228250 File Offset: 0x00226450
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628829, RefRangeEnd = 628830, XrefRangeStart = 628819, XrefRangeEnd = 628829, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsValid(ref string message)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				ref IntPtr ptr2 = ref *ptr;
				IntPtr intPtr = IL2CPP.ManagedStringToIl2Cpp(message);
				ptr2 = &intPtr;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				message = IL2CPP.Il2CppStringToManaged(intPtr);
				return *IL2CPP.il2cpp_object_unbox(intPtr2);
			}
		}

		// Token: 0x06008744 RID: 34628 RVA: 0x002282D0 File Offset: 0x002264D0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628841, RefRangeEnd = 628842, XrefRangeStart = 628830, XrefRangeEnd = 628841, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Initiate(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008745 RID: 34629 RVA: 0x0022832C File Offset: 0x0022652C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628857, RefRangeEnd = 628858, XrefRangeStart = 628842, XrefRangeEnd = 628857, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ReadPose(IKSolverFullBody solver, bool fullBody)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fullBody;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008746 RID: 34630 RVA: 0x00228398 File Offset: 0x00226598
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 628888, RefRangeEnd = 628890, XrefRangeStart = 628858, XrefRangeEnd = 628888, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void CalculateBoneLengths(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_CalculateBoneLengths_Private_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008747 RID: 34631 RVA: 0x002283F4 File Offset: 0x002265F4
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 628899, RefRangeEnd = 628901, XrefRangeStart = 628890, XrefRangeEnd = 628899, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Reach(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Reach_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008748 RID: 34632 RVA: 0x00228450 File Offset: 0x00226650
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 628906, RefRangeEnd = 628908, XrefRangeStart = 628901, XrefRangeEnd = 628906, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 Push(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Push_Public_Vector3_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008749 RID: 34633 RVA: 0x002284B8 File Offset: 0x002266B8
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 628926, RefRangeEnd = 628930, XrefRangeStart = 628908, XrefRangeEnd = 628926, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveTrigonometric(IKSolverFullBody solver, bool calculateBendDirection = false)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref calculateBendDirection;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveTrigonometric_Public_Void_IKSolverFullBody_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600874A RID: 34634 RVA: 0x00228524 File Offset: 0x00226724
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 628939, RefRangeEnd = 628941, XrefRangeStart = 628930, XrefRangeEnd = 628939, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Stage1(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Stage1_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x0600874B RID: 34635 RVA: 0x00228580 File Offset: 0x00226780
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 628946, RefRangeEnd = 628948, XrefRangeStart = 628941, XrefRangeEnd = 628946, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Stage2(IKSolverFullBody solver, Vector3 position)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref position;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Stage2_Public_Void_IKSolverFullBody_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600874C RID: 34636 RVA: 0x002285EC File Offset: 0x002267EC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628951, RefRangeEnd = 628952, XrefRangeStart = 628948, XrefRangeEnd = 628951, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveConstraintSystems(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveConstraintSystems_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x0600874D RID: 34637 RVA: 0x00228648 File Offset: 0x00226848
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628953, RefRangeEnd = 628954, XrefRangeStart = 628952, XrefRangeEnd = 628953, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 SolveFABRIKJoint(Vector3 pos1, Vector3 pos2, float length)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref pos1;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pos2;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref length;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Vector3_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600874E RID: 34638 RVA: 0x002286D0 File Offset: 0x002268D0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 628954, XrefRangeEnd = 628966, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetDirToBendPoint(Vector3 direction, Vector3 bendDirection, float directionMagnitude)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref direction;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref bendDirection;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref directionMagnitude;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_GetDirToBendPoint_Protected_Vector3_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600874F RID: 34639 RVA: 0x00228758 File Offset: 0x00226958
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628968, RefRangeEnd = 628969, XrefRangeStart = 628966, XrefRangeEnd = 628968, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveChildConstraints(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveChildConstraints_Private_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008750 RID: 34640 RVA: 0x002287B4 File Offset: 0x002269B4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 628969, XrefRangeEnd = 628970, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveLinearConstraint(IKSolver.Node node1, IKSolver.Node node2, float crossFade, float distance)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(node1);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(node2);
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref crossFade;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref distance;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveLinearConstraint_Private_Void_Node_Node_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008751 RID: 34641 RVA: 0x0022884C File Offset: 0x00226A4C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628971, RefRangeEnd = 628972, XrefRangeStart = 628970, XrefRangeEnd = 628971, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ForwardReach(Vector3 position)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref position;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_ForwardReach_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008752 RID: 34642 RVA: 0x002288A0 File Offset: 0x00226AA0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 628975, RefRangeEnd = 628976, XrefRangeStart = 628972, XrefRangeEnd = 628975, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void BackwardReach(Vector3 position)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref position;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_BackwardReach_Private_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008753 RID: 34643 RVA: 0x002288F4 File Offset: 0x00226AF4
		public FBIKChain(float pin, float pull, params Transform[] nodeTransforms)
			: this(pin, pull, new Il2CppReferenceArray<Transform>(nodeTransforms))
		{
		}

		// Token: 0x06008754 RID: 34644 RVA: 0x0022890D File Offset: 0x00226B0D
		public void SetNodes(params Transform[] boneTransforms)
		{
			this.SetNodes(new Il2CppReferenceArray<Transform>(boneTransforms));
		}

		// Token: 0x06008755 RID: 34645 RVA: 0x00228920 File Offset: 0x00226B20
		// Note: this type is marked as 'beforefieldinit'.
		static FBIKChain()
		{
			Il2CppClassPointerStore<FBIKChain>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "FBIKChain");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr);
			FBIKChain.NativeFieldInfoPtr_pin = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pin");
			FBIKChain.NativeFieldInfoPtr_pull = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pull");
			FBIKChain.NativeFieldInfoPtr_push = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "push");
			FBIKChain.NativeFieldInfoPtr_pushParent = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pushParent");
			FBIKChain.NativeFieldInfoPtr_reach = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reach");
			FBIKChain.NativeFieldInfoPtr_reachSmoothing = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reachSmoothing");
			FBIKChain.NativeFieldInfoPtr_pushSmoothing = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pushSmoothing");
			FBIKChain.NativeFieldInfoPtr_nodes = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "nodes");
			FBIKChain.NativeFieldInfoPtr_children = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "children");
			FBIKChain.NativeFieldInfoPtr_childConstraints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "childConstraints");
			FBIKChain.NativeFieldInfoPtr_bendConstraint = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "bendConstraint");
			FBIKChain.NativeFieldInfoPtr_rootLength = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "rootLength");
			FBIKChain.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "initiated");
			FBIKChain.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "length");
			FBIKChain.NativeFieldInfoPtr_distance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "distance");
			FBIKChain.NativeFieldInfoPtr_p = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "p");
			FBIKChain.NativeFieldInfoPtr_reachForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reachForce");
			FBIKChain.NativeFieldInfoPtr_pullParentSum = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pullParentSum");
			FBIKChain.NativeFieldInfoPtr_crossFades = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "crossFades");
			FBIKChain.NativeFieldInfoPtr_sqrMag1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMag1");
			FBIKChain.NativeFieldInfoPtr_sqrMag2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMag2");
			FBIKChain.NativeFieldInfoPtr_sqrMagDif = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMagDif");
			FBIKChain.NativeFieldInfoPtr_maxLimbLength = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "maxLimbLength");
			FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673579);
			FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673580);
			FBIKChain.NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673581);
			FBIKChain.NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673582);
			FBIKChain.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673583);
			FBIKChain.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673584);
			FBIKChain.NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673585);
			FBIKChain.NativeMethodInfoPtr_CalculateBoneLengths_Private_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673586);
			FBIKChain.NativeMethodInfoPtr_Reach_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673587);
			FBIKChain.NativeMethodInfoPtr_Push_Public_Vector3_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673588);
			FBIKChain.NativeMethodInfoPtr_SolveTrigonometric_Public_Void_IKSolverFullBody_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673589);
			FBIKChain.NativeMethodInfoPtr_Stage1_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673590);
			FBIKChain.NativeMethodInfoPtr_Stage2_Public_Void_IKSolverFullBody_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673591);
			FBIKChain.NativeMethodInfoPtr_SolveConstraintSystems_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673592);
			FBIKChain.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673593);
			FBIKChain.NativeMethodInfoPtr_GetDirToBendPoint_Protected_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673594);
			FBIKChain.NativeMethodInfoPtr_SolveChildConstraints_Private_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673595);
			FBIKChain.NativeMethodInfoPtr_SolveLinearConstraint_Private_Void_Node_Node_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673596);
			FBIKChain.NativeMethodInfoPtr_ForwardReach_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673597);
			FBIKChain.NativeMethodInfoPtr_BackwardReach_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100673598);
		}

		// Token: 0x06008756 RID: 34646 RVA: 0x0000A74C File Offset: 0x0000894C
		public FBIKChain(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002DE2 RID: 11746
		// (get) Token: 0x06008757 RID: 34647 RVA: 0x00228CAC File Offset: 0x00226EAC
		// (set) Token: 0x06008758 RID: 34648 RVA: 0x00228CD4 File Offset: 0x00226ED4
		public unsafe float pin
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pin);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pin)) = value;
			}
		}

		// Token: 0x17002DE3 RID: 11747
		// (get) Token: 0x06008759 RID: 34649 RVA: 0x00228CF8 File Offset: 0x00226EF8
		// (set) Token: 0x0600875A RID: 34650 RVA: 0x00228D20 File Offset: 0x00226F20
		public unsafe float pull
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pull);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pull)) = value;
			}
		}

		// Token: 0x17002DE4 RID: 11748
		// (get) Token: 0x0600875B RID: 34651 RVA: 0x00228D44 File Offset: 0x00226F44
		// (set) Token: 0x0600875C RID: 34652 RVA: 0x00228D6C File Offset: 0x00226F6C
		public unsafe float push
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_push);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_push)) = value;
			}
		}

		// Token: 0x17002DE5 RID: 11749
		// (get) Token: 0x0600875D RID: 34653 RVA: 0x00228D90 File Offset: 0x00226F90
		// (set) Token: 0x0600875E RID: 34654 RVA: 0x00228DB8 File Offset: 0x00226FB8
		public unsafe float pushParent
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushParent);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushParent)) = value;
			}
		}

		// Token: 0x17002DE6 RID: 11750
		// (get) Token: 0x0600875F RID: 34655 RVA: 0x00228DDC File Offset: 0x00226FDC
		// (set) Token: 0x06008760 RID: 34656 RVA: 0x00228E04 File Offset: 0x00227004
		public unsafe float reach
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reach);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reach)) = value;
			}
		}

		// Token: 0x17002DE7 RID: 11751
		// (get) Token: 0x06008761 RID: 34657 RVA: 0x00228E28 File Offset: 0x00227028
		// (set) Token: 0x06008762 RID: 34658 RVA: 0x00228E50 File Offset: 0x00227050
		public unsafe FBIKChain.Smoothing reachSmoothing
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachSmoothing);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachSmoothing)) = value;
			}
		}

		// Token: 0x17002DE8 RID: 11752
		// (get) Token: 0x06008763 RID: 34659 RVA: 0x00228E74 File Offset: 0x00227074
		// (set) Token: 0x06008764 RID: 34660 RVA: 0x00228E9C File Offset: 0x0022709C
		public unsafe FBIKChain.Smoothing pushSmoothing
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushSmoothing);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushSmoothing)) = value;
			}
		}

		// Token: 0x17002DE9 RID: 11753
		// (get) Token: 0x06008765 RID: 34661 RVA: 0x00228EC0 File Offset: 0x002270C0
		// (set) Token: 0x06008766 RID: 34662 RVA: 0x00228EF4 File Offset: 0x002270F4
		public unsafe Il2CppReferenceArray<IKSolver.Node> nodes
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_nodes);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolver.Node>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_nodes), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DEA RID: 11754
		// (get) Token: 0x06008767 RID: 34663 RVA: 0x00228F1C File Offset: 0x0022711C
		// (set) Token: 0x06008768 RID: 34664 RVA: 0x00228F50 File Offset: 0x00227150
		public unsafe Il2CppStructArray<int> children
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_children);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<int>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_children), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DEB RID: 11755
		// (get) Token: 0x06008769 RID: 34665 RVA: 0x00228F78 File Offset: 0x00227178
		// (set) Token: 0x0600876A RID: 34666 RVA: 0x00228FAC File Offset: 0x002271AC
		public unsafe Il2CppReferenceArray<FBIKChain.ChildConstraint> childConstraints
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_childConstraints);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<FBIKChain.ChildConstraint>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_childConstraints), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DEC RID: 11756
		// (get) Token: 0x0600876B RID: 34667 RVA: 0x00228FD4 File Offset: 0x002271D4
		// (set) Token: 0x0600876C RID: 34668 RVA: 0x00229008 File Offset: 0x00227208
		public unsafe IKConstraintBend bendConstraint
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_bendConstraint);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKConstraintBend(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_bendConstraint), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DED RID: 11757
		// (get) Token: 0x0600876D RID: 34669 RVA: 0x00229030 File Offset: 0x00227230
		// (set) Token: 0x0600876E RID: 34670 RVA: 0x00229058 File Offset: 0x00227258
		public unsafe float rootLength
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_rootLength);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_rootLength)) = value;
			}
		}

		// Token: 0x17002DEE RID: 11758
		// (get) Token: 0x0600876F RID: 34671 RVA: 0x0022907C File Offset: 0x0022727C
		// (set) Token: 0x06008770 RID: 34672 RVA: 0x002290A4 File Offset: 0x002272A4
		public unsafe bool initiated
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_initiated);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_initiated)) = value;
			}
		}

		// Token: 0x17002DEF RID: 11759
		// (get) Token: 0x06008771 RID: 34673 RVA: 0x002290C8 File Offset: 0x002272C8
		// (set) Token: 0x06008772 RID: 34674 RVA: 0x002290F0 File Offset: 0x002272F0
		public unsafe float length
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_length);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_length)) = value;
			}
		}

		// Token: 0x17002DF0 RID: 11760
		// (get) Token: 0x06008773 RID: 34675 RVA: 0x00229114 File Offset: 0x00227314
		// (set) Token: 0x06008774 RID: 34676 RVA: 0x0022913C File Offset: 0x0022733C
		public unsafe float distance
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_distance);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_distance)) = value;
			}
		}

		// Token: 0x17002DF1 RID: 11761
		// (get) Token: 0x06008775 RID: 34677 RVA: 0x00229160 File Offset: 0x00227360
		// (set) Token: 0x06008776 RID: 34678 RVA: 0x00229194 File Offset: 0x00227394
		public unsafe IKSolver.Point p
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_p);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.Point(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_p), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DF2 RID: 11762
		// (get) Token: 0x06008777 RID: 34679 RVA: 0x002291BC File Offset: 0x002273BC
		// (set) Token: 0x06008778 RID: 34680 RVA: 0x002291E4 File Offset: 0x002273E4
		public unsafe float reachForce
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachForce);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachForce)) = value;
			}
		}

		// Token: 0x17002DF3 RID: 11763
		// (get) Token: 0x06008779 RID: 34681 RVA: 0x00229208 File Offset: 0x00227408
		// (set) Token: 0x0600877A RID: 34682 RVA: 0x00229230 File Offset: 0x00227430
		public unsafe float pullParentSum
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pullParentSum);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pullParentSum)) = value;
			}
		}

		// Token: 0x17002DF4 RID: 11764
		// (get) Token: 0x0600877B RID: 34683 RVA: 0x00229254 File Offset: 0x00227454
		// (set) Token: 0x0600877C RID: 34684 RVA: 0x00229288 File Offset: 0x00227488
		public unsafe Il2CppStructArray<float> crossFades
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_crossFades);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<float>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_crossFades), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002DF5 RID: 11765
		// (get) Token: 0x0600877D RID: 34685 RVA: 0x002292B0 File Offset: 0x002274B0
		// (set) Token: 0x0600877E RID: 34686 RVA: 0x002292D8 File Offset: 0x002274D8
		public unsafe float sqrMag1
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag1);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag1)) = value;
			}
		}

		// Token: 0x17002DF6 RID: 11766
		// (get) Token: 0x0600877F RID: 34687 RVA: 0x002292FC File Offset: 0x002274FC
		// (set) Token: 0x06008780 RID: 34688 RVA: 0x00229324 File Offset: 0x00227524
		public unsafe float sqrMag2
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag2);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag2)) = value;
			}
		}

		// Token: 0x17002DF7 RID: 11767
		// (get) Token: 0x06008781 RID: 34689 RVA: 0x00229348 File Offset: 0x00227548
		// (set) Token: 0x06008782 RID: 34690 RVA: 0x00229370 File Offset: 0x00227570
		public unsafe float sqrMagDif
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMagDif);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMagDif)) = value;
			}
		}

		// Token: 0x17002DF8 RID: 11768
		// (get) Token: 0x06008783 RID: 34691 RVA: 0x00229394 File Offset: 0x00227594
		// (set) Token: 0x06008784 RID: 34692 RVA: 0x002293B2 File Offset: 0x002275B2
		public unsafe static float maxLimbLength
		{
			get
			{
				float num;
				IL2CPP.il2cpp_field_static_get_value(FBIKChain.NativeFieldInfoPtr_maxLimbLength, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(FBIKChain.NativeFieldInfoPtr_maxLimbLength, (void*)(&value));
			}
		}

		// Token: 0x04005A5F RID: 23135
		private static readonly IntPtr NativeFieldInfoPtr_pin;

		// Token: 0x04005A60 RID: 23136
		private static readonly IntPtr NativeFieldInfoPtr_pull;

		// Token: 0x04005A61 RID: 23137
		private static readonly IntPtr NativeFieldInfoPtr_push;

		// Token: 0x04005A62 RID: 23138
		private static readonly IntPtr NativeFieldInfoPtr_pushParent;

		// Token: 0x04005A63 RID: 23139
		private static readonly IntPtr NativeFieldInfoPtr_reach;

		// Token: 0x04005A64 RID: 23140
		private static readonly IntPtr NativeFieldInfoPtr_reachSmoothing;

		// Token: 0x04005A65 RID: 23141
		private static readonly IntPtr NativeFieldInfoPtr_pushSmoothing;

		// Token: 0x04005A66 RID: 23142
		private static readonly IntPtr NativeFieldInfoPtr_nodes;

		// Token: 0x04005A67 RID: 23143
		private static readonly IntPtr NativeFieldInfoPtr_children;

		// Token: 0x04005A68 RID: 23144
		private static readonly IntPtr NativeFieldInfoPtr_childConstraints;

		// Token: 0x04005A69 RID: 23145
		private static readonly IntPtr NativeFieldInfoPtr_bendConstraint;

		// Token: 0x04005A6A RID: 23146
		private static readonly IntPtr NativeFieldInfoPtr_rootLength;

		// Token: 0x04005A6B RID: 23147
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x04005A6C RID: 23148
		private static readonly IntPtr NativeFieldInfoPtr_length;

		// Token: 0x04005A6D RID: 23149
		private static readonly IntPtr NativeFieldInfoPtr_distance;

		// Token: 0x04005A6E RID: 23150
		private static readonly IntPtr NativeFieldInfoPtr_p;

		// Token: 0x04005A6F RID: 23151
		private static readonly IntPtr NativeFieldInfoPtr_reachForce;

		// Token: 0x04005A70 RID: 23152
		private static readonly IntPtr NativeFieldInfoPtr_pullParentSum;

		// Token: 0x04005A71 RID: 23153
		private static readonly IntPtr NativeFieldInfoPtr_crossFades;

		// Token: 0x04005A72 RID: 23154
		private static readonly IntPtr NativeFieldInfoPtr_sqrMag1;

		// Token: 0x04005A73 RID: 23155
		private static readonly IntPtr NativeFieldInfoPtr_sqrMag2;

		// Token: 0x04005A74 RID: 23156
		private static readonly IntPtr NativeFieldInfoPtr_sqrMagDif;

		// Token: 0x04005A75 RID: 23157
		private static readonly IntPtr NativeFieldInfoPtr_maxLimbLength;

		// Token: 0x04005A76 RID: 23158
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x04005A77 RID: 23159
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x04005A78 RID: 23160
		private static readonly IntPtr NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x04005A79 RID: 23161
		private static readonly IntPtr NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0;

		// Token: 0x04005A7A RID: 23162
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0;

		// Token: 0x04005A7B RID: 23163
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0;

		// Token: 0x04005A7C RID: 23164
		private static readonly IntPtr NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x0200047F RID: 1151
		[Serializable]
		public class ChildConstraint : Il2CppSystem.Object
		{
			// Token: 0x17002E03 RID: 11779
			// (get) Token: 0x06008785 RID: 34693 RVA: 0x002293C4 File Offset: 0x002275C4
			// (set) Token: 0x06008786 RID: 34694 RVA: 0x00229414 File Offset: 0x00227614
			public unsafe float nominalDistance
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_nominalDistance_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 225930, RefRangeEnd = 225932, XrefRangeStart = 225930, XrefRangeEnd = 225932, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_nominalDistance_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002E04 RID: 11780
			// (get) Token: 0x06008787 RID: 34695 RVA: 0x00229468 File Offset: 0x00227668
			// (set) Token: 0x06008788 RID: 34696 RVA: 0x002294B8 File Offset: 0x002276B8
			public unsafe bool isRigid
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_isRigid_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_isRigid_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008789 RID: 34697 RVA: 0x0022950C File Offset: 0x0022770C
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 628719, RefRangeEnd = 628723, XrefRangeStart = 628716, XrefRangeEnd = 628719, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe ChildConstraint(Transform bone1, Transform bone2, float pushElasticity = 0f, float pullElasticity = 0f)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bone1);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bone2);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pushElasticity;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pullElasticity;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr__ctor_Public_Void_Transform_Transform_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600878A RID: 34698 RVA: 0x002295AC File Offset: 0x002277AC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 628727, RefRangeEnd = 628728, XrefRangeStart = 628723, XrefRangeEnd = 628727, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Initiate(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600878B RID: 34699 RVA: 0x00229608 File Offset: 0x00227808
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 628733, RefRangeEnd = 628735, XrefRangeStart = 628728, XrefRangeEnd = 628733, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void OnPreSolve(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_OnPreSolve_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600878C RID: 34700 RVA: 0x00229664 File Offset: 0x00227864
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 628737, RefRangeEnd = 628739, XrefRangeStart = 628735, XrefRangeEnd = 628737, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_Solve_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600878D RID: 34701 RVA: 0x002296C0 File Offset: 0x002278C0
			// Note: this type is marked as 'beforefieldinit'.
			static ChildConstraint()
			{
				Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "ChildConstraint");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr);
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "pushElasticity");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "pullElasticity");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "bone1");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "bone2");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "<nominalDistance>k__BackingField");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "<isRigid>k__BackingField");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "crossFade");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "inverseCrossFade");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "chain1Index");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "chain2Index");
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_nominalDistance_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673599);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_nominalDistance_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673600);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_isRigid_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673601);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_isRigid_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673602);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr__ctor_Public_Void_Transform_Transform_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673603);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673604);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_OnPreSolve_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673605);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_Solve_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100673606);
			}

			// Token: 0x0600878E RID: 34702 RVA: 0x0000A74C File Offset: 0x0000894C
			public ChildConstraint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002DF9 RID: 11769
			// (get) Token: 0x0600878F RID: 34703 RVA: 0x00229854 File Offset: 0x00227A54
			// (set) Token: 0x06008790 RID: 34704 RVA: 0x0022987C File Offset: 0x00227A7C
			public unsafe float pushElasticity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity)) = value;
				}
			}

			// Token: 0x17002DFA RID: 11770
			// (get) Token: 0x06008791 RID: 34705 RVA: 0x002298A0 File Offset: 0x00227AA0
			// (set) Token: 0x06008792 RID: 34706 RVA: 0x002298C8 File Offset: 0x00227AC8
			public unsafe float pullElasticity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity)) = value;
				}
			}

			// Token: 0x17002DFB RID: 11771
			// (get) Token: 0x06008793 RID: 34707 RVA: 0x002298EC File Offset: 0x00227AEC
			// (set) Token: 0x06008794 RID: 34708 RVA: 0x00229920 File Offset: 0x00227B20
			public unsafe Transform bone1
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002DFC RID: 11772
			// (get) Token: 0x06008795 RID: 34709 RVA: 0x00229948 File Offset: 0x00227B48
			// (set) Token: 0x06008796 RID: 34710 RVA: 0x0022997C File Offset: 0x00227B7C
			public unsafe Transform bone2
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002DFD RID: 11773
			// (get) Token: 0x06008797 RID: 34711 RVA: 0x002299A4 File Offset: 0x00227BA4
			// (set) Token: 0x06008798 RID: 34712 RVA: 0x002299CC File Offset: 0x00227BCC
			public unsafe float _nominalDistance_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField)) = value;
				}
			}

			// Token: 0x17002DFE RID: 11774
			// (get) Token: 0x06008799 RID: 34713 RVA: 0x002299F0 File Offset: 0x00227BF0
			// (set) Token: 0x0600879A RID: 34714 RVA: 0x00229A18 File Offset: 0x00227C18
			public unsafe bool _isRigid_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField)) = value;
				}
			}

			// Token: 0x17002DFF RID: 11775
			// (get) Token: 0x0600879B RID: 34715 RVA: 0x00229A3C File Offset: 0x00227C3C
			// (set) Token: 0x0600879C RID: 34716 RVA: 0x00229A64 File Offset: 0x00227C64
			public unsafe float crossFade
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade)) = value;
				}
			}

			// Token: 0x17002E00 RID: 11776
			// (get) Token: 0x0600879D RID: 34717 RVA: 0x00229A88 File Offset: 0x00227C88
			// (set) Token: 0x0600879E RID: 34718 RVA: 0x00229AB0 File Offset: 0x00227CB0
			public unsafe float inverseCrossFade
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade)) = value;
				}
			}

			// Token: 0x17002E01 RID: 11777
			// (get) Token: 0x0600879F RID: 34719 RVA: 0x00229AD4 File Offset: 0x00227CD4
			// (set) Token: 0x060087A0 RID: 34720 RVA: 0x00229AFC File Offset: 0x00227CFC
			public unsafe int chain1Index
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index)) = value;
				}
			}

			// Token: 0x17002E02 RID: 11778
			// (get) Token: 0x060087A1 RID: 34721 RVA: 0x00229B20 File Offset: 0x00227D20
			// (set) Token: 0x060087A2 RID: 34722 RVA: 0x00229B48 File Offset: 0x00227D48
			public unsafe int chain2Index
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index)) = value;
				}
			}

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

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

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

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

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

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

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

			// Token: 0x04005A91 RID: 23185
			private static readonly IntPtr NativeFieldInfoPtr_inverseCrossFade;

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

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

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

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

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

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

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

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

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

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

		// Token: 0x02000480 RID: 1152
		[Serializable]
		public enum Smoothing
		{
			// Token: 0x04005A9D RID: 23197
			None,
			// Token: 0x04005A9E RID: 23198
			Exponential,
			// Token: 0x04005A9F RID: 23199
			Cubic
		}
	}
}
