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

// Token: 0x020000B8 RID: 184
public class LockPointsManager : Il2CppSystem.Object
{
	// Token: 0x06001472 RID: 5234 RVA: 0x000589BC File Offset: 0x00056BBC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509201, RefRangeEnd = 509202, XrefRangeStart = 509168, XrefRangeEnd = 509201, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Init()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_Init_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001473 RID: 5235 RVA: 0x00058A00 File Offset: 0x00056C00
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509206, RefRangeEnd = 509207, XrefRangeStart = 509202, XrefRangeEnd = 509206, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AddLockPoints(Il2CppReferenceArray<LockPoint> lockPointArr)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPointArr);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001474 RID: 5236 RVA: 0x00058A5C File Offset: 0x00056C5C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509207, XrefRangeEnd = 509208, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe int GetLockPointsCount()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001475 RID: 5237 RVA: 0x00058AAC File Offset: 0x00056CAC
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 509211, RefRangeEnd = 509232, XrefRangeStart = 509208, XrefRangeEnd = 509211, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockPoint(int i)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref i;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x06001476 RID: 5238 RVA: 0x00058B14 File Offset: 0x00056D14
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509237, RefRangeEnd = 509238, XrefRangeStart = 509232, XrefRangeEnd = 509237, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockPoint(LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x06001477 RID: 5239 RVA: 0x00058B84 File Offset: 0x00056D84
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509252, RefRangeEnd = 509253, XrefRangeStart = 509238, XrefRangeEnd = 509252, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LockReset()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_LockReset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001478 RID: 5240 RVA: 0x00058BC8 File Offset: 0x00056DC8
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 509254, RefRangeEnd = 509262, XrefRangeStart = 509253, XrefRangeEnd = 509254, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe int GetLockedOnPointsCount()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001479 RID: 5241 RVA: 0x00058C18 File Offset: 0x00056E18
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509272, RefRangeEnd = 509273, XrefRangeStart = 509262, XrefRangeEnd = 509272, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Il2CppReferenceArray<Transform> GetLockedOnTargetArray()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Il2CppReferenceArray<Transform>(intPtr3) : null;
	}

	// Token: 0x0600147A RID: 5242 RVA: 0x00058C70 File Offset: 0x00056E70
	[CallerCount(0)]
	public unsafe void SetPerspectiveLockEnabled(bool isEnabled)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isEnabled;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600147B RID: 5243 RVA: 0x00058CC4 File Offset: 0x00056EC4
	[CallerCount(0)]
	public unsafe bool GetPerspectiveLockEnabled()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600147C RID: 5244 RVA: 0x00058D14 File Offset: 0x00056F14
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 11311, RefRangeEnd = 11312, XrefRangeStart = 11311, XrefRangeEnd = 11312, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetPerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
	}

	// Token: 0x0600147D RID: 5245 RVA: 0x00058D6C File Offset: 0x00056F6C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509274, RefRangeEnd = 509276, XrefRangeStart = 509273, XrefRangeEnd = 509274, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ClearPerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600147E RID: 5246 RVA: 0x00058DB0 File Offset: 0x00056FB0
	[CallerCount(0)]
	public unsafe float GetPerspectiveLockDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600147F RID: 5247 RVA: 0x00058E00 File Offset: 0x00057000
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 225977, RefRangeEnd = 225978, XrefRangeStart = 225977, XrefRangeEnd = 225978, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetPerspectiveLockDistance(float lockDistance)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref lockDistance;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001480 RID: 5248 RVA: 0x00058E54 File Offset: 0x00057054
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509276, RefRangeEnd = 509278, XrefRangeStart = 509276, XrefRangeEnd = 509276, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DefaultPerspectiveLockDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001481 RID: 5249 RVA: 0x00058E98 File Offset: 0x00057098
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 509296, RefRangeEnd = 509300, XrefRangeStart = 509278, XrefRangeEnd = 509296, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CancelLock()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_CancelLock_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001482 RID: 5250 RVA: 0x00058EDC File Offset: 0x000570DC
	[CallerCount(0)]
	public unsafe void SetAimPointEnabled(bool isEnabled)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isEnabled;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001483 RID: 5251 RVA: 0x00058F30 File Offset: 0x00057130
	[CallerCount(0)]
	public unsafe bool GetAimPointEnabled()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001484 RID: 5252 RVA: 0x00058F80 File Offset: 0x00057180
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509392, RefRangeEnd = 509393, XrefRangeStart = 509300, XrefRangeEnd = 509392, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateLockedOnPoint()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001485 RID: 5253 RVA: 0x00058FC4 File Offset: 0x000571C4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509421, RefRangeEnd = 509423, XrefRangeStart = 509393, XrefRangeEnd = 509421, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AutoLockNearby(Vector3 v3PlayerPos, float fDistance)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3PlayerPos;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fDistance;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001486 RID: 5254 RVA: 0x0005902C File Offset: 0x0005722C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509432, RefRangeEnd = 509433, XrefRangeStart = 509423, XrefRangeEnd = 509432, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Transform GetClosest()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetClosest_Public_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Transform(intPtr3) : null;
	}

	// Token: 0x06001487 RID: 5255 RVA: 0x00059084 File Offset: 0x00057284
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509474, RefRangeEnd = 509475, XrefRangeStart = 509433, XrefRangeEnd = 509474, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SwitchPerspectiveLockTarget(Vector2 direction, Vector2 rootPosition)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref direction;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootPosition;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001488 RID: 5256 RVA: 0x000590EC File Offset: 0x000572EC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509495, RefRangeEnd = 509496, XrefRangeStart = 509475, XrefRangeEnd = 509495, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool TryUpdatePerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001489 RID: 5257 RVA: 0x0005913C File Offset: 0x0005733C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509498, RefRangeEnd = 509500, XrefRangeStart = 509496, XrefRangeEnd = 509498, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateMagicLockMax(PlayerEffectPlay.Magic magicType)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref magicType;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600148A RID: 5258 RVA: 0x00059190 File Offset: 0x00057390
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509508, RefRangeEnd = 509510, XrefRangeStart = 509500, XrefRangeEnd = 509508, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetIceLockNumMax()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600148B RID: 5259 RVA: 0x000591D4 File Offset: 0x000573D4
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 509534, RefRangeEnd = 509539, XrefRangeStart = 509510, XrefRangeEnd = 509534, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool TryGetDistanceLockData(int index, LockPointsManager.LockSetupData lockSetupData, out LockPointsManager.LockResultData lockResultData)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lockSetupData;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &lockResultData;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600148C RID: 5260 RVA: 0x00059260 File Offset: 0x00057460
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509543, RefRangeEnd = 509545, XrefRangeStart = 509539, XrefRangeEnd = 509543, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AddLockedOnPoint(LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600148D RID: 5261 RVA: 0x000592BC File Offset: 0x000574BC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509549, RefRangeEnd = 509551, XrefRangeStart = 509545, XrefRangeEnd = 509549, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetLockedOnPoint(int index, LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600148E RID: 5262 RVA: 0x00059328 File Offset: 0x00057528
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509571, RefRangeEnd = 509573, XrefRangeStart = 509551, XrefRangeEnd = 509571, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void RemoveLockedOnPoint(int index)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600148F RID: 5263 RVA: 0x0005937C File Offset: 0x0005757C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509575, RefRangeEnd = 509577, XrefRangeStart = 509573, XrefRangeEnd = 509575, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockedOnPoint(int index)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x06001490 RID: 5264 RVA: 0x000593E4 File Offset: 0x000575E4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509577, XrefRangeEnd = 509581, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ClearLockedOnPoints()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001491 RID: 5265 RVA: 0x00059428 File Offset: 0x00057628
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509581, XrefRangeEnd = 509593, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void RefreshLockedOnPoints()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001492 RID: 5266 RVA: 0x0005946C File Offset: 0x0005766C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509594, RefRangeEnd = 509595, XrefRangeStart = 509593, XrefRangeEnd = 509594, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPointsManager()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001493 RID: 5267 RVA: 0x000594B8 File Offset: 0x000576B8
	// Note: this type is marked as 'beforefieldinit'.
	static LockPointsManager()
	{
		Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "LockPointsManager");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr);
		LockPointsManager.NativeFieldInfoPtr_lockPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockPoints");
		LockPointsManager.NativeFieldInfoPtr_lockedOnPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockedOnPoints");
		LockPointsManager.NativeFieldInfoPtr_lockMask = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockMask");
		LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "isAimPointEnabled");
		LockPointsManager.NativeFieldInfoPtr_lockWaitDelta = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockWaitDelta");
		LockPointsManager.NativeFieldInfoPtr_lockWaitValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockWaitValue");
		LockPointsManager.NativeFieldInfoPtr_magicLockMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "magicLockMax");
		LockPointsManager.NativeFieldInfoPtr_iceLockRange = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "iceLockRange");
		LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "iceLockWorldRange");
		LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "isPerspectiveLockEnabled");
		LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "perspectiveLockTarget");
		LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "PERSPECTIVE_LOCK_DISTANCE");
		LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "perspectiveLockDistance");
		LockPointsManager.NativeMethodInfoPtr_Init_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665240);
		LockPointsManager.NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665241);
		LockPointsManager.NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665242);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665243);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665244);
		LockPointsManager.NativeMethodInfoPtr_LockReset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665245);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665246);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665247);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665248);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665249);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665250);
		LockPointsManager.NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665251);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665252);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665253);
		LockPointsManager.NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665254);
		LockPointsManager.NativeMethodInfoPtr_CancelLock_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665255);
		LockPointsManager.NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665256);
		LockPointsManager.NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665257);
		LockPointsManager.NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665258);
		LockPointsManager.NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665259);
		LockPointsManager.NativeMethodInfoPtr_GetClosest_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665260);
		LockPointsManager.NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665261);
		LockPointsManager.NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665262);
		LockPointsManager.NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665263);
		LockPointsManager.NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665264);
		LockPointsManager.NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665265);
		LockPointsManager.NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665266);
		LockPointsManager.NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665267);
		LockPointsManager.NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665268);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665269);
		LockPointsManager.NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665270);
		LockPointsManager.NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665271);
		LockPointsManager.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665272);
	}

	// Token: 0x06001494 RID: 5268 RVA: 0x0000A74C File Offset: 0x0000894C
	public LockPointsManager(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x17000618 RID: 1560
	// (get) Token: 0x06001495 RID: 5269 RVA: 0x00059880 File Offset: 0x00057A80
	// (set) Token: 0x06001496 RID: 5270 RVA: 0x000598B4 File Offset: 0x00057AB4
	public unsafe List<LockPoint> lockPoints
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockPoints);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LockPoint>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000619 RID: 1561
	// (get) Token: 0x06001497 RID: 5271 RVA: 0x000598DC File Offset: 0x00057ADC
	// (set) Token: 0x06001498 RID: 5272 RVA: 0x00059910 File Offset: 0x00057B10
	public unsafe List<LockPoint> lockedOnPoints
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockedOnPoints);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LockPoint>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockedOnPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x1700061A RID: 1562
	// (get) Token: 0x06001499 RID: 5273 RVA: 0x00059938 File Offset: 0x00057B38
	// (set) Token: 0x0600149A RID: 5274 RVA: 0x00059960 File Offset: 0x00057B60
	public unsafe LayerMask lockMask
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockMask);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockMask)) = value;
		}
	}

	// Token: 0x1700061B RID: 1563
	// (get) Token: 0x0600149B RID: 5275 RVA: 0x00059984 File Offset: 0x00057B84
	// (set) Token: 0x0600149C RID: 5276 RVA: 0x000599AC File Offset: 0x00057BAC
	public unsafe bool isAimPointEnabled
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled)) = value;
		}
	}

	// Token: 0x1700061C RID: 1564
	// (get) Token: 0x0600149D RID: 5277 RVA: 0x000599D0 File Offset: 0x00057BD0
	// (set) Token: 0x0600149E RID: 5278 RVA: 0x000599F8 File Offset: 0x00057BF8
	public unsafe float lockWaitDelta
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitDelta);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitDelta)) = value;
		}
	}

	// Token: 0x1700061D RID: 1565
	// (get) Token: 0x0600149F RID: 5279 RVA: 0x00059A1C File Offset: 0x00057C1C
	// (set) Token: 0x060014A0 RID: 5280 RVA: 0x00059A44 File Offset: 0x00057C44
	public unsafe float lockWaitValue
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitValue);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitValue)) = value;
		}
	}

	// Token: 0x1700061E RID: 1566
	// (get) Token: 0x060014A1 RID: 5281 RVA: 0x00059A68 File Offset: 0x00057C68
	// (set) Token: 0x060014A2 RID: 5282 RVA: 0x00059A90 File Offset: 0x00057C90
	public unsafe int magicLockMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_magicLockMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_magicLockMax)) = value;
		}
	}

	// Token: 0x1700061F RID: 1567
	// (get) Token: 0x060014A3 RID: 5283 RVA: 0x00059AB4 File Offset: 0x00057CB4
	// (set) Token: 0x060014A4 RID: 5284 RVA: 0x00059ADC File Offset: 0x00057CDC
	public unsafe float iceLockRange
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockRange);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockRange)) = value;
		}
	}

	// Token: 0x17000620 RID: 1568
	// (get) Token: 0x060014A5 RID: 5285 RVA: 0x00059B00 File Offset: 0x00057D00
	// (set) Token: 0x060014A6 RID: 5286 RVA: 0x00059B28 File Offset: 0x00057D28
	public unsafe float iceLockWorldRange
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange)) = value;
		}
	}

	// Token: 0x17000621 RID: 1569
	// (get) Token: 0x060014A7 RID: 5287 RVA: 0x00059B4C File Offset: 0x00057D4C
	// (set) Token: 0x060014A8 RID: 5288 RVA: 0x00059B74 File Offset: 0x00057D74
	public unsafe bool isPerspectiveLockEnabled
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled)) = value;
		}
	}

	// Token: 0x17000622 RID: 1570
	// (get) Token: 0x060014A9 RID: 5289 RVA: 0x00059B98 File Offset: 0x00057D98
	// (set) Token: 0x060014AA RID: 5290 RVA: 0x00059BCC File Offset: 0x00057DCC
	public unsafe LockPoint perspectiveLockTarget
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new LockPoint(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000623 RID: 1571
	// (get) Token: 0x060014AB RID: 5291 RVA: 0x00059BF4 File Offset: 0x00057DF4
	// (set) Token: 0x060014AC RID: 5292 RVA: 0x00059C12 File Offset: 0x00057E12
	public unsafe static float PERSPECTIVE_LOCK_DISTANCE
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE, (void*)(&value));
		}
	}

	// Token: 0x17000624 RID: 1572
	// (get) Token: 0x060014AD RID: 5293 RVA: 0x00059C24 File Offset: 0x00057E24
	// (set) Token: 0x060014AE RID: 5294 RVA: 0x00059C4C File Offset: 0x00057E4C
	public unsafe float perspectiveLockDistance
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance)) = value;
		}
	}

	// Token: 0x04000FFD RID: 4093
	private static readonly IntPtr NativeFieldInfoPtr_lockPoints;

	// Token: 0x04000FFE RID: 4094
	private static readonly IntPtr NativeFieldInfoPtr_lockedOnPoints;

	// Token: 0x04000FFF RID: 4095
	private static readonly IntPtr NativeFieldInfoPtr_lockMask;

	// Token: 0x04001000 RID: 4096
	private static readonly IntPtr NativeFieldInfoPtr_isAimPointEnabled;

	// Token: 0x04001001 RID: 4097
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitDelta;

	// Token: 0x04001002 RID: 4098
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitValue;

	// Token: 0x04001003 RID: 4099
	private static readonly IntPtr NativeFieldInfoPtr_magicLockMax;

	// Token: 0x04001004 RID: 4100
	private static readonly IntPtr NativeFieldInfoPtr_iceLockRange;

	// Token: 0x04001005 RID: 4101
	private static readonly IntPtr NativeFieldInfoPtr_iceLockWorldRange;

	// Token: 0x04001006 RID: 4102
	private static readonly IntPtr NativeFieldInfoPtr_isPerspectiveLockEnabled;

	// Token: 0x04001007 RID: 4103
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockTarget;

	// Token: 0x04001008 RID: 4104
	private static readonly IntPtr NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE;

	// Token: 0x04001009 RID: 4105
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockDistance;

	// Token: 0x0400100A RID: 4106
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_0;

	// Token: 0x0400100B RID: 4107
	private static readonly IntPtr NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0;

	// Token: 0x0400100C RID: 4108
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0;

	// Token: 0x0400100D RID: 4109
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0;

	// Token: 0x0400100E RID: 4110
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0;

	// Token: 0x0400100F RID: 4111
	private static readonly IntPtr NativeMethodInfoPtr_LockReset_Public_Void_0;

	// Token: 0x04001010 RID: 4112
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0;

	// Token: 0x04001011 RID: 4113
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0;

	// Token: 0x04001012 RID: 4114
	private static readonly IntPtr NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0;

	// Token: 0x04001013 RID: 4115
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0;

	// Token: 0x04001014 RID: 4116
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0;

	// Token: 0x04001015 RID: 4117
	private static readonly IntPtr NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0;

	// Token: 0x04001016 RID: 4118
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0;

	// Token: 0x04001017 RID: 4119
	private static readonly IntPtr NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0;

	// Token: 0x04001018 RID: 4120
	private static readonly IntPtr NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0;

	// Token: 0x04001019 RID: 4121
	private static readonly IntPtr NativeMethodInfoPtr_CancelLock_Public_Void_0;

	// Token: 0x0400101A RID: 4122
	private static readonly IntPtr NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0;

	// Token: 0x0400101B RID: 4123
	private static readonly IntPtr NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0;

	// Token: 0x0400101C RID: 4124
	private static readonly IntPtr NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0;

	// Token: 0x0400101D RID: 4125
	private static readonly IntPtr NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0;

	// Token: 0x0400101E RID: 4126
	private static readonly IntPtr NativeMethodInfoPtr_GetClosest_Public_Transform_0;

	// Token: 0x0400101F RID: 4127
	private static readonly IntPtr NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0;

	// Token: 0x04001020 RID: 4128
	private static readonly IntPtr NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0;

	// Token: 0x04001021 RID: 4129
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0;

	// Token: 0x04001022 RID: 4130
	private static readonly IntPtr NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0;

	// Token: 0x04001023 RID: 4131
	private static readonly IntPtr NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0;

	// Token: 0x04001024 RID: 4132
	private static readonly IntPtr NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0;

	// Token: 0x04001025 RID: 4133
	private static readonly IntPtr NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0;

	// Token: 0x04001026 RID: 4134
	private static readonly IntPtr NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0;

	// Token: 0x04001027 RID: 4135
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0;

	// Token: 0x04001028 RID: 4136
	private static readonly IntPtr NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0;

	// Token: 0x04001029 RID: 4137
	private static readonly IntPtr NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0;

	// Token: 0x0400102A RID: 4138
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

	// Token: 0x020000B9 RID: 185
	[StructLayout(2)]
	public struct LockSetupData
	{
		// Token: 0x17000625 RID: 1573
		// (get) Token: 0x060014AF RID: 5295 RVA: 0x00059C70 File Offset: 0x00057E70
		public unsafe static LockPointsManager.LockSetupData Default
		{
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 509163, RefRangeEnd = 509168, XrefRangeStart = 509153, XrefRangeEnd = 509163, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.LockSetupData.NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x060014B0 RID: 5296 RVA: 0x00059CB4 File Offset: 0x00057EB4
		// Note: this type is marked as 'beforefieldinit'.
		static LockSetupData()
		{
			Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "LockSetupData");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr);
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_PlayerCamPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "PlayerCamPos");
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_PlayerPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "PlayerPos");
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_ScreenCentre = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "ScreenCentre");
			LockPointsManager.LockSetupData.NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, 100665273);
		}

		// Token: 0x060014B1 RID: 5297 RVA: 0x00059D2F File Offset: 0x00057F2F
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, ref this));
		}

		// Token: 0x0400102B RID: 4139
		private static readonly IntPtr NativeFieldInfoPtr_PlayerCamPos;

		// Token: 0x0400102C RID: 4140
		private static readonly IntPtr NativeFieldInfoPtr_PlayerPos;

		// Token: 0x0400102D RID: 4141
		private static readonly IntPtr NativeFieldInfoPtr_ScreenCentre;

		// Token: 0x0400102E RID: 4142
		private static readonly IntPtr NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0;

		// Token: 0x0400102F RID: 4143
		[FieldOffset(0)]
		public Vector3 PlayerCamPos;

		// Token: 0x04001030 RID: 4144
		[FieldOffset(12)]
		public Vector3 PlayerPos;

		// Token: 0x04001031 RID: 4145
		[FieldOffset(24)]
		public Vector3 ScreenCentre;
	}

	// Token: 0x020000BA RID: 186
	[StructLayout(2)]
	public struct LockResultData
	{
		// Token: 0x060014B2 RID: 5298 RVA: 0x00059D44 File Offset: 0x00057F44
		// Note: this type is marked as 'beforefieldinit'.
		static LockResultData()
		{
			Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "LockResultData");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr);
			LockPointsManager.LockResultData.NativeFieldInfoPtr_WorldDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "WorldDistance");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_ScreenPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "ScreenPos");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_ScreenDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "ScreenDistance");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_PlayerDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "PlayerDistance");
		}

		// Token: 0x060014B3 RID: 5299 RVA: 0x00059DBF File Offset: 0x00057FBF
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, ref this));
		}

		// Token: 0x04001032 RID: 4146
		private static readonly IntPtr NativeFieldInfoPtr_WorldDistance;

		// Token: 0x04001033 RID: 4147
		private static readonly IntPtr NativeFieldInfoPtr_ScreenPos;

		// Token: 0x04001034 RID: 4148
		private static readonly IntPtr NativeFieldInfoPtr_ScreenDistance;

		// Token: 0x04001035 RID: 4149
		private static readonly IntPtr NativeFieldInfoPtr_PlayerDistance;

		// Token: 0x04001036 RID: 4150
		[FieldOffset(0)]
		public float WorldDistance;

		// Token: 0x04001037 RID: 4151
		[FieldOffset(4)]
		public Vector3 ScreenPos;

		// Token: 0x04001038 RID: 4152
		[FieldOffset(16)]
		public float ScreenDistance;

		// Token: 0x04001039 RID: 4153
		[FieldOffset(20)]
		public float PlayerDistance;
	}
}