using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
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 CWVR.Assets;
using CWVR.Input;
using CWVR.Networking;
using CWVR.Patches;
using CWVR.Player;
using CWVR.Properties;
using CWVR.UI;
using CWVR.UI.Settings;
using ContentSettings.API;
using ContentSettings.API.Settings.UI;
using CurvedUI;
using HarmonyLib;
using HorizonBasedAmbientOcclusion.Universal;
using Microsoft.CodeAnalysis;
using Microsoft.MixedReality.Toolkit.Experimental.UI;
using Newtonsoft.Json;
using Photon.Pun;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Animations.Rigging;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.SpatialTracking;
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;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Core.Serizalization;

[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("CWVR")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2024")]
[assembly: AssemblyDescription("Recording creatures in VR")]
[assembly: AssemblyFileVersion("1.0.4.0")]
[assembly: AssemblyInformationalVersion("1.0.4+ae9bc8dceb174dec0e2d4f85b5de067db5a0cba4")]
[assembly: AssemblyProduct("CWVR")]
[assembly: AssemblyTitle("CWVR")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/CWVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace Microsoft.MixedReality.Toolkit.Experimental.UI
{
	public class CapsLockHighlight : MonoBehaviour
	{
		[SerializeField]
		private Image m_Highlight;

		private NonNativeKeyboard m_Keyboard;

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

		private void Update()
		{
			UpdateState();
		}

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

		private NonNativeKeyboard keyboard;

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

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

		public Function ButtonFunction => buttonFunction;

		public string MacroText => macroText;

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

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

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

		public string Value;

		public string ShiftValue;

		private TextMeshProUGUI m_Text;

		private Button m_Button;

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

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

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

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

		public TMP_InputField InputField;

		public bool SliderEnabled;

		public bool CloseOnEnter = true;

		public bool SubmitOnEnter;

		public bool DisableLayouts = true;

		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()
		{
			TMP_InputField inputField = InputField;
			if (inputField != null)
			{
				((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;
		}

		public void PresentKeyboard()
		{
			ResetClosingTime();
			((Component)this).gameObject.SetActive(true);
			ActivateSpecificKeyboard(LayoutType.Alpha);
			this.OnPlacement(this, EventArgs.Empty);
			TMP_InputField inputField = InputField;
			if (inputField != null)
			{
				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)
		{
			if (DisableLayouts)
			{
				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);
			if (Object.op_Implicit((Object)(object)InputField))
			{
				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 (!Object.op_Implicit((Object)(object)InputField))
			{
				return;
			}
			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()
		{
			if (DisableLayouts)
			{
				Image numbersKeyboard = NumbersKeyboard;
				if (numbersKeyboard != null)
				{
					((Component)numbersKeyboard).gameObject.SetActive(false);
				}
				Image alphaKeyboard = AlphaKeyboard;
				if (alphaKeyboard != null)
				{
					((Component)alphaKeyboard).gameObject.SetActive(false);
				}
				Image symbolKeyboard = SymbolKeyboard;
				if (symbolKeyboard != null)
				{
					((Component)symbolKeyboard).gameObject.SetActive(false);
				}
				Image alphaWebKeys = AlphaWebKeys;
				if (alphaWebKeys != null)
				{
					((Component)alphaWebKeys).gameObject.SetActive(false);
				}
				Image alphaMailKeys = AlphaMailKeys;
				if (alphaMailKeys != null)
				{
					((Component)alphaMailKeys).gameObject.SetActive(false);
				}
				Image alphaSubKeys = AlphaSubKeys;
				if (alphaSubKeys != null)
				{
					((Component)alphaSubKeys).gameObject.SetActive(false);
				}
			}
		}

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

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

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

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

		[SerializeField]
		private Image m_ImageField;

		[SerializeField]
		private Color m_DisabledColor = Color.grey;

		private Color m_StartingColor = Color.white;

		private Button m_Button;

		private void Start()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_TextField != (Object)null)
			{
				m_StartingColor = ((Graphic)m_TextField).color;
			}
			if ((Object)(object)m_ImageField != (Object)null)
			{
				m_StartingColor = ((Graphic)m_ImageField).color;
			}
			m_Button = ((Component)this).GetComponentInParent<Button>();
			UpdateState();
		}

		private void Update()
		{
			UpdateState();
		}

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

		[SerializeField]
		private Button m_PageBck;

		[SerializeField]
		private Button m_PageFwd;

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

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

		[SerializeField]
		private float maxHeight = -1f;

		[SerializeField]
		private float horizontalSpacing;

		[SerializeField]
		private float verticalSpacing;

		private RectTransform rectTransform;

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

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

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

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

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

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

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

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

		public void AddItem(RectTransform item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Items.Add(item);
			((Transform)item).SetParent(((Component)this).transform);
			((Component)item).transform.localScale = Vector3.one;
			((Transform)item).position = Vector3.zero;
			item.anchoredPosition3D = Vector3.zero;
			UpdateLayout();
		}

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

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

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

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

			public string Guid { get; }

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

		private readonly CompatibleMod[] ModCompatibilityList = new CompatibleMod[1]
		{
			new CompatibleMod("ContentSettings", "CommanderCat101.ContentSettings")
		};

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

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

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

		public ConfigFile File { get; }

		public ConfigEntry<bool> DisableVR { get; }

		public ConfigEntry<bool> DisableRagdollCamera { get; }

		public ConfigEntry<TurnProviderOption> TurnProvider { get; }

		public ConfigEntry<float> SmoothTurnSpeedModifier { get; }

		public ConfigEntry<int> SnapTurnSize { get; }

		public ConfigEntry<bool> ToggleSprint { get; }

		public ConfigEntry<bool> InteractToZoom { get; }

		public ConfigEntry<bool> FirstTimeLaunch { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public ConfigEntry<bool> EnableCustomControls { get; }

		public ConfigEntry<string> CustomControls { get; }

		public Config(ConfigFile file)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			File = file;
			DisableVR = file.Bind<bool>("General", "DisableVR", false, "Disables the main functionality of this mod, can be used if you want to play without VR while keeping the mod installed.");
			DisableRagdollCamera = file.Bind<bool>("General", "DisableRagdollCamera", false, "Disable if coward");
			TurnProvider = file.Bind<TurnProviderOption>("Input", "TurnProvider", TurnProviderOption.Smooth, 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<int>("Input", "SnapTurnSize", 45, 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<int>(10, 180), Array.Empty<object>()));
			ToggleSprint = file.Bind<bool>("Input", "ToggleSprint", false, "Whether the sprint button should toggle sprint instead of having to hold it down.");
			InteractToZoom = file.Bind<bool>("Input", "InteractToZoom", false, "Require holding the interact button to zoom the camera. Removes the need to hold interact to swap items.");
			FirstTimeLaunch = file.Bind<bool>("Internal", "FirstTimeLaunch", true, "Keeps track if the game was launched in VR before. For internal use only.");
			OpenXRRuntimeFile = file.Bind<string>("Internal", "OpenXRRuntimeFile", "", "Overrides the OpenXR plugin to use a specific json file. For internal use only.");
			EnableCustomControls = file.Bind<bool>("Internal", "EnableCustomControls", false, "Whether or not to use a customized control schema");
			CustomControls = file.Bind<string>("Internal", "CustomControls", "", "The custom control schema to use");
			base..ctor();
		}
	}
	internal class AcceptableValueEnum<T> : AcceptableValueBase where T : notnull, Enum
	{
		private readonly string[] names = Enum.GetNames(typeof(T));

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

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

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

		public override string ToDescriptionString()
		{
			return "# Acceptable values: " + string.Join(", ", names);
		}
	}
	[CWVRPatch(CWVRPatchTarget.VROnly, null)]
	[HarmonyPatch]
	internal static class VREntrypoint
	{
		[HarmonyPatch(typeof(GameAPI), "Awake")]
		[HarmonyPostfix]
		private static void OnGameEntered(GameAPI __instance)
		{
			if (!(((Object)__instance).name != "MainMenuGame"))
			{
				((Component)__instance).gameObject.AddComponent<MainMenu>();
			}
		}
	}
	[CWVRPatch(CWVRPatchTarget.Universal, null)]
	[HarmonyPatch]
	internal static class UniversalEntrypoint
	{
		[HarmonyPatch(typeof(GameAPI), "Awake")]
		[HarmonyPostfix]
		private static void OnGameEntered(GameAPI __instance)
		{
			if (((Object)__instance).name == "MainMenuGame")
			{
				GameObject gameObject = ((Component)Object.FindObjectOfType<MainMenuSettingsPage>(true)).gameObject;
				RemapHandler remapHandler = gameObject.AddComponent<RemapHandler>();
				gameObject.AddComponent<SettingsMenu>().remapHandler = remapHandler;
			}
			else
			{
				((MonoBehaviour)__instance).StartCoroutine(Start());
			}
		}

		private static IEnumerator Start()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => Player.localPlayer != null));
			Scene activeScene = SceneManager.GetActiveScene();
			if (!(((Scene)(ref activeScene)).name == "MainMenuGame"))
			{
				new GameObject("CWVR Session Manager").AddComponent<VRSession>();
			}
		}
	}
	public class Logger
	{
		private static ManualLogSource logSource;

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

		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
	{
		public static readonly IntPtr HKEY_LOCAL_MACHINE = new IntPtr(2147483650L);

		[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);
	}
	internal static class OpenXR
	{
		public class OpenXRReport
		{
			public string RuntimeName { get; }

			public string RuntimeVersion { get; }

			public string Error { get; }

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

		[DataContract]
		private struct OpenXRRuntime
		{
			[DataMember(Name = "runtime")]
			public RuntimeInfo Runtime { get; set; }
		}

		[DataContract]
		private struct RuntimeInfo
		{
			[DataMember(Name = "name")]
			public string Name { get; set; }
		}

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

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

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

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

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

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

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

		public static bool GetRuntimeName(out string name)
		{
			name = null;
			if (!GetRuntimeName(out IntPtr runtimeNamePtr))
			{
				return false;
			}
			if (runtimeNamePtr == IntPtr.Zero)
			{
				return false;
			}
			name = Marshal.PtrToStringAnsi(runtimeNamePtr);
			return true;
		}
	}
	[ContentWarningPlugin("io.daxcess.cwvr", "1.0.4", true)]
	[BepInPlugin("io.daxcess.cwvr", "CWVR", "1.0.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string PLUGIN_GUID = "io.daxcess.cwvr";

		private const string PLUGIN_NAME = "CWVR";

		private const string PLUGIN_VERSION = "1.0.4";

		private const string BANNER = "                             ,--.,--.                         \n ,-----.,--.   ,--.         /  //  /     ,--.   ,--.,------.  \n'  .--./|  |   |  |        /  //  /       \\  `.'  / |  .--. ' \n|  |    |  |.'.|  |       /  //  /         \\     /  |  '--'.' \n'  '--'\\|   ,'.   |      /  //  /           \\   /   |  |\\  \\  \n `-----''--'   '--'     /  //  /             `-'    `--' '--' \n                       `--'`--'                               \n\n             ___________________________ \n            < Another VR mod by DaXcess >\n             --------------------------- \n                    \\   ^__^\n                     \\  (oo)\\_______\n                        (__)\\       )\\/\\\n                            ||----w |\n                            ||     ||\n";

		public static Config Config { get; private set; }

		public static Compat Compatibility { get; private set; }

		public static Flags Flags { get; private set; }

		private void Awake()
		{
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			Logger.SetSource(((BaseUnityPlugin)this).Logger);
			Config = new Config(((BaseUnityPlugin)this).Config);
			Dictionary<string, PluginInfo>.ValueCollection values = Chainloader.PluginInfos.Values;
			int num = 0;
			PluginInfo[] array = (PluginInfo[])(object)new PluginInfo[values.Count];
			foreach (PluginInfo item in values)
			{
				array[num] = item;
				num++;
			}
			Compatibility = new Compat(new <>z__ReadOnlyArray<PluginInfo>(array));
			string[] array2 = "                             ,--.,--.                         \n ,-----.,--.   ,--.         /  //  /     ,--.   ,--.,------.  \n'  .--./|  |   |  |        /  //  /       \\  `.'  / |  .--. ' \n|  |    |  |.'.|  |       /  //  /         \\     /  |  '--'.' \n'  '--'\\|   ,'.   |      /  //  /           \\   /   |  |\\  \\  \n `-----''--'   '--'     /  //  /             `-'    `--' '--' \n                       `--'`--'                               \n\n             ___________________________ \n            < Another VR mod by DaXcess >\n             --------------------------- \n                    \\   ^__^\n                     \\  (oo)\\_______\n                        (__)\\       )\\/\\\n                            ||----w |\n                            ||     ||\n".Split('\n');
			foreach (string text in array2)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("   " + text));
			}
			bool flag = Config.DisableVR.Value || Environment.GetCommandLineArgs().Contains<string>("--disable-vr", StringComparer.InvariantCultureIgnoreCase);
			if (flag)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"VR has been disabled by config or the `--disable-vr` command line flag");
			}
			if (!LoadEarlyRuntimeDependencies())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because required runtime dependencies could not be loaded!");
				return;
			}
			if (!AssetManager.LoadAssets())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because assets could not be loaded!");
				return;
			}
			HarmonyPatcher.PatchUniversal();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Inserted Universal patches using Harmony");
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Loaded scene: " + ((Scene)(ref scene)).name));
			};
			if (!flag && InitializeVR())
			{
				Flags |= Flags.VR;
			}
		}

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

		private bool InitializeVR()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading VR...");
			SetupRuntimeAssets(out var mustRestart);
			if (mustRestart)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"You must restart the game to allow VR to function properly");
				Flags |= Flags.RestartRequired;
				return false;
			}
			if (!string.IsNullOrEmpty(Config.OpenXRRuntimeFile.Value))
			{
				Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", Config.OpenXRRuntimeFile.Value);
			}
			EnableControllerProfiles();
			InitializeXRRuntime();
			if (!StartDisplay())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Failed to start in VR Mode! Only Non-VR features are available!");
				if (OpenXR.GetDiagnosticReport(out var report))
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Runtime Name:    " + report.RuntimeName));
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Runtime Version: " + report.RuntimeVersion));
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Last Error:      " + report.Error));
					((BaseUnityPlugin)this).Logger.LogWarning((object)"");
					string error = report.Error;
					if (!(error == "XR_ERROR_RUNTIME_UNAVAILABLE"))
					{
						if (error == "XR_ERROR_FORM_FACTOR_UNAVAILABLE")
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)"This generally means that your headset is not connected, or that your headset is connected to a different runtime. Please make sure your headset is active and connected, and that you are using the correct OpenXR runtime.");
						}
						else
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)"Unknown reason for OpenXR failure!");
							((BaseUnityPlugin)this).Logger.LogWarning((object)("\n" + OpenXR.GenerateTextReport()));
						}
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)"It appears that no OpenXR runtime is currently active. Please go to the dedicated application for your VR headset and make sure that it is running, and set as default OpenXR runtime.");
					}
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Failed to generate OpenXR diagnostics report!");
				}
				string defaultRuntime;
				Dictionary<string, string> dictionary = OpenXR.DetectOpenXRRuntimes(out defaultRuntime);
				if (dictionary == null)
				{
					return false;
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)"List of registered OpenXR runtimes on this device:");
				((BaseUnityPlugin)this).Logger.LogWarning((object)((defaultRuntime != null) ? (">>> " + defaultRuntime) : "No default runtime detected!"));
				foreach (string item in dictionary.Keys.Where((string rt) => rt != defaultRuntime))
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("    " + item));
				}
				return false;
			}
			if (OpenXR.GetRuntimeName(out var name) && OpenXR.GetRuntimeVersion(out var major, out var minor, out var patch))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"OpenXR Runtime being used: {name} ({major}.{minor}.{patch})");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not get OpenXR Runtime info?");
			}
			HarmonyPatcher.PatchVR();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Inserted VR patches using Harmony");
			return true;
		}

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

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

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

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

		private void SetupRuntimeAssets(out bool mustRestart)
		{
			mustRestart = false;
			string path = Path.Combine(Paths.GameRootPath, "Content Warning_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}");
				mustRestart = true;
			}
			string path3 = Path.Combine(path, "Plugins");
			string destinationFile = Path.Combine(path3, "UnityOpenXR.dll");
			string destinationFile2 = Path.Combine(path3, "openxr_loader.dll");
			string? directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string sourceFile = Path.Combine(directoryName, "RuntimeDeps/UnityOpenXR.dll");
			string sourceFile2 = Path.Combine(directoryName, "RuntimeDeps/openxr_loader.dll");
			if (!CopyResourceFile(sourceFile, destinationFile))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not find UnityOpenXR.dll to copy to the game, VR might not work!");
			}
			if (!CopyResourceFile(sourceFile2, destinationFile2))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not find openxr_loader.dll to copy to the game, VR might not work!");
			}
		}
	}
	[Flags]
	public enum Flags
	{
		VR = 1,
		RestartRequired = 2
	}
	internal static class Utils
	{
		public static byte[] ComputeHash(byte[] input)
		{
			using SHA256 sHA = SHA256.Create();
			return sHA.ComputeHash(input);
		}

		public static Pose GetPoseData(this TrackedPoseDriver driver)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			Pose result = default(Pose);
			driver.GetPoseData(driver.m_Device, driver.m_PoseSource, ref result);
			return result;
		}

		public static void SetLayerRecursive(this GameObject go, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			go.layer = layer;
			foreach (Transform item in go.transform)
			{
				Transform val = item;
				((Component)val).gameObject.layer = layer;
				if (((Component)val).GetComponentInChildren<Transform>() != null)
				{
					((Component)val).gameObject.SetLayerRecursive(layer);
				}
			}
		}

		public static string PascalToLongString(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text[0].ToString());
			if (stringBuilder.Length <= 0)
			{
				return stringBuilder.ToString();
			}
			for (int i = 1; i < text.Length; i++)
			{
				char c = text[i - 1];
				char c2 = ((i + 1 < text.Length) ? text[i + 1] : '\0');
				bool flag = char.IsLower(c2);
				bool flag2 = char.IsUpper(c2);
				bool flag3 = char.IsUpper(text[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(text[i]);
				}
				else
				{
					stringBuilder.Append(text[i]);
				}
			}
			return stringBuilder.ToString();
		}

		public static bool InVR(this Player player)
		{
			if (player.IsLocal)
			{
				return VRSession.InVR;
			}
			if (Object.op_Implicit((Object)(object)VRSession.Instance))
			{
				return VRSession.Instance.NetworkManager.InVR(player);
			}
			return false;
		}

		public static InputDevice GetDevice(this InputSystem.XRController controller)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return (InputDevice)(controller switch
			{
				InputSystem.XRController.Left => InputDevices.GetDeviceAtXRNode((XRNode)4), 
				InputSystem.XRController.Right => InputDevices.GetDeviceAtXRNode((XRNode)5), 
				_ => throw new ArgumentOutOfRangeException("controller", controller, null), 
			});
		}
	}
	internal static class JSON
	{
		public static T Deserialize<T>(string json)
		{
			using MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
			return (T)new DataContractJsonSerializer(typeof(T)).ReadObject(stream);
		}
	}
}
namespace CWVR.UI
{
	public class AutoKeyboard : MonoBehaviour
	{
		private readonly Dictionary<TMP_InputField, UnityAction<string>> inputFields = new Dictionary<TMP_InputField, UnityAction<string>>();

		private Coroutine populateCoroutine;

		public NonNativeKeyboard keyboard;

		private void OnEnable()
		{
			populateCoroutine = ((MonoBehaviour)this).StartCoroutine(PopulateInputsRoutine());
		}

		private void OnDisable()
		{
			((MonoBehaviour)this).StopCoroutine(populateCoroutine);
		}

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

		private void RemoveDestroyed()
		{
			foreach (KeyValuePair<TMP_InputField, UnityAction<string>> item in inputFields.Where((KeyValuePair<TMP_InputField, UnityAction<string>> kvp) => (Object)(object)kvp.Key == (Object)null).ToList())
			{
				inputFields.Remove(item.Key);
			}
		}

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

		private void OnDestroy()
		{
			foreach (KeyValuePair<TMP_InputField, UnityAction<string>> inputField in inputFields)
			{
				((UnityEvent<string>)(object)inputField.Key.onSelect).RemoveListener(inputField.Value);
			}
		}
	}
	public class Customizer : MonoBehaviour
	{
		private NonNativeKeyboard keyboard;

		private PlayerCustomizer customizer;

		private XRRayInteractor leftHandInteractor;

		private XRRayInteractor rightHandInteractor;

		private XRInteractorLineVisual leftHandVisual;

		private XRInteractorLineVisual rightHandVisual;

		private bool leftTerminal;

		private void Awake()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			customizer = ((Component)this).GetComponent<PlayerCustomizer>();
			((Component)((Component)this).GetComponentInChildren<Canvas>()).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			(leftHandInteractor, leftHandVisual) = CreateInteractorController((XRNode)4);
			(rightHandInteractor, rightHandVisual) = CreateInteractorController((XRNode)5);
			((Behaviour)leftHandInteractor).enabled = false;
			((Behaviour)leftHandVisual).enabled = false;
			((Behaviour)rightHandInteractor).enabled = false;
			((Behaviour)rightHandVisual).enabled = false;
			keyboard = Object.Instantiate<GameObject>(AssetManager.Keyboard, ((Component)this).transform).GetComponent<NonNativeKeyboard>();
			((Component)keyboard).transform.localPosition = new Vector3(0f, -0.85f, 0.25f);
			((Component)keyboard).transform.localEulerAngles = new Vector3(12f, 180f, 0f);
			((Component)keyboard).transform.localScale = Vector3.one * 0.0015f;
			keyboard.OnKeyboardValueKeyPressed += OnKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed += OnFnKeyPressed;
			keyboard.OnClosed += KeyboardOnOnClosed;
		}

		private void KeyboardOnOnClosed(object sender, EventArgs e)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!leftTerminal)
			{
				customizer.backSound.Play(((Component)this).transform.position, false, 1f, (Transform)null);
				customizer.view_g.RPC("RPCA_PlayerLeftTerminal", (RpcTarget)0, new object[1] { false });
			}
		}

		private void OnFnKeyPressed(KeyboardKeyFunc obj)
		{
			//IL_00c5: 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)
			switch (obj.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Backspace:
				customizer.backSound.Play(((Component)this).transform.position, false, 1f, (Transform)null);
				if (((TMP_Text)customizer.faceText).text.Length != 0)
				{
					PhotonView view_g = customizer.view_g;
					object[] array = new object[1];
					string text = ((TMP_Text)customizer.faceText).text;
					array[0] = text.Substring(0, text.Length - 1);
					view_g.RPC("RCP_SetFaceText", (RpcTarget)0, array);
				}
				break;
			case KeyboardKeyFunc.Function.Enter:
				customizer.view_g.RPC("RPCA_PlayerLeftTerminal", (RpcTarget)0, new object[1] { true });
				customizer.applySound.Play(((Component)this).transform.position, false, 1f, (Transform)null);
				break;
			}
		}

		private void OnKeyPressed(KeyboardValueKey obj)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			string text = ((keyboard.IsShifted && !string.IsNullOrEmpty(obj.ShiftValue)) ? obj.ShiftValue : obj.Value);
			if (text.Length >= 1 && ((TMP_Text)customizer.faceText).text.Length < 3)
			{
				customizer.typeSound.Play(((Component)this).transform.position, false, 1f, (Transform)null);
				customizer.view_g.RPC("RCP_SetFaceText", (RpcTarget)0, new object[1] { ((TMP_Text)customizer.faceText).text + text[0] });
			}
		}

		internal void OnEnter()
		{
			leftTerminal = false;
			((Behaviour)leftHandInteractor).enabled = true;
			((Behaviour)leftHandVisual).enabled = true;
			((Behaviour)rightHandInteractor).enabled = true;
			((Behaviour)rightHandVisual).enabled = true;
			keyboard.PresentKeyboard();
		}

		internal void OnLeave()
		{
			leftTerminal = true;
			((Behaviour)leftHandInteractor).enabled = false;
			((Behaviour)leftHandVisual).enabled = false;
			((Behaviour)rightHandInteractor).enabled = false;
			((Behaviour)rightHandVisual).enabled = false;
			keyboard.Close();
		}

		private static (XRRayInteractor, XRInteractorLineVisual) CreateInteractorController(XRNode node)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"{node} Controller (Player Customizer)");
			val.transform.SetParent(((Component)VRSession.Instance.LocalPlayer.Rig).transform, false);
			XRController val2 = val.AddComponent<XRController>();
			XRRayInteractor val3 = val.AddComponent<XRRayInteractor>();
			XRInteractorLineVisual val4 = val.AddComponent<XRInteractorLineVisual>();
			LineRenderer component = val.GetComponent<LineRenderer>();
			val.AddComponent<SortingGroup>().sortingOrder = 5;
			Transform rayOriginTransform = val3.rayOriginTransform;
			Vector3 localEulerAngles;
			if ((int)node != 4)
			{
				if ((int)node != 5)
				{
					throw new ArgumentOutOfRangeException("node", node, null);
				}
				localEulerAngles = new Vector3(60f, 347f, 270f);
			}
			else
			{
				localEulerAngles = new Vector3(60f, 347f, 90f);
			}
			rayOriginTransform.localEulerAngles = localEulerAngles;
			val3.raycastMask = LayerMask.op_Implicit(32);
			val4.lineBendRatio = 1f;
			Gradient val5 = new Gradient();
			val5.mode = (GradientMode)0;
			val5.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(0.1f, 0f),
				new GradientAlphaKey(0.1f, 1f)
			};
			val5.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			val4.invalidColorGradient = val5;
			((Behaviour)val4).enabled = true;
			((Renderer)component).material = AssetManager.WhiteMat;
			val2.controllerNode = node;
			return (val3, val4);
		}
	}
	[CWVRPatch(CWVRPatchTarget.VROnly, null)]
	[HarmonyPatch]
	internal static class PlayerCustomizerPatches
	{
		[HarmonyPatch(typeof(PlayerCustomizer), "RPCA_EnterTerminal")]
		[HarmonyPostfix]
		private static void OnEnterTerminal(PlayerCustomizer __instance)
		{
			if (__instance.playerInTerminal.refs.view.IsMine)
			{
				((Component)__instance).GetComponent<Customizer>().OnEnter();
			}
		}

		[HarmonyPatch(typeof(PlayerCustomizer), "RPCA_PlayerLeftTerminal")]
		[HarmonyPrefix]
		private static void OnLeaveTerminal(PlayerCustomizer __instance)
		{
			if (__instance.playerInTerminal.refs.view.IsMine)
			{
				((Component)__instance).GetComponent<Customizer>().OnLeave();
			}
		}
	}
	public class HUD : MonoBehaviour
	{
		private CurvedUISettings curvedUISettings;

		private Canvas modalCanvas;

		public Camera UICamera { get; private set; }

		public Canvas WorldInteractionCanvas { get; private set; }

		public Canvas LeftHandCanvas { get; private set; }

		public Canvas RightHandCanvas { get; private set; }

		public PauseMenu PauseMenu { get; private set; }

		private void Awake()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = Player.localPlayer.refs.rigRoot.transform;
			UserInterface val = Object.FindObjectOfType<UserInterface>();
			Transform val2 = transform.Find("Rig/Armature/Hip/Torso/Arm_L/Elbow_L/Hand_L");
			Transform val3 = transform.Find("Rig/Armature/Hip/Torso/Arm_R/Elbow_R/Hand_R");
			Transform val4 = ((Component)val).transform.Find("Pivot/Others");
			string text = JsonUtility.ToJson((object)((Component)val).GetComponent<CurvedUISettings>());
			curvedUISettings = ((Component)this).gameObject.AddComponent<CurvedUISettings>();
			JsonUtility.FromJsonOverwrite(text, (object)curvedUISettings);
			curvedUISettings.Angle = 0;
			WorldInteractionCanvas = new GameObject("World Interaction Canvas").AddComponent<Canvas>();
			WorldInteractionCanvas.worldCamera = VRSession.Instance.MainCamera;
			WorldInteractionCanvas.renderMode = (RenderMode)2;
			((Component)WorldInteractionCanvas).transform.localScale = Vector3.one * 0.0066f;
			((Component)WorldInteractionCanvas).gameObject.layer = 6;
			LeftHandCanvas = new GameObject("Left Hand VR Canvas").AddComponent<Canvas>();
			LeftHandCanvas.worldCamera = VRSession.Instance.MainCamera;
			LeftHandCanvas.renderMode = (RenderMode)2;
			((Component)LeftHandCanvas).transform.localScale = Vector3.one * 0.001f;
			((Component)LeftHandCanvas).gameObject.layer = LayerMask.NameToLayer("UI");
			((Component)LeftHandCanvas).transform.SetParent(val2, false);
			((Component)LeftHandCanvas).transform.localPosition = Vector3.zero;
			((Component)LeftHandCanvas).transform.localEulerAngles = Vector3.zero;
			RightHandCanvas = new GameObject("Right Hand VR Canvas").AddComponent<Canvas>();
			RightHandCanvas.worldCamera = VRSession.Instance.MainCamera;
			RightHandCanvas.renderMode = (RenderMode)2;
			((Component)RightHandCanvas).transform.localScale = Vector3.one * 0.001f;
			((Component)RightHandCanvas).gameObject.layer = LayerMask.NameToLayer("UI");
			((Component)RightHandCanvas).transform.SetParent(val3, false);
			((Component)RightHandCanvas).transform.localPosition = Vector3.zero;
			((Component)RightHandCanvas).transform.localEulerAngles = Vector3.zero;
			Transform val5 = val4.Find("InteractionUI");
			((Component)val5).transform.SetParent(((Component)WorldInteractionCanvas).transform, false);
			TextMeshProUGUI[] componentsInChildren = ((Component)val5).GetComponentsInChildren<TextMeshProUGUI>();
			foreach (TextMeshProUGUI obj in componentsInChildren)
			{
				((TMP_Text)obj).fontSharedMaterial = new Material(((TMP_Text)obj).fontSharedMaterial);
				((TMP_Text)obj).isOverlay = true;
			}
			((Component)val5.Find("KEY")).gameObject.SetActive(false);
			Transform val6 = val4.Find("Stamina");
			((Component)val6).transform.SetParent(((Component)LeftHandCanvas).transform, false);
			val6.localPosition = new Vector3(0f, 450f, -170f);
			val6.localEulerAngles = Vector3.zero;
			val6.localScale = new Vector3(1.75f, 2.5f, 1.75f);
			Transform val7 = val4.Find("O2");
			((Component)val7).transform.SetParent(((Component)LeftHandCanvas).transform, false);
			val7.localPosition = new Vector3(-55f, 610f, -170f);
			val7.localEulerAngles = Vector3.zero;
			val7.localScale = Vector3.one * 3.5f;
			Transform val8 = val4.Find("Health");
			((Component)val8).transform.SetParent(((Component)LeftHandCanvas).transform, false);
			val8.localPosition = new Vector3(0f, 520f, -170f);
			val8.localEulerAngles = Vector3.zero;
			val8.localScale = Vector3.one * 2.5f;
			Transform val9 = val4.Find("NextStep/List/GameObject");
			((Component)val9).transform.SetParent(((Component)RightHandCanvas).transform, false);
			val9.localPosition = new Vector3(250f, 710f, -215f);
			val9.localEulerAngles = new Vector3(0f, 0f, 270f);
			val9.localScale = Vector3.one * 2.5f;
			Transform val10 = val4.Find("Hotbar");
			((Component)val10).transform.SetParent(((Component)RightHandCanvas).transform, false);
			val10.localPosition = new Vector3(-100f, 800f, -200f);
			val10.localEulerAngles = new Vector3(0f, 0f, 270f);
			val10.localScale = Vector3.one * 2.5f;
			Transform val11 = val4.Find("HelmetMessage");
			Transform obj2 = val4.parent.Find("MoneyAdded");
			val11.localPosition = new Vector3(0f, 150f, -225f);
			obj2.localPosition = new Vector3(260f, -115f, -100f);
			modalCanvas = ((Component)RetrievableResourceSingleton<Modal>.Instance).GetComponent<Canvas>();
			modalCanvas.worldCamera = VRSession.Instance.MainCamera;
			modalCanvas.renderMode = (RenderMode)2;
			((Component)modalCanvas).transform.localScale = Vector3.one * 0.001f;
			((Component)modalCanvas).gameObject.SetLayerRecursive(6);
			((Component)modalCanvas).transform.Find("Image").localScale = Vector3.one * 10f;
			((Component)val4.parent.Find("Edge")).gameObject.SetActive(false);
			((Component)val4.Find("NextStep")).gameObject.SetActive(false);
			((Component)val4.Find("LINE")).gameObject.SetActive(false);
			((Component)val4.Find("LINE (1)")).gameObject.SetActive(false);
			((Component)val4.Find("EmoteUI")).gameObject.SetActive(false);
			PauseMenu = Singleton<EscapeMenu>.Instance.m_menu.gameObject.AddComponent<PauseMenu>();
			PlayerCustomizer obj3 = Object.FindObjectOfType<PlayerCustomizer>();
			if (obj3 != null)
			{
				((Component)obj3).gameObject.AddComponent<Customizer>();
			}
			ReplaceCurvedUISettings((Component)val5, (Component)val6, (Component)val7, (Component)val8, (Component)val9, (Component)val10);
			CreateUICamera();
		}

		private void LateUpdate()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)VRSession.Instance.MainCamera).transform;
			((Component)modalCanvas).transform.position = ((Component)transform).transform.position + ((Component)transform).transform.forward * 1.5f;
			((Component)modalCanvas).transform.rotation = transform.rotation;
			if (Object.op_Implicit((Object)(object)Singleton<UserInterface>.Instance.interactionUI.m_currentInteractable))
			{
				((Component)WorldInteractionCanvas).transform.position = ((Component)Singleton<UserInterface>.Instance.interactionUI.m_currentInteractable).transform.position;
			}
			((Component)WorldInteractionCanvas).transform.rotation = Quaternion.LookRotation(((Component)WorldInteractionCanvas).transform.position - transform.position);
			Transform transform2 = ((Component)WorldInteractionCanvas).transform;
			transform2.position += ((Component)WorldInteractionCanvas).transform.forward * -0.2f;
		}

		private void CreateUICamera()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Camera mainCamera = VRSession.Instance.MainCamera;
			UICamera = new GameObject("VR UI Camera").AddComponent<Camera>();
			((Component)UICamera).transform.SetParent(((Component)mainCamera).transform, false);
			((Component)UICamera).transform.localPosition = Vector3.zero;
			((Component)UICamera).transform.localEulerAngles = Vector3.zero;
			UICamera.clearFlags = (CameraClearFlags)3;
			UICamera.depth = 10f;
			UICamera.cullingMask = 64;
			mainCamera.cullingMask &= -65;
			CameraExtensions.GetUniversalAdditionalCameraData(UICamera).renderType = (CameraRenderType)1;
			CameraExtensions.GetUniversalAdditionalCameraData(mainCamera).cameraStack.Add(UICamera);
		}

		private void ReplaceCurvedUISettings(params Component[] sources)
		{
			foreach (Component obj in sources)
			{
				CurvedUIVertexEffect component = obj.GetComponent<CurvedUIVertexEffect>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.mySettings = curvedUISettings;
				}
				CurvedUIVertexEffect[] componentsInChildren = obj.GetComponentsInChildren<CurvedUIVertexEffect>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					componentsInChildren[j].mySettings = curvedUISettings;
				}
			}
		}
	}
	public class MainMenu : MonoBehaviour
	{
		private Transform xrOrigin;

		private TrackedPoseDriver cameraTracker;

		private void Awake()
		{
			//IL_001c: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: 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)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Expected O, but got Unknown
			GameObject gameObject = ((Component)((Component)this).transform.Find("Main Camera")).gameObject;
			xrOrigin = new GameObject("XR Origin").transform;
			xrOrigin.position = gameObject.transform.position;
			xrOrigin.eulerAngles = new Vector3(0f, 180f, 0f);
			gameObject.transform.SetParent(xrOrigin, false);
			cameraTracker = gameObject.AddComponent<TrackedPoseDriver>();
			cameraTracker.deviceType = (DeviceType)0;
			cameraTracker.poseSource = (TrackedPose)2;
			cameraTracker.trackingType = (TrackingType)0;
			CreateInteractorController((XRNode)4);
			CreateInteractorController((XRNode)5);
			Canvas component = ((Component)Object.FindObjectOfType<IntroScreenAnimator>()).GetComponent<Canvas>();
			Canvas component2 = ((Component)MainMenuHandler.Instance.UIHandler).GetComponent<Canvas>();
			Canvas component3 = ((Component)RetrievableResourceSingleton<Modal>.Instance).GetComponent<Canvas>();
			RenderMode val = (RenderMode)2;
			component3.renderMode = (RenderMode)2;
			RenderMode renderMode = (component2.renderMode = val);
			component.renderMode = renderMode;
			Camera val3 = (component3.worldCamera = gameObject.GetComponent<Camera>());
			Camera worldCamera = (component2.worldCamera = val3);
			component.worldCamera = worldCamera;
			Transform transform = ((Component)component).transform;
			Transform transform2 = ((Component)component2).transform;
			Vector3 val6 = (((Component)component3).transform.localScale = Vector3.one * 0.0033f);
			Vector3 localScale = (transform2.localScale = val6);
			transform.localScale = localScale;
			((Component)component).transform.position = xrOrigin.position + ((Component)xrOrigin).transform.forward * 3f + new Vector3(0f, 1f, 0f);
			((Component)component).transform.LookAt(xrOrigin);
			((Component)component).transform.eulerAngles = new Vector3(0f, ((Component)component).transform.eulerAngles.y + 180f, 0f);
			Transform transform3 = ((Component)component2).transform;
			localScale = (((Component)component3).transform.position = ((Component)component).transform.position);
			transform3.position = localScale;
			Transform transform4 = ((Component)component2).transform;
			Quaternion rotation2 = (((Component)component3).transform.rotation = ((Component)component).transform.rotation);
			transform4.rotation = rotation2;
			((Component)component).GetComponent<RectTransform>().sizeDelta = new Vector2(1920f, 1080f);
			((Component)component2).GetComponent<RectTransform>().sizeDelta = new Vector2(1920f, 1080f);
			((Component)component3).GetComponent<RectTransform>().sizeDelta = new Vector2(1920f, 1080f);
			((Component)component3).transform.Find("Image").localScale = Vector3.one;
			((Component)component2).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			((Component)component3).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			NonNativeKeyboard component5 = Object.Instantiate<GameObject>(AssetManager.Keyboard).GetComponent<NonNativeKeyboard>();
			component5.SubmitOnEnter = true;
			((Component)component5).transform.position = new Vector3(-20.0352f, 4.4452f, 34.5683f);
			((Component)component5).transform.eulerAngles = new Vector3(20f, 180f, 0f);
			((Component)component5).transform.localScale = Vector3.one * 0.005f;
			((Component)component2).gameObject.AddComponent<AutoKeyboard>().keyboard = component5;
			if (Plugin.Config.FirstTimeLaunch.Value)
			{
				Modal.Show("Welcome to CW // VR", "Due to the nature of this game, the VR mod might cause more severe motion sickness than usual in some individuals.\nIf you suffer from motion sickness easily, it is recommended to enable \"Reduced Motion Sickness\".\nGoing for the full experience means that the camera can rotate on its own during ragdolls, death, sleeping and certain enemy attacks.\n(You can always change this setting in the VR Settings later).\n\nI wish you happy travels in trying to get SpöökFamous in VR!\n- DaXcess", (ModalOption[])(object)new ModalOption[2]
				{
					new ModalOption("Full Experience", (Action)delegate
					{
						Plugin.Config.DisableRagdollCamera.Value = false;
					}),
					new ModalOption("Reduced Motion Sickness", (Action)delegate
					{
						Plugin.Config.DisableRagdollCamera.Value = true;
					})
				}, (Action)delegate
				{
					Plugin.Config.FirstTimeLaunch.Value = false;
				});
			}
			((MonoBehaviour)this).StartCoroutine(DisableDoF());
			((MonoBehaviour)this).StartCoroutine(AutoRotate());
		}

		private void CreateInteractorController(XRNode node)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			GameObject val = new GameObject($"{node} Controller");
			val.transform.SetParent(xrOrigin, false);
			XRController val2 = val.AddComponent<XRController>();
			XRRayInteractor val3 = val.AddComponent<XRRayInteractor>();
			XRInteractorLineVisual val4 = val.AddComponent<XRInteractorLineVisual>();
			LineRenderer component = val.GetComponent<LineRenderer>();
			val.AddComponent<SortingGroup>().sortingOrder = 5;
			Transform rayOriginTransform = val3.rayOriginTransform;
			Vector3 localEulerAngles;
			if ((int)node != 4)
			{
				if ((int)node != 5)
				{
					throw new ArgumentOutOfRangeException("node", node, null);
				}
				localEulerAngles = new Vector3(60f, 347f, 270f);
			}
			else
			{
				localEulerAngles = new Vector3(60f, 347f, 90f);
			}
			rayOriginTransform.localEulerAngles = localEulerAngles;
			val4.lineBendRatio = 1f;
			Gradient val5 = new Gradient();
			val5.mode = (GradientMode)0;
			val5.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(0.1f, 0f),
				new GradientAlphaKey(0.1f, 1f)
			};
			val5.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			val4.invalidColorGradient = val5;
			((Behaviour)val4).enabled = true;
			((Renderer)component).material = AssetManager.WhiteMat;
			val2.controllerNode = node;
		}

		private IEnumerator DisableDoF()
		{
			PostVolumeHandler pvh;
			while ((pvh = Object.FindObjectOfType<PostVolumeHandler>()) == null)
			{
				yield return null;
			}
			yield return (object)new WaitUntil((Func<bool>)(() => pvh.m_volume != null));
			yield return (object)new WaitUntil((Func<bool>)(() => pvh.m_volume.profile != null));
			DepthOfField val = default(DepthOfField);
			if (pvh.m_volume.profile.TryGet<DepthOfField>(ref val))
			{
				((VolumeComponent)val).active = false;
			}
		}

		private IEnumerator AutoRotate()
		{
			Pose poseData;
			while (true)
			{
				Pose val = (poseData = cameraTracker.GetPoseData());
				if (!(((Quaternion)(ref val.rotation)).eulerAngles == Vector3.zero))
				{
					break;
				}
				yield return null;
			}
			xrOrigin.eulerAngles = new Vector3(0f, 180f - ((Quaternion)(ref poseData.rotation)).eulerAngles.y, 0f);
		}
	}
	public class PauseMenu : MonoBehaviour
	{
		private XRRayInteractor leftHandInteractor;

		private XRRayInteractor rightHandInteractor;

		private XRInteractorLineVisual leftHandVisual;

		private XRInteractorLineVisual rightHandVisual;

		private NonNativeKeyboard keyboard;

		private void Awake()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result typ