using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("quaternion")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Configurable H3VR quickbelt slots attached below each hand.")]
[assembly: AssemblyFileVersion("0.4.2.0")]
[assembly: AssemblyInformationalVersion("0.4.2")]
[assembly: AssemblyProduct("quaternion.hqb")]
[assembly: AssemblyTitle("Hand Quickbelts")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.2.0")]
[module: UnverifiableCode]
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace HandQuickbelts
{
	internal sealed class HandQuickbeltController
	{
		private const float MillimetersToMeters = 0.001f;

		private readonly List<FVRQuickBeltSlot> _slots = new List<FVRQuickBeltSlot>();

		private readonly List<FVRQuickBeltSlot> _leftSlots = new List<FVRQuickBeltSlot>();

		private readonly List<FVRQuickBeltSlot> _rightSlots = new List<FVRQuickBeltSlot>();

		private FVRPlayerBody _body;

		private GameObject _leftRoot;

		private GameObject _rightRoot;

		private HandQuickbeltAdjustmentHandle _leftHandle;

		private HandQuickbeltAdjustmentHandle _rightHandle;

		private bool _rebuildRequested;

		private bool _layoutRequested;

		private bool _templateWarningLogged;

		private float _nextTemplateLookupTime;

		internal void Tick()
		{
			FVRPlayerBody currentPlayerBody = GM.CurrentPlayerBody;
			if (!SceneAllowsQuickbelts(currentPlayerBody))
			{
				DisableForScene();
			}
			else if ((Object)(object)_body != (Object)(object)currentPlayerBody || (Object)(object)_leftRoot == (Object)null || (Object)(object)_rightRoot == (Object)null)
			{
				Rebuild(currentPlayerBody, dropContents: false);
			}
			else if (_rebuildRequested)
			{
				_rebuildRequested = false;
				_layoutRequested = false;
				Rebuild(currentPlayerBody, dropContents: true);
			}
			else if (_layoutRequested)
			{
				_layoutRequested = false;
				ApplyLayout();
			}
		}

		internal void RebuildAfterQuickbeltChange(FVRPlayerBody body)
		{
			if (!SceneAllowsQuickbelts(body))
			{
				DisableForScene();
			}
			else
			{
				Rebuild(body, dropContents: false);
			}
		}

		internal void RequestRebuild()
		{
			_rebuildRequested = true;
		}

		internal void RequestLayout()
		{
			_layoutRequested = true;
		}

		internal void Dispose()
		{
			RemoveSlots(dropContents: true);
			_body = null;
		}

		private void Rebuild(FVRPlayerBody body, bool dropContents)
		{
			if (!SceneAllowsQuickbelts(body) || Time.unscaledTime < _nextTemplateLookupTime)
			{
				return;
			}
			FVRQuickBeltSlot val = FindTemplate(body);
			if ((Object)(object)val == (Object)null)
			{
				_nextTemplateLookupTime = Time.unscaledTime + 1f;
				if (!_templateWarningLogged)
				{
					_templateWarningLogged = true;
					Plugin.Logger.LogWarning((object)"Native spherical quickbelt slots are not ready; retrying once per second.");
				}
				return;
			}
			_nextTemplateLookupTime = 0f;
			_templateWarningLogged = false;
			RemoveSlots(dropContents);
			_body = body;
			_leftRoot = CreateHandRoot("HQB_LeftHand", body.LeftHand);
			_rightRoot = CreateHandRoot("HQB_RightHand", body.RightHand);
			_leftHandle = CreateAdjustmentHandle(_leftRoot.transform, isLeftHand: true);
			_rightHandle = CreateAdjustmentHandle(_rightRoot.transform, isLeftHand: false);
			CreateHandSlots(_leftRoot.transform, _leftSlots, val, Plugin.LeftLargeSlots.Value, Plugin.LeftMediumSlots.Value, Plugin.LeftSmallSlots.Value);
			CreateHandSlots(_rightRoot.transform, _rightSlots, val, Plugin.RightLargeSlots.Value, Plugin.RightMediumSlots.Value, Plugin.RightSmallSlots.Value);
			ApplyLayout();
			Plugin.Logger.LogInfo((object)$"Created {_slots.Count} hand quickbelt slots.");
		}

		private static bool SceneAllowsQuickbelts(FVRPlayerBody body)
		{
			if ((Object)(object)body != (Object)null && (Object)(object)body.LeftHand != (Object)null && (Object)(object)body.RightHand != (Object)null && (Object)(object)GM.CurrentSceneSettings != (Object)null)
			{
				return GM.CurrentSceneSettings.AreQuickbeltSlotsEnabled;
			}
			return false;
		}

		private void DisableForScene()
		{
			if (_slots.Count > 0 || (Object)(object)_leftRoot != (Object)null || (Object)(object)_rightRoot != (Object)null)
			{
				RemoveSlots(dropContents: true);
				Plugin.Logger.LogInfo((object)"Removed hand quickbelt slots because the current scene disables quickbelts.");
			}
			_body = null;
			_rebuildRequested = false;
			_layoutRequested = false;
			_nextTemplateLookupTime = 0f;
			_templateWarningLogged = false;
		}

		private static GameObject CreateHandRoot(string name, Transform hand)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			FVRViveHand component = ((Component)hand).GetComponent<FVRViveHand>();
			Transform val = (((Object)(object)component != (Object)null && (Object)(object)component.PalmTransform != (Object)null) ? component.PalmTransform : hand);
			GameObject val2 = new GameObject(name);
			val2.transform.SetParent(val, false);
			return val2;
		}

		private static HandQuickbeltAdjustmentHandle CreateAdjustmentHandle(Transform root, bool isLeftHand)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)val).name = (isLeftHand ? "HQB_LeftAnchorHandle" : "HQB_RightAnchorHandle");
			val.transform.SetParent(root, false);
			val.transform.localPosition = new Vector3(0f, 0.055f, 0f);
			val.transform.localScale = Vector3.one * 0.035f;
			int num = LayerMask.NameToLayer("Interactable");
			if (num >= 0)
			{
				val.layer = num;
			}
			Renderer component = val.GetComponent<Renderer>();
			Shader val2 = Shader.Find("Unlit/Color");
			if ((Object)(object)component != (Object)null && (Object)(object)val2 != (Object)null)
			{
				Material val3 = new Material(val2);
				val3.color = (isLeftHand ? new Color(1f, 0.72f, 0.12f, 1f) : new Color(0.35f, 0.9f, 1f, 1f));
				component.material = val3;
			}
			Rigidbody obj = val.AddComponent<Rigidbody>();
			obj.isKinematic = true;
			obj.useGravity = false;
			HandQuickbeltAdjustmentHandle handQuickbeltAdjustmentHandle = val.AddComponent<HandQuickbeltAdjustmentHandle>();
			handQuickbeltAdjustmentHandle.Configure(root, isLeftHand);
			val.SetActive(false);
			return handQuickbeltAdjustmentHandle;
		}

		private void CreateHandSlots(Transform root, List<FVRQuickBeltSlot> handSlots, FVRQuickBeltSlot template, int large, int medium, int small)
		{
			FVRPhysicalObjectSize[] array = (FVRPhysicalObjectSize[])(object)new FVRPhysicalObjectSize[3]
			{
				(FVRPhysicalObjectSize)2,
				(FVRPhysicalObjectSize)1,
				default(FVRPhysicalObjectSize)
			};
			int[] array2 = new int[3] { large, medium, small };
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				int num2 = 0;
				while (num2 < array2[i])
				{
					FVRQuickBeltSlot val = CreateSlot(root, template, array[i], num);
					if ((Object)(object)val != (Object)null)
					{
						handSlots.Add(val);
					}
					num2++;
					num++;
				}
			}
		}

		private FVRQuickBeltSlot CreateSlot(Transform root, FVRQuickBeltSlot template, FVRPhysicalObjectSize size, int index)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject);
			val.SetActive(false);
			((Object)val).name = $"HQB_{size}_{index + 1:00}";
			val.transform.SetParent(root, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			FVRQuickBeltSlot component = val.GetComponent<FVRQuickBeltSlot>();
			if ((Object)(object)component == (Object)null || !BuildLocalGeometry(component, template))
			{
				Plugin.Logger.LogError((object)$"Could not create {((Object)val).name} from template {((Object)template).name}.");
				Object.Destroy((Object)(object)val);
				return null;
			}
			component.SizeLimit = size;
			component.Shape = (QuickbeltSlotShape)0;
			component.Type = (QuickbeltSlotType)0;
			component.IsPlayer = true;
			component.IsSelectable = true;
			component.CurObject = null;
			component.HeldObject = null;
			component.IsKeepingTrackWithHead = false;
			component.IsHovered = false;
			val.AddComponent<HandQuickbeltSlotMarker>();
			val.AddComponent<HandQuickbeltMiniaturizer>();
			val.SetActive(true);
			_body.QBSlots_Internal.Add(component);
			_slots.Add(component);
			return component;
		}

		private static bool BuildLocalGeometry(FVRQuickBeltSlot slot, FVRQuickBeltSlot template)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)template == (Object)null || (Object)(object)template.HoverGeo == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = ((Component)slot).GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].enabled = false;
			}
			for (int num = ((Component)slot).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)slot).transform.GetChild(num)).gameObject);
			}
			GameObject val = new GameObject("HQB_QuickbeltRoot");
			val.transform.SetParent(((Component)slot).transform, false);
			GameObject val2 = Object.Instantiate<GameObject>(template.HoverGeo);
			((Object)val2).name = "HQB_HoverGeo";
			val2.transform.SetParent(val.transform, false);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			Transform root = (((Object)(object)template.QuickbeltRoot != (Object)null) ? template.QuickbeltRoot : template.HoverGeo.transform.parent);
			Transform val3 = FindBaseSphere(template, root);
			GameObject val4 = Object.Instantiate<GameObject>(((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : template.HoverGeo);
			((Object)val4).name = "HQB_BaseSphere";
			val4.transform.SetParent(val.transform, false);
			val4.transform.localPosition = Vector3.zero;
			val4.transform.localRotation = Quaternion.identity;
			val4.SetActive(true);
			GameObject val5 = new GameObject("HQB_PoseOverride");
			val5.transform.SetParent(val.transform, false);
			Renderer val6 = FindRenderer(val2.transform);
			Renderer val7 = FindRenderer(val4.transform);
			if ((Object)(object)val6 == (Object)null || (Object)(object)val7 == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			slot.QuickbeltRoot = val.transform;
			slot.HoverGeo = val2;
			slot.PoseOverride = val5.transform;
			slot.RectBounds = val4.transform;
			slot.m_hoverGeoRend = val6;
			val6.enabled = true;
			val7.enabled = true;
			val2.SetActive(false);
			slot.SetBaseRotation(Quaternion.identity);
			ApplyGeometryScale(slot);
			if ((Object)(object)val3 == (Object)null)
			{
				Plugin.Logger.LogWarning((object)$"{((Object)slot).name} uses a hover-material clone as its fallback base sphere.");
			}
			return true;
		}

		private static Transform FindBaseSphere(FVRQuickBeltSlot template, Transform root)
		{
			if ((Object)(object)template == (Object)null || (Object)(object)template.HoverGeo == (Object)null || (Object)(object)root == (Object)null)
			{
				return null;
			}
			Renderer val = FindRenderer(template.HoverGeo.transform);
			MeshFilter val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshFilter>() : null);
			Renderer val3 = null;
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val4 in componentsInChildren)
			{
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4 == (Object)(object)val) && !((Component)val4).transform.IsChildOf(template.HoverGeo.transform))
				{
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = val4;
					}
					MeshFilter component = ((Component)val4).GetComponent<MeshFilter>();
					if ((Object)(object)val2 != (Object)null && (Object)(object)component != (Object)null && (Object)(object)component.sharedMesh == (Object)(object)val2.sharedMesh)
					{
						return ((Component)val4).transform;
					}
				}
			}
			if (!((Object)(object)val3 != (Object)null))
			{
				return null;
			}
			return ((Component)val3).transform;
		}

		private static Renderer FindRenderer(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Renderer component = ((Component)root).GetComponent<Renderer>();
			if (!((Object)(object)component != (Object)null))
			{
				return ((Component)root).GetComponentInChildren<Renderer>(true);
			}
			return component;
		}

		private void ApplyLayout()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_leftRoot == (Object)null) && !((Object)(object)_rightRoot == (Object)null))
			{
				_leftRoot.transform.localPosition = Plugin.MirrorPosition(Plugin.AnchorPosition.Value);
				_leftRoot.transform.localRotation = Plugin.MirrorRotation(Quaternion.Euler(Plugin.AnchorRotation.Value));
				_rightRoot.transform.localPosition = Plugin.AnchorPosition.Value;
				_rightRoot.transform.localRotation = Quaternion.Euler(Plugin.AnchorRotation.Value);
				ArrangeSlots(_leftSlots);
				ArrangeSlots(_rightSlots);
				SetHandleVisible(_leftHandle);
				SetHandleVisible(_rightHandle);
			}
		}

		private static void ArrangeSlots(List<FVRQuickBeltSlot> slots)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(1, Plugin.GridColumns.Value);
			float num2 = (float)Plugin.SlotSpacingMillimeters.Value * 0.001f;
			for (int i = 0; i < slots.Count; i++)
			{
				FVRQuickBeltSlot val = slots[i];
				if (!((Object)(object)val == (Object)null))
				{
					int num3 = i / num;
					int num4 = i % num;
					int num5 = Mathf.Min(num, slots.Count - num3 * num);
					float num6 = ((float)num4 - (float)(num5 - 1) * 0.5f) * num2;
					float num7 = (float)(-num3) * num2;
					Transform parent = ((Component)val).transform.parent;
					((Component)val).transform.localPosition = (Vector3)(((Object)(object)parent != (Object)null) ? parent.InverseTransformVector(parent.right * num6 + parent.forward * num7) : new Vector3(num6, 0f, num7));
					ApplyGeometryScale(val);
				}
			}
		}

		private static void SetHandleVisible(HandQuickbeltAdjustmentHandle handle)
		{
			if (!((Object)(object)handle == (Object)null))
			{
				bool value = Plugin.ShowAdjustmentHandles.Value;
				if (!value && ((FVRInteractiveObject)handle).IsHeld)
				{
					((FVRInteractiveObject)handle).ForceBreakInteraction();
				}
				if (((Component)handle).gameObject.activeSelf != value)
				{
					((Component)handle).gameObject.SetActive(value);
				}
			}
		}

		private static void ApplyGeometryScale(FVRQuickBeltSlot slot)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			float diameter = Mathf.Max(0.001f, Mathf.Abs((float)Plugin.SlotDiameterMillimeters.Value * 0.001f));
			if ((Object)(object)slot.HoverGeo != (Object)null)
			{
				SetWorldDiameter(slot.HoverGeo.transform, diameter);
			}
			if ((Object)(object)slot.RectBounds != (Object)null && (Object)(object)slot.HoverGeo != (Object)null)
			{
				slot.RectBounds.position = slot.HoverGeo.transform.position;
				slot.RectBounds.rotation = slot.HoverGeo.transform.rotation;
				slot.RectBounds.localScale = slot.HoverGeo.transform.localScale;
			}
		}

		private static void SetWorldDiameter(Transform sphere, float diameter)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (((Object)(object)sphere.parent != (Object)null) ? sphere.parent.lossyScale : Vector3.one);
			sphere.localScale = new Vector3(diameter / Mathf.Max(0.0001f, Mathf.Abs(val.x)), diameter / Mathf.Max(0.0001f, Mathf.Abs(val.y)), diameter / Mathf.Max(0.0001f, Mathf.Abs(val.z)));
		}

		private FVRQuickBeltSlot FindTemplate(FVRPlayerBody body)
		{
			if ((Object)(object)body != (Object)null && body.QBSlots_Internal != null)
			{
				for (int i = 0; i < body.QBSlots_Internal.Count; i++)
				{
					FVRQuickBeltSlot val = body.QBSlots_Internal[i];
					if (IsUsableTemplate(val) && (Object)(object)((Component)val).GetComponent<HandQuickbeltSlotMarker>() == (Object)null)
					{
						return val;
					}
				}
			}
			if ((Object)(object)ManagerSingleton<GM>.Instance == (Object)null || ManagerSingleton<GM>.Instance.QuickbeltConfigurations == null)
			{
				return null;
			}
			FVRQuickBeltSlot val2 = null;
			GameObject[] quickbeltConfigurations = ManagerSingleton<GM>.Instance.QuickbeltConfigurations;
			foreach (GameObject val3 in quickbeltConfigurations)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				FVRQuickBeltSlot[] componentsInChildren = val3.GetComponentsInChildren<FVRQuickBeltSlot>(true);
				foreach (FVRQuickBeltSlot val4 in componentsInChildren)
				{
					if (IsUsableTemplate(val4))
					{
						if ((Object)(object)val2 == (Object)null)
						{
							val2 = val4;
						}
						if (((Object)val4).name == "QuickBeltSlot_Harness")
						{
							return val4;
						}
					}
				}
			}
			return val2;
		}

		private static bool IsUsableTemplate(FVRQuickBeltSlot slot)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slot == (Object)null || (int)slot.Shape != 0 || (Object)(object)slot.HoverGeo == (Object)null)
			{
				return false;
			}
			Transform root = (((Object)(object)slot.QuickbeltRoot != (Object)null) ? slot.QuickbeltRoot : slot.HoverGeo.transform.parent);
			return (Object)(object)FindBaseSphere(slot, root) != (Object)null;
		}

		private void RemoveSlots(bool dropContents)
		{
			for (int num = _slots.Count - 1; num >= 0; num--)
			{
				FVRQuickBeltSlot val = _slots[num];
				if (!((Object)(object)val == (Object)null))
				{
					val.IsSelectable = false;
					HandQuickbeltMiniaturizer component = ((Component)val).GetComponent<HandQuickbeltMiniaturizer>();
					if ((Object)(object)component != (Object)null)
					{
						component.Restore();
					}
					if (dropContents && (Object)(object)val.CurObject != (Object)null)
					{
						val.CurObject.ClearQuickbeltState();
					}
					if ((Object)(object)_body != (Object)null && _body.QBSlots_Internal != null)
					{
						_body.QBSlots_Internal.Remove(val);
					}
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			_slots.Clear();
			_leftSlots.Clear();
			_rightSlots.Clear();
			_leftHandle = null;
			_rightHandle = null;
			DestroyRoot(ref _leftRoot);
			DestroyRoot(ref _rightRoot);
		}

		private static void DestroyRoot(ref GameObject root)
		{
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
				root = null;
			}
		}
	}
	internal sealed class HandQuickbeltSlotMarker : MonoBehaviour
	{
	}
	internal sealed class HandQuickbeltAdjustmentHandle : FVRInteractiveObject
	{
		private Transform _anchor;

		private bool _isLeftHand;

		private Vector3 _positionOffset;

		private Quaternion _rotationOffset;

		internal void Configure(Transform anchor, bool isLeftHand)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_anchor = anchor;
			_isLeftHand = isLeftHand;
			base.ControlType = (FVRInteractionControlType)0;
			base.PoseOverride = ((Component)this).transform;
			base.EndInteractionIfDistant = false;
		}

		public override bool IsDistantGrabbable()
		{
			return false;
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).BeginInteraction(hand);
			if ((Object)(object)_anchor != (Object)null)
			{
				Quaternion val = Quaternion.Inverse(((FVRInteractiveObject)this).m_handRot);
				_positionOffset = val * (_anchor.position - ((FVRInteractiveObject)this).m_handPos);
				_rotationOffset = val * _anchor.rotation;
			}
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).UpdateInteraction(hand);
			if ((Object)(object)_anchor != (Object)null)
			{
				_anchor.position = ((FVRInteractiveObject)this).m_handPos + ((FVRInteractiveObject)this).m_handRot * _positionOffset;
				_anchor.rotation = ((FVRInteractiveObject)this).m_handRot * _rotationOffset;
			}
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_anchor != (Object)null && (Object)(object)Plugin.Instance != (Object)null)
			{
				Plugin.Instance.SaveAnchorPose(_isLeftHand, _anchor.localPosition, _anchor.localRotation);
			}
			((FVRInteractiveObject)this).EndInteraction(hand);
		}
	}
	internal sealed class HandQuickbeltMiniaturizer : MonoBehaviour
	{
		private readonly HashSet<GameObject> _knownPhysicalObjects = new HashSet<GameObject>();

		private FVRQuickBeltSlot _slot;

		private FVRPhysicalObject _item;

		private Vector3 _originalScale;

		private Vector3 _storedScale;

		private float _scaleFactor = 1f;

		private float _targetSize;

		private int _knownTransformCount;

		private void Awake()
		{
			_slot = ((Component)this).GetComponent<FVRQuickBeltSlot>();
		}

		private void Update()
		{
			FVRPhysicalObject val = (FVRPhysicalObject)((Plugin.MiniaturizeStoredObjects.Value && (Object)(object)_slot != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val != (Object)(object)_item)
			{
				Restore();
				if ((Object)(object)val != (Object)null)
				{
					Track(val);
				}
			}
			if (!((Object)(object)_item == (Object)null))
			{
				float num = TargetSizeMeters();
				if (!Mathf.Approximately(num, _targetSize))
				{
					RestoreScale();
					Fit(num);
				}
				if (((FVRInteractiveObject)_item).IsHeld)
				{
					RestoreScale();
					return;
				}
				RefitAfterHierarchyChange();
				ApplyScale();
			}
		}

		private void OnDestroy()
		{
			Restore();
		}

		internal void Restore()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			RestoreScale();
			_item = null;
			_storedScale = Vector3.zero;
			_scaleFactor = 1f;
			_targetSize = 0f;
			_knownTransformCount = 0;
			_knownPhysicalObjects.Clear();
		}

		internal void RestoreBeforeRemoval(FVRPhysicalObject physicalObject)
		{
			if ((Object)(object)_item == (Object)(object)physicalObject)
			{
				Restore();
			}
		}

		private void Track(FVRPhysicalObject physicalObject)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_item = physicalObject;
			_originalScale = ((Component)physicalObject).transform.localScale;
			RecordHierarchy();
			Fit(TargetSizeMeters());
		}

		private void Fit(float targetSize)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			_targetSize = targetSize;
			_scaleFactor = 1f;
			_storedScale = _originalScale;
			if (TryGetColliderBounds(((Component)_item).gameObject, out var bounds))
			{
				Vector3 size = ((Bounds)(ref bounds)).size;
				float num = Mathf.Max(size.x, Mathf.Max(size.y, size.z));
				if (num > targetSize)
				{
					_scaleFactor = targetSize / num;
					_storedScale = _originalScale * _scaleFactor;
				}
			}
		}

		private void RefitAfterHierarchyChange()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)_item).GetComponentsInChildren<Transform>(true).Length == _knownTransformCount)
			{
				return;
			}
			RestoreScale();
			FVRPhysicalObject[] componentsInChildren = ((Component)_item).GetComponentsInChildren<FVRPhysicalObject>(true);
			foreach (FVRPhysicalObject val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)_item && !_knownPhysicalObjects.Contains(((Component)val).gameObject))
				{
					Transform transform = ((Component)val).transform;
					transform.localScale *= _scaleFactor;
				}
			}
			RecordHierarchy();
			Fit(_targetSize);
		}

		private void RecordHierarchy()
		{
			_knownPhysicalObjects.Clear();
			_knownTransformCount = ((Component)_item).GetComponentsInChildren<Transform>(true).Length;
			FVRPhysicalObject[] componentsInChildren = ((Component)_item).GetComponentsInChildren<FVRPhysicalObject>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					_knownPhysicalObjects.Add(((Component)componentsInChildren[i]).gameObject);
				}
			}
		}

		private void RestoreScale()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_item != (Object)null)
			{
				((Component)_item).transform.localScale = _originalScale;
			}
		}

		private void ApplyScale()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_item != (Object)null && !((FVRInteractiveObject)_item).IsHeld)
			{
				((Component)_item).transform.localScale = _storedScale;
			}
		}

		private static float TargetSizeMeters()
		{
			float num = (float)Mathf.Abs(Plugin.SlotDiameterMillimeters.Value) * 0.001f;
			return Mathf.Max(0.001f, num * (float)Plugin.StoredSizePercent.Value * 0.01f);
		}

		private static bool TryGetColliderBounds(GameObject root, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			bool flag = false;
			Collider[] componentsInChildren = root.GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled && ((Component)val).gameObject.activeInHierarchy && !val.isTrigger)
				{
					if (!flag)
					{
						bounds = val.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(val.bounds);
					}
				}
			}
			return flag;
		}
	}
	[HarmonyPatch(typeof(FVRPlayerBody), "ConfigureQuickbelt")]
	internal static class ConfigureQuickbeltPatch
	{
		[HarmonyPostfix]
		private static void Postfix(FVRPlayerBody __instance)
		{
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				Plugin.Instance.RebuildAfterQuickbeltChange(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(FVRViveHand), "TestQuickBeltDistances")]
	internal static class HandQuickbeltInteractionPatch
	{
		[HarmonyPostfix]
		private static void Postfix(FVRViveHand __instance)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)GM.CurrentPlayerBody == (Object)null || GM.CurrentPlayerBody.QBSlots_Internal == null)
			{
				return;
			}
			FVRInteractiveObject currentInteractable = __instance.CurrentInteractable;
			FVRPhysicalObject val = (FVRPhysicalObject)(object)((currentInteractable is FVRPhysicalObject) ? currentInteractable : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.QuickbeltSlot != (Object)null)
			{
				return;
			}
			FVRQuickBeltSlot val2 = null;
			float num = float.MaxValue;
			for (int i = 0; i < GM.CurrentPlayerBody.QBSlots_Internal.Count; i++)
			{
				FVRQuickBeltSlot val3 = GM.CurrentPlayerBody.QBSlots_Internal[i];
				if (CanStore(val3, val) && IntersectsSlot(val3, val))
				{
					Vector3 val4 = val3.HoverGeo.transform.position - ((Component)val).transform.position;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						val2 = val3;
						num = sqrMagnitude;
					}
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				__instance.CurrentHoveredQuickbeltSlot = val2;
				__instance.CurrentHoveredQuickbeltSlotDirty = val2;
			}
			else if (IsHandQuickbelt(__instance.CurrentHoveredQuickbeltSlot))
			{
				__instance.CurrentHoveredQuickbeltSlot = null;
				__instance.CurrentHoveredQuickbeltSlotDirty = null;
			}
		}

		private static bool CanStore(FVRQuickBeltSlot slot, FVRPhysicalObject physicalObject)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (IsHandQuickbelt(slot) && slot.IsSelectable && (Object)(object)slot.CurObject == (Object)null && (Object)(object)slot.HeldObject == (Object)null && slot.SizeLimit >= physicalObject.Size)
			{
				return slot.Type == physicalObject.QBSlotType;
			}
			return false;
		}

		private static bool IsHandQuickbelt(FVRQuickBeltSlot slot)
		{
			if ((Object)(object)slot != (Object)null)
			{
				return (Object)(object)((Component)slot).GetComponent<HandQuickbeltSlotMarker>() != (Object)null;
			}
			return false;
		}

		private static bool IntersectsSlot(FVRQuickBeltSlot slot, FVRPhysicalObject physicalObject)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slot.HoverGeo == (Object)null)
			{
				return false;
			}
			Vector3 position = slot.HoverGeo.transform.position;
			Vector3 lossyScale = slot.HoverGeo.transform.lossyScale;
			float num = 0.5f * Mathf.Min(Mathf.Abs(lossyScale.x), Mathf.Min(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
			float num2 = num * num;
			Collider[] componentsInChildren = ((Component)physicalObject).GetComponentsInChildren<Collider>(true);
			bool flag = false;
			foreach (Collider val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled && ((Component)val).gameObject.activeInHierarchy && !val.isTrigger)
				{
					flag = true;
					Bounds bounds = val.bounds;
					if (((Bounds)(ref bounds)).SqrDistance(position) <= num2)
					{
						return true;
					}
				}
			}
			if (flag)
			{
				return false;
			}
			Transform val2 = (((Object)(object)((FVRInteractiveObject)physicalObject).PoseOverride != (Object)null) ? ((FVRInteractiveObject)physicalObject).PoseOverride : ((Component)physicalObject).transform);
			Vector3 val3 = slot.HoverGeo.transform.InverseTransformPoint(val2.position);
			return ((Vector3)(ref val3)).magnitude < 0.5f;
		}
	}
	[HarmonyPatch]
	internal static class StoredObjectScalePatch
	{
		[HarmonyPatch(typeof(FVRPhysicalObject), "SetParentage")]
		[HarmonyPrefix]
		private static void BeforeSetParentage(FVRPhysicalObject __instance)
		{
			RestoreBeforeRemoval(__instance);
		}

		[HarmonyPatch(typeof(FVRPhysicalObject), "SetQuickBeltSlot")]
		[HarmonyPrefix]
		private static void BeforeClearQuickbelt(FVRPhysicalObject __instance, FVRQuickBeltSlot slot)
		{
			if ((Object)(object)slot == (Object)null)
			{
				RestoreBeforeRemoval(__instance);
			}
		}

		private static void RestoreBeforeRemoval(FVRPhysicalObject physicalObject)
		{
			if (!((Object)(object)physicalObject == (Object)null) && !((Object)(object)physicalObject.QuickbeltSlot == (Object)null))
			{
				HandQuickbeltMiniaturizer component = ((Component)physicalObject.QuickbeltSlot).GetComponent<HandQuickbeltMiniaturizer>();
				if ((Object)(object)component != (Object)null)
				{
					component.RestoreBeforeRemoval(physicalObject);
				}
			}
		}
	}
	[BepInProcess("h3vr.exe")]
	[BepInPlugin("quaternion.hqb", "Hand Quickbelts", "0.4.2")]
	public class Plugin : BaseUnityPlugin
	{
		internal static readonly Vector3 DefaultAnchorPosition = new Vector3(-1.4656025f, 0.07558223f, -0.8075327f);

		internal static readonly Vector3 DefaultAnchorRotation = new Vector3(-6.0018616f, 36.728462f, 174.04753f);

		private HandQuickbeltController _controller;

		private Harmony _harmony;

		private bool _resetting;

		public const string Id = "quaternion.hqb";

		internal static Plugin Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static ConfigEntry<int> LeftLargeSlots { get; private set; }

		internal static ConfigEntry<int> LeftMediumSlots { get; private set; }

		internal static ConfigEntry<int> LeftSmallSlots { get; private set; }

		internal static ConfigEntry<int> RightLargeSlots { get; private set; }

		internal static ConfigEntry<int> RightMediumSlots { get; private set; }

		internal static ConfigEntry<int> RightSmallSlots { get; private set; }

		internal static ConfigEntry<int> GridColumns { get; private set; }

		internal static ConfigEntry<int> SlotSpacingMillimeters { get; private set; }

		internal static ConfigEntry<int> SlotDiameterMillimeters { get; private set; }

		internal static ConfigEntry<Vector3> AnchorPosition { get; private set; }

		internal static ConfigEntry<Vector3> AnchorRotation { get; private set; }

		internal static ConfigEntry<bool> ShowAdjustmentHandles { get; private set; }

		internal static ConfigEntry<bool> ResetAllSettings { get; private set; }

		internal static ConfigEntry<bool> MiniaturizeStoredObjects { get; private set; }

		internal static ConfigEntry<int> StoredSizePercent { get; private set; }

		public static string Name => "Hand Quickbelts";

		public static string Version => "0.4.2";

		private void Awake()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			RegisterVectorConverter();
			BindConfig();
			_controller = new HandQuickbeltController();
			SubscribeToConfigChanges();
			_harmony = new Harmony("quaternion.hqb");
			_harmony.PatchAll();
			Logger.LogMessage((object)$"{Name} {Version} loaded.");
		}

		private void Update()
		{
			if (_controller != null)
			{
				_controller.Tick();
			}
		}

		private void OnDestroy()
		{
			if (_controller != null)
			{
				_controller.Dispose();
				_controller = null;
			}
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
				_harmony = null;
			}
			Instance = null;
		}

		private void BindConfig()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			LeftLargeSlots = BindSlotCount("Left Large Slots", 1, "Large quickbelt slots attached below the left hand.");
			LeftMediumSlots = BindSlotCount("Left Medium Slots", 0, "Medium quickbelt slots attached below the left hand.");
			LeftSmallSlots = BindSlotCount("Left Small Slots", 0, "Small quickbelt slots attached below the left hand.");
			RightLargeSlots = BindSlotCount("Right Large Slots", 1, "Large quickbelt slots attached below the right hand.");
			RightMediumSlots = BindSlotCount("Right Medium Slots", 0, "Medium quickbelt slots attached below the right hand.");
			RightSmallSlots = BindSlotCount("Right Small Slots", 0, "Small quickbelt slots attached below the right hand.");
			GridColumns = ((BaseUnityPlugin)this).Config.Bind<int>("Slots", "Grid Columns", 2, "Slots per row before the grid wraps toward the elbow.");
			SlotSpacingMillimeters = ((BaseUnityPlugin)this).Config.Bind<int>("Slots", "Slot Spacing (mm)", 120, "World-space center-to-center spacing on both grid axes.");
			SlotDiameterMillimeters = ((BaseUnityPlugin)this).Config.Bind<int>("Slots", "Slot Diameter (mm)", 100, "World-space diameter of each native sphere visual and interaction volume.");
			AnchorPosition = ((BaseUnityPlugin)this).Config.Bind<Vector3>("Placement", "Anchor Position (meters)", DefaultAnchorPosition, "Shared palm-local position. The left hand uses its mirrored pose.");
			AnchorRotation = ((BaseUnityPlugin)this).Config.Bind<Vector3>("Placement", "Anchor Rotation (degrees)", DefaultAnchorRotation, "Shared palm-local Euler rotation. The left hand uses its mirrored pose.");
			ShowAdjustmentHandles = ((BaseUnityPlugin)this).Config.Bind<bool>("Placement", "Show Adjustment Handles", false, "Show grabbable handles for moving and rotating the shared anchor pose.");
			ResetAllSettings = ((BaseUnityPlugin)this).Config.Bind<bool>("Placement", "Reset All Settings", false, "Restore every Hand Quickbelts setting to its default, then turn this toggle off.");
			MiniaturizeStoredObjects = ((BaseUnityPlugin)this).Config.Bind<bool>("Stored Objects", "Miniaturize Stored Objects", true, "Reduce stored items to fit and restore their original scale before removal.");
			StoredSizePercent = ((BaseUnityPlugin)this).Config.Bind<int>("Stored Objects", "Stored Size (% of Slot Diameter)", 80, new ConfigDescription("Maximum stored-object size as a percentage of the slot diameter. Objects are reduced to fit but never enlarged.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000), new object[0]));
		}

		private ConfigEntry<int> BindSlotCount(string name, int defaultValue, string description)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			return ((BaseUnityPlugin)this).Config.Bind<int>("Slots", name, defaultValue, new ConfigDescription(description + " Changing a slot count drops items stored in hand slots.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), new object[0]));
		}

		private void SubscribeToConfigChanges()
		{
			ConfigEntry<int>[] array = new ConfigEntry<int>[6] { LeftLargeSlots, LeftMediumSlots, LeftSmallSlots, RightLargeSlots, RightMediumSlots, RightSmallSlots };
			for (int i = 0; i < array.Length; i++)
			{
				array[i].SettingChanged += OnSlotCountChanged;
			}
			GridColumns.SettingChanged += OnLayoutChanged;
			SlotSpacingMillimeters.SettingChanged += OnLayoutChanged;
			SlotDiameterMillimeters.SettingChanged += OnLayoutChanged;
			AnchorPosition.SettingChanged += OnLayoutChanged;
			AnchorRotation.SettingChanged += OnLayoutChanged;
			ShowAdjustmentHandles.SettingChanged += OnLayoutChanged;
			ResetAllSettings.SettingChanged += OnResetAllSettingsChanged;
		}

		private void OnSlotCountChanged(object sender, EventArgs eventArgs)
		{
			if (_controller != null)
			{
				_controller.RequestRebuild();
			}
		}

		private void OnLayoutChanged(object sender, EventArgs eventArgs)
		{
			if (_controller != null)
			{
				_controller.RequestLayout();
			}
		}

		private void OnResetAllSettingsChanged(object sender, EventArgs eventArgs)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!_resetting && ResetAllSettings.Value)
			{
				_resetting = true;
				LeftLargeSlots.Value = 1;
				LeftMediumSlots.Value = 0;
				LeftSmallSlots.Value = 0;
				RightLargeSlots.Value = 1;
				RightMediumSlots.Value = 0;
				RightSmallSlots.Value = 0;
				GridColumns.Value = 2;
				SlotSpacingMillimeters.Value = 120;
				SlotDiameterMillimeters.Value = 100;
				AnchorPosition.Value = DefaultAnchorPosition;
				AnchorRotation.Value = DefaultAnchorRotation;
				ShowAdjustmentHandles.Value = false;
				MiniaturizeStoredObjects.Value = true;
				StoredSizePercent.Value = 80;
				ResetAllSettings.Value = false;
				((BaseUnityPlugin)this).Config.Save();
				_resetting = false;
				if (_controller != null)
				{
					_controller.RequestRebuild();
				}
				Logger.LogInfo((object)"Reset all settings to defaults.");
			}
		}

		internal void RebuildAfterQuickbeltChange(FVRPlayerBody body)
		{
			if (_controller != null)
			{
				_controller.RebuildAfterQuickbeltChange(body);
			}
		}

		internal void SaveAnchorPose(bool isLeftHand, Vector3 position, Quaternion rotation)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value = (isLeftHand ? MirrorPosition(position) : position);
			Quaternion val = (isLeftHand ? MirrorRotation(rotation) : rotation);
			Vector3 eulerAngles = ((Quaternion)(ref val)).eulerAngles;
			AnchorPosition.Value = value;
			AnchorRotation.Value = new Vector3(NormalizeAngle(eulerAngles.x), NormalizeAngle(eulerAngles.y), NormalizeAngle(eulerAngles.z));
			((BaseUnityPlugin)this).Config.Save();
			Logger.LogInfo((object)string.Format("Saved shared anchor from the {0} handle: position {1}, rotation {2}.", isLeftHand ? "left" : "right", AnchorPosition.Value, AnchorRotation.Value));
		}

		internal static Vector3 MirrorPosition(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(0f - position.x, position.y, position.z);
		}

		internal static Quaternion MirrorRotation(Quaternion rotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(rotation.x, 0f - rotation.y, 0f - rotation.z, rotation.w);
		}

		private static float NormalizeAngle(float angle)
		{
			if (!(angle > 180f))
			{
				return angle;
			}
			return angle - 360f;
		}

		private static void RegisterVectorConverter()
		{
			if (!TypeDescriptor.GetConverter(typeof(Vector3)).CanConvertFrom(typeof(string)))
			{
				TypeDescriptor.AddAttributes(typeof(Vector3), new TypeConverterAttribute(typeof(Vector3ConfigTypeConverter)));
			}
		}
	}
	public sealed class Vector3ConfigTypeConverter : TypeConverter
	{
		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			if ((object)sourceType != typeof(string))
			{
				return base.CanConvertFrom(context, sourceType);
			}
			return true;
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			if ((object)destinationType != typeof(string))
			{
				return base.CanConvertTo(context, destinationType);
			}
			return true;
		}

		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!(value is string text))
			{
				return base.ConvertFrom(context, culture, value);
			}
			string[] array = text.Trim().Trim('(', ')').Split(new char[1] { ',' });
			if (array.Length != 3)
			{
				throw new FormatException("Expected a vector in x, y, z format.");
			}
			return (object)new Vector3(float.Parse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture), float.Parse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture), float.Parse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture));
		}

		public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if ((object)destinationType == typeof(string) && value is Vector3 val)
			{
				return string.Format(CultureInfo.InvariantCulture, "{0:0.######}, {1:0.######}, {2:0.######}", new object[3] { val.x, val.y, val.z });
			}
			return base.ConvertTo(context, culture, value, destinationType);
		}
	}
}