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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GWYFVR.Preload")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.3.0")]
[assembly: AssemblyInformationalVersion("0.3.3+b6949304683a727e6082cd7a7d3f0dd27d5e0cf4")]
[assembly: AssemblyProduct("GWYFVR.Preload")]
[assembly: AssemblyTitle("GWYFVR.Preload")]
[assembly: AssemblyVersion("0.3.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 GWYFVR.Preload
{
	public static class Preload
	{
		private const string DataFolder = "Gamble With Your Friends_Data";

		private const string SubsystemManifest = "{\r\n  \"name\": \"OpenXR XR Plugin\",\r\n  \"version\": \"1.18.0\",\r\n  \"libraryName\": \"UnityOpenXR\",\r\n  \"displays\": [\r\n    {\r\n      \"id\": \"OpenXR Display\"\r\n    }\r\n  ],\r\n  \"inputs\": [\r\n    {\r\n      \"id\": \"OpenXR Input\"\r\n    }\r\n  ]\r\n}";

		private static readonly string[] NativeLibraries = new string[2] { "UnityOpenXR.dll", "openxr_loader.dll" };

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

		private static readonly string[] RenderPipelineAssemblies = new string[2] { "Unity.RenderPipelines.Core.Runtime.dll", "Unity.RenderPipelines.Universal.Runtime.dll" };

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

		public static void Initialize()
		{
			try
			{
				SetupRuntimeAssets();
				InstallRenderPipeline();
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to set up the OpenXR runtime, VR will not be available: {arg}");
			}
		}

		public static void Patch(AssemblyDefinition assembly)
		{
		}

		private static void InstallRenderPipeline()
		{
			string text = FindRuntimeDeps();
			if (text == null)
			{
				return;
			}
			string path = Path.Combine(Paths.GameRootPath, "Gamble With Your Friends_Data", "Managed");
			string text2 = Path.Combine(Paths.BepInExRootPath, "GWYFVR-backup");
			string text3 = Path.Combine(Paths.CachePath, "GWYFVR");
			Directory.CreateDirectory(text2);
			Directory.CreateDirectory(text3);
			bool flag = false;
			string[] renderPipelineAssemblies = RenderPipelineAssemblies;
			foreach (string text4 in renderPipelineAssemblies)
			{
				string text5 = Path.Combine(text, "RenderPipelines", text4);
				string text6 = Path.Combine(path, text4);
				string text7 = Path.Combine(text2, text4);
				string text8 = Path.Combine(text3, text4);
				if (!File.Exists(text5))
				{
					Log.LogWarning((object)("XR-enabled " + text4 + " is missing from the mod, VR will show a black screen"));
					continue;
				}
				if (!File.Exists(text7))
				{
					File.Copy(text6, text7);
				}
				if (!File.Exists(text8) || File.GetLastWriteTimeUtc(text8) < File.GetLastWriteTimeUtc(text5))
				{
					AlignSerializedLayout(text5, text7, text8);
				}
				if (SameFile(text8, text6))
				{
					continue;
				}
				try
				{
					string text9 = text6 + ".gwyfvr-old";
					if (File.Exists(text9))
					{
						File.Delete(text9);
					}
					File.Move(text6, text9);
					File.Copy(text8, text6);
					flag = true;
					Log.LogInfo((object)("Installed XR-enabled " + text4));
				}
				catch (IOException)
				{
					Log.LogDebug((object)(text4 + " is in use, relying on the doorstop search path override"));
				}
			}
			if (flag | EnsureDoorstopSearchPath())
			{
				Log.LogWarning((object)"The XR-enabled render pipeline was just installed. Restart the game once for VR to show in the headset.");
			}
		}

		private static void AlignSerializedLayout(string xrBuild, string original, string output)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			DefaultAssemblyResolver val = new DefaultAssemblyResolver();
			((BaseAssemblyResolver)val).AddSearchDirectory(Path.GetDirectoryName(original));
			((BaseAssemblyResolver)val).AddSearchDirectory(Path.Combine(Paths.GameRootPath, "Gamble With Your Friends_Data", "Managed"));
			ReaderParameters val2 = new ReaderParameters
			{
				AssemblyResolver = (IAssemblyResolver)(object)val
			};
			AssemblyDefinition val3 = AssemblyDefinition.ReadAssembly(xrBuild, val2);
			try
			{
				AssemblyDefinition val4 = AssemblyDefinition.ReadAssembly(original, val2);
				try
				{
					Dictionary<string, TypeDefinition> dictionary = val4.MainModule.GetTypes().ToDictionary((TypeDefinition t) => ((MemberReference)t).FullName);
					int num = 0;
					foreach (TypeDefinition type in val3.MainModule.GetTypes())
					{
						if (!dictionary.TryGetValue(((MemberReference)type).FullName, out var value))
						{
							continue;
						}
						Dictionary<string, int> order = ((IEnumerable<FieldDefinition>)value.Fields).Select((FieldDefinition f, int i) => (Name: ((MemberReference)f).Name, i: i)).ToDictionary(((string Name, int i) x) => x.Name, ((string Name, int i) x) => x.i);
						List<FieldDefinition> list = ((IEnumerable<FieldDefinition>)type.Fields).ToList();
						foreach (FieldDefinition item in list)
						{
							if (!item.IsStatic && !order.ContainsKey(((MemberReference)item).Name) && !item.IsNotSerialized)
							{
								item.IsNotSerialized = true;
								num++;
								Log.LogDebug((object)("Not serializing " + ((MemberReference)type).FullName + "." + ((MemberReference)item).Name));
							}
						}
						if (((TypeReference)type).IsValueType)
						{
							continue;
						}
						int value2;
						List<FieldDefinition> list2 = list.OrderBy((FieldDefinition f) => (!order.TryGetValue(((MemberReference)f).Name, out value2)) ? int.MaxValue : value2).ToList();
						type.Fields.Clear();
						foreach (FieldDefinition item2 in list2)
						{
							type.Fields.Add(item2);
						}
					}
					val3.Write(output);
					Log.LogInfo((object)$"Prepared {Path.GetFileName(output)} ({num} XR-only fields excluded from serialization)");
				}
				finally
				{
					((IDisposable)val4)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val3)?.Dispose();
			}
		}

		private static bool EnsureDoorstopSearchPath()
		{
			string path = Path.Combine(Paths.GameRootPath, "doorstop_config.ini");
			if (!File.Exists(path))
			{
				return false;
			}
			string value = Path.Combine("BepInEx", "cache", "GWYFVR");
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].TrimStart().StartsWith("dll_search_path_override"))
				{
					string text = array[i].Substring(array[i].IndexOf('=') + 1).Trim();
					if (text.Split(';').Any((string p) => p.Trim() == value))
					{
						return false;
					}
					array[i] = "dll_search_path_override = " + ((text.Length > 0) ? (value + ";" + text) : value);
					File.WriteAllLines(path, array);
					Log.LogInfo((object)"Added the XR render pipeline folder to doorstop's dll search path");
					return true;
				}
			}
			return false;
		}

		private static bool SameFile(string a, string b)
		{
			if (!File.Exists(b))
			{
				return false;
			}
			byte[] array = File.ReadAllBytes(a);
			byte[] array2 = File.ReadAllBytes(b);
			if (array.Length == array2.Length)
			{
				return ((ReadOnlySpan<byte>)array).SequenceEqual((ReadOnlySpan<byte>)array2);
			}
			return false;
		}

		private static void SetupRuntimeAssets()
		{
			string text = FindRuntimeDeps();
			if (text == null)
			{
				Log.LogError((object)"Could not find the GWYFVR RuntimeDeps folder next to GWYFVR.dll, is the mod installed correctly?");
				return;
			}
			string path = Path.Combine(Paths.GameRootPath, "Gamble With Your Friends_Data");
			string text2 = Path.Combine(path, "UnitySubsystems", "UnityOpenXR");
			Directory.CreateDirectory(text2);
			File.WriteAllText(Path.Combine(text2, "UnitySubsystemsManifest.json"), "{\r\n  \"name\": \"OpenXR XR Plugin\",\r\n  \"version\": \"1.18.0\",\r\n  \"libraryName\": \"UnityOpenXR\",\r\n  \"displays\": [\r\n    {\r\n      \"id\": \"OpenXR Display\"\r\n    }\r\n  ],\r\n  \"inputs\": [\r\n    {\r\n      \"id\": \"OpenXR Input\"\r\n    }\r\n  ]\r\n}");
			string text3 = Path.Combine(path, "Plugins", "x86_64");
			Directory.CreateDirectory(text3);
			string[] nativeLibraries = NativeLibraries;
			foreach (string text4 in nativeLibraries)
			{
				string text5 = Path.Combine(text, text4);
				string text6 = Path.Combine(text3, text4);
				if (!File.Exists(text6) || new FileInfo(text6).Length != new FileInfo(text5).Length || !(File.GetLastWriteTimeUtc(text6) >= File.GetLastWriteTimeUtc(text5)))
				{
					File.Copy(text5, text6, overwrite: true);
					Log.LogInfo((object)("Installed " + text4));
				}
			}
			Log.LogInfo((object)"OpenXR runtime assets are in place");
		}

		private static string FindRuntimeDeps()
		{
			return (from dll in Directory.GetFiles(Paths.PluginPath, "GWYFVR.dll", SearchOption.AllDirectories)
				select Path.Combine(Path.GetDirectoryName(dll), "RuntimeDeps")).FirstOrDefault((string dir) => NativeLibraries.All((string lib) => File.Exists(Path.Combine(dir, lib))));
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Extensions;
using GWYFVR.Input;
using GWYFVR.Patches;
using GWYFVR.Player;
using GWYFVR.UI;
using GWYFVR.XR;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GWYFVR")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("VR mod for Gamble With Your Friends")]
[assembly: AssemblyFileVersion("0.3.3.0")]
[assembly: AssemblyInformationalVersion("0.3.3+b6949304683a727e6082cd7a7d3f0dd27d5e0cf4")]
[assembly: AssemblyProduct("GWYFVR")]
[assembly: AssemblyTitle("GWYFVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 GWYFVR
{
	internal class DevCommands : MonoBehaviour
	{
		private static DevCommands Instance;

		private float nextCheck;

		private bool lastGrip;

		private bool lastTrigger;

		private static string CommandFile => Path.Combine(Paths.BepInExRootPath, "gwyfvr-command.txt");

		private void Awake()
		{
			Instance = this;
		}

		private void LogPresses()
		{
			_ = HandRoles.Active;
			bool flag = XRControllers.Left.Grip || XRControllers.Right.Grip;
			bool flag2 = XRControllers.Left.Trigger || XRControllers.Right.Trigger;
			if ((flag && !lastGrip) || (flag2 && !lastTrigger))
			{
				Run(new string[1] { "state" }, ((flag && !lastGrip) ? "Grip" : "Trigger") + " press: ");
			}
			lastGrip = flag;
			lastTrigger = flag2;
		}

		private void Update()
		{
			LogPresses();
			if (Time.unscaledTime < nextCheck)
			{
				return;
			}
			nextCheck = Time.unscaledTime + 0.5f;
			if (!File.Exists(CommandFile))
			{
				return;
			}
			string[] array;
			try
			{
				array = File.ReadAllLines(CommandFile);
				File.Delete(CommandFile);
			}
			catch (IOException)
			{
				return;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					try
					{
						Run(text.Trim().Split(new char[1] { ' ' }, 2));
					}
					catch (Exception arg)
					{
						Plugin.Log.LogError((object)$"Dev command '{text}' failed: {arg}");
					}
				}
			}
		}

		private static string RayHit()
		{
			//IL_0030: 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)
			Camera val = (((Object)(object)VRPointer.Instance != (Object)null) ? VRPointer.Instance.PointerCamera : null);
			if ((Object)(object)val == (Object)null)
			{
				return "";
			}
			RaycastHit[] array = Physics.RaycastAll(((Component)val).transform.position, ((Component)val).transform.forward, 5f, -1, (QueryTriggerInteraction)2);
			Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
			StringBuilder stringBuilder = new StringBuilder();
			for (int num = 0; num < array.Length && num < 4; num++)
			{
				stringBuilder.Append(string.Format("{0} [{1}{2}] {3:F2}m; ", PathOf(((Component)((RaycastHit)(ref array[num])).collider).transform), LayerMask.LayerToName(((Component)((RaycastHit)(ref array[num])).collider).gameObject.layer), ((RaycastHit)(ref array[num])).collider.isTrigger ? ", trigger" : "", ((RaycastHit)(ref array[num])).distance));
			}
			return stringBuilder.ToString();
		}

		private static void Run(string[] args, string prefix = "")
		{
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_146c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1473: Unknown result type (might be due to invalid IL or missing references)
			//IL_1478: Unknown result type (might be due to invalid IL or missing references)
			//IL_147d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1490: Unknown result type (might be due to invalid IL or missing references)
			//IL_149c: Unknown result type (might be due to invalid IL or missing references)
			//IL_14a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_14a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_14bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_12da: Unknown result type (might be due to invalid IL or missing references)
			//IL_12e1: Expected O, but got Unknown
			//IL_12fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_10b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_10b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_10b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_10be: Unknown result type (might be due to invalid IL or missing references)
			//IL_10c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_10c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_15f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_111b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1120: Unknown result type (might be due to invalid IL or missing references)
			//IL_1124: Unknown result type (might be due to invalid IL or missing references)
			//IL_11c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_11c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_11cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a75: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_1239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c17: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c46: Unknown result type (might be due to invalid IL or missing references)
			//IL_096f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cbf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0da6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dcc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd1: Unknown result type (might be due to invalid IL or missing references)
			//IL_16b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e90: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds;
			Vector3 val2;
			switch (args[0])
			{
			case "screenshot":
			{
				string text = ((args.Length > 1) ? args[1] : Path.Combine(Paths.BepInExRootPath, "gwyfvr-screenshot.png"));
				ScreenCapture.CaptureScreenshot(text);
				Plugin.Log.LogInfo((object)("Screenshot saved to " + text));
				break;
			}
			case "capture":
				Capture((args.Length > 1) ? args[1] : Path.Combine(Paths.BepInExRootPath, "gwyfvr-capture.png"));
				break;
			case "xrcapture":
				XRSubmitter.CaptureFile = ((args.Length > 1) ? args[1] : Path.Combine(Paths.BepInExRootPath, "gwyfvr-xrcapture.png"));
				if (URPXRSetup.Active)
				{
					((MonoBehaviour)Instance).StartCoroutine(CaptureHeadsetAtEndOfFrame());
				}
				break;
			case "buttons":
			{
				Button[] array7 = Object.FindObjectsByType<Button>((FindObjectsSortMode)0);
				foreach (Button val9 in array7)
				{
					if (((Behaviour)val9).isActiveAndEnabled)
					{
						Plugin.Log.LogInfo((object)$"Button '{((Object)val9).name}' label '{Label((Component)(object)val9)}' interactable {((Selectable)val9).interactable}");
					}
				}
				break;
			}
			case "click":
				Click((args.Length > 1) ? args[1] : "");
				break;
			case "key":
			{
				string[] array = ((args.Length > 1) ? args[1].Split(' ') : new string[0]);
				Key key = (Key)Enum.Parse(typeof(Key), array[0], ignoreCase: true);
				float seconds = ((array.Length > 1) ? float.Parse(array[1], CultureInfo.InvariantCulture) : 0.15f);
				((MonoBehaviour)Instance).StartCoroutine(HoldKey(key, seconds));
				break;
			}
			case "turn":
				VRRig.Instance?.FaceYaw(float.Parse(args[1], CultureInfo.InvariantCulture));
				break;
			case "cam":
			{
				string[] array13 = args[1].Split(' ');
				Camera vRCamera = VRRig.Instance.VRCamera;
				UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(vRCamera);
				bool flag = array13.Length > 1 && array13[1] != "0";
				if (array13[0] == "renderer")
				{
					universalAdditionalCameraData.SetRenderer(int.Parse(array13[1]));
				}
				if (array13[0] == "pp")
				{
					universalAdditionalCameraData.renderPostProcessing = flag;
				}
				if (array13[0] == "hdr")
				{
					vRCamera.allowHDR = flag;
				}
				if (array13[0] == "msaa")
				{
					vRCamera.allowMSAA = flag;
				}
				if (array13[0] == "aa")
				{
					universalAdditionalCameraData.antialiasing = (AntialiasingMode)(flag ? 1 : 0);
				}
				Plugin.Log.LogInfo((object)$"VR camera: renderer {VRRig.RendererIndexOf(universalAdditionalCameraData)} pp {universalAdditionalCameraData.renderPostProcessing} hdr {vRCamera.allowHDR} msaa {vRCamera.allowMSAA} aa {universalAdditionalCameraData.antialiasing} stack {universalAdditionalCameraData.cameraStack.Count}");
				break;
			}
			case "hands":
			{
				string[] array6 = args[1].Split(' ');
				Vector3 val8 = default(Vector3);
				((Vector3)(ref val8))..ctor(float.Parse(array6[1], CultureInfo.InvariantCulture), float.Parse(array6[2], CultureInfo.InvariantCulture), float.Parse(array6[3], CultureInfo.InvariantCulture));
				if (array6[0] == "rot")
				{
					VRHands.RotationOffset = val8;
				}
				if (array6[0] == "pos")
				{
					VRHands.PositionOffset = val8;
				}
				if (array6[0] == "item")
				{
					VRHands.ItemOffset = val8;
				}
				Plugin.Log.LogInfo((object)$"Hands rot {VRHands.RotationOffset} pos {VRHands.PositionOffset} item {VRHands.ItemOffset}");
				break;
			}
			case "find":
			{
				Transform[] array5 = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Transform val22 in array5)
				{
					if (((Object)val22).name.IndexOf(args[1], StringComparison.OrdinalIgnoreCase) >= 0)
					{
						Plugin.Log.LogInfo((object)string.Format("{0} active {1} layer {2} components [{3}]", PathOf(val22), ((Component)val22).gameObject.activeInHierarchy, ((Component)val22).gameObject.layer, string.Join(", ", from c in ((Component)val22).GetComponents<Component>()
							select ((object)c).GetType().Name)));
					}
				}
				break;
			}
			case "go":
			{
				string[] array14 = args[1].Split(' ');
				int maxDepth = ((array14.Length > 1) ? int.Parse(array14[1]) : 4);
				Transform[] array5 = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Transform val17 in array5)
				{
					if (((Object)val17).name == array14[0])
					{
						LogObject(val17, 0, maxDepth);
					}
				}
				break;
			}
			case "tree":
			{
				Canvas[] array11 = Object.FindObjectsByType<Canvas>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Canvas val15 in array11)
				{
					if (val15.isRootCanvas && ((Object)val15).name == ((args.Length > 1) ? args[1] : ""))
					{
						LogTree(((Component)val15).transform, 0);
					}
				}
				break;
			}
			case "badshaders":
			{
				Renderer[] array3 = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val6 in array3)
				{
					Material[] sharedMaterials = val6.sharedMaterials;
					foreach (Material val7 in sharedMaterials)
					{
						if ((Object)(object)val7 != (Object)null && ((Object)(object)val7.shader == (Object)null || !val7.shader.isSupported || ((Object)val7.shader).name.Contains("InternalError")))
						{
							Plugin.Log.LogInfo((object)string.Format("Bad shader '{0}' on {1} ({2}) pos {3} layer {4} material '{5}'", ((Object)(object)val7.shader != (Object)null) ? ((Object)val7.shader).name : "null", PathOf(((Component)val6).transform), ((object)val6).GetType().Name, ((Component)val6).transform.position, ((Component)val6).gameObject.layer, ((Object)val7).name));
						}
					}
				}
				break;
			}
			case "renderers":
			{
				SortedDictionary<int, int> sortedDictionary = new SortedDictionary<int, int>();
				Renderer[] array3 = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val16 in array3)
				{
					if (val16.enabled)
					{
						sortedDictionary.TryGetValue(((Component)val16).gameObject.layer, out var value);
						sortedDictionary[((Component)val16).gameObject.layer] = value + 1;
						if (args.Length > 1 && ((Component)val16).gameObject.layer == int.Parse(args[1]))
						{
							Plugin.Log.LogInfo((object)string.Format("{0} ({1}) pos {2} material '{3}' shader '{4}'", PathOf(((Component)val16).transform), ((object)val16).GetType().Name, ((Component)val16).transform.position, ((Object)(object)val16.sharedMaterial != (Object)null) ? ((Object)val16.sharedMaterial).name : "", ((Object)(object)val16.sharedMaterial != (Object)null) ? ((Object)val16.sharedMaterial.shader).name : ""));
						}
					}
				}
				foreach (KeyValuePair<int, int> item in sortedDictionary)
				{
					Plugin.Log.LogInfo((object)$"Layer {item.Key} '{LayerMask.LayerToName(item.Key)}': {item.Value} renderers");
				}
				if ((Object)(object)VRRig.Instance?.Source != (Object)null)
				{
					Plugin.Log.LogInfo((object)$"Source mask {VRRig.Instance.Source.cullingMask:X8}, VR mask {VRRig.Instance.VRCamera.cullingMask:X8}");
				}
				break;
			}
			case "inview":
			{
				Transform transform2 = ((Component)VRRig.Instance.VRCamera).transform;
				float num2 = ((args.Length > 1) ? float.Parse(args[1], CultureInfo.InvariantCulture) : 12f);
				List<(float, string)> list2 = new List<(float, string)>();
				Renderer[] array3 = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val18 in array3)
				{
					if (val18.enabled && ((Component)val18).gameObject.activeInHierarchy)
					{
						bounds = val18.bounds;
						Vector3 val19 = ((Bounds)(ref bounds)).center - transform2.position;
						if (!(((Vector3)(ref val19)).magnitude > 15f) && !(Vector3.Angle(transform2.forward, val19) > num2))
						{
							Material sharedMaterial = val18.sharedMaterial;
							float magnitude = ((Vector3)(ref val19)).magnitude;
							object[] obj9 = new object[8]
							{
								((Vector3)(ref val19)).magnitude,
								PathOf(((Component)val18).transform),
								((object)val18).GetType().Name,
								((Component)val18).gameObject.layer,
								null,
								null,
								null,
								null
							};
							bounds = val18.bounds;
							obj9[4] = ((Bounds)(ref bounds)).size;
							obj9[5] = (((Object)(object)sharedMaterial != (Object)null) ? ((Object)sharedMaterial).name : "");
							obj9[6] = (((Object)(object)sharedMaterial != (Object)null) ? ((Object)sharedMaterial.shader).name : "");
							obj9[7] = (((Object)(object)sharedMaterial != (Object)null && (Object)(object)sharedMaterial.mainTexture != (Object)null) ? ((Object)sharedMaterial.mainTexture).name : "");
							list2.Add((magnitude, string.Format("{0:F2}m {1} ({2}) layer {3} size {4} material '{5}' shader '{6}' tex '{7}'", obj9)));
						}
					}
				}
				Graphic[] array9 = Object.FindObjectsByType<Graphic>((FindObjectsSortMode)0);
				foreach (Graphic val20 in array9)
				{
					if (((Behaviour)val20).isActiveAndEnabled && !((Object)(object)val20.canvas == (Object)null) && ((Component)val20).gameObject.layer != WorldSpaceUI.Layer)
					{
						Vector3 val21 = ((Component)val20).transform.position - transform2.position;
						if (!(((Vector3)(ref val21)).magnitude > 15f) && !(Vector3.Angle(transform2.forward, val21) > num2))
						{
							list2.Add((((Vector3)(ref val21)).magnitude, string.Format("{0:F2}m UI {1} ({2}) layer {3} canvas '{4}' material '{5}' shader '{6}' tex '{7}' color {8}", ((Vector3)(ref val21)).magnitude, PathOf(((Component)val20).transform), ((object)val20).GetType().Name, ((Component)val20).gameObject.layer, ((Object)val20.canvas).name, ((Object)val20.material).name, ((Object)val20.material.shader).name, ((Object)(object)val20.mainTexture != (Object)null) ? ((Object)val20.mainTexture).name : "", val20.color)));
						}
					}
				}
				list2.Sort(((float, string) a, (float, string) b) => a.Item1.CompareTo(b.Item1));
				{
					foreach (var item2 in list2)
					{
						Plugin.Log.LogInfo((object)item2.Item2);
					}
					break;
				}
			}
			case "features":
			{
				ScriptableRenderer scriptableRenderer = CameraExtensions.GetUniversalAdditionalCameraData(VRRig.Instance.VRCamera).scriptableRenderer;
				List<ScriptableRendererFeature> list = (List<ScriptableRendererFeature>)typeof(ScriptableRenderer).GetProperty("rendererFeatures", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(scriptableRenderer);
				string[] array12 = ((args.Length > 1) ? args[1].Split(' ') : new string[0]);
				if (array12.Length == 2)
				{
					list[int.Parse(array12[0])].SetActive(array12[1] == "1");
				}
				for (int k = 0; k < list.Count; k++)
				{
					ManualLogSource log4 = Plugin.Log;
					object[] obj6 = new object[4] { k, null, null, null };
					ScriptableRendererFeature obj7 = list[k];
					obj6[1] = ((obj7 != null) ? ((Object)obj7).name : null);
					obj6[2] = ((object)list[k])?.GetType().FullName;
					ScriptableRendererFeature obj8 = list[k];
					obj6[3] = ((obj8 != null) ? new bool?(obj8.isActive) : ((bool?)null));
					log4.LogInfo((object)string.Format("Feature {0}: '{1}' {2} active {3}", obj6));
				}
				break;
			}
			case "near":
			{
				string[] array8 = args[1].Split(' ');
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				Vector3 val10 = default(Vector3);
				((Vector3)(ref val10))..ctor(float.Parse(array8[0], invariantCulture), float.Parse(array8[1], invariantCulture), float.Parse(array8[2], invariantCulture));
				float num = float.Parse(array8[3], invariantCulture);
				Renderer[] array3 = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val11 in array3)
				{
					if (val11.enabled)
					{
						bounds = val11.bounds;
						val2 = ((Bounds)(ref bounds)).center - val10;
						if (((Vector3)(ref val2)).magnitude <= num)
						{
							ManualLogSource log3 = Plugin.Log;
							object[] obj5 = new object[6]
							{
								PathOf(((Component)val11).transform),
								((object)val11).GetType().Name,
								((Component)val11).gameObject.layer,
								null,
								null,
								null
							};
							bounds = val11.bounds;
							obj5[3] = ((Bounds)(ref bounds)).center;
							obj5[4] = (((Object)(object)val11.sharedMaterial != (Object)null) ? ((Object)val11.sharedMaterial).name : "");
							obj5[5] = (((Object)(object)val11.sharedMaterial != (Object)null) ? ((Object)val11.sharedMaterial.shader).name : "");
							log3.LogInfo((object)string.Format("Near: {0} ({1}) layer {2} pos {3} material '{4}' shader '{5}'", obj5));
						}
					}
				}
				Graphic[] array9 = Object.FindObjectsByType<Graphic>((FindObjectsSortMode)0);
				foreach (Graphic val12 in array9)
				{
					if (((Behaviour)val12).isActiveAndEnabled)
					{
						val2 = ((Component)val12).transform.position - val10;
						if (((Vector3)(ref val2)).magnitude <= num)
						{
							Plugin.Log.LogInfo((object)string.Format("Near UI: {0} ({1}) layer {2} alpha {3} color {4} material '{5}' tex '{6}'", PathOf(((Component)val12).transform), ((object)val12).GetType().Name, ((Component)val12).gameObject.layer, val12.canvasRenderer.GetInheritedAlpha(), val12.color, ((Object)val12.material).name, ((Object)(object)val12.mainTexture != (Object)null) ? ((Object)val12.mainTexture).name : ""));
						}
					}
				}
				break;
			}
			case "rt":
			{
				RenderTexture[] array10 = Resources.FindObjectsOfTypeAll<RenderTexture>();
				foreach (RenderTexture val13 in array10)
				{
					if (((Object)val13).name == args[1])
					{
						RenderTexture active = RenderTexture.active;
						RenderTexture.active = val13;
						Texture2D val14 = new Texture2D(((Texture)val13).width, ((Texture)val13).height, (TextureFormat)4, false);
						val14.ReadPixels(new Rect(0f, 0f, (float)((Texture)val13).width, (float)((Texture)val13).height), 0, 0);
						RenderTexture.active = active;
						File.WriteAllBytes(Path.Combine(Paths.BepInExRootPath, "gwyfvr-rt.png"), ImageConversion.EncodeToPNG(val14));
						Object.Destroy((Object)(object)val14);
						Plugin.Log.LogInfo((object)$"Saved render texture '{((Object)val13).name}' {((Texture)val13).width}x{((Texture)val13).height}");
						break;
					}
				}
				break;
			}
			case "active":
			{
				string[] array4 = args[1].Split(' ');
				Transform[] array5 = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Transform val5 in array5)
				{
					if (((Object)val5).name == array4[0])
					{
						((Component)val5).gameObject.SetActive(array4[1] == "1");
						Plugin.Log.LogInfo((object)("Set " + PathOf(val5) + " active " + array4[1]));
					}
				}
				break;
			}
			case "particles":
			{
				ParticleSystem[] array2 = Object.FindObjectsByType<ParticleSystem>((FindObjectsSortMode)0);
				foreach (ParticleSystem val in array2)
				{
					if (val.particleCount > 0)
					{
						ParticleSystemRenderer component = ((Component)val).GetComponent<ParticleSystemRenderer>();
						Transform transform = ((Component)VRRig.Instance.VRCamera).transform;
						ManualLogSource log = Plugin.Log;
						object[] obj = new object[8]
						{
							PathOf(((Component)val).transform),
							val.particleCount,
							null,
							null,
							null,
							null,
							null,
							null
						};
						val2 = ((Component)val).transform.position - transform.position;
						obj[2] = ((Vector3)(ref val2)).magnitude;
						obj[3] = Vector3.Angle(transform.forward, ((Component)val).transform.position - transform.position);
						MainModule main = val.main;
						obj[4] = ((MainModule)(ref main)).simulationSpace;
						obj[5] = ((Component)val).gameObject.layer;
						obj[6] = (((Object)(object)component != (Object)null && (Object)(object)((Renderer)component).sharedMaterial != (Object)null) ? ((Object)((Renderer)component).sharedMaterial).name : "");
						obj[7] = (((Object)(object)component != (Object)null && (Object)(object)((Renderer)component).sharedMaterial != (Object)null) ? ((Object)((Renderer)component).sharedMaterial.shader).name : "");
						log.LogInfo((object)string.Format("Particles {0} count {1} dist {2:F2}m angle {3:F0} space {4} layer {5} material '{6}' shader '{7}'", obj));
					}
				}
				break;
			}
			case "hide":
			{
				Renderer[] array3 = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val3 in array3)
				{
					if (PathOf(((Component)val3).transform).IndexOf(args[1], StringComparison.OrdinalIgnoreCase) >= 0)
					{
						val3.enabled = false;
						Plugin.Log.LogInfo((object)("Hid " + PathOf(((Component)val3).transform)));
					}
				}
				break;
			}
			case "state":
			{
				PlayerController controller = LocalPlayer.Controller;
				PlayerInteract val4 = (((Object)(object)controller != (Object)null) ? ((Component)controller).GetComponent<PlayerInteract>() : null);
				ManualLogSource log2 = Plugin.Log;
				string[] obj2 = new string[7]
				{
					prefix,
					$"Layer {InputEvents.ActiveLayer}, pointing at menu {VRPointer.Instance?.IsPointingAtMenu} ('{WorldSpaceUI.LastHit}'), ",
					null,
					null,
					null,
					null,
					null
				};
				object arg = ((controller != null) ? new bool?(controller.IsLocked) : ((bool?)null));
				object arg2 = ((val4 != null) ? new bool?(((Behaviour)val4).enabled) : ((bool?)null));
				IInteractable obj3 = val4?.TargetInteractable;
				IInteractable obj4 = ((obj3 is Component) ? obj3 : null);
				obj2[2] = $"locked {arg}, interact enabled {arg2}, target '{((obj4 != null) ? ((Object)obj4).name : null)}', ";
				obj2[3] = $"holding {HandRoles.IsHoldingItem}, active hand {HandRoles.ActiveHand}, ";
				obj2[4] = "ray hits '";
				obj2[5] = RayHit();
				obj2[6] = "'";
				log2.LogInfo((object)string.Concat(obj2));
				break;
			}
			case "loading":
			{
				SceneTransitioner instance = MonoSingleton<SceneTransitioner>.Instance;
				if (instance != null)
				{
					instance.ForceSet(args.Length > 1 && args[1] == "1");
				}
				break;
			}
			case "dump":
				VRInput.LogDevices();
				Plugin.Log.LogInfo((object)Dump());
				break;
			default:
				Plugin.Log.LogWarning((object)("Unknown dev command '" + args[0] + "'"));
				break;
			}
		}

		private static IEnumerator HoldKey(Key key, float seconds)
		{
			//IL_0007: 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)
			Keyboard keyboard = Keyboard.current;
			if (keyboard != null)
			{
				Plugin.Log.LogInfo((object)$"Holding {key} for {seconds}s");
				float end = Time.unscaledTime + seconds;
				while (Time.unscaledTime < end)
				{
					InputSystem.QueueStateEvent<KeyboardState>((InputDevice)(object)keyboard, new KeyboardState((Key[])(object)new Key[1] { (Key)(int)key }), -1.0);
					yield return null;
				}
				InputSystem.QueueStateEvent<KeyboardState>((InputDevice)(object)keyboard, default(KeyboardState), -1.0);
			}
		}

		private static IEnumerator CaptureHeadsetAtEndOfFrame()
		{
			yield return (object)new WaitForEndOfFrame();
			List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
			SubsystemManager.GetSubsystems<XRDisplaySubsystem>(list);
			if (list.Count == 0 || list[0].GetRenderPassCount() == 0)
			{
				Plugin.Log.LogWarning((object)"No XR render pass to capture");
				yield break;
			}
			XRRenderPass pass = default(XRRenderPass);
			list[0].GetRenderPass(0, ref pass);
			XRSubmitter.CaptureTarget(pass, 0);
		}

		private static string PathOf(Transform t)
		{
			if (!((Object)(object)t.parent == (Object)null))
			{
				return PathOf(t.parent) + "/" + ((Object)t).name;
			}
			return ((Object)t).name;
		}

		private static void LogObject(Transform t, int depth, int maxDepth)
		{
			//IL_006b: 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)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfo((object)(string.Format("{0}{1}{2} layer {3} ", new string(' ', depth * 2), ((Object)t).name, ((Component)t).gameObject.activeSelf ? "" : " [inactive]", ((Component)t).gameObject.layer) + $"lpos {t.localPosition} lrot {t.localEulerAngles} lscale {t.localScale} " + "[" + string.Join(", ", from c in ((Component)t).GetComponents<Component>()
				select ((object)c).GetType().Name) + "]"));
			if (depth < maxDepth)
			{
				for (int num = 0; num < t.childCount; num++)
				{
					LogObject(t.GetChild(num), depth + 1, maxDepth);
				}
			}
		}

		private static void LogTree(Transform t, int depth)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(new string(' ', depth * 2)).Append(((Object)t).name).Append(((Component)t).gameObject.activeSelf ? "" : " [inactive]")
				.Append($" layer {((Component)t).gameObject.layer} pos {t.localPosition} scale {t.localScale}");
			CanvasGroup component = ((Component)t).GetComponent<CanvasGroup>();
			if ((Object)(object)component != (Object)null)
			{
				stringBuilder.Append($" group alpha {component.alpha}");
			}
			Graphic component2 = ((Component)t).GetComponent<Graphic>();
			if ((Object)(object)component2 != (Object)null)
			{
				object[] obj = new object[4]
				{
					((object)component2).GetType().Name,
					((Behaviour)component2).enabled,
					component2.color,
					null
				};
				Rect rect = component2.rectTransform.rect;
				obj[3] = ((Rect)(ref rect)).size;
				stringBuilder.Append(string.Format(" {0} enabled {1} color {2} size {3}", obj));
				Material material = component2.material;
				if ((Object)(object)material != (Object)null)
				{
					stringBuilder.Append(" material '" + ((Object)material).name + "' shader '" + ((Object)material.shader).name + "'");
				}
				if ((Object)(object)component2.mainTexture != (Object)null)
				{
					stringBuilder.Append($" texture '{((Object)component2.mainTexture).name}' {component2.mainTexture.width}x{component2.mainTexture.height} wrap {component2.mainTexture.wrapMode}");
				}
			}
			Canvas component3 = ((Component)t).GetComponent<Canvas>();
			if ((Object)(object)component3 != (Object)null)
			{
				stringBuilder.Append($" canvas mode {component3.renderMode} order {component3.sortingOrder} override {component3.overrideSorting}");
			}
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
			if (depth < 6)
			{
				for (int i = 0; i < t.childCount; i++)
				{
					LogTree(t.GetChild(i), depth + 1);
				}
			}
		}

		private static string Label(Component button)
		{
			TMP_Text componentInChildren = button.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren.text;
			}
			Text componentInChildren2 = button.GetComponentInChildren<Text>();
			if (!((Object)(object)componentInChildren2 != (Object)null))
			{
				return "";
			}
			return componentInChildren2.text;
		}

		private static void Click(string query)
		{
			//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_00a2: Expected O, but got Unknown
			Button[] array = Object.FindObjectsByType<Button>((FindObjectsSortMode)0);
			foreach (Button val in array)
			{
				if (!((Behaviour)val).isActiveAndEnabled || !((Selectable)val).interactable)
				{
					continue;
				}
				bool num;
				if (!query.StartsWith("="))
				{
					if (((Object)val).name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						goto IL_0071;
					}
					num = Label((Component)(object)val).IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
				}
				else
				{
					num = ((Object)val).name == query.Substring(1);
				}
				if (!num)
				{
					continue;
				}
				goto IL_0071;
				IL_0071:
				Plugin.Log.LogInfo((object)("Clicking '" + ((Object)val).name + "'"));
				PointerEventData val2 = new PointerEventData(EventSystem.current)
				{
					button = (InputButton)0
				};
				ExecuteEvents.Execute<IPointerEnterHandler>(((Component)val).gameObject, (BaseEventData)(object)val2, ExecuteEvents.pointerEnterHandler);
				ExecuteEvents.Execute<IPointerDownHandler>(((Component)val).gameObject, (BaseEventData)(object)val2, ExecuteEvents.pointerDownHandler);
				ExecuteEvents.Execute<IPointerUpHandler>(((Component)val).gameObject, (BaseEventData)(object)val2, ExecuteEvents.pointerUpHandler);
				ExecuteEvents.Execute<IPointerClickHandler>(((Component)val).gameObject, (BaseEventData)(object)val2, ExecuteEvents.pointerClickHandler);
				return;
			}
			Plugin.Log.LogWarning((object)("No button matching '" + query + "'"));
		}

		private static void Capture(string file)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			RenderTexture temporary = RenderTexture.GetTemporary(1280, 720, 24);
			GameObject val = new GameObject("GWYFVR Capture");
			try
			{
				Camera obj = val.AddComponent<Camera>();
				obj.CopyFrom(instance.VRCamera);
				obj.stereoTargetEye = (StereoTargetEyeMask)0;
				obj.fieldOfView = 90f;
				obj.cullingMask |= 1 << WorldSpaceUI.Layer;
				obj.targetTexture = temporary;
				((Component)obj).transform.SetPositionAndRotation(((Component)instance.VRCamera).transform.position, ((Component)instance.VRCamera).transform.rotation);
				obj.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = temporary;
				Texture2D val2 = new Texture2D(((Texture)temporary).width, ((Texture)temporary).height, (TextureFormat)3, false);
				val2.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
				val2.Apply();
				RenderTexture.active = active;
				File.WriteAllBytes(file, ImageConversion.EncodeToPNG(val2));
				Object.Destroy((Object)(object)val2);
				Plugin.Log.LogInfo((object)("Capture saved to " + file));
			}
			finally
			{
				Object.Destroy((Object)(object)val);
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private static string Dump()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder("State dump\n");
			Scene activeScene = SceneManager.GetActiveScene();
			stringBuilder.AppendLine("Scene: " + ((Scene)(ref activeScene)).name);
			stringBuilder.AppendLine($"XR device active {XRSettings.isDeviceActive} eye {XRSettings.eyeTextureWidth}x{XRSettings.eyeTextureHeight} mode {XRSettings.stereoRenderingMode}");
			List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
			SubsystemManager.GetSubsystems<XRDisplaySubsystem>(list);
			int num = default(int);
			int num2 = default(int);
			foreach (XRDisplaySubsystem item in list)
			{
				item.TryGetDroppedFrameCount(ref num);
				item.TryGetFramePresentCount(ref num2);
				stringBuilder.AppendLine($"XR display running {((IntegratedSubsystem)item).running} passes {item.GetRenderPassCount()} presented {num2} dropped {num}");
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				stringBuilder.AppendLine($"Frames submitted {((Component)instance).GetComponent<XRSubmitter>()?.FramesSubmitted}");
				stringBuilder.AppendLine($"VR camera stereo {instance.VRCamera.stereoEnabled} active {((Behaviour)instance.VRCamera).isActiveAndEnabled}");
				if ((Object)(object)LocalPlayer.Head != (Object)null)
				{
					stringBuilder.AppendLine($"Local head rot {((Component)LocalPlayer.Head).transform.eulerAngles} state {LocalPlayer.Controller.State} locked {LocalPlayer.Controller.IsLocked} body pos {((Component)LocalPlayer.Controller).transform.position}");
				}
				stringBuilder.AppendLine($"Rig pos {((Component)instance).transform.position} rot {((Component)instance).transform.eulerAngles}, player mode {instance.PlayerMode}");
				stringBuilder.AppendLine($"VR camera pos {((Component)instance.VRCamera).transform.position} rot {((Component)instance.VRCamera).transform.eulerAngles} mask {instance.VRCamera.cullingMask:X}");
				if ((Object)(object)instance.Source != (Object)null)
				{
					stringBuilder.AppendLine($"Source '{((Object)instance.Source).name}' pos {((Component)instance.Source).transform.position} rot {((Component)instance.Source).transform.eulerAngles} rt {instance.Source.targetTexture}");
				}
			}
			Camera[] array = Object.FindObjectsByType<Camera>((FindObjectsSortMode)0);
			foreach (Camera val in array)
			{
				stringBuilder.AppendLine($"Camera '{((Object)val).name}' enabled {((Behaviour)val).enabled} depth {val.depth} target {val.targetTexture} eye {val.stereoTargetEye}");
			}
			if ((Object)(object)WorldSpaceUI.Instance != (Object)null)
			{
				foreach (Canvas canvase in WorldSpaceUI.Instance.Canvases)
				{
					if ((Object)(object)canvase != (Object)null)
					{
						object[] obj = new object[7]
						{
							((Object)canvase).name,
							((Behaviour)canvase).isActiveAndEnabled,
							canvase.sortingOrder,
							((Component)canvase).transform.position,
							null,
							null,
							null
						};
						Rect rect = ((RectTransform)((Component)canvase).transform).rect;
						obj[4] = ((Rect)(ref rect)).size;
						obj[5] = ((Component)canvase).transform.lossyScale;
						obj[6] = canvase.renderMode;
						stringBuilder.AppendLine(string.Format("Canvas '{0}' active {1} order {2} pos {3} size {4} scale {5} mode {6}", obj));
					}
				}
			}
			return stringBuilder.ToString();
		}
	}
	[BepInPlugin("io.github.drdraxi.gwyfvr", "GWYFVR", "0.3.3")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "io.github.drdraxi.gwyfvr";

		public const string Name = "GWYFVR";

		public const string Version = "0.3.3";

		internal static ManualLogSource Log { get; private set; }

		internal static VRConfig Settings { get; private set; }

		public static bool VREnabled { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = new VRConfig(((BaseUnityPlugin)this).Config);
			Log.LogInfo((object)"GWYFVR 0.3.3 starting");
			if (!Settings.EnableVR.Value || Environment.GetCommandLineArgs().Contains<string>("--disable-vr", StringComparer.OrdinalIgnoreCase))
			{
				Log.LogWarning((object)"VR is disabled by config or the --disable-vr launch option");
			}
			else if (PreloadRuntimeDependencies())
			{
				StartVR();
			}
		}

		private bool PreloadRuntimeDependencies()
		{
			string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "RuntimeDeps");
			if (!Directory.Exists(text))
			{
				Log.LogError((object)("RuntimeDeps folder is missing (" + text + "), the mod is not installed correctly"));
				return false;
			}
			string[] files = Directory.GetFiles(text, "Unity.*.dll");
			foreach (string path in files)
			{
				try
				{
					Assembly.LoadFile(path);
				}
				catch (Exception ex)
				{
					Log.LogError((object)("Failed to load " + Path.GetFileName(path) + ": " + ex.Message));
					return false;
				}
			}
			return true;
		}

		private void StartVR()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (!OpenXRBootstrap.Start())
			{
				Log.LogError((object)"Could not start VR. Is the headset connected and your OpenXR runtime (SteamVR, Oculus, Virtual Desktop) running?");
				return;
			}
			VREnabled = true;
			VRPrompts.Init(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
			if (!URPXRSetup.TryInitialize(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "RuntimeDeps")))
			{
				Log.LogWarning((object)"Falling back to rendering the eyes manually (experimental)");
			}
			new Harmony("io.github.drdraxi.gwyfvr").PatchAll(typeof(Plugin).Assembly);
			GameObject val = new GameObject("GWYFVR");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<VRManager>();
			Log.LogInfo((object)"VR started");
		}
	}
	internal enum TurnMode
	{
		Snap,
		Smooth
	}
	internal enum StereoMode
	{
		MultiPass,
		SinglePassInstanced
	}
	internal class VRConfig
	{
		public readonly ConfigEntry<bool> EnableVR;

		public readonly ConfigEntry<string> OpenXRRuntimeFile;

		public readonly ConfigEntry<bool> SkipSplash;

		public readonly ConfigEntry<string> MenuBackdropScene;

		public readonly ConfigEntry<Vector3> MenuBackdropPosition;

		public readonly ConfigEntry<float> MenuBackdropYaw;

		public readonly ConfigEntry<StereoMode> RenderMode;

		public readonly ConfigEntry<float> RenderScale;

		public readonly ConfigEntry<bool> PostProcessing;

		public readonly ConfigEntry<bool> DesktopMirror;

		public readonly ConfigEntry<TurnMode> Turning;

		public readonly ConfigEntry<float> SnapTurnAngle;

		public readonly ConfigEntry<float> SmoothTurnSpeed;

		public readonly ConfigEntry<bool> LeftHandedPointer;

		public readonly ConfigEntry<Vector3> LaserRotation;

		public readonly ConfigEntry<bool> HandInteraction;

		public readonly ConfigEntry<bool> RoomScale;

		public readonly ConfigEntry<bool> PhysicalThrowing;

		public readonly ConfigEntry<float> ThrowStrength;

		public readonly ConfigEntry<bool> ProximityGrab;

		public readonly ConfigEntry<bool> DrunkEffect;

		public readonly ConfigEntry<Vector3> HandRotation;

		public readonly ConfigEntry<Vector3> HandPosition;

		public readonly ConfigEntry<Vector3> ItemOffset;

		public readonly ConfigEntry<float> HandScale;

		public readonly ConfigEntry<float> HeldItemScale;

		public readonly ConfigEntry<float> UIDistance;

		public readonly ConfigEntry<float> UIWidth;

		public readonly ConfigEntry<float> HudDistance;

		public readonly ConfigEntry<float> HudWidth;

		public readonly ConfigEntry<float> HudTilt;

		public readonly ConfigEntry<bool> DevCommands;

		public VRConfig(ConfigFile config)
		{
			//IL_0099: 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_011d: Expected O, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Expected O, but got Unknown
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Expected O, but got Unknown
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Expected O, but got Unknown
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Expected O, but got Unknown
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Expected O, but got Unknown
			EnableVR = config.Bind<bool>("General", "EnableVR", true, "Start the game in VR. You can also launch with --disable-vr to play flat once.");
			OpenXRRuntimeFile = config.Bind<string>("General", "OpenXRRuntimeFile", "", "Optional path to an OpenXR runtime json to use instead of the system default (for example SteamVR's steamxr_win64.json).");
			SkipSplash = config.Bind<bool>("General", "SkipSplash", true, "Skip the coin flip question at start-up and go straight to the main menu.");
			MenuBackdropScene = config.Bind<string>("General", "MenuBackdropScene", "HomeScene", "Game scene shown (as static scenery) behind the main menu in VR. Empty to disable.");
			MenuBackdropPosition = config.Bind<Vector3>("General", "MenuViewpoint", new Vector3(7.4f, 6.97f, -14.7f), "Where you stand in the menu backdrop scene (eye position).");
			MenuBackdropYaw = config.Bind<float>("General", "MenuViewpointYaw", 0f, "Which way you face in the menu backdrop scene, in degrees.");
			RenderMode = config.Bind<StereoMode>("Rendering", "StereoMode", StereoMode.MultiPass, "MultiPass is the most compatible. SinglePassInstanced is faster but some game shaders may render in one eye only.");
			RenderScale = config.Bind<float>("Rendering", "RenderScale", 1f, new ConfigDescription("Headset render resolution multiplier.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			PostProcessing = config.Bind<bool>("Rendering", "PostProcessingInVR", true, "Use the game's post-processing effects (colour grading, bloom, the drunk wobble) in VR.");
			PostProcessing.SettingChanged += delegate
			{
				VRRig.Instance?.RefreshCamera();
			};
			DesktopMirror = config.Bind<bool>("Rendering", "DesktopMirror", true, "Show the left eye in the game window.");
			Turning = config.Bind<TurnMode>("Controls", "TurnMode", TurnMode.Snap, "How the right thumbstick turns you.");
			SnapTurnAngle = config.Bind<float>("Controls", "SnapTurnAngle", 45f, new ConfigDescription("Degrees per snap turn.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 90f), Array.Empty<object>()));
			SmoothTurnSpeed = config.Bind<float>("Controls", "SmoothTurnSpeed", 120f, new ConfigDescription("Degrees per second for smooth turning.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 360f), Array.Empty<object>()));
			LaserRotation = config.Bind<Vector3>("Controls", "LaserRotation", Vector3.zero, "Extra rotation of the laser / aiming direction relative to the controller's pointing direction, in degrees (mirrored for the left hand). Tune in game with F8.");
			HandInteraction = config.Bind<bool>("Controls", "HandInteraction", true, "Aim interaction (picking up, pressing buttons) with the right controller instead of your head.");
			RoomScale = config.Bind<bool>("Controls", "RoomScale", true, "Walking and leaning in your room moves your character.");
			PhysicalThrowing = config.Bind<bool>("Controls", "PhysicalThrowing", true, "Hold the right grip to keep holding an item; swing and let go to throw it.");
			ThrowStrength = config.Bind<float>("Controls", "ThrowStrength", 1.5f, new ConfigDescription("Multiplier from your hand speed to the item's throw speed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			LeftHandedPointer = config.Bind<bool>("Controls", "LeftHandedPointer", false, "Use the left controller as the menu pointer.");
			ProximityGrab = config.Bind<bool>("Controls", "ProximityGrab", true, "Grab items your hand is touching with the grip; the laser picks things out of reach.");
			DrunkEffect = config.Bind<bool>("Rendering", "DrunkEffect", true, "Keep the game's wobbling drunk screen effect (Tipsy Fortune) in VR. Turn off if it makes you queasy. Needs PostProcessing.");
			HandRotation = config.Bind<Vector3>("Hands", "Rotation", new Vector3(10f, 95f, 138f), "Rotation from the right controller to the right hand, in degrees (mirrored for the left hand). Tune in game with F8.");
			HandPosition = config.Bind<Vector3>("Hands", "Position", new Vector3(0.035f, 0.05f, 0.02f), "Offset from the right controller to the right hand, in meters (mirrored for the left hand).");
			ItemOffset = config.Bind<Vector3>("Hands", "ItemOffset", new Vector3(0.01f, 0f, 0.12f), "Offset from the right controller to held items, in meters.");
			HandScale = config.Bind<float>("Hands", "Scale", 0.5f, new ConfigDescription("Size of the hands compared to the flat game.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1.5f), Array.Empty<object>()));
			HeldItemScale = config.Bind<float>("Hands", "HeldItemScale", 0.5f, new ConfigDescription("Size of held items compared to the flat game (only while held).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1.5f), Array.Empty<object>()));
			UIDistance = config.Bind<float>("UI", "Distance", 1.6f, new ConfigDescription("How far in front of you menus and the HUD float, in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			UIWidth = config.Bind<float>("UI", "Width", 2.4f, new ConfigDescription("Width of menus and the HUD, in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			HudDistance = config.Bind<float>("UI", "HudDistance", 1.2f, new ConfigDescription("How far in front of you the in-game HUD floats, in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 5f), Array.Empty<object>()));
			HudWidth = config.Bind<float>("UI", "HudWidth", 1.3f, new ConfigDescription("Width of the in-game HUD, in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 5f), Array.Empty<object>()));
			HudTilt = config.Bind<float>("UI", "HudTilt", 8f, new ConfigDescription("Degrees the HUD sits below the centre of your view.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-30f, 45f), Array.Empty<object>()));
			DevCommands = config.Bind<bool>("Debug", "DevCommands", false, "For mod development: run commands written to BepInEx/gwyfvr-command.txt (screenshot, dump).");
		}
	}
	internal class VRManager : MonoBehaviour
	{
		private void Awake()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			VRInput.Create();
			((MonoBehaviour)this).Invoke("LogDevices", 5f);
			InputSystem.settings.backgroundBehavior = (BackgroundBehavior)2;
			Application.runInBackground = true;
			GameObject val = new GameObject("VRRig");
			val.transform.SetParent(((Component)this).transform, false);
			((Component)this).gameObject.AddComponent<WorldSpaceUI>();
			val.AddComponent<VRRig>();
			if (!URPXRSetup.Active)
			{
				val.AddComponent<XRSubmitter>();
			}
			((Component)this).gameObject.AddComponent<VRPointer>();
			val.AddComponent<VRHands>();
			val.AddComponent<VRThrowing>();
			val.AddComponent<RoomScale>();
			val.AddComponent<VREyePatches>();
			if (URPXRSetup.Active)
			{
				val.AddComponent<DesktopMirror>();
			}
			((Component)this).gameObject.AddComponent<HandCalibration>();
			((Component)this).gameObject.AddComponent<MenuBackdrop>();
			VRSettingsMenu.Install();
			((Component)this).gameObject.AddComponent<VirtualGamepad>();
			((Component)this).gameObject.AddComponent<GazeDot>();
			((Component)this).gameObject.AddComponent<EmoteWheelMount>();
			((Component)this).gameObject.AddComponent<VRLogo>();
			((Component)this).gameObject.AddComponent<ImmersiveScreens>();
			((Component)this).gameObject.AddComponent<SkipPrompts>();
			((Component)this).gameObject.AddComponent<SettingsTabLabel>();
			if (Plugin.Settings.DevCommands.Value)
			{
				((Component)this).gameObject.AddComponent<DevCommands>();
			}
		}

		private void LogDevices()
		{
			VRInput.LogDevices();
		}
	}
}
namespace GWYFVR.XR
{
	internal static class OpenXRBootstrap
	{
		private static XRGeneralSettings generalSettings;

		private static XRManagerSettings managerSettings;

		private static OpenXRLoader loader;

		public static bool Start()
		{
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			List<ISubsystemDescriptor> list = new List<ISubsystemDescriptor>();
			SubsystemManager.GetAllSubsystemDescriptors(list);
			if (!list.Any((ISubsystemDescriptor d) => d.id == "OpenXR Display") || !list.Any((ISubsystemDescriptor d) => d.id == "OpenXR Input"))
			{
				Plugin.Log.LogError((object)"The OpenXR subsystem is not registered. If this is the first launch after installing, restart the game once; otherwise check that GWYFVR.Preload is in BepInEx/patchers.");
				return false;
			}
			string value = Plugin.Settings.OpenXRRuntimeFile.Value;
			if (!string.IsNullOrWhiteSpace(value))
			{
				Plugin.Log.LogInfo((object)("Using OpenXR runtime override " + value));
				Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", value);
			}
			generalSettings = Keep<XRGeneralSettings>(ScriptableObject.CreateInstance<XRGeneralSettings>());
			managerSettings = Keep<XRManagerSettings>(ScriptableObject.CreateInstance<XRManagerSettings>());
			loader = Keep<OpenXRLoader>(ScriptableObject.CreateInstance<OpenXRLoader>());
			generalSettings.Manager = managerSettings;
			managerSettings.automaticLoading = false;
			managerSettings.automaticRunning = false;
			((List<XRLoader>)managerSettings.activeLoaders).Add((XRLoader)(object)loader);
			OpenXRSettings instance = OpenXRSettings.Instance;
			Keep<OpenXRSettings>(instance);
			instance.renderMode = (RenderMode)(Plugin.Settings.RenderMode.Value == StereoMode.SinglePassInstanced);
			instance.depthSubmissionMode = (DepthSubmissionMode)0;
			SetFeatures(instance, CreateInteractionProfiles());
			Plugin.Log.LogInfo((object)$"Initializing OpenXR ({SystemInfo.graphicsDeviceType})");
			managerSettings.InitializeLoaderSync();
			if ((Object)(object)managerSettings.activeLoader == (Object)null)
			{
				Plugin.Log.LogError((object)"OpenXR loader failed to initialize");
				LogDiagnosticReport();
				return false;
			}
			managerSettings.StartSubsystems();
			List<XRDisplaySubsystem> list2 = new List<XRDisplaySubsystem>();
			SubsystemManager.GetSubsystems<XRDisplaySubsystem>(list2);
			if (list2.Count == 0)
			{
				Plugin.Log.LogError((object)"OpenXR started but no headset display was created");
				managerSettings.DeinitializeLoader();
				return false;
			}
			XRSettings.eyeTextureResolutionScale = Plugin.Settings.RenderScale.Value;
			Plugin.Log.LogInfo((object)("OpenXR running on " + OpenXRRuntime.name + " " + OpenXRRuntime.version));
			return true;
		}

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

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

		private static void LogDiagnosticReport()
		{
			try
			{
				IntPtr intPtr = GenerateReport();
				if (!(intPtr == IntPtr.Zero))
				{
					Plugin.Log.LogWarning((object)("OpenXR diagnostic report:\n" + Marshal.PtrToStringAnsi(intPtr)));
					ReleaseReport(intPtr);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not read the OpenXR diagnostic report: " + ex.Message));
			}
		}

		private static T Keep<T>(T obj) where T : Object
		{
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static OpenXRFeature[] CreateInteractionProfiles()
		{
			return (OpenXRFeature[])(object)new OpenXRFeature[8]
			{
				Profile<OculusTouchControllerProfile>("com.unity.openxr.feature.input.oculustouch", "Oculus Touch Controller Profile", ""),
				Profile<MetaQuestTouchPlusControllerProfile>("com.unity.openxr.feature.input.metaquestplus", "Meta Quest Touch Plus Controller Profile", "XR_META_touch_controller_plus"),
				Profile<MetaQuestTouchProControllerProfile>("com.unity.openxr.feature.input.metaquestpro", "Meta Quest Touch Pro Controller Profile", "XR_FB_touch_controller_pro"),
				Profile<ValveIndexControllerProfile>("com.unity.openxr.feature.input.valveindex", "Valve Index Controller Profile", ""),
				Profile<HTCViveControllerProfile>("com.unity.openxr.feature.input.htcvive", "HTC Vive Controller Profile", ""),
				Profile<MicrosoftMotionControllerProfile>("com.unity.openxr.feature.input.microsoftmotioncontroller", "Microsoft Motion Controller Profile", ""),
				Profile<HPReverbG2ControllerProfile>("com.unity.openxr.feature.input.hpreverb", "HP Reverb G2 Controller Profile", "XR_EXT_hp_mixed_reality_controller"),
				Profile<KHRSimpleControllerProfile>("com.unity.openxr.feature.input.khrsimpleprofile", "Khronos Simple Controller Profile", "")
			};
		}

		private static OpenXRFeature Profile<T>(string id, string name, string extensions = "") where T : OpenXRFeature
		{
			T val = Keep<T>(ScriptableObject.CreateInstance<T>());
			SetField(val, "nameUi", name);
			SetField(val, "version", "0.0.1");
			SetField(val, "featureIdInternal", id);
			SetField(val, "openxrExtensionStrings", extensions);
			SetField(val, "company", "Unity");
			SetField(val, "priority", 0);
			SetField(val, "required", false);
			((OpenXRFeature)val).enabled = true;
			return (OpenXRFeature)(object)val;
		}

		private static void SetFeatures(OpenXRSettings settings, OpenXRFeature[] features)
		{
			FieldInfo? field = typeof(OpenXRSettings).GetField("features", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new MissingFieldException("OpenXRSettings", "features");
			}
			field.SetValue(settings, features);
		}

		private static void SetField(object target, string name, object value)
		{
			FieldInfo? field = typeof(OpenXRFeature).GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new MissingFieldException("OpenXRFeature", name);
			}
			field.SetValue(target, value);
		}
	}
	internal static class URPXRSetup
	{
		private const string ShaderBundle = "gwyfvr_xrshaders";

		private static readonly FieldInfo OcclusionMaterialField = typeof(XRSystem).GetField("s_OcclusionMeshMaterial", BindingFlags.Static | BindingFlags.NonPublic);

		public static bool Active { get; private set; }

		public static void DisableOcclusionMesh()
		{
			if (Active && OcclusionMaterialField != null && OcclusionMaterialField.GetValue(null) != null)
			{
				OcclusionMaterialField.SetValue(null, null);
				Plugin.Log.LogInfo((object)"Turned off the XR occlusion mesh");
			}
		}

		public static bool TryInitialize(string runtimeDeps)
		{
			if (typeof(XRSystem).GetField("s_Display", BindingFlags.Static | BindingFlags.NonPublic) == null)
			{
				Plugin.Log.LogError((object)"The game's render pipeline has no XR support and the XR-enabled one was not loaded. If this is the first launch after installing, restart the game once.");
				return false;
			}
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(runtimeDeps, "gwyfvr_xrshaders"));
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogError((object)"Could not load gwyfvr_xrshaders");
				return false;
			}
			Shader[] source = val.LoadAllAssets<Shader>();
			Shader? obj = ((IEnumerable<Shader>)source).FirstOrDefault((Func<Shader, bool>)((Shader s) => ((Object)s).name.EndsWith("XROcclusionMesh")));
			Shader val2 = ((IEnumerable<Shader>)source).FirstOrDefault((Func<Shader, bool>)((Shader s) => ((Object)s).name.EndsWith("XRMirrorView")));
			Shader val3 = ((IEnumerable<Shader>)source).FirstOrDefault((Func<Shader, bool>)((Shader s) => ((Object)s).name.EndsWith("XRMotionVector")));
			if ((Object)(object)obj == (Object)null || (Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogError((object)("XR shaders missing from gwyfvr_xrshaders (" + string.Join(", ", source.Select((Shader s) => ((Object)s).name)) + ")"));
				return false;
			}
			Assembly assembly = typeof(UniversalRenderPipeline).Assembly;
			MethodInfo methodInfo = assembly.GetType("UnityEngine.Rendering.Universal.XRPassUniversal")?.GetMethod("Create", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				Plugin.Log.LogError((object)"XRPassUniversal.Create not found");
				return false;
			}
			XRSystem.Initialize((Func<XRPassCreateInfo, XRPass>)Delegate.CreateDelegate(typeof(Func<XRPassCreateInfo, XRPass>), methodInfo), (Shader)null, val2);
			typeof(XRSystem).GetMethod("SetUseVisibilityMesh", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, new object[1] { false });
			MethodInfo methodInfo2 = assembly.GetType("UnityEngine.Rendering.Universal.XRSystemUniversal")?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Initialize" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Shader));
			if (methodInfo2 != null && (Object)(object)val3 != (Object)null)
			{
				methodInfo2.Invoke(null, new object[1] { val3 });
			}
			Active = true;
			Plugin.Log.LogInfo((object)"URP XR rendering initialized");
			return true;
		}
	}
}
namespace GWYFVR.UI
{
	public class EmoteWheelMount : MonoBehaviour
	{
		private const float Diameter = 1.28f;

		private static readonly Vector3 Offset = new Vector3(0f, 0.07f, 0.02f);

		private static readonly Vector2 VirtualScreen = new Vector2(1920f, 1080f);

		private EmoteWheelController wheel;

		private Canvas canvas;

		private float nextSearch;

		private void LateUpdate()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)wheel == (Object)null)
			{
				if (Time.unscaledTime < nextSearch)
				{
					return;
				}
				nextSearch = Time.unscaledTime + 1f;
				wheel = Object.FindAnyObjectByType<EmoteWheelController>();
				if ((Object)(object)wheel == (Object)null || (Object)(object)wheel.radialMenu == (Object)null)
				{
					wheel = null;
					return;
				}
				Mount();
			}
			if (!wheel.IsEmoteWheelActive || (Object)(object)canvas == (Object)null)
			{
				return;
			}
			VRRig instance = VRRig.Instance;
			if (!((Object)(object)instance == (Object)null) && XRControllers.TryGetAimPose((XRNode)4, out var position, out var rotation))
			{
				Quaternion val = ((Component)instance).transform.rotation * rotation;
				Vector3 val2 = ((Component)instance).transform.TransformPoint(position) + val * Offset;
				Transform transform = ((Component)canvas).transform;
				transform.rotation = val * Quaternion.LookRotation(Vector3.down, Vector3.forward);
				RectTransform val3 = (RectTransform)(((Object)(object)wheel.radialMenu.rt != (Object)null) ? ((object)wheel.radialMenu.rt) : ((object)(RectTransform)((Component)wheel.radialMenu).transform));
				Rect rect = val3.rect;
				float num = ((Rect)(ref rect)).width * ((Transform)val3).lossyScale.x;
				if (num > 0.0001f)
				{
					transform.localScale *= 1.28f / num;
				}
				Vector3 position2 = transform.position;
				rect = val3.rect;
				transform.position = position2 + (val2 - ((Transform)val3).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center)));
				WorldSpaceUI.SetLayer(transform);
			}
		}

		private void Mount()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Canvas component = ((Component)wheel).GetComponent<Canvas>();
			if ((Object)(object)component != (Object)null && component.isRootCanvas)
			{
				canvas = component;
				WorldSpaceUI.Instance?.Release(component);
				canvas.renderMode = (RenderMode)2;
				((RectTransform)((Component)canvas).transform).sizeDelta = VirtualScreen;
			}
			else
			{
				GameObject val = new GameObject("VREmoteWheelCanvas", new Type[1] { typeof(RectTransform) });
				SceneManager.MoveGameObjectToScene(val, ((Component)wheel).gameObject.scene);
				canvas = val.AddComponent<Canvas>();
				canvas.renderMode = (RenderMode)2;
				canvas.sortingOrder = 30000;
				((RectTransform)val.transform).sizeDelta = VirtualScreen;
				val.transform.localScale = Vector3.one * 0.0021333334f;
				((Component)wheel).transform.SetParent(val.transform, false);
			}
			canvas.worldCamera = (((Object)(object)VRPointer.Instance != (Object)null) ? VRPointer.Instance.PointerCamera : null);
			HideBackdrop();
			WorldSpaceUI.SetLayer(((Component)canvas).transform);
			Plugin.Log.LogInfo((object)("Mounted the emote wheel '" + ((Object)wheel).name + "' on the left hand"));
		}

		private void HideBackdrop()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0073: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Canvas.ForceUpdateCanvases();
			RectTransform val = (RectTransform)((Component)canvas).transform;
			Rect rect = val.rect;
			Vector2 val2 = Vector2.Scale(((Rect)(ref rect)).size, Vector2.op_Implicit(((Transform)val).lossyScale));
			Graphic[] componentsInChildren = ((Component)wheel).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val3 in componentsInChildren)
			{
				if (!((Object)(object)((Component)val3).GetComponentInParent<RMF_RadialMenuElement>(true) != (Object)null))
				{
					RectTransform rectTransform = val3.rectTransform;
					rect = rectTransform.rect;
					Vector2 val4 = Vector2.Scale(((Rect)(ref rect)).size, Vector2.op_Implicit(((Transform)rectTransform).lossyScale));
					if (val4.x >= val2.x * 0.9f && val4.y >= val2.y * 0.9f)
					{
						((Behaviour)val3).enabled = false;
						Plugin.Log.LogInfo((object)("Hid emote wheel backdrop '" + ((Object)val3).name + "'"));
					}
				}
			}
			LineRenderer[] componentsInChildren2 = ((Component)wheel).GetComponentsInChildren<LineRenderer>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Renderer)componentsInChildren2[i]).enabled = false;
			}
		}
	}
	public class GazeDot : MonoBehaviour
	{
		private const float Distance = 2f;

		private Transform dot;

		private BaseCursor[] cursors = (BaseCursor[])(object)new BaseCursor[0];

		private float nextCursorScan;

		private void Awake()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			dot = GameObject.CreatePrimitive((PrimitiveType)0).transform;
			((Object)dot).name = "VRGazeDot";
			Object.Destroy((Object)(object)((Component)dot).GetComponent<Collider>());
			dot.localScale = Vector3.one * 0.008f;
			Renderer component = ((Component)dot).GetComponent<Renderer>();
			component.sharedMaterial = VRMaterials.Unlit(Color.white);
			component.shadowCastingMode = (ShadowCastingMode)0;
			((Component)dot).gameObject.layer = WorldSpaceUI.Layer;
			dot.SetParent(((Component)this).transform, false);
		}

		private void LateUpdate()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			HideGameCursors();
			VRRig instance = VRRig.Instance;
			bool flag = (Object)(object)instance != (Object)null && instance.PlayerMode && GameCrosshairVisible();
			((Component)dot).gameObject.SetActive(flag);
			if (flag)
			{
				Transform transform = ((Component)instance.VRCamera).transform;
				dot.position = transform.position + transform.forward * 2f;
			}
		}

		private void HideGameCursors()
		{
			if (Time.unscaledTime >= nextCursorScan)
			{
				nextCursorScan = Time.unscaledTime + 1f;
				cursors = Object.FindObjectsByType<BaseCursor>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			}
			BaseCursor[] array = cursors;
			foreach (BaseCursor val in array)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.uiCursorImage != (Object)null && ((Behaviour)val.uiCursorImage).enabled)
				{
					((Behaviour)val.uiCursorImage).enabled = false;
				}
			}
		}

		private static bool GameCrosshairVisible()
		{
			LocalManager instance = MonoSingleton<LocalManager>.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.crosshair == (Object)null)
			{
				return false;
			}
			Graphic[] componentsInChildren = instance.crosshair.GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
			return instance.crosshair.activeInHierarchy;
		}
	}
	public class HandCalibration : MonoBehaviour
	{
		private static HandCalibration instance;

		private bool visible;

		private Rect window = new Rect(20f, 20f, 420f, 580f);

		public static bool Visible
		{
			get
			{
				if ((Object)(object)instance != (Object)null)
				{
					return instance.visible;
				}
				return false;
			}
		}

		private void Awake()
		{
			instance = this;
		}

		private void Update()
		{
			Keyboard current = Keyboard.current;
			if (current != null && ((ButtonControl)current.f8Key).wasPressedThisFrame)
			{
				visible = !visible;
			}
		}

		private void LateUpdate()
		{
			if (visible)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}

		private void OnGUI()
		{
			//IL_0010: 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_0030: Expected O, but got Unknown
			//IL_002b: 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)
			if (visible)
			{
				window = GUILayout.Window(28287, window, new WindowFunction(Draw), "GWYFVR hand calibration (F8)", Array.Empty<GUILayoutOption>());
			}
		}

		private void Draw(int id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			VRHands.RotationOffset = Vector3Sliders("Hand rotation", VRHands.RotationOffset, -180f, 180f, 1f);
			VRHands.PositionOffset = Vector3Sliders("Hand position (m)", VRHands.PositionOffset, -0.3f, 0.3f, 0.005f);
			VRHands.ItemOffset = Vector3Sliders("Item offset (m)", VRHands.ItemOffset, -0.3f, 0.3f, 0.005f);
			Plugin.Settings.LaserRotation.Value = Vector3Sliders("Laser rotation (pitch, yaw, roll)", Plugin.Settings.LaserRotation.Value, -90f, 90f, 1f);
			GUILayout.Label($"Hand scale: {Plugin.Settings.HandScale.Value:0.00}   Held item scale: {Plugin.Settings.HeldItemScale.Value:0.00}", Array.Empty<GUILayoutOption>());
			Plugin.Settings.HandScale.Value = Mathf.Round(GUILayout.HorizontalSlider(Plugin.Settings.HandScale.Value, 0.2f, 1.5f, Array.Empty<GUILayoutOption>()) * 20f) / 20f;
			Plugin.Settings.HeldItemScale.Value = Mathf.Round(GUILayout.HorizontalSlider(Plugin.Settings.HeldItemScale.Value, 0.2f, 1.5f, Array.Empty<GUILayoutOption>()) * 20f) / 20f;
			if (GUILayout.Button("Reset to defaults", Array.Empty<GUILayoutOption>()))
			{
				Plugin.Settings.HandRotation.Value = (Vector3)((ConfigEntryBase)Plugin.Settings.HandRotation).DefaultValue;
				Plugin.Settings.HandPosition.Value = (Vector3)((ConfigEntryBase)Plugin.Settings.HandPosition).DefaultValue;
				Plugin.Settings.ItemOffset.Value = (Vector3)((ConfigEntryBase)Plugin.Settings.ItemOffset).DefaultValue;
				Plugin.Settings.LaserRotation.Value = (Vector3)((ConfigEntryBase)Plugin.Settings.LaserRotation).DefaultValue;
			}
			GUI.DragWindow();
		}

		private static Vector3 Vector3Sliders(string label, Vector3 value, float min, float max, float step)
		{
			//IL_0011: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Label($"{label}: {value.x:0.###}, {value.y:0.###}, {value.z:0.###}", Array.Empty<GUILayoutOption>());
			value.x = Slider("X", value.x, min, max, step);
			value.y = Slider("Y", value.y, min, max, step);
			value.z = Slider("Z", value.z, min, max, step);
			return value;
		}

		private static float Slider(string axis, float value, float min, float max, float step)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(axis, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(15f) });
			float num = GUILayout.HorizontalSlider(value, min, max, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			return Mathf.Round(num / step) * step;
		}
	}
	public class ImmersiveScreens : MonoBehaviour
	{
		private class Backdrop
		{
			public Graphic Source;

			public Canvas Canvas;

			public int Index;

			public Renderer Renderer;

			public Material Material;
		}

		private const float Radius = 5f;

		private static readonly Vector2 PanelToSphere = new Vector2(4.8f, 4f);

		private static readonly HashSet<Canvas> Showing = new HashSet<Canvas>();

		private readonly Dictionary<Graphic, Backdrop> backdrops = new Dictionary<Graphic, Backdrop>();

		private readonly List<Graphic> stale = new List<Graphic>();

		private Mesh sphere;

		private float nextScan;

		public static bool IsFullScreen(Canvas canvas)
		{
			return Showing.Contains(canvas);
		}

		private void Awake()
		{
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			sphere = Object.Instantiate<Mesh>(val.GetComponent<MeshFilter>().sharedMesh);
			Object.Destroy((Object)(object)val);
			int[] triangles = sphere.triangles;
			for (int i = 0; i < triangles.Length; i += 3)
			{
				ref int reference = ref triangles[i];
				ref int reference2 = ref triangles[i + 1];
				int num = triangles[i + 1];
				int num2 = triangles[i];
				reference = num;
				reference2 = num2;
			}
			sphere.triangles = triangles;
			Vector2[] uv = sphere.uv;
			for (int j = 0; j < uv.Length; j++)
			{
				uv[j].x = 1f - uv[j].x;
			}
			sphere.uv = uv;
		}

		private void LateUpdate()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (Time.unscaledTime >= nextScan)
			{
				nextScan = Time.unscaledTime + 0.25f;
				Scan();
			}
			Vector3 position = ((Component)instance.VRCamera).transform.position;
			stale.Clear();
			Showing.Clear();
			foreach (KeyValuePair<Graphic, Backdrop> backdrop in backdrops)
			{
				Backdrop value = backdrop.Value;
				if ((Object)(object)value.Source == (Object)null || (Object)(object)value.Canvas == (Object)null)
				{
					stale.Add(backdrop.Key);
					continue;
				}
				float num = (((Behaviour)value.Source).isActiveAndEnabled ? (value.Source.color.a * value.Source.canvasRenderer.GetInheritedAlpha()) : 0f);
				bool flag = num > 0.001f && ((Behaviour)value.Canvas).isActiveAndEnabled;
				((Component)value.Renderer).gameObject.SetActive(flag);
				value.Source.canvasRenderer.cull = true;
				if (flag)
				{
					Showing.Add(value.Canvas);
					((Component)value.Renderer).transform.position = position;
					Color color = value.Source.color;
					color.a = num;
					value.Material.color = color;
					Texture mainTexture = value.Source.mainTexture;
					if ((Object)(object)value.Material.mainTexture != (Object)(object)mainTexture)
					{
						value.Material.mainTexture = mainTexture;
					}
					value.Renderer.sortingLayerID = value.Canvas.sortingLayerID;
					value.Renderer.sortingOrder = value.Canvas.sortingOrder - 1;
				}
			}
			foreach (Graphic item in stale)
			{
				Remove(item);
			}
		}

		private void Scan()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_006b: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			Canvas[] array = Object.FindObjectsByType<Canvas>((FindObjectsSortMode)0);
			foreach (Canvas val in array)
			{
				if (!val.isRootCanvas || ((Component)val).gameObject.layer != WorldSpaceUI.Layer || (int)val.renderMode != 2)
				{
					continue;
				}
				Scene scene = ((Component)val).gameObject.scene;
				if (((Scene)(ref scene)).name == "MainMenuScene")
				{
					continue;
				}
				RectTransform val2 = (RectTransform)((Component)val).transform;
				Rect rect = val2.rect;
				Vector2 size = ((Rect)(ref rect)).size;
				Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(false);
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					Graphic val3 = componentsInChildren[j];
					if (!backdrops.ContainsKey(val3) && IsBackdrop(val3, val2, size))
					{
						Add(val3, val, j);
					}
				}
			}
		}

		private static bool IsBackdrop(Graphic graphic, RectTransform root, Vector2 screen)
		{
			//IL_0011: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00d4: 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_00e6: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			if (graphic is TMP_Text || graphic is Text || graphic.color.a < 0.95f || !((Behaviour)graphic).enabled)
			{
				return false;
			}
			if ((Object)(object)((Component)graphic).GetComponentInParent<EmoteWheelController>(true) != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)graphic).transform.parent != (Object)null && ((Object)(object)((Component)((Component)graphic).transform.parent).GetComponentInParent<Mask>(true) != (Object)null || (Object)(object)((Component)((Component)graphic).transform.parent).GetComponentInParent<RectMask2D>(true) != (Object)null))
			{
				return false;
			}
			RawImage val = (RawImage)(object)((graphic is RawImage) ? graphic : null);
			if (val != null && val.texture is RenderTexture)
			{
				return false;
			}
			RectTransform rectTransform = graphic.rectTransform;
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rectTransform.GetWorldCorners(array);
			Vector3 val2 = ((Transform)root).InverseTransformPoint(array[0]);
			Vector3 val3 = ((Transform)root).InverseTransformPoint(array[2]);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(Mathf.Abs(val3.x - val2.x), Mathf.Abs(val3.y - val2.y));
			if (val4.x >= screen.x * 0.9f)
			{
				return val4.y >= screen.y * 0.9f;
			}
			return false;
		}

		private void Add(Graphic graphic, Canvas canvas, int index)
		{
			//IL_0030: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//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)
			GameObject val = new GameObject("VRBackdrop " + ((Object)graphic).name, new Type[2]
			{
				typeof(MeshFilter),
				typeof(MeshRenderer)
			});
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localScale = Vector3.one * 10f;
			val.layer = WorldSpaceUI.Layer;
			val.GetComponent<MeshFilter>().sharedMesh = sphere;
			Material val2 = new Material(graphic.material)
			{
				name = "VRBackdrop " + ((Object)graphic).name
			};
			val2.renderQueue = 3000 + Mathf.Min(index, 99);
			if (val2.HasProperty("unity_GUIZTestMode"))
			{
				val2.SetInt("unity_GUIZTestMode", 8);
			}
			if (val2.HasProperty("_StencilComp"))
			{
				val2.SetInt("_StencilComp", 8);
			}
			if (val2.HasProperty("_Stencil"))
			{
				val2.SetInt("_Stencil", 0);
			}
			val2.mainTextureScale = TextureScale(graphic);
			MeshRenderer component = val.GetComponent<MeshRenderer>();
			((Renderer)component).sharedMaterial = val2;
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)component).receiveShadows = false;
			val.SetActive(false);
			backdrops[graphic] = new Backdrop
			{
				Source = graphic,
				Canvas = canvas,
				Index = index,
				Renderer = (Renderer)(object)component,
				Material = val2
			};
			Plugin.Log.LogInfo((object)("Surrounding backdrop for '" + ((Object)graphic).name + "' on '" + ((Object)canvas).name + "' (material '" + ((Object)graphic.material).name + "', shader '" + ((Object)graphic.material.shader).name + "')"));
		}

		private static Vector2 TextureScale(Graphic graphic)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_00bd: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Vector2 one = Vector2.one;
			Image val = (Image)(object)((graphic is Image) ? graphic : null);
			if (val != null && (int)val.type == 2 && (Object)(object)val.sprite != (Object)null)
			{
				Rect rect = val.sprite.rect;
				Vector2 val2 = ((Rect)(ref rect)).size / val.pixelsPerUnit;
				rect = ((Graphic)val).rectTransform.rect;
				Vector2 size = ((Rect)(ref rect)).size;
				if (val2.x > 0f && val2.y > 0f)
				{
					((Vector2)(ref one))..ctor(size.x / val2.x, size.y / val2.y);
				}
			}
			else if ((Object)(object)graphic.mainTexture == (Object)null || (int)graphic.mainTexture.wrapMode != 0)
			{
				return Vector2.one;
			}
			Vector2 val3 = Vector2.Scale(one, PanelToSphere);
			return new Vector2(Mathf.Max(1f, Mathf.Round(val3.x)), Mathf.Max(1f, Mathf.Round(val3.y)));
		}

		private void Remove(Graphic key)
		{
			if (backdrops.TryGetValue(key, out var value))
			{
				if ((Object)(object)value.Renderer != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value.Renderer).gameObject);
				}
				if ((Object)(object)value.Material != (Object)null)
				{
					Object.Destroy((Object)(object)value.Material);
				}
			}
			backdrops.Remove(key);
		}
	}
	public class MenuBackdrop : MonoBehaviour
	{
		public const string MenuScene = "MainMenuScene";

		private Scene backdrop;

		private bool loading;

		private HashSet<GameObject> persistentBefore;

		private GameObject persistentProbe;

		public static MenuBackdrop Instance { get; private set; }

		public Transform Viewpoint { get; private set; }

		public bool Active
		{
			get
			{
				if ((Object)(object)Viewpoint != (Object)null && ((Scene)(ref backdrop)).IsValid())
				{
					return ((Scene)(ref backdrop)).isLoaded;
				}
				return false;
			}
		}

		private void Awake()
		{
			Instance = this;
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			SceneManager.sceneUnloaded -= OnSceneUnloaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (((Scene)(ref scene)).name == "MainMenuScene" && !loading && !((Scene)(ref backdrop)).IsValid())
			{
				LoadBackdrop();
			}
			else if (loading && ((Scene)(ref scene)).name == Plugin.Settings.MenuBackdropScene.Value && (int)mode == 1)
			{
				OnBackdropLoaded(scene);
			}
			else if ((int)mode == 0 && ((Scene)(ref scene)).name != "MainMenuScene")
			{
				Unload();
			}
		}

		private void OnSceneUnloaded(Scene scene)
		{
			if (((Scene)(ref scene)).name == "MainMenuScene")
			{
				Unload();
			}
		}

		private void LoadBackdrop()
		{
			string value = Plugin.Settings.MenuBackdropScene.Value;
			if (!string.IsNullOrWhiteSpace(value) && Application.CanStreamedLevelBeLoaded(value))
			{
				persistentBefore = PersistentObjects();
				loading = true;
				SceneManager.LoadSceneAsync(value, (LoadSceneMode)1);
				Plugin.Log.LogInfo((object)("Loading " + value + " as the menu backdrop"));
			}
		}

		private void OnBackdropLoaded(Scene scene)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00ed: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_00fe: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_01a6: Expected O, but got Unknown
			//IL_01a8: Unknown result