using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;

[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("DaXcess")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2024-2025")]
[assembly: AssemblyDescription("LCVR Preloader")]
[assembly: AssemblyFileVersion("1.3.10.0")]
[assembly: AssemblyInformationalVersion("1.3.10+646124814299921d73d1a7aca12424a73481eb37")]
[assembly: AssemblyProduct("LCVR.Preload")]
[assembly: AssemblyTitle("LCVR.Preload")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/LCVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.10.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.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = 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 LCVR.Preload
{
	public static class Preload
	{
		private const string VR_MANIFEST = "{\n  \"name\": \"OpenXR XR Plugin\",\n  \"version\": \"1.8.2\",\n  \"libraryName\": \"UnityOpenXR\",\n  \"displays\": [\n    {\n      \"id\": \"OpenXR Display\"\n    }\n  ],\n  \"inputs\": [\n    {\n      \"id\": \"OpenXR Input\"\n    }\n  ]\n}";

		private static readonly ManualLogSource Logger = Logger.CreateLogSource("LCVR.Preload");

		public static IEnumerable<string> TargetDLLs { get; } = Array.Empty<string>();


		public static void Initialize()
		{
			Logger.LogInfo((object)"Setting up VR runtime assets");
			SetupRuntimeAssets();
			Logger.LogInfo((object)"We're done here. Goodbye!");
		}

		private static void SetupRuntimeAssets()
		{
			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, "{\n  \"name\": \"OpenXR XR Plugin\",\n  \"version\": \"1.8.2\",\n  \"libraryName\": \"UnityOpenXR\",\n  \"displays\": [\n    {\n      \"id\": \"OpenXR Display\"\n    }\n  ],\n  \"inputs\": [\n    {\n      \"id\": \"OpenXR Input\"\n    }\n  ]\n}");
			}
			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))
			{
				Logger.LogWarning((object)"Could not find plugin UnityOpenXR.dll, VR might not work!");
			}
			if (!CopyResourceFile(sourceFile2, destinationFile2))
			{
				Logger.LogWarning((object)"Could not find plugin openxr_loader.dll, VR might not work!");
			}
		}

		private static 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;
		}

		public static void Patch(AssemblyDefinition assembly)
		{
		}
	}
	public static class Utils
	{
		public static byte[] ComputeHash(byte[] input)
		{
			using SHA256 sHA = SHA256.Create();
			return sHA.ComputeHash(input);
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
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 CullFactory.Extenders;
using Dissonance;
using Dissonance.Integrations.Unity_NFGO;
using Dissonance.Networking;
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.Physics.Interactions.Car;
using LCVR.Player;
using LCVR.Rendering;
using LCVR.UI;
using LCVR.UI.Settings;
using Microsoft.CodeAnalysis;
using Microsoft.MixedReality.Toolkit.Experimental.UI;
using MoreCompany.Cosmetics;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Steamworks;
using TMPro;
using Unity.Netcode;
using Unity.XR.CoreUtils;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Animations.Rigging;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.UI;
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("DaXcess")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2024-2025")]
[assembly: AssemblyDescription("Collecting Scrap in VR")]
[assembly: AssemblyFileVersion("1.3.10.0")]
[assembly: AssemblyInformationalVersion("1.3.10+646124814299921d73d1a7aca12424a73481eb37")]
[assembly: AssemblyProduct("LCVR")]
[assembly: AssemblyTitle("LCVR")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/LCVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.10.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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			//IL_0025: Expected O, but got Unknown
			Items.Clear();
			foreach (Transform item in ((Component)this).transform)
			{
				Transform val = item;
				RectTransform component = ((Component)val).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 static class Compat
	{
		public const string MoreCompany = "me.swipez.melonloader.morecompany";

		public const string CullFactory = "com.fumiko.CullFactory";

		public static bool IsLoaded(string modId)
		{
			return Chainloader.PluginInfos.ContainsKey(modId);
		}
	}
	public class Config
	{
		public enum TurnProviderOption
		{
			Snap,
			Smooth,
			Disabled
		}

		private const string PERSISTENT_KEY = "io.daxcess.lcvr.persistent-settings";

		private bool isSerializing;

		public string AssemblyPath { get; }

		public ConfigFile File { get; }

		public ConfigEntry<bool> DisableVR { get; }

		public ConfigEntry<bool> AskOnStartup { get; }

		public ConfigEntry<bool> EnableHelmetVisor { get; }

		public ConfigEntry<bool> EnableVerboseLogging { get; }

		[ES3NonSerializable]
		public ConfigEntry<bool> DisablePersistentSettings { get; }

		public ConfigEntry<bool> EnableOcclusionMesh { get; }

		public ConfigEntry<bool> EnableDynamicResolution { get; }

		public ConfigEntry<DynamicResUpscaleFilter> DynamicResolutionUpscaleFilter { get; }

		public ConfigEntry<float> DynamicResolutionPercentage { get; }

		public ConfigEntry<float> CameraResolution { get; }

		public ConfigEntry<bool> DisableVolumetrics { get; }

		public ConfigEntry<TurnProviderOption> TurnProvider { get; }

		public ConfigEntry<float> SmoothTurnSpeedModifier { get; }

		public ConfigEntry<float> SnapTurnSize { get; }

		public ConfigEntry<bool> ToggleSprint { get; }

		public ConfigEntry<float> MovementSprintToggleCooldown { get; }

		public ConfigEntry<float> ButtonPressPoint { get; }

		public ConfigEntry<bool> EnablePitchLockedCanvas { get; }

		public ConfigEntry<bool> DisableArmHUD { get; }

		public ConfigEntry<float> HUDOffsetX { get; }

		public ConfigEntry<float> HUDOffsetY { get; }

		public ConfigEntry<bool> EnableInteractRay { get; }

		public ConfigEntry<bool> DisableLensDistortion { get; }

		public ConfigEntry<bool> DisableCameraShake { get; }

		public ConfigEntry<bool> EnableCustomCamera { get; }

		public ConfigEntry<float> CustomCameraFOV { get; }

		public ConfigEntry<float> CustomCameraLerpFactor { get; }

		public ConfigEntry<float> LODBias { get; }

		public ConfigEntry<bool> SpectatorLightRemovesVolumetrics { get; }

		public ConfigEntry<float> MirrorXOffset { get; }

		public ConfigEntry<float> MirrorYOffset { 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> DisableLightSwitchInteraction { get; }

		public ConfigEntry<bool> DisableDoorInteraction { get; }

		public ConfigEntry<bool> DisableHangarLeverInteraction { get; }

		public ConfigEntry<bool> DisableMuffleInteraction { get; }

		public ConfigEntry<bool> DisableFaceInteractions { get; }

		public ConfigEntry<bool> DisableElevatorButtonInteraction { get; }

		public ConfigEntry<bool> DisableCarSteeringWheelInteraction { get; }

		public ConfigEntry<bool> DisableCarButtonInteractions { get; }

		public ConfigEntry<bool> DisableCarHonkInteraction { get; }

		public ConfigEntry<bool> DisableCarEjectInteraction { get; }

		public ConfigEntry<bool> DisableCarGearStickInteractions { get; }

		public ConfigEntry<bool> DisableCarIgnitionInteractions { get; }

		public ConfigEntry<bool> IntroScreenSeen { get; }

		public ConfigEntry<string> ControllerBindingsOverride { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public ConfigEntry<bool> DisableSettingsButton { get; }

		public Config(string assemblyPath, ConfigFile file)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Expected O, but got Unknown
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Expected O, but got Unknown
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Expected O, but got Unknown
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Expected O, but got Unknown
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Expected O, but got Unknown
			AssemblyPath = assemblyPath;
			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.");
			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.");
			EnableVerboseLogging = file.Bind<bool>("General", "EnableVerboseLogging", false, "Enables verbose debug logging during OpenXR initialization");
			DisablePersistentSettings = file.Bind<bool>("General", "DisablePersistentSettings", false, "Persistent settings makes sure that all of your LCVR settings are the same across different modpacks. Disabling this will mean that your LCVR settings will be reset every time you create a new modpack.");
			EnableOcclusionMesh = file.Bind<bool>("Performance", "EnableOcclusionMesh", true, "The occlusion mesh will cause the game to stop rendering pixels outside of the lens views, which increases performance.");
			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>(10f, 100f), Array.Empty<object>()));
			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, 1.5f), 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>()));
			ButtonPressPoint = file.Bind<float>("Input", "ButtonPressPoint", 0.25f, new ConfigDescription("The amount of force required to register a UI button press. The lower the value, the more sensitive UI presses become.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			EnablePitchLockedCanvas = file.Bind<bool>("UI", "EnablePitchLockedCanvas", true, "Whether most of the camera-locked UI elements should only (smoothly) rotate on the Y axis, instead of being stuck on your face.");
			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", "HUDOffsetX", 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", "HUDOffsetY", 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.");
			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.");
			DisableCameraShake = file.Bind<bool>("Rendering", "DisableCameraShake", false, "Disables the camera shake that happens during explosions, rerouting, and other types of events.");
			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>()));
			SpectatorLightRemovesVolumetrics = file.Bind<bool>("Rendering", "SpectatorLightRemovesVolumetrics", false, "When spectating, also disable all volumetrics (fog) while the fullbright lighting is enabled for more visibility.");
			MirrorXOffset = file.Bind<float>("Rendering", "MirrorXOffset", 0f, new ConfigDescription("The X offset that is added to the XR Mirror View shader. Do not touch if you don't know what this means.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 1f), Array.Empty<object>()));
			MirrorYOffset = file.Bind<float>("Rendering", "MirrorYOffset", 0f, new ConfigDescription("The Y offset that is added to the XR Mirror View shader. Do not touch if you don't know what this means.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 1f), Array.Empty<object>()));
			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, "Disable needing to physically open the breaker box and flip the switches with your finger.");
			DisableLightSwitchInteraction = file.Bind<bool>("Interaction", "DisableLightSwitchInteraction", false, "Disable needing to physically switch light switches");
			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.");
			DisableHangarLeverInteraction = file.Bind<bool>("Interaction", "DisableHangarLeverInteraction", false, "Disable needing to physically pull the lever for the big doors on Artiface");
			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.");
			DisableElevatorButtonInteraction = file.Bind<bool>("Interaction", "DisableElevatorButtonInteraction", false, "Disables needing to physically press the elevator buttons");
			DisableCarSteeringWheelInteraction = file.Bind<bool>("Car", "DisableCarSteeringWheelInteraction", false, "Disables the need to physically steer the Company Cruiser");
			DisableCarButtonInteractions = file.Bind<bool>("Car", "DisableCarButtonInteractions", false, "Disables the need to physically press the generic buttons in the Company Cruiser (radio, windshield wipers, etc)");
			DisableCarHonkInteraction = file.Bind<bool>("Car", "DisableCarHonkInteraction", false, "Disables the need to physically press the car honk in the Company Cruiser");
			DisableCarEjectInteraction = file.Bind<bool>("Car", "DisableCarEjectInteraction", false, "Disables the need to physically press the eject button in the Company Cruiser");
			DisableCarGearStickInteractions = file.Bind<bool>("Car", "DisableCarGearStickInteractions", false, "Disables the need to physically shift the gears in the Company Cruiser");
			DisableCarIgnitionInteractions = file.Bind<bool>("Car", "DisableCarIgnitionInteractions", false, "Disables the need to physically start/stop the car ignition in the Company Cruiser");
			IntroScreenSeen = file.Bind<bool>("Internal", "IntroScreenSeen", false, "Whether the VR intro screen has been displayed before. This configuration option should be set automatically.");
			ControllerBindingsOverride = file.Bind<string>("Internal", "ControllerBindingsOverride", "", "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();
		}

		public void SerializeToES3()
		{
			if (isSerializing || DisablePersistentSettings.Value)
			{
				return;
			}
			isSerializing = true;
			try
			{
				Dictionary<string, Dictionary<string, object>> dictionary = new Dictionary<string, Dictionary<string, object>>();
				foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in File)
				{
					string section = item.Key.Section;
					string key = item.Key.Key;
					object boxedValue = item.Value.BoxedValue;
					PropertyInfo propertyInfo = AccessTools.Property(typeof(Config), key);
					if ((object)propertyInfo == null || ((MemberInfo)propertyInfo).GetCustomAttribute<ES3NonSerializable>() == null)
					{
						if (!dictionary.ContainsKey(section))
						{
							dictionary[section] = new Dictionary<string, object>();
						}
						dictionary[section][key] = boxedValue;
					}
				}
				string text = JsonConvert.SerializeObject((object)dictionary, (Formatting)0);
				ES3.Save<string>("io.daxcess.lcvr.persistent-settings", text);
			}
			catch (Exception ex)
			{
				Logger.LogError("Failed to serialize LCVR settings to persistent storage: " + ex.Message);
			}
			finally
			{
				isSerializing = false;
			}
		}

		public void DeserializeFromES3()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (isSerializing || DisablePersistentSettings.Value)
			{
				return;
			}
			isSerializing = true;
			try
			{
				if (!ES3.KeyExists("io.daxcess.lcvr.persistent-settings"))
				{
					return;
				}
				string text = ES3.Load<string>("io.daxcess.lcvr.persistent-settings");
				Dictionary<string, Dictionary<string, object>> dictionary = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, object>>>(text);
				foreach (KeyValuePair<string, Dictionary<string, object>> item in dictionary)
				{
					item.Deconstruct(out var key, out var value);
					string text2 = key;
					Dictionary<string, object> dictionary2 = value;
					foreach (KeyValuePair<string, object> item2 in dictionary2)
					{
						item2.Deconstruct(out key, out var value2);
						string text3 = key;
						object value3 = value2;
						ConfigDefinition val = new ConfigDefinition(text2, text3);
						if (!File.ContainsKey(val))
						{
							Logger.LogWarning("Setting '" + text2 + "." + text3 + "' is unrecognized, and will be discarded next time the settings are written to disk");
						}
						else
						{
							PropertyInfo propertyInfo = AccessTools.Property(typeof(Config), text3);
							if ((object)propertyInfo == null || ((MemberInfo)propertyInfo).GetCustomAttribute<ES3NonSerializable>() == null)
							{
								ConfigEntryBase val2 = File[text2, text3];
								val2.BoxedValue = (val2.SettingType.IsEnum ? Enum.ToObject(val2.SettingType, value3) : Convert.ChangeType(value3, val2.SettingType));
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogError("Failed to deserialize LCVR settings from persistent storage: " + ex.Message);
			}
			finally
			{
				isSerializing = false;
			}
		}
	}
	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.Universal, null)]
	[HarmonyPatch]
	internal static class Entrypoint
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPrefix]
		private static void OnGameEntered()
		{
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(Start());
		}

		private static IEnumerator Start()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance.activeCamera != (Object)null));
			new GameObject("LCVR Session Manager").AddComponent<VRSession>();
		}
	}
	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);
		}
	}
	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);

		[DllImport("kernel32.dll", SetLastError = true)]
		private static extern IntPtr GetCurrentProcess();

		[DllImport("advapi32.dll", SetLastError = true)]
		private static extern bool OpenProcessToken(IntPtr hProcess, uint dwAccess, out IntPtr hToken);

		[DllImport("advapi32.dll", SetLastError = true)]
		private static extern bool GetTokenInformation(IntPtr hToken, uint tokenInformationClass, IntPtr lpData, uint tokenInformationLength, out uint returnLength);

		[DllImport("kernel32.dll", SetLastError = true)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[SuppressUnmanagedCodeSecurity]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CloseHandle(IntPtr handle);

		public static bool RegOpenSubKey(ref IntPtr hKey, string lpSubKey, int samDesired)
		{
			if (RegOpenKeyEx(hKey, lpSubKey, 0, samDesired, out var phkResult) != 0)
			{
				return false;
			}
			RegCloseKey(hKey);
			hKey = phkResult;
			return true;
		}

		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 = 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);
		}

		public static bool IsElevated()
		{
			IntPtr hToken = IntPtr.Zero;
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				if (!OpenProcessToken(GetCurrentProcess(), 8u, out hToken))
				{
					return false;
				}
				intPtr = Marshal.AllocHGlobal(4);
				if (!GetTokenInformation(hToken, 20u, intPtr, 4u, out var _))
				{
					return false;
				}
				return Marshal.ReadIntPtr(intPtr).ToInt32() != 0;
			}
			finally
			{
				if (hToken != IntPtr.Zero)
				{
					CloseHandle(hToken);
				}
				if (intPtr != IntPtr.Zero)
				{
					Marshal.FreeHGlobal(intPtr);
				}
			}
		}
	}
	internal static class OpenXR
	{
		public class Runtimes : IReadOnlyCollection<Runtime>, IEnumerable<Runtime>, IEnumerable
		{
			[CompilerGenerated]
			private Runtime[] <runtimes>P;

			public Runtime? Default => ((IEnumerable<Runtime>)<runtimes>P).Select((Func<Runtime, Runtime?>)((Runtime rt) => rt)).FirstOrDefault((Runtime? rt) => rt.Value.Default);

			public int Count => <runtimes>P.Length;

			public Runtimes(Runtime[] runtimes)
			{
				<runtimes>P = runtimes;
				base..ctor();
			}

			public bool TryGetRuntime(string name, out Runtime runtime)
			{
				runtime = default(Runtime);
				try
				{
					runtime = <runtimes>P.First((Runtime rt) => rt.Name == name);
					return true;
				}
				catch
				{
					return false;
				}
			}

			public bool TryGetRuntimeByPath(string path, out Runtime runtime)
			{
				runtime = default(Runtime);
				try
				{
					runtime = <runtimes>P.First((Runtime rt) => rt.Path == path);
					return true;
				}
				catch
				{
					return false;
				}
			}

			public IEnumerator<Runtime> GetEnumerator()
			{
				return ((IEnumerable<Runtime>)<runtimes>P).GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		public struct Runtime : IEquatable<Runtime>
		{
			public string Name { get; set; }

			public string Path { get; set; }

			public bool Default { get; set; }

			public static bool ReadFromJson(string path, out Runtime runtime)
			{
				runtime = default(Runtime);
				try
				{
					JToken val = JsonConvert.DeserializeObject<JToken>(File.ReadAllText(path))[(object)"runtime"];
					object name;
					if (val == null)
					{
						name = null;
					}
					else
					{
						JToken obj = val[(object)"name"];
						name = ((obj != null) ? obj.ToObject<string>() : null);
					}
					runtime.Name = (string)name;
					runtime.Path = path;
					string defaultRuntimePath = GetDefaultRuntimePath();
					if (defaultRuntimePath != null)
					{
						runtime.Default = string.Equals(path, defaultRuntimePath, StringComparison.CurrentCultureIgnoreCase);
					}
					return true;
				}
				catch
				{
					return false;
				}
			}

			public bool Equals(Runtime other)
			{
				return Path == other.Path;
			}

			public override bool Equals(object obj)
			{
				if (obj is Runtime other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(Path);
			}
		}

		public static class Loader
		{
			private static XRGeneralSettings xrGeneralSettings;

			private static XRManagerSettings xrManagerSettings;

			private static OpenXRLoader xrLoader;

			private static readonly ManualLogSource Logger;

			static Loader()
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				Logger = new ManualLogSource("OpenXR Loader");
				Logger.Sources.Add((ILogSource)(object)Logger);
			}

			public static bool InitializeXR()
			{
				InitializeScripts();
				if (Native.IsElevated())
				{
					Logger.LogWarning((object)"Application is elevated! Unable to override the XR runtime! Only the system default OpenXR runtime will be available.");
					return InitializeXR(null);
				}
				Runtimes runtimes = GetRuntimes();
				if (runtimes.Count == 0)
				{
					Logger.LogWarning((object)"Failed to query runtimes, or no runtimes were found. Falling back to old behavior.");
					Runtime? runtime;
					if (!string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value))
					{
						Runtime value = default(Runtime);
						value.Name = "LCVR OpenXR Override";
						value.Path = Plugin.Config.OpenXRRuntimeFile.Value;
						runtime = value;
					}
					else
					{
						runtime = null;
					}
					return InitializeXR(runtime);
				}
				if (!string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value))
				{
					Runtime value2;
					if (!runtimes.TryGetRuntimeByPath(Plugin.Config.OpenXRRuntimeFile.Value, out var runtime2))
					{
						Runtime value = default(Runtime);
						value.Name = "LCVR OpenXR Override";
						value.Path = Plugin.Config.OpenXRRuntimeFile.Value;
						value2 = value;
					}
					else
					{
						value2 = runtime2;
					}
					if (InitializeXR(value2))
					{
						return true;
					}
					Logger.LogWarning((object)"Loading OpenXR using override failed, falling back to automatic enumeration...");
				}
				Runtime? @default = runtimes.Default;
				if (@default.HasValue)
				{
					Runtime valueOrDefault = @default.GetValueOrDefault();
					if (valueOrDefault.Path != Plugin.Config.OpenXRRuntimeFile.Value && InitializeXR(valueOrDefault))
					{
						return true;
					}
				}
				foreach (Runtime item in runtimes.Where((Runtime rt) => rt.Path != Plugin.Config.OpenXRRuntimeFile.Value && !rt.Default))
				{
					if (InitializeXR(item))
					{
						return true;
					}
				}
				Logger.LogError((object)"All available runtimes were attempted but none worked. Aborting...");
				return false;
			}

			public static void DeinitializeXR()
			{
				xrManagerSettings.DeinitializeLoader();
				xrGeneralSettings.StopXRSDK();
			}

			private static bool InitializeXR(Runtime? runtime)
			{
				if (runtime.HasValue)
				{
					Runtime valueOrDefault = runtime.GetValueOrDefault();
					Logger.LogInfo((object)("Attempting to initialize OpenXR on " + valueOrDefault.Name));
					Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", valueOrDefault.Path);
				}
				else
				{
					Logger.LogInfo((object)"Attempting to initialize OpenXR using default runtime");
					Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", null);
				}
				xrGeneralSettings.InitXRSDK();
				xrGeneralSettings.Start();
				List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
				SubsystemManager.GetInstances<XRDisplaySubsystem>(list);
				if (Plugin.Config.EnableVerboseLogging.Value)
				{
					Logger.LogWarning((object)"OpenXR Diagnostics Report:");
					string[] array = GenerateReport().Split("\n");
					foreach (string text in array)
					{
						Logger.LogWarning((object)text);
					}
					Logger.LogWarning((object)"");
					Logger.LogWarning((object)"To prevent diagnostics report from being printed, disable the 'EnableVerboseLogging' option in the settings.");
				}
				return list.Count > 0;
			}

			private static void InitializeScripts()
			{
				if (xrGeneralSettings == null)
				{
					xrGeneralSettings = ScriptableObject.CreateInstance<XRGeneralSettings>();
				}
				if (xrManagerSettings == null)
				{
					xrManagerSettings = ScriptableObject.CreateInstance<XRManagerSettings>();
				}
				if (xrLoader == null)
				{
					xrLoader = ScriptableObject.CreateInstance<OpenXRLoader>();
				}
				xrGeneralSettings.Manager = xrManagerSettings;
				((List<XRLoader>)xrManagerSettings.activeLoaders).Clear();
				((List<XRLoader>)xrManagerSettings.activeLoaders).Add((XRLoader)(object)xrLoader);
				OpenXRSettings.Instance.renderMode = (RenderMode)0;
				OpenXRSettings.Instance.depthSubmissionMode = (DepthSubmissionMode)0;
				if (OpenXRSettings.Instance.features.Length == 0)
				{
					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
					};
				}
			}
		}

		[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);

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

		public static Runtimes GetRuntimes()
		{
			HashSet<Runtime> hashSet = new HashSet<Runtime>();
			foreach (Runtime item2 in LocateCommonRuntimes())
			{
				hashSet.Add(item2);
			}
			string defaultRuntimePath = GetDefaultRuntimePath();
			if (Native.RegOpenKeyEx(Native.HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenXR\\1", 0, 131097, out var phkResult) != 0)
			{
				return new Runtimes(hashSet.ToArray());
			}
			List<string> list = new List<string>();
			if (!Native.RegOpenSubKey(ref phkResult, "AvailableRuntimes", 131097) || !EnumRuntimeFiles(phkResult, list))
			{
				if (string.IsNullOrEmpty(defaultRuntimePath))
				{
					return new Runtimes(hashSet.ToArray());
				}
				try
				{
					JToken val = JsonConvert.DeserializeObject<JToken>(File.ReadAllText(defaultRuntimePath))[(object)"runtime"];
					Runtime item = default(Runtime);
					object name;
					if (val == null)
					{
						name = null;
					}
					else
					{
						JToken obj = val[(object)"name"];
						name = ((obj != null) ? obj.ToObject<string>() : null);
					}
					item.Name = (string)name;
					item.Path = defaultRuntimePath;
					item.Default = true;
					hashSet.Add(item);
				}
				catch
				{
				}
				return new Runtimes(hashSet.ToArray());
			}
			if (!list.Contains(defaultRuntimePath))
			{
				list.Add(defaultRuntimePath);
			}
			foreach (string item3 in list)
			{
				try
				{
					JToken val2 = JsonConvert.DeserializeObject<JToken>(File.ReadAllText(item3))[(object)"runtime"];
					Runtime item = default(Runtime);
					object name2;
					if (val2 == null)
					{
						name2 = null;
					}
					else
					{
						JToken obj3 = val2[(object)"name"];
						name2 = ((obj3 != null) ? obj3.ToObject<string>() : null);
					}
					item.Name = (string)name2;
					item.Path = item3;
					item.Default = item3 == defaultRuntimePath;
					hashSet.Add(item);
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Failed to parse " + item3 + ": " + ex.Message + ". Runtime will not be used.");
				}
			}
			return new Runtimes(hashSet.ToArray());
		}

		[CanBeNull]
		private static string GetDefaultRuntimePath()
		{
			if (Native.RegOpenKeyEx(Native.HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenXR\\1", 0, 131097, out var phkResult) != 0)
			{
				return null;
			}
			string result = null;
			uint lpcbData = 0u;
			uint lpType;
			bool flag = Native.RegQueryValueEx(phkResult, "ActiveRuntime", 0, out lpType, null, ref lpcbData) != 0;
			bool flag2 = flag;
			if (!flag2)
			{
				bool flag3 = lpType - 1 <= 1;
				flag2 = !flag3;
			}
			if (flag2)
			{
				return null;
			}
			StringBuilder stringBuilder = new StringBuilder((int)lpcbData);
			if (Native.RegQueryValueEx(phkResult, "ActiveRuntime", 0, out lpType, stringBuilder, ref lpcbData) == 0)
			{
				result = stringBuilder.ToString();
			}
			return result;
		}

		private static bool EnumRuntimeFiles(IntPtr hKey, List<string> files)
		{
			if (Native.RegQueryInfoKey(hKey, null, IntPtr.Zero, IntPtr.Zero, out var _, out var _, out var _, out var lpcValues, out var lpcbMaxValueNameLen, out var _, IntPtr.Zero, IntPtr.Zero) != 0)
			{
				return false;
			}
			for (uint num = 0u; num < lpcValues; num++)
			{
				StringBuilder stringBuilder = new StringBuilder((int)(lpcbMaxValueNameLen + 1));
				uint lpcchValueName = lpcbMaxValueNameLen + 1;
				if (Native.RegEnumValue(hKey, num, stringBuilder, ref lpcchValueName, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) == 0)
				{
					files.Add(stringBuilder.ToString());
				}
			}
			return true;
		}

		private static IEnumerable<Runtime> LocateCommonRuntimes()
		{
			Runtime? runtime = Utils.ExecuteWithSteamAPI((Func<Runtime?>)delegate
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (SteamApps.IsAppInstalled(AppId.op_Implicit(250820)))
				{
					string text = SteamApps.AppInstallDir(AppId.op_Implicit(250820));
					if (text != null && Runtime.ReadFromJson(Path.Combine(text, "steamxr_win64.json"), out var runtime3))
					{
						return runtime3;
					}
				}
				return null;
			});
			if (runtime.HasValue)
			{
				yield return runtime.Value;
			}
			string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Virtual Desktop Streamer\\OpenXR\\virtualdesktop-openxr.json");
			if (File.Exists(path) && Runtime.ReadFromJson(path, out var runtime2))
			{
				yield return runtime2;
			}
			path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Oculus\\Support\\oculus-runtime\\oculus_openxr_64.json");
			if (File.Exists(path) && Runtime.ReadFromJson(path, out runtime2))
			{
				yield return runtime2;
			}
		}

		public static bool GetActiveRuntimeName(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 GetActiveRuntimeVersion(out ushort major, out ushort minor, out ushort patch)
		{
			return Internal_GetRuntimeVersion(out major, out minor, out patch);
		}
	}
	[BepInPlugin("io.daxcess.lcvr", "LCVR", "1.3.10")]
	[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.3.10";

		private const string SKIP_CHECKSUM_VAR = "--lcvr-skip-checksum=1.3.10";

		private const string HASHES_OVERRIDE_URL = "https://gist.githubusercontent.com/DaXcess/72c4fbac0f18c76ebc99e6b769f19389/raw/LCVR%2520Game%2520Hashes";

		private readonly string[] GAME_ASSEMBLY_HASHES = new string[7] { "BFF45683C267F402429049EF7D8095C078D5CD534E5300E56317ACB6056D70FB", "A6BDE2EB39028B36CB1667DCFB4ED10F688FB3FF72E71491AC25C5CB47A7EF6C", "B0BC7D3392FDAD3BB6515C0769363A51FF3599E67325FAE153948E0B82EB7596", "B644AD19F3CE1E82071AC5F45D1E96D76B9FC06C11763381E1979BCDC5889607", "6F822FD5F804B519FA95D91DC2B2AE13A646C51D7BF1DE87A0A3D270A889A2DF", "BA9028C8F8DBDEF4CD179FF2A2AD57549C8D7135911B1AD48B53F638ABD3D595", "2AF191104F9E57F0E3CF2C24153C5AAFC64D8E6DA56CD49E9BE580B19B3A1833" };

		public static Config Config { 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).Info.Location, ((BaseUnityPlugin)this).Config);
			Config.DeserializeFromES3();
			Config.File.SettingChanged += delegate
			{
				Config.SerializeToES3();
			};
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Starting LCVR v1.3.10 (" + GetCommitHash() + ")"));
			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;
				}
			}
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			if (commandLineArgs.Contains("--lcvr-debug-interactables"))
			{
				Flags |= Flags.InteractableDebug;
			}
			if (commandLineArgs.Contains("--lcvr-item-offset-editor"))
			{
				Flags |= Flags.ItemOffsetEditor;
			}
			bool flag2 = Environment.GetCommandLineArgs().Contains("--lcvr-skip-checksum=1.3.10");
			if (!VerifyGameVersion())
			{
				if (!flag2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Error: Unsupported game version, or corrupted game detected!");
					((BaseUnityPlugin)this).Logger.LogError((object)"This usually happens if Lethal Company got updated recently.");
					((BaseUnityPlugin)this).Logger.LogWarning((object)"To bypass this check, add the following flag to your launch options in Steam: --lcvr-skip-checksum=1.3.10");
					return;
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Warning: Unsupported game version, or corrupted game detected!");
				Flags |= Flags.InvalidGameAssembly;
			}
			if (!PreloadRuntimeDependencies())
			{
				((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 && InitializeVR())
			{
				Flags |= Flags.VR;
				((MonoBehaviour)this).StartCoroutine(HijackSplashScreen());
			}
			HarmonyPatcher.PatchUniversal();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Inserted universal patches using Harmony");
			Native.BringGameWindowToFront();
		}

		private static string GetCommitHash()
		{
			try
			{
				AssemblyInformationalVersionAttribute customAttribute = Assembly.GetExecutingAssembly().GetCustomAttribute<AssemblyInformationalVersionAttribute>();
				return ((customAttribute != null) ? customAttribute.InformationalVersion.Split('+')[1].Substring(0, 7) : null) ?? "unknown";
			}
			catch
			{
				Logger.LogWarning("Failed to retrieve commit hash (compiled outside of git repo?).");
				return "unknown";
			}
		}

		private bool VerifyGameVersion()
		{
			string path = Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll");
			string value = BitConverter.ToString(Utils.ComputeHash(File.ReadAllBytes(path))).Replace("-", "");
			if (GAME_ASSEMBLY_HASHES.Contains(value))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Game version verified using local hashes");
				return true;
			}
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Failed to verify game version using local hashes, checking remotely for updated hashes...");
			try
			{
				string content = new WebClient().DownloadString("https://gist.githubusercontent.com/DaXcess/72c4fbac0f18c76ebc99e6b769f19389/raw/LCVR%2520Game%2520Hashes");
				string[] source = Utils.ParseConfig(content);
				if (!source.Contains(value))
				{
					return false;
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Game version verified using remote hashes");
				return true;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to verify using remote hashes: " + ex.Message));
				return false;
			}
		}

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

		public static void ToggleVR()
		{
			if (Flags.HasFlag(Flags.VR))
			{
				OpenXR.Loader.DeinitializeXR();
				HarmonyPatcher.UnpatchVR();
				Flags &= ~Flags.VR;
			}
			else if (InitializeVR())
			{
				Flags |= Flags.VR;
				Flags &= ~Flags.StartupFailed;
			}
		}

		private static bool InitializeVR()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: 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_019a: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo("Loading VR...");
			if (!OpenXR.Loader.InitializeXR())
			{
				Logger.LogError("Failed to start in VR Mode! Only Non-VR features are available!");
				Logger.LogWarning("You may ignore the previous error if you are intending to play without VR");
				Flags |= Flags.StartupFailed;
				return false;
			}
			if (OpenXR.GetActiveRuntimeName(out var name) && OpenXR.GetActiveRuntimeVersion(out var major, out var minor, out var patch))
			{
				Logger.LogInfo($"OpenXR runtime being used: {name} ({major}.{minor}.{patch})");
			}
			else
			{
				Logger.LogError("Could not get OpenXR runtime info?");
			}
			HarmonyPatcher.PatchVR();
			Logger.LogDebug("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.dynResType = (DynamicResolutionType)1;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.upsampleFilter = Config.DynamicResolutionUpscaleFilter.Value;
			currentPlatformRenderPipelineSettings.dynamicResolutionSettings.minPercentage = (currentPlatformRenderPipelineSettings.dynamicResolutionSettings.maxPercentage = Config.DynamicResolutionPercentage.Value);
			currentPlatformRenderPipelineSettings.supportMotionVectors = true;
			currentPlatformRenderPipelineSettings.xrSettings.occlusionMesh = Config.EnableOcclusionMesh.Value;
			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;
			InputSystem.settings.defaultButtonPressPoint = Config.ButtonPressPoint.Value;
			return true;
		}

		private static 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;
				}
			});
			MeshRenderer component = GameObject.Find("SplashRootObject/Quad").GetComponent<MeshRenderer>();
			((Renderer)component).material = AssetManager.SplashMaterial;
		}
	}
	[Flags]
	public enum Flags
	{
		VR = 1,
		InvalidGameAssembly = 2,
		InteractableDebug = 4,
		ItemOffsetEditor = 8,
		StartupFailed = 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[] ParseConfig(string content)
		{
			string[] source = content.Split("\n", StringSplitOptions.RemoveEmptyEntries);
			return (from line in source
				where !line.TrimStart().StartsWith("#")
				let commentIndex = line.IndexOf('#')
				select (commentIndex < 0) ? line.Trim() : line.Substring(0, commentIndex).Trim() into parsedLine
				where !string.IsNullOrEmpty(parsedLine)
				select parsedLine).ToArray();
		}

		public static string FormatPascalAndAcronym(string input)
		{
			StringBuilder stringBuilder = new StringBuilder(input[0].ToString());
			if (stringBuilder.Length <= 0)
			{
				return stringBuilder.ToString();
			}
			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_0032: Unknown result type (might be due to invalid IL or missing references)
			TrackedPoseDriver val = @object.AddComponent<TrackedPoseDriver>();
			val.positionAction = Actions.Instance.HeadPosition;
			val.rotationAction = Actions.Instance.HeadRotation;
			val.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 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;
		}

		private 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.DefaultXRActions.FindAction($"{hand}/Select", false));
			controller.selectActionValue = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Select Value", false));
			controller.activateAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Activate", false));
			controller.activateActionValue = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Activate Value", false));
			controller.uiPressAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/UI Press", false));
			controller.uiPressActionValue = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/UI Press Value", false));
			controller.uiScrollAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/UI Scroll", false));
			controller.rotateAnchorAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Rotate Anchor", false));
			controller.translateAnchorAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Translate Anchor", false));
			controller.scaleToggleAction = new InputActionProperty(AssetManager.DefaultXRActions.FindAction($"{hand}/Scale Toggle", false));
			controller.scaleDeltaAction = new InputActionProperty(AssetManager.DefaultXRActions.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);
		}

		private static InputAction Position(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandPosition, 
				Hand.Right => Actions.Instance.RightHandPosition, 
				_ => throw new ArgumentOutOfRangeException("hand", "Invalid hand variant was given"), 
			});
		}

		private static InputAction Rotation(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandRotation, 
				Hand.Right => Actions.Instance.RightHandRotation, 
				_ => throw new ArgumentOutOfRangeException("hand", "Invalid hand variant was given"), 
			});
		}

		private static InputAction TrackingState(this Hand hand)
		{
			return (InputAction)(hand switch
			{
				Hand.Left => Actions.Instance.LeftHandTrackingState, 
				Hand.Right => Actions.Instance.RightHandTrackingState, 
				_ => throw new ArgumentOutOfRangeException("hand", "Invalid hand variant was given"), 
			});
		}

		public static bool IsLocalPlayer(this PlayerControllerB player)
		{
			return (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)player;
		}

		public static IEnumerator NopRoutine()
		{
			yield break;
		}

		public static T ExecuteWithSteamAPI<T>(Func<T> func)
		{
			bool isValid = SteamClient.IsValid;
			if (!isValid)
			{
				SteamClient.Init(1966720u, false);
			}
			T result = func();
			if (!isValid)
			{
				SteamClient.Shutdown();
			}
			return result;
		}
	}
}
namespace LCVR.UI
{
	public class BeltBagUI : MonoBehaviour
	{
		private const float UI_SCALE_GROUNDED = 0.002f;

		private const float UI_SCALE_IN_HAND = 0.0015f;

		private BeltBagInventoryUI inventoryUI;

		private Canvas canvas;

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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)
			inventoryUI = Object.FindObjectOfType<BeltBagInventoryUI>();
			GameObject val = new GameObject("VR Belt Bag UI");
			val.transform.localScale = Vector3.one * 0.002f;
			canvas = val.AddComponent<Canvas>();
			canvas.worldCamera = VRSession.Instance.MainCamera;
			canvas.renderMode = (RenderMode)2;
			canvas.sortingOrder = 1;
			Transform transform = GameObject.Find("BeltBagUI").transform;
			transform.SetParent(((Component)canvas).transform, false);
			transform.localPosition = Vector3.zero;
			transform.localRotation = Quaternion.identity;
			((Component)((Component)transform).transform.Find("Buttons/ExitButton")).gameObject.SetActive(false);
			for (int i = 0; i < inventoryUI.inventorySlots.Length; i++)
			{
				BeltBagInventorySlot beltBagInventorySlot = Object.Instantiate<GameObject>(AssetManager.Interactable, inventoryUI.inventorySlots[i].transform).AddComponent<BeltBagInventorySlot>();
				((Component)beltBagInventorySlot).transform.localScale = new Vector3(30f, 30f, 1f);
				beltBagInventorySlot.inventory = inventoryUI;
				beltBagInventorySlot.slot = i;
			}
		}

		private void Update()
		{
			if (inventoryUI.currentBeltBag != null)
			{
				if (((GrabbableObject)inventoryUI.currentBeltBag).playerHeldBy == null)
				{
					UpdateGrounded();
				}
				else if ((Object)(object)((GrabbableObject)inventoryUI.currentBeltBag).playerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController)
				{
					UpdateHand();
				}
			}
		}

		private void LateUpdate()
		{
			//IL_002d: 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_0046: 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)
			if (inventoryUI.currentBeltBag != null)
			{
				Transform transform = ((Component)inventoryUI.currentBeltBag).transform;
				Transform transform2 = ((Component)canvas).transform;
				transform2.rotation = transform.rotation * Quaternion.Euler(290f, 180f, 0f);
				transform2.position = transform.TransformPoint(new Vector3(0f, 0.15f, 1f));
			}
		}

		private void UpdateGrounded()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)inventoryUI.currentBeltBag.currentPlayerChecking != (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				return;
			}
			((Component)canvas).transform.localScale = Vector3.one * 0.002f;
			Vector3 val = VRSession.Instance.MainCamera.WorldToViewportPoint(((Component)inventoryUI.currentBeltBag).transform.position);
			float x = val.x;
			if (x >= 0f && x <= 1f)
			{
				x = val.y;
				if (x >= 0f && x <= 1f && val.z > 0f)
				{
					return;
				}
			}
			StartOfRound.Instance.localPlayerController.SetInSpecialMenu(false, (SpecialHUDMenu)1);
		}

		private void UpdateHand()
		{
			//IL_000b: 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)
			((Component)canvas).transform.localScale = Vector3.one * 0.0015f;
		}
	}
	public class BeltBagInventorySlot : MonoBehaviour, VRInteractable
	{
		public BeltBagInventoryUI inventory;

		public int slot;

		public InteractableFlags Flags => InteractableFlags.BothHands;

		public void OnColliderEnter(VRInteractor interactor)
		{
		}

		public void OnColliderExit(VRInteractor interactor)
		{
		}

		public bool OnButtonPress(VRInteractor interactor)
		{
			BeltBagItem currentBeltBag = inventory.currentBeltBag;
			if (currentBeltBag == null || currentBeltBag.objectsInBag.Count < slot || (Object)(object)currentBeltBag.objectsInBag[slot] == (Object)null)
			{
				return true;
			}
			inventory.RemoveItemFromUI(slot);
			return true;
		}

		public void OnButtonRelease(VRInteractor interactor)
		{
		}
	}
	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["Reset Height"].performed += OnResetHeight;
			enemyTransform = Object.Instantiate<GameObject>(AssetManager.EnemyPrefab).transform;
			((MonoBehaviour)this).StartCoroutine(Init());
		}

		private void OnDestroy()
		{
			Actions.Instance["Reset Height"].performed -= OnResetHeight;
			if ((Object)(object)enemyTransform != (Object)null)
			{
				Object.Destroy((Object)(object)((Comp