using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CullFactory.Data;
using Dissonance;
using Dissonance.Integrations.Unity_NFGO;
using Dissonance.Networking;
using Dissonance.Networking.Client;
using Diversity.Misc;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using LCVR.Assets;
using LCVR.Compatibility.MoreCompany;
using LCVR.Experiments;
using LCVR.Input;
using LCVR.Items;
using LCVR.Networking;
using LCVR.Patches;
using LCVR.Physics;
using LCVR.Physics.Interactions;
using LCVR.Player;
using LCVR.Properties;
using LCVR.Rendering;
using LCVR.UI;
using LCVR.UI.Settings;
using Microsoft.CodeAnalysis;
using Microsoft.MixedReality.Toolkit.Experimental.UI;
using Mimics;
using MoreCompany.Behaviors;
using MoreCompany.Cosmetics;
using Newtonsoft.Json;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Animations.Rigging;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.UI;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit;
using UnityEngine.XR.Interaction.Toolkit.UI;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LCVR")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2024")]
[assembly: AssemblyDescription("Collecting Scrap in VR")]
[assembly: AssemblyFileVersion("1.2.3.0")]
[assembly: AssemblyInformationalVersion("1.2.3+1722f98932769334945d2a0fe71f5dd58b788c09")]
[assembly: AssemblyProduct("LCVR")]
[assembly: AssemblyTitle("LCVR")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/LCVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Microsoft.MixedReality.Toolkit.Experimental.UI
{
	public class CapsLockHighlight : MonoBehaviour
	{
		[SerializeField]
		private Image m_Highlight;

		private NonNativeKeyboard m_Keyboard;

		private void Start()
		{
			m_Keyboard = ((Component)this).GetComponentInParent<NonNativeKeyboard>();
			UpdateState();
		}

		private void Update()
		{
			UpdateState();
		}

		private void UpdateState()
		{
			bool enabled = false;
			if ((Object)(object)m_Keyboard != (Object)null)
			{
				enabled = m_Keyboard.IsCapsLocked;
			}
			if ((Object)(object)m_Highlight != (Object)null)
			{
				((Behaviour)m_Highlight).enabled = enabled;
			}
		}
	}
	[RequireComponent(typeof(Button))]
	public class KeyboardKeyFunc : MonoBehaviour
	{
		public enum Function
		{
			Enter,
			Tab,
			ABC,
			Symbol,
			Previous,
			Next,
			Close,
			Dictate,
			Shift,
			CapsLock,
			Space,
			Backspace,
			Macro,
			UNDEFINED
		}

		private NonNativeKeyboard keyboard;

		[SerializeField]
		[FormerlySerializedAs("m_ButtonFunction")]
		private Function buttonFunction = Function.UNDEFINED;

		[SerializeField]
		[FormerlySerializedAs("m_MacroText")]
		private string macroText;

		public Function ButtonFunction => buttonFunction;

		public string MacroText => macroText;

		private void Awake()
		{
			if ((Object)(object)keyboard == (Object)null)
			{
				keyboard = ((Component)this).GetComponentInParent<NonNativeKeyboard>();
			}
		}

		private void Start()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Button component = ((Component)this).GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			((UnityEvent)component.onClick).AddListener(new UnityAction(FireFunctionKey));
		}

		private void FireFunctionKey()
		{
			keyboard.FunctionKey(this);
		}
	}
	[RequireComponent(typeof(Button))]
	public class KeyboardValueKey : MonoBehaviour
	{
		private NonNativeKeyboard keyboard;

		public string Value;

		public string ShiftValue;

		private TextMeshProUGUI m_Text;

		private Button m_Button;

		private void Awake()
		{
			if ((Object)(object)keyboard == (Object)null)
			{
				keyboard = ((Component)this).GetComponentInParent<NonNativeKeyboard>();
			}
			m_Button = ((Component)this).GetComponent<Button>();
		}

		private void Start()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			m_Text = ((Component)this).gameObject.GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)m_Text).text = Value;
			((UnityEventBase)m_Button.onClick).RemoveAllListeners();
			((UnityEvent)m_Button.onClick).AddListener(new UnityAction(FireAppendValue));
			keyboard.OnKeyboardShifted += Shift;
		}

		private void FireAppendValue()
		{
			keyboard.AppendValue(this);
		}

		public void Shift(bool isShifted)
		{
			if (isShifted && !string.IsNullOrEmpty(ShiftValue))
			{
				((TMP_Text)m_Text).text = ShiftValue;
			}
			else
			{
				((TMP_Text)m_Text).text = Value;
			}
		}
	}
	public class NonNativeKeyboard : MonoBehaviour
	{
		public enum LayoutType
		{
			Alpha,
			Symbol,
			URL,
			Email
		}

		public TMP_InputField InputField;

		public bool SliderEnabled;

		public bool CloseOnEnter = true;

		public bool SubmitOnEnter;

		public Image NumbersKeyboard;

		public Image AlphaKeyboard;

		public Image SymbolKeyboard;

		public Image AlphaSubKeys;

		public Image AlphaWebKeys;

		public Image AlphaMailKeys;

		private LayoutType m_LastKeyboardLayout;

		[Header("Positioning")]
		[SerializeField]
		private float m_MaxScale = 1f;

		[SerializeField]
		private float m_MinScale = 1f;

		[SerializeField]
		private float m_MaxDistance = 3.5f;

		[SerializeField]
		private float m_MinDistance = 0.25f;

		public bool CloseOnInactivity = true;

		public float CloseOnInactivityTime = 15f;

		private float _closingTime;

		private bool m_IsShifted;

		private bool m_IsCapslocked;

		private int m_CaretPosition;

		private Vector3 m_StartingScale = Vector3.one;

		private Vector3 m_ObjectBounds;

		private AudioSource _audioSource;

		public bool IsShifted => m_IsShifted;

		public bool IsCapsLocked => m_IsCapslocked;

		public event EventHandler OnTextSubmitted = delegate
		{
		};

		public event Action<string> OnMacroTriggered = delegate
		{
		};

		public event Action<string> OnTextUpdated = delegate
		{
		};

		public event EventHandler OnClosed = delegate
		{
		};

		public event EventHandler OnPrevious = delegate
		{
		};

		public event EventHandler OnNext = delegate
		{
		};

		public event EventHandler OnPlacement = delegate
		{
		};

		public event Action<bool> OnKeyboardShifted = delegate
		{
		};

		public event Action<KeyboardValueKey> OnKeyboardValueKeyPressed = delegate
		{
		};

		public event Action<KeyboardKeyFunc> OnKeyboardFunctionKeyPressed = delegate
		{
		};

		private void Awake()
		{
			//IL_0007: 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_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_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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			m_StartingScale = ((Component)this).transform.localScale;
			Bounds val = RectTransformUtility.CalculateRelativeRectTransformBounds(((Component)this).transform);
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			m_ObjectBounds = new Vector3(((Bounds)(ref val)).size.x * ((Transform)component).localScale.x, ((Bounds)(ref val)).size.y * ((Transform)component).localScale.y, ((Bounds)(ref val)).size.z * ((Transform)component).localScale.z);
			((Component)this).gameObject.SetActive(false);
		}

		protected void Start()
		{
			((UnityEvent<string>)(object)InputField.onValueChanged).AddListener((UnityAction<string>)DoTextUpdated);
		}

		private void DoTextUpdated(string value)
		{
			this.OnTextUpdated?.Invoke(value);
		}

		private void UpdateCaretPosition(int newPos)
		{
			InputField.caretPosition = newPos;
		}

		protected void OnDisable()
		{
			m_LastKeyboardLayout = LayoutType.Alpha;
		}

		private void OnDestroy()
		{
		}

		public void PresentKeyboard()
		{
			ResetClosingTime();
			((Component)this).gameObject.SetActive(true);
			ActivateSpecificKeyboard(LayoutType.Alpha);
			this.OnPlacement(this, EventArgs.Empty);
			InputField.ActivateInputField();
		}

		public void PresentKeyboard(string startText)
		{
			PresentKeyboard();
			Clear();
			InputField.text = startText;
		}

		public void PresentKeyboard(LayoutType keyboardType)
		{
			PresentKeyboard();
			ActivateSpecificKeyboard(keyboardType);
		}

		public void PresentKeyboard(string startText, LayoutType keyboardType)
		{
			PresentKeyboard(startText);
			ActivateSpecificKeyboard(keyboardType);
		}

		public void RepositionKeyboard(Vector3 kbPos, float verticalOffset = 0f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = kbPos;
			ScaleToSize();
			LookAtTargetOrigin();
		}

		public void RepositionKeyboard(Transform objectTransform, BoxCollider aCollider = null, float verticalOffset = 0f)
		{
			//IL_0007: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = objectTransform.position;
			if ((Object)(object)aCollider != (Object)null)
			{
				Bounds bounds = ((Collider)aCollider).bounds;
				float num = 0f - (((Bounds)(ref bounds)).size.y * 0.5f + verticalOffset);
				((Component)this).transform.Translate(0f, num, -0.6f, objectTransform);
			}
			else
			{
				float num2 = 0f - (m_ObjectBounds.y * 0.5f + verticalOffset);
				((Component)this).transform.Translate(0f, num2, -0.6f, objectTransform);
			}
			ScaleToSize();
			LookAtTargetOrigin();
		}

		private void ScaleToSize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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)
			//IL_001f: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)this).transform.position - ((Component)Camera.main).transform.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			float num = (magnitude - m_MinDistance) / (m_MaxDistance - m_MinDistance);
			float num2 = m_MinScale + (m_MaxScale - m_MinScale) * num;
			num2 = Mathf.Clamp(num2, m_MinScale, m_MaxScale);
			((Component)this).transform.localScale = m_StartingScale * num2;
			Debug.LogFormat("Setting scale: {0} for distance: {1}", new object[2] { num2, magnitude });
		}

		private void LookAtTargetOrigin()
		{
			//IL_0010: 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)
			((Component)this).transform.LookAt(((Component)Camera.main).transform.position);
			((Component)this).transform.Rotate(Vector3.up, 180f);
		}

		private void ActivateSpecificKeyboard(LayoutType keyboardType)
		{
			DisableAllKeyboards();
			ResetKeyboardState();
			switch (keyboardType)
			{
			case LayoutType.URL:
				ShowAlphaKeyboard();
				TryToShowURLSubkeys();
				break;
			case LayoutType.Email:
				ShowAlphaKeyboard();
				TryToShowEmailSubkeys();
				break;
			case LayoutType.Symbol:
				ShowSymbolKeyboard();
				break;
			default:
				ShowAlphaKeyboard();
				TryToShowAlphaSubkeys();
				break;
			}
		}

		public void AppendValue(KeyboardValueKey valueKey)
		{
			IndicateActivity();
			string text = "";
			this.OnKeyboardValueKeyPressed(valueKey);
			text = ((!m_IsShifted || string.IsNullOrEmpty(valueKey.ShiftValue)) ? valueKey.Value : valueKey.ShiftValue);
			if (!m_IsCapslocked)
			{
				Shift(newShiftState: false);
			}
			m_CaretPosition = InputField.caretPosition;
			InputField.text = InputField.text.Insert(m_CaretPosition, text);
			m_CaretPosition += text.Length;
			UpdateCaretPosition(m_CaretPosition);
		}

		public void FunctionKey(KeyboardKeyFunc functionKey)
		{
			IndicateActivity();
			this.OnKeyboardFunctionKeyPressed(functionKey);
			switch (functionKey.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Enter:
				Enter();
				break;
			case KeyboardKeyFunc.Function.Tab:
				Tab();
				break;
			case KeyboardKeyFunc.Function.ABC:
				ActivateSpecificKeyboard(m_LastKeyboardLayout);
				break;
			case KeyboardKeyFunc.Function.Symbol:
				ActivateSpecificKeyboard(LayoutType.Symbol);
				break;
			case KeyboardKeyFunc.Function.Previous:
				MoveCaretLeft();
				break;
			case KeyboardKeyFunc.Function.Next:
				MoveCaretRight();
				break;
			case KeyboardKeyFunc.Function.Close:
				Close();
				break;
			case KeyboardKeyFunc.Function.Shift:
				Shift(!m_IsShifted);
				break;
			case KeyboardKeyFunc.Function.CapsLock:
				CapsLock(!m_IsCapslocked);
				break;
			case KeyboardKeyFunc.Function.Space:
				Space();
				break;
			case KeyboardKeyFunc.Function.Backspace:
				Backspace();
				break;
			case KeyboardKeyFunc.Function.Macro:
				Macro(functionKey.MacroText);
				break;
			case KeyboardKeyFunc.Function.UNDEFINED:
				Debug.LogErrorFormat("The {0} key on this keyboard hasn't been assigned a function.", new object[1] { ((Object)functionKey).name });
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
		}

		public void Backspace()
		{
			if (InputField.selectionFocusPosition != InputField.caretPosition || InputField.selectionAnchorPosition != InputField.caretPosition)
			{
				if (InputField.selectionAnchorPosition > InputField.selectionFocusPosition)
				{
					InputField.text = InputField.text.Substring(0, InputField.selectionFocusPosition) + InputField.text.Substring(InputField.selectionAnchorPosition);
					InputField.caretPosition = InputField.selectionFocusPosition;
				}
				else
				{
					InputField.text = InputField.text.Substring(0, InputField.selectionAnchorPosition) + InputField.text.Substring(InputField.selectionFocusPosition);
					InputField.caretPosition = InputField.selectionAnchorPosition;
				}
				m_CaretPosition = InputField.caretPosition;
				InputField.selectionAnchorPosition = m_CaretPosition;
				InputField.selectionFocusPosition = m_CaretPosition;
			}
			else
			{
				m_CaretPosition = InputField.caretPosition;
				if (m_CaretPosition > 0)
				{
					m_CaretPosition--;
					InputField.text = InputField.text.Remove(m_CaretPosition, 1);
					UpdateCaretPosition(m_CaretPosition);
				}
			}
		}

		public void Previous()
		{
			this.OnPrevious(this, EventArgs.Empty);
		}

		public void Next()
		{
			this.OnNext(this, EventArgs.Empty);
		}

		public void Enter()
		{
			this.OnTextSubmitted?.Invoke(this, EventArgs.Empty);
			if (SubmitOnEnter)
			{
				InputField.OnSubmit((BaseEventData)null);
			}
			if (CloseOnEnter)
			{
				Close();
			}
		}

		public void Macro(string text)
		{
			this.OnMacroTriggered?.Invoke(text);
		}

		public void Shift(bool newShiftState)
		{
			m_IsShifted = newShiftState;
			this.OnKeyboardShifted(m_IsShifted);
			if (m_IsCapslocked && !newShiftState)
			{
				m_IsCapslocked = false;
			}
		}

		public void CapsLock(bool newCapsLockState)
		{
			m_IsCapslocked = newCapsLockState;
			Shift(newCapsLockState);
		}

		public void Space()
		{
			m_CaretPosition = InputField.caretPosition;
			InputField.text = InputField.text.Insert(m_CaretPosition++, " ");
			UpdateCaretPosition(m_CaretPosition);
		}

		public void Tab()
		{
			string text = "\t";
			m_CaretPosition = InputField.caretPosition;
			InputField.text = InputField.text.Insert(m_CaretPosition, text);
			m_CaretPosition += text.Length;
			UpdateCaretPosition(m_CaretPosition);
		}

		public void MoveCaretLeft()
		{
			m_CaretPosition = InputField.caretPosition;
			if (m_CaretPosition > 0)
			{
				m_CaretPosition--;
				UpdateCaretPosition(m_CaretPosition);
			}
		}

		public void MoveCaretRight()
		{
			m_CaretPosition = InputField.caretPosition;
			if (m_CaretPosition < InputField.text.Length)
			{
				m_CaretPosition++;
				UpdateCaretPosition(m_CaretPosition);
			}
		}

		public void Close()
		{
			((Component)this).gameObject.SetActive(false);
			this.OnClosed(this, EventArgs.Empty);
		}

		public void Clear()
		{
			ResetKeyboardState();
			if (InputField.caretPosition != 0)
			{
				InputField.MoveTextStart(false);
			}
			InputField.text = "";
			m_CaretPosition = InputField.caretPosition;
		}

		public void SetScaleSizeValues(float minScale, float maxScale, float minDistance, float maxDistance)
		{
			m_MinScale = minScale;
			m_MaxScale = maxScale;
			m_MinDistance = minDistance;
			m_MaxDistance = maxDistance;
		}

		public void ShowAlphaKeyboard()
		{
			((Component)NumbersKeyboard).gameObject.SetActive(true);
			((Component)AlphaKeyboard).gameObject.SetActive(true);
			m_LastKeyboardLayout = LayoutType.Alpha;
		}

		private bool TryToShowAlphaSubkeys()
		{
			if (((UIBehaviour)AlphaKeyboard).IsActive())
			{
				((Component)AlphaSubKeys).gameObject.SetActive(true);
				return true;
			}
			return false;
		}

		private bool TryToShowEmailSubkeys()
		{
			if (((UIBehaviour)AlphaKeyboard).IsActive())
			{
				((Component)AlphaMailKeys).gameObject.SetActive(true);
				m_LastKeyboardLayout = LayoutType.Email;
				return true;
			}
			return false;
		}

		private bool TryToShowURLSubkeys()
		{
			if (((UIBehaviour)AlphaKeyboard).IsActive())
			{
				((Component)AlphaWebKeys).gameObject.SetActive(true);
				m_LastKeyboardLayout = LayoutType.URL;
				return true;
			}
			return false;
		}

		public void ShowSymbolKeyboard()
		{
			((Component)SymbolKeyboard).gameObject.SetActive(true);
		}

		private void DisableAllKeyboards()
		{
			((Component)NumbersKeyboard).gameObject.SetActive(false);
			((Component)AlphaKeyboard).gameObject.SetActive(false);
			((Component)SymbolKeyboard).gameObject.SetActive(false);
			((Component)AlphaWebKeys).gameObject.SetActive(false);
			((Component)AlphaMailKeys).gameObject.SetActive(false);
			((Component)AlphaSubKeys).gameObject.SetActive(false);
		}

		private void ResetKeyboardState()
		{
			CapsLock(newCapsLockState: false);
		}

		private void IndicateActivity()
		{
			ResetClosingTime();
			if ((Object)(object)_audioSource == (Object)null)
			{
				_audioSource = ((Component)this).GetComponent<AudioSource>();
			}
			if ((Object)(object)_audioSource != (Object)null)
			{
				_audioSource.Play();
			}
		}

		private void ResetClosingTime()
		{
			if (CloseOnInactivity)
			{
				_closingTime = Time.time + CloseOnInactivityTime;
			}
		}

		private void CheckForCloseOnInactivityTimeExpired()
		{
			if (Time.time > _closingTime && CloseOnInactivity)
			{
				Close();
			}
		}
	}
	public class SymbolDisableHighlight : MonoBehaviour
	{
		[SerializeField]
		private Text m_TextField;

		[SerializeField]
		private Image m_ImageField;

		[SerializeField]
		private Color m_DisabledColor = Color.grey;

		private Color m_StartingColor = Color.white;

		private Button m_Button;

		private void Start()
		{
			//IL_0015: 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)
			//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)
			if ((Object)(object)m_TextField != (Object)null)
			{
				m_StartingColor = ((Graphic)m_TextField).color;
			}
			if ((Object)(object)m_ImageField != (Object)null)
			{
				m_StartingColor = ((Graphic)m_ImageField).color;
			}
			m_Button = ((Component)this).GetComponentInParent<Button>();
			UpdateState();
		}

		private void Update()
		{
			UpdateState();
		}

		private void UpdateState()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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)
			if ((Object)(object)m_TextField != (Object)null && (Object)(object)m_Button != (Object)null)
			{
				((Graphic)m_TextField).color = (((Selectable)m_Button).interactable ? m_StartingColor : m_DisabledColor);
			}
			if ((Object)(object)m_ImageField != (Object)null && (Object)(object)m_Button != (Object)null)
			{
				((Graphic)m_ImageField).color = (((Selectable)m_Button).interactable ? m_StartingColor : m_DisabledColor);
			}
		}
	}
	public class SymbolKeyboard : MonoBehaviour
	{
		private NonNativeKeyboard keyboard;

		[SerializeField]
		private Button m_PageBck;

		[SerializeField]
		private Button m_PageFwd;

		private void Awake()
		{
			if ((Object)(object)keyboard == (Object)null)
			{
				keyboard = ((Component)this).GetComponentInParent<NonNativeKeyboard>();
			}
		}

		private void Update()
		{
			((Selectable)m_PageBck).interactable = keyboard.IsShifted;
			((Selectable)m_PageFwd).interactable = !keyboard.IsShifted;
		}
	}
	[AddComponentMenu("Scripts/MRTK/Experimental/UICollection")]
	[RequireComponent(typeof(RectTransform))]
	[ExecuteInEditMode]
	public class UICollection : MonoBehaviour
	{
		[SerializeField]
		private float maxWidth = -1f;

		[SerializeField]
		private float maxHeight = -1f;

		[SerializeField]
		private float horizontalSpacing;

		[SerializeField]
		private float verticalSpacing;

		private RectTransform rectTransform;

		public float MaxWidth
		{
			get
			{
				return maxWidth;
			}
			set
			{
				maxWidth = value;
			}
		}

		public float MaxHeight
		{
			get
			{
				return maxHeight;
			}
			set
			{
				maxHeight = value;
			}
		}

		public float HorizontalSpacing
		{
			get
			{
				return horizontalSpacing;
			}
			set
			{
				horizontalSpacing = value;
			}
		}

		public float VerticalSpacing
		{
			get
			{
				return verticalSpacing;
			}
			set
			{
				verticalSpacing = value;
			}
		}

		public List<RectTransform> Items { get; private set; }

		private void Awake()
		{
			Items = new List<RectTransform>();
		}

		private void Start()
		{
			rectTransform = ((Component)this).GetComponent<RectTransform>();
			if (Application.isEditor)
			{
				CollectItems();
				UpdateLayout();
			}
		}

		private void Update()
		{
			if (Application.isEditor)
			{
				CollectItems();
				UpdateLayout();
			}
		}

		public void AddItem(RectTransform item)
		{
			//IL_001e: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			Items.Add(item);
			((Transform)item).SetParent(((Component)this).transform);
			((Component)item).transform.localScale = Vector3.one;
			((Transform)item).position = Vector3.zero;
			item.anchoredPosition3D = Vector3.zero;
			UpdateLayout();
		}

		public void RemoveItem(RectTransform item)
		{
			Items.Remove(item);
			UpdateLayout();
		}

		public void RemoveAllItems()
		{
			Items.Clear();
			UpdateLayout();
		}

		private void CollectItems()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Items.Clear();
			foreach (Transform item in ((Component)this).transform)
			{
				RectTransform component = ((Component)item).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					AddItem(component);
				}
			}
		}

		protected virtual void UpdateLayout()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = rectTransform.rect;
			Vector2 zero = Vector2.zero;
			if (maxWidth < 0f)
			{
				zero.x = ((Rect)(ref rect)).width;
			}
			else
			{
				zero.x = maxWidth;
			}
			if (maxHeight < 0f)
			{
				zero.y = ((Rect)(ref rect)).height;
			}
			else
			{
				zero.y = maxHeight;
			}
			Vector2 zero2 = Vector2.zero;
			Vector2 up = Vector2.up;
			float num = 0f;
			float num2 = 0f;
			for (int i = 0; i < Items.Count; i++)
			{
				Items[i].anchorMin = up;
				Items[i].anchorMax = up;
				Items[i].pivot = up;
				Rect rect2 = Items[i].rect;
				num = Mathf.Max(((Rect)(ref rect2)).height, num);
				rect2 = Items[i].rect;
				if (((Rect)(ref rect2)).width + zero2.x > zero.x)
				{
					zero2.y += num + verticalSpacing;
					zero2.x = 0f;
					rect2 = Items[i].rect;
					num = ((Rect)(ref rect2)).height;
					rect2 = Items[i].rect;
					if (((Rect)(ref rect2)).height + zero2.y > zero.y)
					{
						break;
					}
				}
				Items[i].anchoredPosition = new Vector2(zero2.x, 0f - zero2.y);
				ref float x = ref zero2.x;
				float num3 = x;
				rect2 = Items[i].rect;
				x = num3 + (((Rect)(ref rect2)).width + horizontalSpacing);
				num2 = Mathf.Max(zero2.x - horizontalSpacing, num2);
			}
			float num4 = ((maxWidth < 0f) ? ((Rect)(ref rect)).width : num2);
			float num5 = ((maxHeight < 0f) ? ((Rect)(ref rect)).height : (num + zero2.y));
			rectTransform.sizeDelta = new Vector2(num4, num5);
		}
	}
}
namespace LCVR
{
	public class Compat
	{
		private class CompatibleMod
		{
			public string Name { get; }

			public string Guid { get; }

			public CompatibleMod(string name, string guid)
			{
				Name = name;
				Guid = guid;
				base..ctor();
			}
		}

		private readonly CompatibleMod[] ModCompatibilityList = new CompatibleMod[4]
		{
			new CompatibleMod("MoreCompany", "me.swipez.melonloader.morecompany"),
			new CompatibleMod("Mimics", "x753.Mimics"),
			new CompatibleMod("Diversity", "Chaos.Diversity"),
			new CompatibleMod("CullFactory", "com.fumiko.CullFactory")
		};

		private readonly List<string> DetectedMods = new List<string>();

		public Compat(IEnumerable<PluginInfo> plugins)
		{
			foreach (PluginInfo plugin in plugins)
			{
				CompatibleMod compatibleMod = ModCompatibilityList.FirstOrDefault((CompatibleMod mod) => mod.Guid == plugin.Metadata.GUID);
				if (compatibleMod != null)
				{
					Logger.LogInfo("Found compatible mod " + compatibleMod.Name);
					DetectedMods.Add(compatibleMod.Name);
				}
			}
		}

		public bool IsLoaded(string modName)
		{
			return DetectedMods.Contains(modName);
		}
	}
	public class Config
	{
		public enum TurnProviderOption
		{
			Snap,
			Smooth,
			Disabled
		}

		public ConfigEntry<TurnProviderOption> TurnProvider;

		public ConfigFile File { get; }

		public ConfigEntry<bool> DisableVR { get; }

		public ConfigEntry<bool> AskOnStartup { get; }

		public ConfigEntry<bool> IntroScreenSeen { get; }

		public ConfigEntry<bool> EnableHelmetVisor { get; }

		public ConfigEntry<bool> EnableDynamicResolution { get; }

		public ConfigEntry<DynamicResUpscaleFilter> DynamicResolutionUpscaleFilter { get; }

		public ConfigEntry<float> DynamicResolutionPercentage { get; }

		public ConfigEntry<bool> EnableDLSS { get; }

		public ConfigEntry<float> CameraResolution { get; }

		public ConfigEntry<bool> DisableVolumetrics { get; }

		public ConfigEntry<float> SmoothTurnSpeedModifier { get; }

		public ConfigEntry<float> SnapTurnSize { get; }

		public ConfigEntry<bool> ToggleSprint { get; }

		public ConfigEntry<float> MovementSprintToggleCooldown { get; }

		public ConfigEntry<string> ControllerBindingsOverrideProfile { get; }

		public ConfigEntry<bool> DisableArmHUD { get; }

		public ConfigEntry<float> HUDOffsetX { get; }

		public ConfigEntry<float> HUDOffsetY { get; }

		public ConfigEntry<bool> EnableInteractRay { get; }

		public ConfigEntry<bool> EnableCustomCamera { get; }

		public ConfigEntry<float> CustomCameraFOV { get; }

		public ConfigEntry<float> CustomCameraLerpFactor { get; }

		public ConfigEntry<float> LODBias { get; }

		public ConfigEntry<bool> DisableLensDistortion { get; }

		public ConfigEntry<bool> DisableShipLeverInteraction { get; }

		public ConfigEntry<bool> DisableChargeStationInteraction { get; }

		public ConfigEntry<bool> DisableMonitorInteraction { get; }

		public ConfigEntry<bool> DisableShipDoorInteraction { get; }

		public ConfigEntry<bool> DisableTeleporterInteraction { get; }

		public ConfigEntry<bool> DisableShipHornInteraction { get; }

		public ConfigEntry<bool> DisableCompanyBellInteraction { get; }

		public ConfigEntry<bool> DisableBreakerBoxInteraction { get; }

		public ConfigEntry<bool> DisableDoorInteraction { get; }

		public ConfigEntry<bool> DisableMuffleInteraction { get; }

		public ConfigEntry<bool> DisableFaceInteractions { get; }

		public ConfigEntry<string> LastInternalControllerProfile { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public ConfigEntry<bool> DisableSettingsButton { get; }

		public Config(ConfigFile file)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Expected O, but got Unknown
			File = file;
			DisableVR = file.Bind<bool>("General", "DisableVR", false, "Disables the main functionality of this mod, can be used if you want to play without VR while keeping the mod installed.");
			AskOnStartup = file.Bind<bool>("General", "AskOnStartup", false, "When enabled, shows a popup on game launch where you are asked whether or not you want to play in VR. If DisableVR is set to true, this popup will not show.");
			IntroScreenSeen = file.Bind<bool>("General", "IntroScreenSeen", false, "Whether the VR intro screen has been displayed before. This configuration option should be set automatically.");
			EnableHelmetVisor = file.Bind<bool>("General", "EnableHelmetVisor", false, "Enables the first person helmet visor and helmet. This will restrict your field of view, but looks more immersive.");
			EnableDynamicResolution = file.Bind<bool>("Performance", "EnableDynamicResolution", false, "Whether or not dynamic resolution should be enabled. Required for most of these settings to have an effect.");
			DynamicResolutionUpscaleFilter = file.Bind<DynamicResUpscaleFilter>("Performance", "DynamicResolutionUpscaleFilter", (DynamicResUpscaleFilter)4, new ConfigDescription("The filter/algorithm that will be used to perform dynamic resolution upscaling. Defaulted to FSR (Edge Adaptive Scaling).", (AcceptableValueBase)(object)new AcceptableValueEnum<DynamicResUpscaleFilter>(), Array.Empty<object>()));
			DynamicResolutionPercentage = file.Bind<float>("Performance", "DynamicResolutionPercentage", 80f, new ConfigDescription("The percentage of resolution to scale the game down to. The lower the value, the harder the upscale filter has to work which will result in quality loss.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			EnableDLSS = file.Bind<bool>("Performance", "EnableDLSS", false, "(Not recommended!) Enable DLSS support for the game. Requires dynamic resolution to be enabled. DLSS will override the upscale filter used.");
			CameraResolution = file.Bind<float>("Performance", "CameraResolution", 0.75f, new ConfigDescription("This setting configures the resolution scale of the game, lower values are more performant, but will make the game look worse. From around 0.8 the difference is negligible (on a Quest 2, with dynamic resolution disabled).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			DisableVolumetrics = file.Bind<bool>("Performance", "DisableVolumetrics", false, "Disables volumetrics in the game, which significantly improves performance, but removes all fog and may be considered cheating.");
			TurnProvider = file.Bind<TurnProviderOption>("Input", "TurnProvider", TurnProviderOption.Snap, new ConfigDescription("Specify which turning provider your player uses, if any.", (AcceptableValueBase)(object)new AcceptableValueEnum<TurnProviderOption>(), Array.Empty<object>()));
			SmoothTurnSpeedModifier = file.Bind<float>("Input", "SmoothTurnSpeedModifier", 1f, new ConfigDescription("A multiplier that is added to the smooth turning speed. Requires turn provider to be set to smooth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
			SnapTurnSize = file.Bind<float>("Input", "SnapTurnSize", 45f, new ConfigDescription("The amount of rotation that is applied when performing a snap turn. Requires turn provider to be set to snap.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 180f), Array.Empty<object>()));
			ToggleSprint = file.Bind<bool>("Input", "ToggleSprint", false, "Whether the sprint button should toggle sprint instead of having to hold it down.");
			MovementSprintToggleCooldown = file.Bind<float>("Input", "MovementSprintToggleCooldown", 1f, new ConfigDescription("The amount of seconds that you need to stand still for sprint to be toggled off automatically. Requires sprint toggle to be enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 60f), Array.Empty<object>()));
			ControllerBindingsOverrideProfile = file.Bind<string>("Input", "ControllerBindingsOverrideProfile", "", "Specify the name of a controler profile you would like to use. Keep empty to use the built-in controller profiles. You can find a list of available controller profiles on https://github.com/DaXcess/LCVR-Controller-Profiles. To test a local profile, specify a path using the file protocol (e.g. file:///C:/Users/.../profile.inputactions)");
			DisableArmHUD = file.Bind<bool>("UI", "DisableArmHUD", false, "Removes the HUD from the arms and displays them in front of the camera.");
			HUDOffsetX = file.Bind<float>("UI", "OffsetX", 0f, "The x offset of the HUD that was placed on the camera instead of the arms. Requires the arm HUD to be disabled.");
			HUDOffsetY = file.Bind<float>("UI", "OffsetY", 0f, "The y offset of the HUD that was placed on the camera instead of the arms. Requires the arm HUD to be disabled.");
			EnableInteractRay = file.Bind<bool>("UI", "EnableInteractRay", false, "Enable a visible ray coming out of the hand that tells you where you are currently aiming at. More or less for debug purposes, but can be used to get a feel for the rotations and such.");
			EnableCustomCamera = file.Bind<bool>("Rendering", "EnableCustomCamera", false, "Adds a second camera mounted on top of the VR camera that will render seperately from the VR camera to the monitor. This requires quite a bit of extra GPU power!");
			CustomCameraFOV = file.Bind<float>("Rendering", "CustomCameraFOV", 90f, new ConfigDescription("The field of view that the custom camera should have.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(45f, 120f), Array.Empty<object>()));
			CustomCameraLerpFactor = file.Bind<float>("Rendering", "CustomCameraLerpFactor", 0.1f, new ConfigDescription("The smoothing factor of the custom camera rotation. Higher values mean more static movement, lower values are more smooth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 1f), Array.Empty<object>()));
			LODBias = file.Bind<float>("Rendering", "LODBias", 2f, new ConfigDescription("The LOD bias is a multiplier that dictates when an LOD must reduce their quality. Higher values means that more detailed LODs will persist for longer.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f), Array.Empty<object>()));
			DisableLensDistortion = file.Bind<bool>("Rendering", "DisableLensDistortion", false, "Disables the warping effects that you experience when you are under water, use the TZP-inhalant and more.");
			DisableShipLeverInteraction = file.Bind<bool>("Interaction", "DisableShipLeverInteraction", false, "Disables the physical lever pull interaction on the ship lever.");
			DisableChargeStationInteraction = file.Bind<bool>("Interaction", "DisableChargeStationInteraction", false, "Disables needing to hold items up to the charger physically.");
			DisableMonitorInteraction = file.Bind<bool>("Interaction", "DisableMonitorInteraction", false, "Disables needing to physically press the buttons for the monitor.");
			DisableShipDoorInteraction = file.Bind<bool>("Interaction", "DisableShipDoorInteraction", false, "Disables needing to physically press the buttons for the ship door.");
			DisableTeleporterInteraction = file.Bind<bool>("Interaction", "DisableTeleporterInteraction", false, "Disables needing to physically press the buttons for the teleporters.");
			DisableShipHornInteraction = file.Bind<bool>("Interaction", "DisableShipHornInteraction", false, "Disables needing to physically pull the cord on the ship horn.");
			DisableCompanyBellInteraction = file.Bind<bool>("Interaction", "DisableCompanyBellInteraction", false, "Disables needing to physically press the bell at the company desk.");
			DisableBreakerBoxInteraction = file.Bind<bool>("Interaction", "DisableBreakerBoxInteraction", false, "Disabled needing to physically open the breaker box and flip the switches with your finger.");
			DisableDoorInteraction = file.Bind<bool>("Interaction", "DisableDoorInteraction", false, "Disable needing to physically open and close doors by interacting with the door handles. Will also disable the need to use keys and lockpickers physically on the door handle.");
			DisableMuffleInteraction = file.Bind<bool>("Interaction", "DisableMuffleInteraction", false, "Disables the self-muffling feature, which makes it so that holding your hand in front of your mouth will no longer make you inaudible to enemies.");
			DisableFaceInteractions = file.Bind<bool>("Interaction", "DisableFaceInteractions", false, "Disables the functionality to hold certain items up to your face to use them.");
			LastInternalControllerProfile = file.Bind<string>("Internal", "LastInternalControllerProfile", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			OpenXRRuntimeFile = file.Bind<string>("Internal", "OpenXRRuntimeFile", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			DisableSettingsButton = file.Bind<bool>("Internal", "DisableSettingsButton", false, "Disables the settings button on the main menu screen");
			base..ctor();
		}
	}
	internal class AcceptableValueEnum<T> : AcceptableValueBase where T : notnull, Enum
	{
		private readonly string[] names = Enum.GetNames(typeof(T));

		public AcceptableValueEnum()
			: base(typeof(T))
		{
		}

		public override object Clamp(object value)
		{
			return value;
		}

		public override bool IsValid(object value)
		{
			return true;
		}

		public override string ToDescriptionString()
		{
			return "# Acceptable values: " + string.Join(", ", names);
		}
	}
	[LCVRPatch(LCVRPatchTarget.VROnly, null)]
	[HarmonyPatch]
	internal class VREntryPoint
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void OnGameEntered()
		{
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Start());
		}

		private static IEnumerator Start()
		{
			Logger.Log("Hello from VR!");
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance.activeCamera != (Object)null));
		}
	}
	[LCVRPatch(LCVRPatchTarget.Universal, null)]
	[HarmonyPatch]
	internal class UniversalEntryPoint
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void OnGameEntered()
		{
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Start());
		}

		private static IEnumerator Start()
		{
			Logger.Log("Hello from universal!");
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance.activeCamera != (Object)null));
			new GameObject("LCVR Session Manager").AddComponent<VRSession>();
			yield return DNet.Initialize();
		}

		[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
		[HarmonyPostfix]
		private static void OnGameLeave()
		{
			DNet.Shutdown();
		}
	}
	public static class Logger
	{
		private static ManualLogSource logSource;

		public static void SetSource(ManualLogSource Logger)
		{
			logSource = Logger;
		}

		public static void Log(object message)
		{
			logSource.LogInfo(message);
		}

		public static void LogInfo(object message)
		{
			logSource.LogInfo(message);
		}

		public static void LogWarning(object message)
		{
			logSource.LogWarning(message);
		}

		public static void LogError(object message)
		{
			logSource.LogError(message);
		}

		public static void LogDebug(object message)
		{
			logSource.LogDebug(message);
		}
	}
	public class NamedLogger
	{
		private readonly string name;

		public NamedLogger(string name)
		{
			this.name = name;
			base..ctor();
		}

		public void Log(string message)
		{
			Logger.Log("[" + name + "] " + message);
		}

		public void LogInfo(string message)
		{
			Logger.LogInfo("[" + name + "] " + message);
		}

		public void LogWarning(string message)
		{
			Logger.LogWarning("[" + name + "] " + message);
		}

		public void LogError(string message)
		{
			Logger.LogError("[" + name + "] " + message);
		}

		public void LogDebug(string message)
		{
			Logger.LogDebug("[" + name + "] " + message);
		}
	}
	internal static class Native
	{
		private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

		public static readonly IntPtr HKEY_LOCAL_MACHINE = new IntPtr(2147483650L);

		[DllImport("user32.dll", CharSet = CharSet.Unicode)]
		private static extern int GetWindowText(IntPtr hWnd, StringBuilder strText, int maxCount);

		[DllImport("user32.dll", CharSet = CharSet.Unicode)]
		private static extern int GetWindowTextLength(IntPtr hWnd);

		[DllImport("user32.dll")]
		private static extern bool EnumWindows(EnumWindowsProc enumProc, IntPtr lParam);

		[DllImport("user32.dll")]
		private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);

		[DllImport("user32.dll")]
		private static extern bool BringWindowToTop(IntPtr hWnd);

		[DllImport("user32.dll")]
		private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

		[DllImport("user32.dll")]
		private static extern IntPtr GetForegroundWindow();

		[DllImport("user32.dll")]
		private static extern void AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

		[DllImport("kernel32.dll")]
		private static extern uint GetCurrentProcessId();

		[DllImport("kernel32.dll")]
		private static extern uint GetCurrentThreadId();

		[DllImport("Advapi32.dll", CharSet = CharSet.Ansi, EntryPoint = "RegOpenKeyExA")]
		public static extern int RegOpenKeyEx(IntPtr hKey, [In] string lpSubKey, int ulOptions, int samDesired, out IntPtr phkResult);

		[DllImport("advapi32.dll", CharSet = CharSet.Ansi)]
		public static extern int RegQueryValueEx(IntPtr hKey, string lpValueName, int lpReserved, out uint lpType, StringBuilder lpData, ref uint lpcbData);

		[DllImport("advapi32.dll", CharSet = CharSet.Ansi)]
		public static extern int RegQueryInfoKey(IntPtr hKey, StringBuilder lpClass, IntPtr lpcbClass, IntPtr lpReserved, out uint lpcSubKeys, out uint lpcbMaxSubKeyLen, out uint lpcbMaxClassLen, out uint lpcValues, out uint lpcbMaxValueNameLen, out uint lpcbMaxValueLen, IntPtr lpSecurityDescriptor, IntPtr lpftLastWriteTime);

		[DllImport("advapi32.dll", CharSet = CharSet.Ansi, EntryPoint = "RegEnumValueA")]
		public static extern int RegEnumValue(IntPtr hKey, uint dwIndex, StringBuilder lpValueName, ref uint lpcchValueName, IntPtr lpReserved, IntPtr lpType, IntPtr lpData, IntPtr lpcbData);

		[DllImport("advapi32.dll")]
		public static extern int RegCloseKey(IntPtr hKey);

		[DllImport("Shlwapi.dll", CharSet = CharSet.Ansi)]
		public static extern int ShellMessageBox(IntPtr hAppInst, IntPtr hWnd, string lpcText, string lpcTitle, uint fuStyle);

		private static string GetWindowText(IntPtr hWnd)
		{
			int windowTextLength = GetWindowTextLength(hWnd);
			if (windowTextLength > 0)
			{
				StringBuilder stringBuilder = new StringBuilder(windowTextLength + 1);
				GetWindowText(hWnd, stringBuilder, stringBuilder.Capacity);
				return stringBuilder.ToString();
			}
			return string.Empty;
		}

		private static IEnumerable<IntPtr> FindWindows(EnumWindowsProc filter)
		{
			_ = IntPtr.Zero;
			List<IntPtr> windows = new List<IntPtr>();
			EnumWindows(delegate(IntPtr wnd, IntPtr param)
			{
				if (filter(wnd, param))
				{
					windows.Add(wnd);
				}
				return true;
			}, IntPtr.Zero);
			return windows;
		}

		public static void BringGameWindowToFront()
		{
			uint currentPid = GetCurrentProcessId();
			IntPtr[] array = FindWindows(delegate(IntPtr hWnd, IntPtr lParam)
			{
				GetWindowThreadProcessId(hWnd, out var processId2);
				return processId2 == currentPid && GetWindowText(hWnd) == "Lethal Company";
			}).ToArray();
			if (array.Length > 1)
			{
				Logger.LogWarning("Multiple game windows called 'Lethal Company' detected. Selecting only the first one.");
			}
			IntPtr hWnd2 = array[0];
			uint processId;
			uint windowThreadProcessId = GetWindowThreadProcessId(GetForegroundWindow(), out processId);
			uint currentThreadId = GetCurrentThreadId();
			AttachThreadInput(windowThreadProcessId, currentThreadId, fAttach: true);
			BringWindowToTop(hWnd2);
			AttachThreadInput(windowThreadProcessId, currentThreadId, fAttach: false);
		}
	}
	internal class OpenXR
	{
		public class OpenXRReport
		{
			public string RuntimeName { get; }

			public string RuntimeVersion { get; }

			public string Error { get; }

			public OpenXRReport(string runtimeName, string runtimeVersion, string error)
			{
				RuntimeName = runtimeName;
				RuntimeVersion = runtimeVersion;
				Error = error;
				base..ctor();
			}
		}

		[Serializable]
		private struct OpenXRRuntime
		{
			public RuntimeInfo runtime;
		}

		[Serializable]
		private struct RuntimeInfo
		{
			public string name;
		}

		[DllImport("UnityOpenXR", EntryPoint = "DiagnosticReport_GenerateReport")]
		private static extern IntPtr Internal_GenerateReport();

		[DllImport("UnityOpenXR", EntryPoint = "DiagnosticReport_ReleaseReport")]
		private static extern void Internal_ReleaseReport(IntPtr report);

		[DllImport("UnityOpenXR", EntryPoint = "NativeConfig_GetRuntimeName")]
		private static extern bool Internal_GetRuntimeName(out IntPtr runtimeNamePtr);

		[DllImport("UnityOpenXR", EntryPoint = "NativeConfig_GetRuntimeVersion")]
		private static extern bool Internal_GetRuntimeVersion(out ushort major, out ushort minor, out ushort patch);

		public static string GenerateReport()
		{
			string result = "";
			IntPtr intPtr = Internal_GenerateReport();
			if (intPtr != IntPtr.Zero)
			{
				result = Marshal.PtrToStringAnsi(intPtr);
				Internal_ReleaseReport(intPtr);
			}
			return result;
		}

		public static bool GetDiagnosticReport(out OpenXRReport report)
		{
			report = null;
			Regex regex = new Regex("^==== ([A-z0-9-_ ]+) ====$", RegexOptions.Multiline);
			Regex regex2 = new Regex("^\\[FAILURE\\] [A-z]+: ([A-Z_]+) \\(\\d+x\\)$");
			string input = GenerateReport();
			string[] array = (from v in regex.Split(input).Skip(1)
				select v.Trim()).ToArray();
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			for (int i = 0; i < array.Length; i += 2)
			{
				dictionary.Add(array[i], array[i + 1]);
			}
			if (!dictionary.TryGetValue("OpenXR Runtime Info", out var value))
			{
				return false;
			}
			string[] source = value.Split('\n');
			string text = source.FirstOrDefault((string line) => line.StartsWith("Runtime Name: "));
			string text2 = source.FirstOrDefault((string line) => line.StartsWith("Runtime Version: "));
			if (text == null || text2 == null)
			{
				text = "<Missing>";
				text2 = "<Missing>";
			}
			else
			{
				text = text.Split(": ")[1];
				text2 = text2.Split(": ")[1];
			}
			if (!dictionary.TryGetValue("Last 20 non-XR_SUCCESS returns", out value))
			{
				return false;
			}
			Match match = regex2.Match(value.Split('\n')[0].Trim());
			if (match == null)
			{
				return false;
			}
			string value2 = match.Groups[1].Value;
			report = new OpenXRReport(text, text2, value2);
			return true;
		}

		public static Dictionary<string, string> DetectOpenXRRuntimes(out string @default)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			@default = null;
			IntPtr phkResult = IntPtr.Zero;
			uint lpcbData = 0u;
			try
			{
				if (Native.RegOpenKeyEx(Native.HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenXR\\1", 0, 131097, out phkResult) != 0)
				{
					throw new Exception("Failed to open registry key HKLM\\SOFTWARE\\Khronos\\OpenXR\\1");
				}
				if (Native.RegQueryValueEx(phkResult, "ActiveRuntime", 0, out var lpType, null, ref lpcbData) != 0)
				{
					throw new Exception("Failed to query ActiveRuntime value");
				}
				StringBuilder stringBuilder = new StringBuilder((int)lpcbData);
				if (Native.RegQueryValueEx(phkResult, "ActiveRuntime", 0, out lpType, stringBuilder, ref lpcbData) != 0)
				{
					throw new Exception("Failed to query ActiveRuntime value");
				}
				string path = stringBuilder.ToString();
				@default = JsonConvert.DeserializeObject<OpenXRRuntime>(File.ReadAllText(path)).runtime.name;
				if (Native.RegOpenKeyEx(phkResult, "AvailableRuntimes", 0, 131097, out phkResult) != 0)
				{
					throw new Exception("Failed to open AvailableRuntimes registry key");
				}
				if (Native.RegQueryInfoKey(phkResult, null, IntPtr.Zero, IntPtr.Zero, out var _, out var _, out var _, out var lpcValues, out var lpcbMaxValueNameLen, out var _, IntPtr.Zero, IntPtr.Zero) != 0)
				{
					throw new Exception("Failed to query AvailableRuntimes registry key");
				}
				List<string> list = new List<string>();
				for (uint num = 0u; num < lpcValues; num++)
				{
					try
					{
						StringBuilder stringBuilder2 = new StringBuilder((int)(lpcbMaxValueNameLen + 1));
						uint lpcchValueName = lpcbMaxValueNameLen + 1;
						if (Native.RegEnumValue(phkResult, num, stringBuilder2, ref lpcchValueName, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) == 0)
						{
							list.Add(stringBuilder2.ToString());
						}
					}
					catch
					{
					}
				}
				foreach (string item in list)
				{
					int num2 = 0;
					string name = JsonConvert.DeserializeObject<OpenXRRuntime>(File.ReadAllText(item)).runtime.name;
					string key = name;
					while (dictionary.ContainsKey(key))
					{
						num2++;
						key = $"{name} ({num2})";
					}
					dictionary.Add(name, item);
				}
				return dictionary;
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to query runtimes: " + ex.Message);
				return null;
			}
			finally
			{
				if (phkResult != IntPtr.Zero)
				{
					Native.RegCloseKey(phkResult);
				}
			}
		}

		public static bool GetRuntimeName(out string name)
		{
			name = null;
			if (!Internal_GetRuntimeName(out var runtimeNamePtr))
			{
				return false;
			}
			if (runtimeNamePtr == IntPtr.Zero)
			{
				return false;
			}
			name = Marshal.PtrToStringAnsi(runtimeNamePtr);
			return true;
		}

		public static bool GetRuntimeVersion(out ushort major, out ushort minor, out ushort patch)
		{
			return Internal_GetRuntimeVersion(out major, out minor, out patch);
		}
	}
	[BepInPlugin("io.daxcess.lcvr", "LCVR", "1.2.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PLUGIN_GUID = "io.daxcess.lcvr";

		public const string PLUGIN_NAME = "LCVR";

		public const string PLUGIN_VERSION = "1.2.3";

		private readonly string[] GAME_ASSEMBLY_HASHES = new string[2] { "7CFABBA203022CC46EF309B0E651276CB59217AF6D38C34E2085E67957DBBCBD", "4C265CECBC1A075E52D9E1FA458C67AA25C087362B472DF66DF370B9A0676A67" };

		public static Config Config { get; private set; }

		public static Compat Compatibility { get; private set; }

		public static Flags Flags { get; private set; }

		private void Awake()
		{
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			InputSystem.PerformDefaultPluginInitialization();
			Logger.SetSource(((BaseUnityPlugin)this).Logger);
			Config = new Config(((BaseUnityPlugin)this).Config);
			Dictionary<string, PluginInfo>.ValueCollection values = Chainloader.PluginInfos.Values;
			int num = 0;
			PluginInfo[] array = (PluginInfo[])(object)new PluginInfo[values.Count];
			foreach (PluginInfo item in values)
			{
				array[num] = item;
				num++;
			}
			Compatibility = new Compat(new <>z__ReadOnlyArray<PluginInfo>(array));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin LCVR is starting...");
			bool flag = Config.DisableVR.Value || Environment.GetCommandLineArgs().Contains<string>("--disable-vr", StringComparer.OrdinalIgnoreCase);
			if (flag)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"VR has been disabled by config or the `--disable-vr` command line flag");
			}
			else if (Config.AskOnStartup.Value)
			{
				switch (Native.ShellMessageBox(IntPtr.Zero, IntPtr.Zero, "Do you want to run Lethal Company in VR mode?\n\nDon't forget to connect your headset first before launching the game in VR.\nLaunching the game without VR will still allow you to see other VR players' arm movements.\n\nPress 'Cancel' to close the game.", "Lethal Company VR Mod", 4163u))
				{
				case 2:
					Process.GetCurrentProcess().Kill();
					return;
				case 7:
					flag = true;
					break;
				}
			}
			if (Environment.GetCommandLineArgs().Contains("--lcvr-debug-interactables"))
			{
				Flags |= Flags.InteractableDebug;
			}
			bool flag2 = Environment.GetCommandLineArgs().Contains("--lcvr-skip-checksum");
			if (!VerifyGameVersion())
			{
				if (!flag2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Error: Unsupported game version, or corrupted game detected!");
					((BaseUnityPlugin)this).Logger.LogError((object)"Aborting before we blow something up!");
					return;
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Warning: Unsupported game version, or corrupted game detected!");
				Flags |= Flags.InvalidGameAssembly;
			}
			if (!LoadEarlyRuntimeDependencies())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because required runtime dependencies could not be loaded!");
				return;
			}
			if (!AssetManager.LoadAssets())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because assets could not be loaded!");
				return;
			}
			if (!flag && InitVRLoader())
			{
				Flags |= Flags.VR;
				((MonoBehaviour)this).StartCoroutine(HijackSplashScreen());
			}
			HarmonyPatcher.PatchUniversal();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Inserted universal patches using Harmony");
			Native.BringGameWindowToFront();
		}

		private bool VerifyGameVersion()
		{
			string value = BitConverter.ToString(Utils.ComputeHash(File.ReadAllBytes(Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll")))).Replace("-", "");
			return GAME_ASSEMBLY_HASHES.Contains(value);
		}

		private bool LoadEarlyRuntimeDependencies()
		{
			try
			{
				string[] files = Directory.GetFiles(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "RuntimeDeps"), "*.dll");
				foreach (string path in files)
				{
					string fileName = Path.GetFileName(path);
					if (!(fileName == "UnityOpenXR.dll") && !(fileName == "openxr_loader.dll"))
					{
						((BaseUnityPlugin)this).Logger.LogDebug((object)("Early loading " + fileName));
						try
						{
							Assembly.LoadFile(path);
						}
						catch (Exception ex)
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to early load " + fileName + ": " + ex.Message));
						}
					}
				}
			}
			catch (Exception ex2)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Unexpected error occured while loading early runtime dependencies (incorrect folder structure?): " + ex2.Message));
				return false;
			}
			return true;
		}

		private bool InitVRLoader()
		{
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Expected O, but got Unknown
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading VR...");
			if (SetupRuntimeAssets())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"You must restart the game to allow VR to function properly");
				Flags |= Flags.RestartRequired;
				return false;
			}
			if (!string.IsNullOrEmpty(Config.OpenXRRuntimeFile.Value))
			{
				Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", Config.OpenXRRuntimeFile.Value);
			}
			EnableControllerProfiles();
			InitializeXRRuntime();
			if (!StartDisplay())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Failed to start in VR Mode! Only Non-VR features are available!");
				if (OpenXR.GetDiagnosticReport(out var report))
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Runtime Name:    " + report.RuntimeName));
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Runtime Version: " + report.RuntimeVersion));
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Last Error:      " + report.Error));
					((BaseUnityPlugin)this).Logger.LogWarning((object)"");
					string error = report.Error;
					if (!(error == "XR_ERROR_RUNTIME_UNAVAILABLE"))
					{
						if (error == "XR_ERROR_FORM_FACTOR_UNAVAILABLE")
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)"This generally means that your headset is not connected, or that your headset is connected to a different runtime. Please make sure your headset is active and connected, and that you are using the correct OpenXR runtime.");
						}
						else
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)"Unknown reason for OpenXR failure!");
							((BaseUnityPlugin)this).Logger.LogWarning((object)("\n" + OpenXR.GenerateReport()));
						}
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)"It appears that no OpenXR runtime is currently active. Please go to the dedicated application for your VR headset and make sure that it is running, and set as default OpenXR runtime.");
					}
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Failed to generate OpenXR diagnostics report!");
				}
				string @default;
				Dictionary<string, string> dictionary = OpenXR.DetectOpenXRRuntimes(out @default);
				if (dictionary != null)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"List of registered OpenXR runtimes on this device:");
					if (@default != null)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(">>> " + @default));
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)"No default runtime detected!");
					}
					foreach (string key in dictionary.Keys)
					{
						if (!(key == @default))
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)("    " + key));
						}
					}
				}
				return false;
			}
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				if (value.Metadata.GUID == "com.sinai.unityexplorer")
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"WARNING: UNITY EXPLORER DETECTED! UNITY EXPLORER *WILL* BREAK VR UI INPUTS!");
					Flags |= Flags.UnityExplorerDetected;
				}
			}
			if (OpenXR.GetRuntimeName(out var name) && OpenXR.GetRuntimeVersion(out var major, out var minor, out var patch))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"OpenXR runtime being used: {name} ({major}.{minor}.{patch})");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Could not get runtime OpenXR name?");
			}
			HarmonyPatcher.PatchVR();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Inserted VR patches using Harmony");
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			HDRenderPipelineAsset val = (HDRenderPipelineAsset)(object)((renderPipeline is HDRenderPipelineAsset) ? renderPipeline : null);
			RenderPipelineSettings currentPlatformRenderPipelineSettings = val.currentPlatformRenderPipelineSettings;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.enabled = Config.EnableDynamicResolution.Value;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.enableDLSS = Config.EnableDLSS.Value;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.dynResType = (DynamicResolutionType)1;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.upsampleFilter = Config.DynamicResolutionUpscaleFilter.Value;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.minPercentage = (currentPlatformRenderPipelineSettings.dynamicResolutionSettings.maxPercentage = Config.DynamicResolutionPercentage.Value);
			currentPlatformRenderPipelineSettings.supportMotionVectors = true;
			currentPlatformRenderPipelineSettings.xrSettings.occlusionMesh = false;
			currentPlatformRenderPipelineSettings.xrSettings.singlePass = false;
			currentPlatformRenderPipelineSettings.lodBias = new FloatScalableSetting(new float[3]
			{
				Config.LODBias.Value,
				Config.LODBias.Value,
				Config.LODBias.Value
			}, ScalableSettingSchemaId.With3Levels);
			val.currentPlatformRenderPipelineSettings = currentPlatformRenderPipelineSettings;
			return true;
		}

		private void EnableControllerProfiles()
		{
			ValveIndexControllerProfile val = ScriptableObject.CreateInstance<ValveIndexControllerProfile>();
			HPReverbG2ControllerProfile val2 = ScriptableObject.CreateInstance<HPReverbG2ControllerProfile>();
			HTCViveControllerProfile val3 = ScriptableObject.CreateInstance<HTCViveControllerProfile>();
			MicrosoftMotionControllerProfile val4 = ScriptableObject.CreateInstance<MicrosoftMotionControllerProfile>();
			KHRSimpleControllerProfile val5 = ScriptableObject.CreateInstance<KHRSimpleControllerProfile>();
			MetaQuestTouchProControllerProfile val6 = ScriptableObject.CreateInstance<MetaQuestTouchProControllerProfile>();
			OculusTouchControllerProfile val7 = ScriptableObject.CreateInstance<OculusTouchControllerProfile>();
			((OpenXRFeature)val).enabled = true;
			((OpenXRFeature)val2).enabled = true;
			((OpenXRFeature)val3).enabled = true;
			((OpenXRFeature)val4).enabled = true;
			((OpenXRFeature)val5).enabled = true;
			((OpenXRFeature)val6).enabled = true;
			((OpenXRFeature)val7).enabled = true;
			OpenXRSettings.Instance.features = (OpenXRFeature[])(object)new OpenXRFeature[7]
			{
				(OpenXRFeature)val,
				(OpenXRFeature)val2,
				(OpenXRFeature)val3,
				(OpenXRFeature)val4,
				(OpenXRFeature)val5,
				(OpenXRFeature)val6,
				(OpenXRFeature)val7
			};
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Enabled XR Controller Profiles");
		}

		private void InitializeXRRuntime()
		{
			XRGeneralSettings obj = ScriptableObject.CreateInstance<XRGeneralSettings>();
			XRManagerSettings val = ScriptableObject.CreateInstance<XRManagerSettings>();
			OpenXRLoader item = ScriptableObject.CreateInstance<OpenXRLoader>();
			obj.Manager = val;
			((List<XRLoader>)val.activeLoaders).Clear();
			((List<XRLoader>)val.activeLoaders).Add((XRLoader)(object)item);
			OpenXRSettings.Instance.renderMode = (RenderMode)0;
			OpenXRSettings.Instance.depthSubmissionMode = (DepthSubmissionMode)0;
			obj.InitXRSDK();
			obj.Start();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Initialized OpenXR Runtime");
		}

		private bool StartDisplay()
		{
			List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
			SubsystemManager.GetInstances<XRDisplaySubsystem>(list);
			if (list.Count < 1)
			{
				return false;
			}
			((IntegratedSubsystem)list[0]).Start();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Started XR Display subsystem, welcome to VR!");
			return true;
		}

		private bool CopyResourceFile(string sourceFile, string destinationFile)
		{
			if (!File.Exists(sourceFile))
			{
				return false;
			}
			if (File.Exists(destinationFile))
			{
				byte[] first = Utils.ComputeHash(File.ReadAllBytes(sourceFile));
				byte[] second = Utils.ComputeHash(File.ReadAllBytes(destinationFile));
				if (first.SequenceEqual(second))
				{
					return true;
				}
			}
			File.Copy(sourceFile, destinationFile, overwrite: true);
			return true;
		}

		private bool SetupRuntimeAssets()
		{
			bool result = false;
			string path = Path.Combine(Paths.GameRootPath, "Lethal Company_Data");
			string text = Path.Combine(path, "UnitySubsystems");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string text2 = Path.Combine(text, "UnityOpenXR");
			if (!Directory.Exists(text2))
			{
				Directory.CreateDirectory(text2);
			}
			string path2 = Path.Combine(text2, "UnitySubsystemsManifest.json");
			if (!File.Exists(path2))
			{
				File.WriteAllText(path2, Resources.UnitySubsystemsManifest);
				result = true;
			}
			string path3 = Path.Combine(path, "Plugins");
			string destinationFile = Path.Combine(path3, "UnityOpenXR.dll");
			string destinationFile2 = Path.Combine(path3, "openxr_loader.dll");
			string? directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string sourceFile = Path.Combine(directoryName, "RuntimeDeps/UnityOpenXR.dll");
			string sourceFile2 = Path.Combine(directoryName, "RuntimeDeps/openxr_loader.dll");
			if (!CopyResourceFile(sourceFile, destinationFile))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not find UnityOpenXR.dll to copy to the game, VR might not work!");
			}
			if (!CopyResourceFile(sourceFile2, destinationFile2))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not find openxr_loader.dll to copy to the game, VR might not work!");
			}
			return result;
		}

		private IEnumerator HijackSplashScreen()
		{
			yield return (object)new WaitUntil((Func<bool>)delegate
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Scene activeScene = SceneManager.GetActiveScene();
					((Scene)(ref activeScene)).GetRootGameObjects();
					return true;
				}
				catch
				{
					return false;
				}
			});
			((Renderer)GameObject.Find("SplashRootObject/Quad").GetComponent<MeshRenderer>()).material = AssetManager.splashMaterial;
		}
	}
	[Flags]
	public enum Flags
	{
		VR = 1,
		RestartRequired = 2,
		UnityExplorerDetected = 4,
		InvalidGameAssembly = 8,
		InteractableDebug = 0x10
	}
	internal static class GameObjectExtensions
	{
		public static GameObject Find(this GameObject @object, string name)
		{
			Transform obj = @object.transform.Find(name);
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).gameObject;
		}
	}
	internal static class Utils
	{
		public enum Hand
		{
			Left,
			Right
		}

		public static byte[] ComputeHash(byte[] input)
		{
			using SHA256 sHA = SHA256.Create();
			return sHA.ComputeHash(input);
		}

		public static string GetPath(this Transform current)
		{
			if ((Object)(object)current.parent == (Object)null)
			{
				return "/" + ((Object)current).name;
			}
			return current.parent.GetPath() + "/" + ((Object)current).name;
		}

		public static string FormatPascalAndAcronym(string input)
		{
			StringBuilder stringBuilder = new StringBuilder(input[0].ToString());
			if (stringBuilder.Length > 0)
			{
				for (int i = 1; i < input.Length; i++)
				{
					char c = input[i - 1];
					char c2 = ((i + 1 < input.Length) ? input[i + 1] : '\0');
					bool flag = char.IsLower(c2);
					bool flag2 = char.IsUpper(c2);
					bool flag3 = char.IsUpper(input[i]);
					bool flag4 = char.IsLower(c);
					bool flag5 = char.IsUpper(c);
					if (!string.IsNullOrWhiteSpace(c.ToString()) && ((flag5 && flag3 && flag) || (flag4 && flag3 && flag) || (flag4 && flag3 && flag2)))
					{
						stringBuilder.Append(' ');
						stringBuilder.Append(input[i]);
					}
					else
					{
						stringBuilder.Append(input[i]);
					}
				}
			}
			return stringBuilder.ToString();
		}

		public static void EnableQualitySetting(this HDAdditionalCameraData camera, FrameSettingsField setting)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected I4, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[(uint)(int)setting] = false;
			((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled(setting, true);
		}

		public static void DisableQualitySetting(this HDAdditionalCameraData camera, FrameSettingsField setting)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected I4, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[(uint)(int)setting] = true;
			((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled(setting, false);
		}

		public static void AttachHeadTrackedPoseDriver(this GameObject @object)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			TrackedPoseDriver obj = @object.AddComponent<TrackedPoseDriver>();
			obj.positionAction = Actions.Instance.HeadPosition;
			obj.rotationAction = Actions.Instance.HeadRotation;
			obj.trackingStateInput = new InputActionProperty(Actions.Instance.HeadTrackingState);
		}

		public static Transform[] GetChildren(this Transform transform)
		{
			List<Transform> list = new List<Transform>();
			for (int i = 0; i < transform.childCount; i++)
			{
				list.Add(transform.GetChild(i));
			}
			return list.ToArray();
		}

		public static void ApplyOffsetTransform(this Transform transform, Transform parent, Vector3 positionOffset, Vector3 rotationOffset)
		{
			//IL_0002: 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_0015: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			transform.rotation = parent.rotation;
			transform.Rotate(rotationOffset);
			transform.position = parent.position + parent.rotation * positionOffset;
		}

		public static bool IsInactivePlayer(this PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				return false;
			}
			return !((Behaviour)((Component)((Component)player).transform.Find("ScavengerModel/metarig/CameraContainer/MainCamera")).GetComponent<Camera>()).enabled;
		}

		public static XRRayInteractor CreateInteractorController(this GameObject @object, Hand hand, bool rayVisible = true, bool trackingEnabled = true, bool actionsEnabled = true)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			ActionBasedController controller = @object.AddComponent<ActionBasedController>();
			XRRayInteractor result = @object.AddComponent<XRRayInteractor>();
			XRInteractorLineVisual val = @object.AddComponent<XRInteractorLineVisual>();
			LineRenderer component = @object.GetComponent<LineRenderer>();
			val.lineBendRatio = 1f;
			Gradient val2 = new Gradient();
			val2.mode = (GradientMode)0;
			val2.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(0.1f, 0f),
				new GradientAlphaKey(0.1f, 1f)
			};
			val2.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			val.invalidColorGradient = val2;
			((Behaviour)val).enabled = rayVisible;
			((Renderer)component).material = AssetManager.defaultRayMat;
			controller.AddActionBasedControllerBinds(hand, trackingEnabled, actionsEnabled);
			return result;
		}

		public static void AddActionBasedControllerBinds(this ActionBasedController controller, Hand hand, bool trackingEnabled = true, bool actionsEnabled = true)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			((XRBaseController)controller).enableInputTracking = trackingEnabled;
			controller.positionAction = new InputActionProperty(hand.Position());
			controller.rotationAction = new InputActionProperty(hand.Rotation());
			controller.trackingStateAction = new InputActionProperty(hand.TrackingState());
			((XRBaseController)controller).enableInputActions = actionsEnabled;
			controller.selectAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Select", false));
			controller.selectActionValue = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Select Value", false));
			controller.activateAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Activate", false));
			controller.activateActionValue = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Activate Value", false));
			controller.uiPressAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/UI Press", false));
			controller.uiPressActionValue = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/UI Press Value", false));
			controller.uiScrollAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/UI Scroll", false));
			controller.rotateAnchorAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Rotate Anchor", false));
			controller.translateAnchorAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Translate Anchor", false));
			controller.scaleToggleAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Scale Toggle", false));
			controller.scaleDeltaAction = new InputActionProperty(AssetManager.defaultInputActions.FindAction($"{hand}/Scale Delta", false));
		}

		public static bool Raycast(this Ray ray, out RaycastHit hit, float maxDistance = float.PositiveInfinity, int layerMask = -5)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Physics.Raycast(ray, ref hit, maxDistance, layerMask);
		}

		public static bool BoxCast(this Ray ray, float radius, out RaycastHit hit, float maxDistance = float.PositiveInfinity, int layerMask = -5)
		{
			//IL_0002: 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_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 Physics.BoxCast(((Ray)(ref ray)).origin, Vector3.one * radius, ((Ray)(ref ray)).direction, ref hit, Quaternion.identity, maxDistance, layerMask);
		}

		private static InputAction Position(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandPosition, 
				Hand.Right => Actions.Instance.RightHandPosition, 
				_ => throw new NotImplementedException(), 
			});
		}

		private static InputAction Rotation(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandRotation, 
				Hand.Right => Actions.Instance.RightHandRotation, 
				_ => throw new NotImplementedException(), 
			});
		}

		private static InputAction TrackingState(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandTrackingState, 
				Hand.Right => Actions.Instance.RightHandTrackingState, 
				_ => throw new NotImplementedException(), 
			});
		}

		public static IEnumerator NopRoutine()
		{
			yield break;
		}
	}
}
namespace LCVR.UI
{
	internal class CanvasTransformFollow : MonoBehaviour
	{
		private const float TURN_SMOOTHNESS = 0.05f;

		private const float CANVAS_DISTANCE = 5f;

		public Transform sourceTransform;

		public float heightOffset;

		private Quaternion targetRotation;

		private Vector3 targetPosition;

		private Transform enemyTransform;

		private void Awake()
		{
			Actions.Instance.OnReload += OnReloadActions;
			Actions.Instance["Controls/Reset Height"].performed += OnResetHeight;
			enemyTransform = Object.Instantiate<GameObject>(AssetManager.enemyPrefab).transform;
			((MonoBehaviour)this).StartCoroutine(Init());
		}

		private void OnReloadActions(InputActionAsset oldActions, InputActionAsset newActions)
		{
			oldActions["Controls/Reset Height"].performed -= OnResetHeight;
			newActions["Controls/Reset Height"].performed += OnResetHeight;
		}

		private void OnDestroy()
		{
			Actions.Instance.OnReload -= OnReloadActions;
			Actions.Instance["Controls/Reset Height"].performed -= OnResetHeight;
		}

		private void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			((Component)this).transform.rotation = Quaternion.Lerp(((Component)this).transform.rotation, targetRotation, 0.05f);
			((Component)this).transform.position = Vector3.Lerp(((Component)this).transform.position, targetPosition, 0.05f);
		}

		public void ResetPosition(bool force = false)
		{
			//IL_000b: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0033: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Quaternion.Euler(0f, sourceTransform.eulerAngles.y, 0f) * Vector3.forward * 5f;
			targetPosition = new Vector3(val.x + sourceTransform.position.x, heightOffset, val.z + sourceTransform.position.z);
			targetRotation = Quaternion.Euler(0f, sourceTransform.eulerAngles.y, 0f);
			enemyTransform.position = new Vector3(0f - val.x + sourceTransform.position.x, heightOffset - 2f, 0f - val.z + sourceTransform.position.z);
			enemyTransform.rotation = Quaternion.Euler(0f, sourceTransform.eulerAngles.y, 0f);
			if (force)
			{
				((Component)this).transform.rotation = targetRotation;
				((Component)this).transform.position = targetPosition;
			}
		}

		private IEnumerator Init()
		{
			yield return null;
			ResetPosition(force: true);
		}

		private void OnResetHeight(CallbackContext context)
		{
			if (((CallbackContext)(ref context)).performed)
			{
				ResetPosition();
			}
		}
	}
	public class InteractCanvasPositionOffset : MonoBehaviour
	{
		public Vector3 offset;
	}
	internal class Keyboard : MonoBehaviour
	{
		private readonly Dictionary<TMP_InputField, UnityAction<string>> inputFields = new Dictionary<TMP_InputField, UnityAction<string>>();

		public NonNativeKeyboard keyboard;

		private void Awake()
		{
			((MonoBehaviour)this).StartCoroutine(PopulateInputsRoutine());
		}

		private IEnumerator PopulateInputsRoutine()
		{
			while (true)
			{
				PopulateInputs();
				yield return (object)new WaitForSeconds(0.5f);
			}
		}

		private void PopulateInputs()
		{
			TMP_InputField[] array = Object.FindObjectsOfType<TMP_InputField>(true);
			foreach (TMP_InputField input in array)
			{
				if (!inputFields.ContainsKey(input))
				{
					UnityAction<string> val = delegate
					{
						keyboard.InputField = input;
						keyboard.PresentKeyboard();
					};
					inputFields.Add(input, val);
					((UnityEvent<string>)(object)input.onSelect).AddListener(val);
				}
			}
		}

		private void OnDestroy()
		{
			foreach (KeyValuePair<TMP_InputField, UnityAction<string>> inputField in inputFields)
			{
				((UnityEvent<string>)(object)inputField.Key.onSelect).RemoveListener(inputField.Value);
			}
		}
	}
	internal class ObjectScanner
	{
		private Dictionary<RectTransform, ScanNodeProperties> ScanNodes => (Dictionary<RectTransform, ScanNodeProperties>)typeof(HUDManager).GetField("scanNodes", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(HUDManager.Instance);

		internal ObjectScanner()
		{
			//IL_0023: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in GameObject.Find("ObjectScanner").transform)
			{
				Canvas obj = ((Component)item).gameObject.AddComponent<Canvas>();
				obj.worldCamera = VRSession.Instance.MainCamera;
				obj.renderMode = (RenderMode)2;
				CollectionExtensions.Do<Image>((IEnumerable<Image>)((Component)item).GetComponentsInChildren<Image>(), (Action<Image>)delegate(Image image)
				{
					((Graphic)image).material = AssetManager.alwaysOnTopMat;
				});
				CollectionExtensions.Do<TextMeshProUGUI>((IEnumerable<TextMeshProUGUI>)((Component)item).GetComponentsInChildren<TextMeshProUGUI>(), (Action<TextMeshProUGUI>)delegate(TextMeshProUGUI text)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Expected O, but got Unknown
					((TMP_Text)text).fontSharedMaterial = new Material(((TMP_Text)text).fontSharedMaterial);
					((TMP_Text)text).isOverlay = true;
				});
			}
		}

		public void Update()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			HUDManager instance = HUDManager.Instance;
			for (int i = 0; i < instance.scanElements.Length; i++)
			{
				if (ScanNodes.Count > 0 && ScanNodes.TryGetValue(instance.scanElements[i], out var value) && (Object)(object)value != (Object)null && !InvokeFunction<bool>("NodeIsNotVisible", new object[2] { value, i }))
				{
					GameObject gameObject = ((Component)instance.scanElements[i]).gameObject;
					gameObject.transform.position = ((Component)value).transform.position;
					int num = 5;
					float num2 = Vector3.Distance(((Component)VRSession.Instance.MainCamera).transform.position, ((Component)value).transform.position) / (float)num;
					gameObject.transform.rotation = Quaternion.LookRotation(gameObject.transform.position - ((Component)VRSession.Instance.MainCamera).transform.position);
					Transform transform = gameObject.transform;
					transform.position += gameObject.transform.forward * -0.2f;
					gameObject.transform.localScale = Vector3.one * num2;
				}
			}
		}

		private static T InvokeFunction<T>(string name, params object[] args)
		{
			return (T)typeof(HUDManager).GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic).Invoke(HUDManager.Instance, args);
		}
	}
	public class VRHUD : MonoBehaviour
	{
		private ObjectScanner scanner;

		private GameObject selfRed;

		private GameObject self;

		private GameObject sprintMeter;

		private GameObject redGlowBodyParts;

		private GameObject weightUi;

		private GameObject clock;

		private GameObject battery;

		private GameObject inventory;

		private GameObject deathScreen;

		private GameObject spectatorLight;

		public Canvas Canvas { get; private set; }

		public Canvas WorldInteractionCanvas { get; private set; }

		public Canvas SpectateCanvas { get; private set; }

		public Canvas LeftHandCanvas { get; private set; }

		public Canvas RightHandCanvas { get; private set; }

		public NonNativeKeyboard MenuKeyboard { get; private set; }

		public NonNativeKeyboard TerminalKeyboard { get; internal set; }

		private void Awake()
		{
			//IL_0006: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Expected O, but got Unknown
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_0764: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Unknown result type (might be due to invalid IL or missing references)
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0823: Unknown result type (might be due to invalid IL or missing references)
			//IL_082a: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Unknown result type (might be due to invalid IL or missing references)
			//IL_082d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0834: Unknown result type (might be due to invalid IL or missing references)
			//IL_0836: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Unknown result type (might be due to invalid IL or missing references)
			//IL_083e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0840: Unknown result type (might be due to invalid IL or missing references)
			//IL_0841: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Unknown result type (might be due to invalid IL or missing references)
			//IL_0864: Unknown result type (might be due to invalid IL or missing references)
			//IL_086e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_059b: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or miss