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.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using JetBrains.Annotations;
using LCVR;
using LCVR.Assets;
using LCVR.Input;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PEAKLib.UI;
using PEAKLib.UI.Elements;
using PeakVR;
using Photon.Pun;
using Photon.Realtime;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Animations.Rigging;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.SpatialTracking;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit.Inputs.Composites;
using UnityEngine.XR.Interaction.Toolkit.Inputs.Interactions;
using UnityEngine.XR.Interaction.Toolkit.UI;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;
using Zorro.ControllerSupport;
using Zorro.Core;
using Zorro.UI.Modal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.andrey04o.PeakVR")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b4b3ff0a536f5a5f73d9d77c1cb2bc48e7ee6ea6")]
[assembly: AssemblyProduct("com.andrey04o.PeakVR")]
[assembly: AssemblyTitle("PeakVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace LCVR
{
	public class Config
	{
		public string AssemblyPath { get; }

		public ConfigFile File { get; }

		public ConfigEntry<string> OpenXRRuntime { get; }

		public ConfigEntry<bool> EnableVerboseLogging { get; }

		public ConfigEntry<bool> SmoothTurn { get; }

		public ConfigEntry<float> SnapTurnAngle { get; }

		public ConfigEntry<float> SmoothTurnSpeed { get; }

		public ConfigEntry<bool> MovementTunneling { get; }

		public ConfigEntry<float> TunnelingStrength { get; }

		public ConfigEntry<bool> HideControllers { get; }

		public ConfigEntry<LineVisibility> InteractionLine { get; }

		public ConfigEntry<LineVisibility> HudLine { get; }

		public ConfigEntry<bool> AimAtObjectCenter { get; }

		public ConfigEntry<float> ArmSpanScale { get; }

		public ConfigEntry<float> VirtualArmSpan { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public Config(string assemblyPath, ConfigFile file)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			AssemblyPath = assemblyPath;
			File = file;
			OpenXRRuntime = file.Bind<string>("VR", "OpenXR Runtime", "System Default", new ConfigDescription("The OpenXR runtime (headset software) that VR launches with. Restart the game to apply.", (AcceptableValueBase)(object)new AcceptableValueList<string>(OpenXR.GetRuntimeChoices().ToArray()), Array.Empty<object>()));
			EnableVerboseLogging = file.Bind<bool>("VR", "Verbose Logging", false, "Enables verbose debug logging during OpenXR initialization.");
			SmoothTurn = file.Bind<bool>("Comfort", "Smooth Turn", false, "Turn smoothly with the right stick instead of snapping by a fixed angle.");
			SnapTurnAngle = file.Bind<float>("Comfort", "Snap Turn Angle", 45f, new ConfigDescription("Degrees rotated per snap turn.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(15f, 90f), Array.Empty<object>()));
			SmoothTurnSpeed = file.Bind<float>("Comfort", "Smooth Turn Speed", 120f, new ConfigDescription("Smooth turn speed in degrees per second.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(45f, 240f), Array.Empty<object>()));
			MovementTunneling = file.Bind<bool>("Comfort", "Movement Tunneling", true, "Close a tunnel around your view while moving or falling to reduce motion sickness.");
			TunnelingStrength = file.Bind<float>("Comfort", "Tunneling Strength", 0.7f, new ConfigDescription("How far the tunnel closes in (smaller circle). 0 disables it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			HideControllers = file.Bind<bool>("VR", "Hide Controllers", true, "Hide the VR controller models and show only your character's hands. Interaction/aim lasers then originate from your hand instead of the controller.");
			InteractionLine = file.Bind<LineVisibility>("Lasers", "Interaction Line", LineVisibility.OnInteract, "When to show the right-hand interaction line: Always, only when something is interactable (OnInteract), or never (Hidden).");
			HudLine = file.Bind<LineVisibility>("Lasers", "HUD Pointer Line", LineVisibility.OnInteract, "When to show the left-controller HUD selection line: Always, only when pointing at a HUD item (OnInteract), or Hidden.");
			AimAtObjectCenter = file.Bind<bool>("Lasers", "Aim At Object Center", true, "When an interactable is available, snap the interaction line's end to the object's center instead of pointing straight ahead.");
			ArmSpanScale = file.Bind<float>("VR", "Arm Span Scale", 1.089f, new ConfigDescription("Multiplier from your real arm reach to the character's arm reach. Calibrate it in-game with the T-pose window instead of editing by hand.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 1.8f), Array.Empty<object>()));
			VirtualArmSpan = file.Bind<float>("Internal", "VirtualArmSpan", 1.851f, new ConfigDescription("FOR INTERNAL USE ONLY, DO NOT EDIT — cached character wingspan for calibration.", (AcceptableValueBase)null, new object[1] { "Hidden" }));
			OpenXRRuntimeFile = file.Bind<string>("Internal", "OpenXRRuntimeFile", "", new ConfigDescription("FOR INTERNAL USE ONLY, DO NOT EDIT", (AcceptableValueBase)null, new object[1] { "Hidden" }));
			OpenXRRuntimeFile.Value = OpenXR.ResolveRuntimePath(OpenXRRuntime.Value);
			OpenXRRuntime.SettingChanged += delegate
			{
				OpenXRRuntimeFile.Value = OpenXR.ResolveRuntimePath(OpenXRRuntime.Value);
			};
		}
	}
	public static class Logger
	{
		private static ManualLogSource logSource;

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

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

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

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

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

		public static void LogDebug(object message)
		{
			logSource.LogDebug(message);
		}
	}
	internal static class Native
	{
		private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public int Count => runtimes.Length;

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

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

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

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

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

			public string Path { get; set; }

			public bool Default { get; set; }

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

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

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

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

		public static class Loader
		{
			private static XRGeneralSettings xrGeneralSettings;

			private static XRManagerSettings xrManagerSettings;

			private static OpenXRLoader xrLoader;

			private static readonly ManualLogSource Logger;

			private static int recoveryTick;

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

			public static bool IsRunning()
			{
				List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
				SubsystemManager.GetInstances<XRDisplaySubsystem>(list);
				return list.Any((XRDisplaySubsystem d) => d != null && ((IntegratedSubsystem)d).running);
			}

			public static void EnsureRunning()
			{
				if ((Object)(object)xrManagerSettings == (Object)null)
				{
					return;
				}
				List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
				SubsystemManager.GetInstances<XRDisplaySubsystem>(list);
				if (list.Any((XRDisplaySubsystem d) => d != null && ((IntegratedSubsystem)d).running))
				{
					recoveryTick = 0;
				}
				else if (recoveryTick++ % 30 == 0)
				{
					if (list.Count == 0)
					{
						Logger.LogWarning((object)"OpenXR shut down — re-initializing loader");
						xrManagerSettings.InitializeLoaderSync();
					}
					Logger.LogWarning((object)"Restarting XR subsystems");
					xrManagerSettings.StartSubsystems();
				}
			}

			public static bool InitializeXR()
			{
				InitializeScripts();
				List<ISubsystemDescriptor> list = new List<ISubsystemDescriptor>();
				SubsystemManager.GetAllSubsystemDescriptors(list);
				if (!list.Any((ISubsystemDescriptor subsystem) => subsystem.id == "OpenXR Input") || !list.Any((ISubsystemDescriptor subsystem) => subsystem.id == "OpenXR Display"))
				{
					Logger.LogError((object)"No Unity OpenXR subsystem found, this installation of PeakVR was not installed correctly.");
					if (list.Count == 0)
					{
						return false;
					}
					Logger.LogDebug((object)"Subsystems installed:");
					foreach (ISubsystemDescriptor item in list)
					{
						Logger.LogDebug((object)("- " + item.id));
					}
					return false;
				}
				if (Native.IsElevated())
				{
					Logger.LogWarning((object)"Application is elevated! Unable to override the XR runtime! Only the system default OpenXR runtime will be available.");
					return InitializeXR(null);
				}
				Runtimes runtimes = GetRuntimes();
				if (runtimes.Count == 0)
				{
					Logger.LogWarning((object)"Failed to query runtimes, or no runtimes were found. Falling back to old behavior.");
					return InitializeXR(string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value) ? ((Runtime?)null) : new Runtime?(new Runtime
					{
						Name = "LCVR OpenXR Override",
						Path = Plugin.Config.OpenXRRuntimeFile.Value
					}));
				}
				if (!string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value))
				{
					if (InitializeXR(runtimes.TryGetRuntimeByPath(Plugin.Config.OpenXRRuntimeFile.Value, out var runtime) ? runtime : new Runtime
					{
						Name = "LCVR OpenXR Override",
						Path = Plugin.Config.OpenXRRuntimeFile.Value
					}))
					{
						return true;
					}
					Logger.LogWarning((object)"Loading OpenXR using override failed, falling back to automatic enumeration...");
				}
				Runtime? runtime2 = runtimes.Default;
				if (runtime2.HasValue)
				{
					Runtime valueOrDefault = runtime2.GetValueOrDefault();
					if (valueOrDefault.Path != Plugin.Config.OpenXRRuntimeFile.Value && InitializeXR(valueOrDefault))
					{
						return true;
					}
				}
				foreach (Runtime item2 in runtimes.Where((Runtime rt) => rt.Path != Plugin.Config.OpenXRRuntimeFile.Value && !rt.Default))
				{
					if (InitializeXR(item2))
					{
						return true;
					}
				}
				Logger.LogError((object)"All available runtimes were attempted but none worked. Aborting...");
				return false;
			}

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

			private static void InitializeScripts()
			{
				if (xrGeneralSettings == null)
				{
					xrGeneralSettings = ScriptableObject.CreateInstance<XRGeneralSettings>();
				}
				if (xrManagerSettings == null)
				{
					xrManagerSettings = ScriptableObject.CreateInstance<XRManagerSettings>();
				}
				if (xrLoader == null)
				{
					xrLoader = ScriptableObject.CreateInstance<OpenXRLoader>();
				}
				xrGeneralSettings.Manager = xrManagerSettings;
				((List<XRLoader>)xrManagerSettings.activeLoaders).Clear();
				((List<XRLoader>)xrManagerSettings.activeLoaders).Add((XRLoader)(object)xrLoader);
				OpenXRSettings.Instance.renderMode = (RenderMode)0;
				OpenXRSettings.Instance.depthSubmissionMode = (DepthSubmissionMode)0;
				if (OpenXRSettings.Instance.features.Length == 0)
				{
					ValveIndexControllerProfile val = ScriptableObject.CreateInstance<ValveIndexControllerProfile>();
					HPReverbG2ControllerProfile val2 = ScriptableObject.CreateInstance<HPReverbG2ControllerProfile>();
					HTCViveControllerProfile val3 = ScriptableObject.CreateInstance<HTCViveControllerProfile>();
					MicrosoftMotionControllerProfile val4 = ScriptableObject.CreateInstance<MicrosoftMotionControllerProfile>();
					KHRSimpleControllerProfile val5 = ScriptableObject.CreateInstance<KHRSimpleControllerProfile>();
					MetaQuestTouchProControllerProfile val6 = ScriptableObject.CreateInstance<MetaQuestTouchProControllerProfile>();
					OculusTouchControllerProfile val7 = ScriptableObject.CreateInstance<OculusTouchControllerProfile>();
					XRSessionMonitor xRSessionMonitor = ScriptableObject.CreateInstance<XRSessionMonitor>();
					((OpenXRFeature)val).enabled = true;
					((OpenXRFeature)val2).enabled = true;
					((OpenXRFeature)val3).enabled = true;
					((OpenXRFeature)val4).enabled = true;
					((OpenXRFeature)val5).enabled = true;
					((OpenXRFeature)val6).enabled = true;
					((OpenXRFeature)val7).enabled = true;
					((OpenXRFeature)xRSessionMonitor).enabled = true;
					OpenXRSettings.Instance.features = (OpenXRFeature[])(object)new OpenXRFeature[8]
					{
						(OpenXRFeature)val,
						(OpenXRFeature)val2,
						(OpenXRFeature)val3,
						(OpenXRFeature)val4,
						(OpenXRFeature)val5,
						(OpenXRFeature)val6,
						(OpenXRFeature)val7,
						xRSessionMonitor
					};
				}
			}
		}

		private static List<KeyValuePair<string, string>> runtimeCache;

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

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

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

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

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

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

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

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

		private static IEnumerable<Runtime> LocateCommonRuntimes()
		{
			string path = default(string);
			if (SteamAPI.Init() && SteamApps.GetAppInstallDir(new AppId_t(250820u), ref path, 240u) != 0 && Runtime.ReadFromJson(Path.Combine(path, "steamxr_win64.json"), out var runtime))
			{
				yield return runtime;
			}
			path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Virtual Desktop Streamer\\OpenXR\\virtualdesktop-openxr.json");
			if (File.Exists(path) && Runtime.ReadFromJson(path, out runtime))
			{
				yield return runtime;
			}
			path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Oculus\\Support\\oculus-runtime\\oculus_openxr_64.json");
			if (File.Exists(path) && Runtime.ReadFromJson(path, out runtime))
			{
				yield return runtime;
			}
		}

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

		public static bool GetActiveRuntimeVersion(out ushort major, out ushort minor, out ushort patch)
		{
			return Internal_GetRuntimeVersion(out major, out minor, out patch);
		}

		private static List<KeyValuePair<string, string>> RuntimeList()
		{
			if (runtimeCache != null)
			{
				return runtimeCache;
			}
			runtimeCache = new List<KeyValuePair<string, string>>();
			try
			{
				foreach (Runtime runtime in GetRuntimes())
				{
					runtimeCache.Add(new KeyValuePair<string, string>(runtime.Name ?? "Unknown", runtime.Path ?? ""));
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to enumerate OpenXR runtimes: " + ex.Message);
			}
			return runtimeCache;
		}

		public static List<string> GetRuntimeChoices()
		{
			List<string> list = new List<string> { "System Default" };
			foreach (KeyValuePair<string, string> item in RuntimeList())
			{
				list.Add(item.Key);
			}
			return list;
		}

		public static string ResolveRuntimePath(string name)
		{
			if (string.IsNullOrEmpty(name) || name == "System Default")
			{
				return "";
			}
			foreach (KeyValuePair<string, string> item in RuntimeList())
			{
				if (item.Key == name)
				{
					return item.Value;
				}
			}
			return "";
		}
	}
	internal static class GameObjectExtensions
	{
		public static GameObject Find(this GameObject @object, string name)
		{
			Transform obj = @object.transform.Find(name);
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).gameObject;
		}
	}
	internal static class Utils
	{
		public static byte[] ComputeHash(byte[] input)
		{
			using SHA256 sHA = SHA256.Create();
			return sHA.ComputeHash(input);
		}

		public static string[] ParseConfig(string content)
		{
			string[] source = content.Split("\n", StringSplitOptions.RemoveEmptyEntries);
			return (from line in source
				where !line.TrimStart().StartsWith("#")
				let commentIndex = line.IndexOf('#')
				select (commentIndex < 0) ? line.Trim() : line.Substring(0, commentIndex).Trim() into parsedLine
				where !string.IsNullOrEmpty(parsedLine)
				select parsedLine).ToArray();
		}

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

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

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

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

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

		public static IEnumerator NopRoutine()
		{
			yield break;
		}

		public static IEnumerator FixYuckyScrollThing(Animator animator)
		{
			ScrollRect[] rects = ((Component)animator).GetComponentsInChildren<ScrollRect>();
			AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(0);
			float maxTime = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length;
			float time = 0f;
			while (time < maxTime)
			{
				time += Time.deltaTime;
				CollectionExtensions.Do<ScrollRect>((IEnumerable<ScrollRect>)rects, (Action<ScrollRect>)delegate(ScrollRect rect)
				{
					rect.verticalNormalizedPosition = 1f;
				});
				yield return null;
			}
		}
	}
}
namespace LCVR.Assets
{
	public static class AssetManager
	{
		private static AssetBundle assetsBundle;

		private static AssetBundle scenesBundle;

		public static GameObject Interactable;

		public static GameObject Keyboard;

		public static GameObject VolumeManager;

		public static GameObject SpectatorLight;

		public static GameObject SpectatorGhost;

		public static GameObject SteeringWheelPoints;

		public static GameObject PopupText;

		public static GameObject SpectatingMenu;

		public static GameObject Reticle;

		public static GameObject InitMenuEnvironment;

		public static GameObject MainMenuEnvironment;

		public static GameObject PauseMenuEnvironment;

		public static GameObject SettingsPanel;

		public static Material SplashMaterial;

		public static Material DefaultRayMat;

		public static Shader TMPAlwaysOnTop;

		public static Shader VignettePostProcess;

		public static InputActionAsset VRActions;

		public static InputActionAsset DefaultXRActions;

		public static InputActionAsset NullActions;

		public static Sprite GithubImage;

		public static Sprite KofiImage;

		public static Sprite DiscordImage;

		public static Sprite WarningImage;

		public static Sprite SprintImage;

		public static AudioClip DoorLocked;

		internal static bool LoadAssets()
		{
			assetsBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Plugin.Config.AssemblyPath), "lethalcompanyvr"));
			scenesBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Plugin.Config.AssemblyPath), "lethalcompanyvr-levels"));
			if ((Object)(object)assetsBundle == (Object)null || (Object)(object)scenesBundle == (Object)null)
			{
				Logger.LogError("Failed to load asset bundle!");
				return false;
			}
			DefaultXRActions = assetsBundle.LoadAsset<InputActionAsset>("DefaultXRActions");
			return true;
		}
	}
}
namespace LCVR.Input
{
	public class Actions
	{
		public static Actions Instance { get; private set; } = new Actions();

		public InputAction HeadPosition { get; private set; }

		public InputAction HeadRotation { get; private set; }

		public InputAction HeadTrackingState { get; private set; }

		public InputAction LeftHandPosition { get; private set; }

		public InputAction LeftHandRotation { get; private set; }

		public InputAction LeftHandTrackingState { get; private set; }

		public InputAction RightHandPosition { get; private set; }

		public InputAction RightHandRotation { get; private set; }

		public InputAction RightHandTrackingState { get; private set; }

		private Actions()
		{
			HeadPosition = AssetManager.DefaultXRActions.FindAction("Head/Position", false);
			HeadRotation = AssetManager.DefaultXRActions.FindAction("Head/Rotation", false);
			HeadTrackingState = AssetManager.DefaultXRActions.FindAction("Head/Tracking State", false);
			LeftHandPosition = AssetManager.DefaultXRActions.FindAction("Left/Position", false);
			LeftHandRotation = AssetManager.DefaultXRActions.FindAction("Left/Rotation", false);
			LeftHandTrackingState = AssetManager.DefaultXRActions.FindAction("Left/Tracking State", false);
			RightHandPosition = AssetManager.DefaultXRActions.FindAction("Right/Position", false);
			RightHandRotation = AssetManager.DefaultXRActions.FindAction("Right/Rotation", false);
			RightHandTrackingState = AssetManager.DefaultXRActions.FindAction("Right/Tracking State", false);
		}
	}
}
namespace PeakVR
{
	[HarmonyPatch(typeof(MainMenu), "Start")]
	internal static class AboutButtonPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Open;
		}

		private const string ButtonName = "PeakVR AboutButton";

		private const float Margin = 40f;

		private const float SizeScale = 0.65f;

		[HarmonyPostfix]
		private static void Postfix(MainMenu __instance)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: 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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			Button val = (((Object)(object)__instance.aggrocrabButton != (Object)null) ? __instance.aggrocrabButton : __instance.landfallButton);
			MainMenuPageSelector val2 = Object.FindObjectOfType<MainMenuPageSelector>();
			Transform val3 = (((Object)(object)val2 != (Object)null && (Object)(object)val2.mainPage != (Object)null) ? ((Component)val2.mainPage).transform : (((Object)(object)val != (Object)null) ? ((Component)val).transform.parent : null));
			if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.Find("PeakVR AboutButton") != (Object)null))
			{
				GameObject val4 = new GameObject("PeakVR AboutButton", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				val4.transform.SetParent(val3, false);
				Image component = val4.GetComponent<Image>();
				((Graphic)component).color = Color.white;
				if ((Object)(object)PeakAssets.AboutButton != (Object)null)
				{
					component.sprite = PeakAssets.AboutButton;
					component.preserveAspect = true;
				}
				Button component2 = val4.GetComponent<Button>();
				((Selectable)component2).targetGraphic = (Graphic)(object)component;
				Navigation navigation = default(Navigation);
				((Navigation)(ref navigation)).mode = (Mode)3;
				((Selectable)component2).navigation = navigation;
				if ((Object)(object)val != (Object)null)
				{
					((Selectable)component2).transition = (Transition)1;
					((Selectable)component2).colors = ((Selectable)val).colors;
				}
				ButtonClickedEvent onClick = component2.onClick;
				object obj = <>O.<0>__Open;
				if (obj == null)
				{
					UnityAction val5 = VRAboutPanel.Open;
					<>O.<0>__Open = val5;
					obj = (object)val5;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				RectTransform val6 = (RectTransform)val4.transform;
				Vector2 val7 = (val6.pivot = Vector2.zero);
				Vector2 anchorMin = (val6.anchorMax = val7);
				val6.anchorMin = anchorMin;
				Vector2 val9 = (Vector2)(((Object)(object)val != (Object)null) ? ((RectTransform)((Component)val).transform).sizeDelta : new Vector2(220f, 110f));
				val6.sizeDelta = val9 * 0.65f;
				val6.anchoredPosition = new Vector2(40f, 40f);
				((Transform)val6).SetAsLastSibling();
				Plugin.Log.LogInfo((object)"[PeakVR] About button added to main menu (bottom-left)");
			}
		}
	}
	[HarmonyPatch(typeof(MenuWindow), "get_blocksPlayerInput")]
	internal static class BoardingPassInputPatch
	{
		[HarmonyPostfix]
		private static void Postfix(MenuWindow __instance, ref bool __result)
		{
			if (Plugin.VrEnabled && __instance is BoardingPass)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(CameraQuad), "LateUpdate")]
	internal static class FogQuadPatch
	{
		private const float Margin = 1.6f;

		[HarmonyPrefix]
		private static bool Prefix(CameraQuad __instance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Matrix4x4 stereoProjectionMatrix = val.GetStereoProjectionMatrix((StereoscopicEye)0);
			if (stereoProjectionMatrix.m00 <= 0.0001f || stereoProjectionMatrix.m11 <= 0.0001f)
			{
				return false;
			}
			Transform transform = ((Component)__instance).transform;
			float num = val.nearClipPlane + 0.01f;
			float num2 = 2f * num / stereoProjectionMatrix.m00 * 1.6f;
			float num3 = 2f * num / stereoProjectionMatrix.m11 * 1.6f;
			if ((Object)(object)transform.parent != (Object)(object)((Component)val).transform)
			{
				transform.SetParent(((Component)val).transform, false);
			}
			transform.localPosition = new Vector3(0f, 0f, num);
			transform.localRotation = Quaternion.identity;
			transform.localScale = new Vector3(num2, num3, 1f);
			return false;
		}
	}
	[HarmonyPatch(typeof(Guidebook), "LateUpdate")]
	internal static class GuidebookVRPatch
	{
		private const float ForwardOffset = 0.22f;

		private const float UpOffset = 0.04f;

		[HarmonyPrefix]
		private static bool Prefix(Guidebook __instance)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00bf: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			Transform right = VRHands.Right;
			if ((Object)(object)right == (Object)null || !__instance.isOpen || (Object)(object)__instance.bookTransform == (Object)null || (Object)(object)((Item)__instance).holderCharacter == (Object)null || !((Item)__instance).holderCharacter.IsLocal || (Object)(object)MainCamera.instance == (Object)null)
			{
				return true;
			}
			Transform transform = ((Component)MainCamera.instance.cam).transform;
			Vector3 val = right.position + right.forward * 0.22f + right.up * 0.04f;
			__instance.bookTransform.position = Vector3.Lerp(__instance.bookTransform.position, val, Time.deltaTime * 10f);
			Transform bookTransform = __instance.bookTransform;
			Vector3 val2 = val - transform.position;
			bookTransform.forward = ((Vector3)(ref val2)).normalized;
			return false;
		}
	}
	[HarmonyPatch(typeof(Interaction), "DoInteractableRaycasts")]
	internal static class HandInteractPatch
	{
		private static readonly FieldInfo DistanceField = AccessTools.Field(typeof(Interaction), "distance");

		private static readonly FieldInfo AreaField = AccessTools.Field(typeof(Interaction), "area");

		private static readonly RaycastHit[] LineBuffer = (RaycastHit[])(object)new RaycastHit[32];

		private static readonly RaycastHit[] SphereBuffer = (RaycastHit[])(object)new RaycastHit[32];

		private const float LineStartOffset = 0.1f;

		[HarmonyPostfix]
		private static void Postfix(Interaction __instance, ref IInteractible interactableResult)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_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_0102: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)VRHands.Right == (Object)null)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null))
			{
				if (!(interactableResult is ClimbHandle))
				{
					interactableResult = FindHandInteractable(__instance, localCharacter);
				}
				bool flag = interactableResult != null && !(interactableResult is ClimbHandle);
				if (!VRLine.ShouldShow(Plugin.Config.InteractionLine.Value, flag) || !VRAim.TryRight(out var origin, out var direction))
				{
					VRHands.SetInteractRay(show: false, default(Vector3), default(Vector3), default(Color));
					return;
				}
				Vector3 center;
				Vector3 end = ((!flag || !Plugin.Config.AimAtObjectCenter.Value || !TryGetCenter(interactableResult, out center)) ? (origin + direction * RayLength(__instance, localCharacter)) : center);
				Vector3 origin2 = origin + direction * 0.1f;
				Color color = (Color)(flag ? VRLine.CharacterColor() : new Color(0.35f, 0.75f, 1f));
				VRHands.SetInteractRay(show: true, origin2, end, color);
			}
		}

		private static bool TryGetCenter(IInteractible interactable, out Vector3 center)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			center = default(Vector3);
			Component val = (Component)(object)((interactable is Component) ? interactable : null);
			if (val == null || (Object)(object)val == (Object)null)
			{
				return false;
			}
			Collider componentInChildren = val.GetComponentInChildren<Collider>();
			Vector3 val2;
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				val2 = val.transform.position;
			}
			else
			{
				Bounds bounds = componentInChildren.bounds;
				val2 = ((Bounds)(ref bounds)).center;
			}
			center = val2;
			return true;
		}

		private static bool ValidHandTarget(RaycastHit h, Character local, out IInteractible interactible)
		{
			interactible = null;
			if ((Object)(object)((RaycastHit)(ref h)).collider == (Object)null || local.refs.ragdoll.colliderList.Contains(((RaycastHit)(ref h)).collider))
			{
				return false;
			}
			IInteractible componentInParent = ((Component)((RaycastHit)(ref h)).collider).GetComponentInParent<IInteractible>();
			if (componentInParent == null || componentInParent is ClimbHandle || !componentInParent.IsInteractible(local))
			{
				return false;
			}
			Item val = (Item)(object)((componentInParent is Item) ? componentInParent : null);
			if (val != null && (Object)(object)val == (Object)(object)local.data.currentItem)
			{
				return false;
			}
			interactible = componentInParent;
			return true;
		}

		private static float RayLength(Interaction interaction, Character local)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			float num = ((DistanceField != null) ? ((float)DistanceField.GetValue(interaction)) : 3f);
			if (!VRAim.TryRight(out var origin, out var direction))
			{
				return num;
			}
			int num2 = LayerMask.op_Implicit(HelperFunctions.GetMask((LayerType)0));
			int num3 = Physics.RaycastNonAlloc(origin, direction, LineBuffer, num, num2, (QueryTriggerInteraction)1);
			float num4 = num;
			for (int i = 0; i < num3; i++)
			{
				RaycastHit val = LineBuffer[i];
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && !(((RaycastHit)(ref val)).distance >= num4) && !local.refs.ragdoll.colliderList.Contains(((RaycastHit)(ref val)).collider))
				{
					num4 = ((RaycastHit)(ref val)).distance;
				}
			}
			return num4;
		}

		private static IInteractible FindHandInteractable(Interaction interaction, Character local)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (!VRAim.TryRight(out var origin, out var direction))
			{
				return null;
			}
			float num = ((DistanceField != null) ? ((float)DistanceField.GetValue(interaction)) : 3f);
			int num2 = LayerMask.op_Implicit(HelperFunctions.GetMask((LayerType)0));
			int num3 = Physics.RaycastNonAlloc(origin, direction, LineBuffer, num, num2, (QueryTriggerInteraction)2);
			IInteractible val = null;
			float num4 = float.MaxValue;
			for (int i = 0; i < num3; i++)
			{
				RaycastHit h = LineBuffer[i];
				if (!(((RaycastHit)(ref h)).distance >= num4) && ValidHandTarget(h, local, out IInteractible interactible))
				{
					val = interactible;
					num4 = ((RaycastHit)(ref h)).distance;
				}
			}
			if (val != null)
			{
				return val;
			}
			float num5 = ((AreaField != null) ? ((float)AreaField.GetValue(interaction)) : 0.3f);
			int num6 = Physics.SphereCastNonAlloc(origin + direction * (num5 / 2f), num5, direction, SphereBuffer, num, num2, (QueryTriggerInteraction)2);
			float num7 = float.MaxValue;
			for (int j = 0; j < num6; j++)
			{
				RaycastHit h2 = SphereBuffer[j];
				if (ValidHandTarget(h2, local, out IInteractible interactible2))
				{
					float num8 = Vector3.Angle(((RaycastHit)(ref h2)).point - origin, direction);
					if (!(num8 >= num7))
					{
						val = interactible2;
						num7 = num8;
					}
				}
			}
			return val;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "CameraLook")]
	internal static class HeadLookPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)MainCamera.instance == (Object)null) && !((Object)(object)((Component)__instance).GetComponent<Character>() != (Object)(object)localCharacter))
			{
				localCharacter.data.lookValues = Vector2.op_Implicit(HelperFunctions.DirectionToLook(((Component)MainCamera.instance.cam).transform.forward));
				localCharacter.RecalculateLookDirections();
			}
		}
	}
	[HarmonyPatch(typeof(GUIManager), "UpdateItemPrompts")]
	internal static class HudCleanupPatch
	{
		[HarmonyPostfix]
		private static void Postfix(GUIManager __instance)
		{
			if (Plugin.VrEnabled)
			{
				Hide(__instance.itemPromptMain);
				Hide(__instance.itemPromptScroll);
				Hide(__instance.itemPromptSecondary);
				Hide(__instance.itemPromptDrop);
				Hide(__instance.itemPromptThrow);
			}
		}

		private static void Hide(TextMeshProUGUI text)
		{
			if ((Object)(object)text != (Object)null && ((Component)text).gameObject.activeSelf)
			{
				((Component)text).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(GUIManager), "Awake")]
	internal static class HudVRPatch
	{
		[HarmonyPostfix]
		private static void Postfix(GUIManager __instance)
		{
			((Component)__instance).gameObject.AddComponent<VRHud>();
		}
	}
	internal class VRHud : MonoBehaviour
	{
		private const float Distance = 1.5f;

		private const float Scale = 0.001f;

		private bool done;

		private int frame;

		private void Update()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0083: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (!done)
			{
				Canvas val = (((Object)(object)GUIManager.instance != (Object)null) ? GUIManager.instance.hudCanvas : null);
				Camera val2 = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
				{
					done = true;
					val.renderMode = (RenderMode)2;
					val.worldCamera = val2;
					RectTransform val3 = (RectTransform)((Component)val).transform;
					((Transform)val3).SetParent(((Component)val2).transform, false);
					((Transform)val3).localScale = Vector3.one * 0.001f;
					((Transform)val3).localPosition = new Vector3(0f, 0f, 1.5f);
					((Transform)val3).localRotation = Quaternion.identity;
					UIOverlay.MakeAlwaysVisible(val, foreground: false);
					Plugin.Log.LogInfo((object)"[PeakVR] HUD converted to world space");
				}
			}
			else if (++frame % 30 == 0 && (Object)(object)GUIManager.instance != (Object)null)
			{
				UIOverlay.MakeAlwaysVisible(GUIManager.instance.hudCanvas, foreground: false);
			}
		}
	}
	[HarmonyPatch(typeof(MainCameraMovement), "Start")]
	internal static class InGameCameraPatch
	{
		[HarmonyPostfix]
		private static void Postfix(MainCameraMovement __instance)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0048: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00ff: 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)
			Camera component = ((Component)__instance).GetComponent<Camera>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)((Component)component).GetComponent<TrackedPoseDriver>() != (Object)null))
			{
				component.stereoTargetEye = (StereoTargetEyeMask)3;
				component.nearClipPlane = 0.05f;
				GameObject val = new GameObject("PeakVR InGame Rig");
				val.transform.SetPositionAndRotation(((Component)component).transform.position, Quaternion.identity);
				val.transform.localScale = Vector3.one * VRHeadRig.HandScale;
				((Component)component).transform.SetParent(val.transform, false);
				((Component)component).transform.localPosition = Vector3.zero;
				((Component)component).transform.localRotation = Quaternion.identity;
				InputAction val2 = new InputAction("HeadPosition", (InputActionType)0, "<XRHMD>/centerEyePosition", (string)null, (string)null, "Vector3");
				InputAction val3 = new InputAction("HeadRotation", (InputActionType)0, "<XRHMD>/centerEyeRotation", (string)null, (string)null, "Quaternion");
				val2.Enable();
				val3.Enable();
				TrackedPoseDriver val4 = ((Component)component).gameObject.AddComponent<TrackedPoseDriver>();
				val4.trackingType = (TrackingType)0;
				val4.updateType = (UpdateType)0;
				val4.positionInput = new InputActionProperty(val2);
				val4.rotationInput = new InputActionProperty(val3);
				VRRender.DisableXRVisibilityMesh();
				VRRender.DisableBrokenAO();
				((Component)component).gameObject.AddComponent<VRStereoCulling>();
				((Component)component).gameObject.AddComponent<VRTunneling>();
				val.AddComponent<VRHeadRig>();
				val.AddComponent<VRMenuManager>();
				val.AddComponent<VRInteractPrompt>();
				val.AddComponent<VRShoulderTwist>();
				val.AddComponent<VRHeadRoll>();
				val.AddComponent<VRItemAim>();
				val.AddComponent<VRNetSync>();
				val.AddComponent<VRControllerHud>();
				val.AddComponent<VREmoteWheel>();
				VRHands.Create(val.transform);
				RenderDiagnostics.ApplyLodBias();
				RenderDiagnostics.ScheduleScan();
				if (Plugin.DebugButtons || Plugin.Config.EnableVerboseLogging.Value)
				{
					UrpDiagnostics.DumpOnce();
				}
				ForceKeyboardMouseScheme();
				Plugin.Log.LogInfo((object)"[PeakVR] In-game VR camera rig created");
			}
		}

		private static void ForceKeyboardMouseScheme()
		{
			try
			{
				PlayerInput val = Object.FindObjectOfType<PlayerInput>();
				if (!((Object)(object)val == (Object)null) && Keyboard.current != null)
				{
					if (Mouse.current != null)
					{
						val.SwitchCurrentControlScheme("Keyboard&Mouse", (InputDevice[])(object)new InputDevice[2]
						{
							(InputDevice)Keyboard.current,
							(InputDevice)Mouse.current
						});
					}
					else
					{
						val.SwitchCurrentControlScheme("Keyboard&Mouse", (InputDevice[])(object)new InputDevice[1] { (InputDevice)Keyboard.current });
					}
					Plugin.Log.LogInfo((object)"[PeakVR] Forced control scheme to Keyboard&Mouse");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[PeakVR] Could not force Keyboard&Mouse scheme: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(CharacterInput), "Sample")]
	internal static class InteractionInputPatch
	{
		private const float ScrollOn = 0.6f;

		private const float ScrollOff = 0.4f;

		private const float ScrollRepeat = 0.18f;

		private static int scrollDir;

		private static float scrollTickTime;

		private static bool crouchToggle;

		[HarmonyPostfix]
		private static void Postfix(CharacterInput __instance, bool playerMovementActive)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.input != (Object)(object)__instance || VRControls.RightGrip == null)
			{
				return;
			}
			if ((Object)(object)localCharacter.data != (Object)null && localCharacter.data.fullyPassedOut)
			{
				crouchToggle = false;
				if (VRControls.LeftPrimary.WasPressedThisFrame())
				{
					__instance.spectateLeftWasPressed = true;
				}
				if (VRControls.RightPrimary.WasPressedThisFrame())
				{
					__instance.spectateRightWasPressed = true;
				}
				float y = VRControls.TurnStick.ReadValue<Vector2>().y;
				if (y > 0.5f)
				{
					__instance.scrollForwardIsPressed = true;
				}
				else if (y < -0.5f)
				{
					__instance.scrollBackwardIsPressed = true;
				}
			}
			Inject(VRControls.RightGrip, ref __instance.interactWasPressed, ref __instance.interactIsPressed, ref __instance.interactWasReleased);
			Inject(VRControls.LeftGrip, ref __instance.dropWasPressed, ref __instance.dropIsPressed, ref __instance.dropWasReleased);
			__instance.jumpWasPressed = false;
			__instance.jumpIsPressed = false;
			if (VRControls.RightPrimary.WasPressedThisFrame())
			{
				__instance.jumpWasPressed = true;
			}
			if (VRControls.RightPrimary.IsPressed())
			{
				__instance.jumpIsPressed = true;
			}
			if (VRControls.Stash.WasPressedThisFrame())
			{
				__instance.pingWasPressed = true;
			}
			if (VRControls.RightSecondary.WasPressedThisFrame())
			{
				__instance.unselectSlotWasPressed = true;
			}
			__instance.pauseWasPressed = false;
			if (VRControls.Pause.WasPressedThisFrame())
			{
				__instance.pauseWasPressed = true;
				__instance.jumpWasPressed = false;
				__instance.jumpIsPressed = false;
			}
			if (VREmoteWheel.EmoteActive)
			{
				__instance.emoteIsPressed = true;
			}
			if (!playerMovementActive)
			{
				return;
			}
			if (!VREmoteWheel.RightTriggerConsumed)
			{
				Inject(VRControls.RightTrigger, ref __instance.usePrimaryWasPressed, ref __instance.usePrimaryIsPressed, ref __instance.usePrimaryWasReleased);
			}
			if (!VRControllerHud.LeftTriggerConsumed)
			{
				Inject(VRControls.LeftTrigger, ref __instance.useSecondaryWasPressed, ref __instance.useSecondaryIsPressed, ref __instance.useSecondaryWasReleased);
			}
			if (VRControls.Sprint.WasPressedThisFrame())
			{
				__instance.sprintWasPressed = true;
			}
			if (VRControls.Sprint.IsPressed())
			{
				__instance.sprintIsPressed = true;
			}
			if (VRControls.LeftPrimary.WasPressedThisFrame())
			{
				if (crouchToggle || VRHeadRig.Crouching)
				{
					crouchToggle = false;
					VRHeadRig.RequestRecalibrate();
				}
				else
				{
					crouchToggle = true;
				}
			}
			if (VRHeadRig.Crouching || crouchToggle)
			{
				__instance.crouchIsPressed = true;
			}
			InjectScroll(__instance);
		}

		private static void InjectScroll(CharacterInput input)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			float y = VRControls.TurnStick.ReadValue<Vector2>().y;
			int num = ((y > 0.6f) ? 1 : ((y < -0.6f) ? (-1) : 0));
			if (scrollDir != 0 && Mathf.Abs(y) < 0.4f)
			{
				scrollDir = 0;
			}
			if (num == 0)
			{
				return;
			}
			if (num > 0)
			{
				input.scrollForwardIsPressed = true;
			}
			else
			{
				input.scrollBackwardIsPressed = true;
			}
			float time = Time.time;
			if (num != scrollDir || time - scrollTickTime >= 0.18f)
			{
				scrollDir = num;
				scrollTickTime = time;
				if (num > 0)
				{
					input.scrollForwardWasPressed = true;
				}
				else
				{
					input.scrollBackwardWasPressed = true;
				}
			}
		}

		private static void Inject(InputAction action, ref bool wasPressed, ref bool isPressed, ref bool wasReleased)
		{
			if (action.WasPressedThisFrame())
			{
				wasPressed = true;
			}
			if (action.IsPressed())
			{
				isPressed = true;
			}
			if (action.WasReleasedThisFrame())
			{
				wasReleased = true;
			}
		}
	}
	internal static class ItemAim
	{
		public static bool Enabled = true;

		private static Transform proxy;

		public static Transform Get()
		{
			//IL_008a: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			Transform result = (((Object)(object)MainCamera.instance != (Object)null) ? ((Component)MainCamera.instance).transform : null);
			if (!Enabled)
			{
				return result;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data.currentItem == (Object)null)
			{
				return result;
			}
			if (!VRAim.TryRight(out var origin, out var direction))
			{
				return result;
			}
			if ((Object)(object)proxy == (Object)null)
			{
				proxy = new GameObject("PeakVR ItemAim").transform;
				Object.DontDestroyOnLoad((Object)(object)((Component)proxy).gameObject);
			}
			proxy.SetPositionAndRotation(origin, Quaternion.LookRotation(direction));
			return proxy;
		}

		public static Ray GetMiddleScreenRay()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Transform val = Get();
			if ((Object)(object)val == (Object)null)
			{
				return new Ray(Vector3.zero, Vector3.forward);
			}
			return new Ray(val.position, val.forward);
		}
	}
	[HarmonyPatch]
	internal static class ItemAimRedirectPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			(Type, string)[] array = new(Type, string)[13]
			{
				(typeof(RopeShooter), "OnPrimaryFinishedCast"),
				(typeof(RopeShooter), "WillAttach"),
				(typeof(VineShooter), "OnPrimaryFinishedCast"),
				(typeof(VineShooter), "WillAttach"),
				(typeof(RescueHook), "GetHit"),
				(typeof(RopeTier), "Update"),
				(typeof(Action_RaycastDart), "RunAction"),
				(typeof(Action_RaycastDart), "FireDart"),
				(typeof(Constructable), "Update"),
				(typeof(Constructable), "TryUpdatePreview"),
				(typeof(Constructable), "CreateOrMovePreview"),
				(typeof(CharacterItems), "RaycastClimbingSpikeStart"),
				(typeof(CharacterItems), "WithinClimbingSpikePreviewRange")
			};
			(Type type, string method)[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				(Type type, string method) tuple = array2[i];
				Type item = tuple.type;
				string item2 = tuple.method;
				MethodInfo methodInfo = AccessTools.Method(item, item2, (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					yield return methodInfo;
				}
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo operand = AccessTools.Method(typeof(ItemAim), "Get", (Type[])null, (Type[])null);
			MethodInfo operand2 = AccessTools.Method(typeof(ItemAim), "GetMiddleScreenRay", (Type[])null, (Type[])null);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldsfld && val.operand is FieldInfo { Name: "instance" } fieldInfo && fieldInfo.DeclaringType == typeof(MainCamera) && i + 1 < list.Count && list[i + 1].operand is MethodInfo { Name: "get_transform" })
				{
					val.opcode = OpCodes.Call;
					val.operand = operand;
					list[i + 1].opcode = OpCodes.Nop;
					list[i + 1].operand = null;
				}
				else if (val.operand is MethodInfo { Name: "GetMiddleScreenRay" })
				{
					val.opcode = OpCodes.Call;
					val.operand = operand2;
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(CharacterAnimations), "Update")]
	internal static class LegAnimationPatch
	{
		private static readonly int InputX = Animator.StringToHash("Input X");

		private static readonly int InputY = Animator.StringToHash("Input Y");

		private const float VelocityScale = 0.5f;

		private const float Damp = 0.1f;

		[HarmonyPostfix]
		private static void Postfix(CharacterAnimations __instance)
		{
			//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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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)
			if (!VRHeadRig.RoomMoving)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.refs.animations != (Object)(object)__instance)
			{
				return;
			}
			Animator animator = localCharacter.refs.animator;
			if (!((Object)(object)animator == (Object)null))
			{
				Vector3 lookDirection = localCharacter.data.lookDirection;
				lookDirection.y = 0f;
				if (!(((Vector3)(ref lookDirection)).sqrMagnitude < 0.0001f))
				{
					((Vector3)(ref lookDirection)).Normalize();
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(lookDirection.z, 0f, 0f - lookDirection.x);
					Vector3 avarageVelocity = localCharacter.data.avarageVelocity;
					avarageVelocity.y = 0f;
					float num = Mathf.Clamp(Vector3.Dot(avarageVelocity, lookDirection) * 0.5f, -1f, 1f);
					float num2 = Mathf.Clamp(Vector3.Dot(avarageVelocity, val) * 0.5f, -1f, 1f);
					animator.SetFloat(InputX, num2, 0.1f, Time.deltaTime);
					animator.SetFloat(InputY, num, 0.1f, Time.deltaTime);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class LensFlareMultipassPatch
	{
		private static readonly FieldInfo MultipassIdField = typeof(XRPass).GetField("<multipassId>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

		private static IEnumerable<MethodBase> TargetMethods()
		{
			return AccessTools.GetDeclaredMethods(typeof(LensFlareCommonSRP)).Where(delegate(MethodInfo m)
			{
				string name = m.Name;
				return ((name == "ComputeOcclusion" || name == "DoLensFlareDataDrivenCommon") ? true : false) && m.GetParameters().Any((ParameterInfo p) => p.ParameterType == typeof(XRPass) && p.Name == "xr");
			});
		}

		[HarmonyPrefix]
		private static void Prefix(XRPass xr, ref int __state)
		{
			__state = -1;
			if (!(MultipassIdField == null) && xr != null && xr.enabled && !xr.singlePassEnabled)
			{
				int multipassId = xr.multipassId;
				if (multipassId != 0)
				{
					__state = multipassId;
					MultipassIdField.SetValue(xr, 0);
				}
			}
		}

		[HarmonyPostfix]
		private static void Postfix(XRPass xr, int __state)
		{
			if (__state >= 0)
			{
				MultipassIdField.SetValue(xr, __state);
			}
		}
	}
	[HarmonyPatch(typeof(MainCamera), "Awake")]
	internal static class MainCameraPatch
	{
		private static readonly string[] MenuScenes = new string[3] { "Title", "MainMenu", "Pretitle" };

		[HarmonyPostfix]
		private static void Postfix(MainCamera __instance)
		{
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (Array.IndexOf(MenuScenes, name) >= 0)
			{
				Camera component = ((Component)__instance).GetComponent<Camera>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)((Component)component).GetComponent<TrackedPoseDriver>() != (Object)null))
				{
					component.stereoTargetEye = (StereoTargetEyeMask)3;
					component.nearClipPlane = 0.05f;
					GameObject val = new GameObject("PeakVR Camera Rig");
					val.transform.SetPositionAndRotation(((Component)component).transform.position, ((Component)component).transform.rotation);
					((Component)component).transform.SetParent(val.transform, false);
					((Component)component).transform.localPosition = Vector3.zero;
					((Component)component).transform.localRotation = Quaternion.identity;
					TrackedPoseDriver val2 = ((Component)component).gameObject.AddComponent<TrackedPoseDriver>();
					val2.SetPoseSource((DeviceType)0, (TrackedPose)2);
					val2.trackingType = (TrackingType)0;
					val2.updateType = (UpdateType)0;
					VRRender.DisableXRVisibilityMesh();
					VRRender.DisableBrokenAO();
					((Component)component).gameObject.AddComponent<VRStereoCulling>();
					VRControllers.CreateLasers(val.transform);
					Plugin.Log.LogInfo((object)$"[PeakVR] Menu VR camera ready in '{name}', rig at {val.transform.position}");
				}
			}
		}
	}
	[HarmonyPatch(typeof(MainMenu), "Start")]
	internal static class MenuCanvasPatch
	{
		private const float Scale = 0.003f;

		private const float Distance = 4f;

		private const float Height = 0.6f;

		internal static Canvas MenuCanvas;

		internal static TrackedDeviceGraphicRaycaster MenuRaycaster;

		[HarmonyPostfix]
		private static void Postfix(MainMenu __instance)
		{
			//IL_007c: 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_00ec: 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_00f1: 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_0100: Expected O, but got Unknown
			//IL_0102: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInChildren = ((Component)__instance).GetComponentInChildren<Canvas>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[PeakVR] Menu canvas not found");
				return;
			}
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			componentInChildren.renderMode = (RenderMode)2;
			componentInChildren.worldCamera = val;
			TrackedDeviceGraphicRaycaster val2 = ((Component)componentInChildren).GetComponent<TrackedDeviceGraphicRaycaster>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)componentInChildren).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			}
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				new GameObject("PeakVR EventSystem").AddComponent<EventSystem>();
			}
			MenuCanvas = componentInChildren;
			MenuRaycaster = val2;
			VRPointer.Canvas = componentInChildren;
			VRPointer.Raycaster = val2;
			if ((Object)(object)((Component)__instance).GetComponent<VRMenuPopup>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<VRMenuPopup>();
			}
			Transform transform = ((Component)val).transform;
			Vector3 val3 = transform.forward;
			val3.y = 0f;
			val3 = ((((Vector3)(ref val3)).sqrMagnitude < 0.001f) ? transform.forward : ((Vector3)(ref val3)).normalized);
			RectTransform val4 = (RectTransform)((Component)componentInChildren).transform;
			((Transform)val4).localScale = Vector3.one * 0.003f;
			((Transform)val4).position = transform.position + val3 * 4f + Vector3.up * 0.6f;
			((Transform)val4).rotation = Quaternion.LookRotation(val3, Vector3.up);
			Plugin.Log.LogInfo((object)$"[PeakVR] Menu canvas -> world space at {((Transform)val4).position} (scale {0.003f})");
		}
	}
	[HarmonyPatch(typeof(Mirror), "Start")]
	internal static class MirrorPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Mirror __instance)
		{
			if (Plugin.VrEnabled && !((Object)(object)__instance.mirrorCamera == (Object)null))
			{
				int num = LayerMask.NameToLayer("UI");
				if (num >= 0)
				{
					Camera mirrorCamera = __instance.mirrorCamera;
					mirrorCamera.cullingMask &= ~(1 << num);
				}
				Plugin.Log.LogInfo((object)"[PeakVR] Mirror camera set to exclude VR UI + tunneling layer");
			}
		}
	}
	[HarmonyPatch(typeof(CharacterInput), "Sample")]
	internal static class MovementInputPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterInput __instance, bool playerMovementActive)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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)
			if (!playerMovementActive || VRControls.MoveStick == null)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)localCharacter.input != (Object)(object)__instance))
			{
				Vector2 val = VRControls.MoveStick.ReadValue<Vector2>() + VRHeadRig.RoomInput;
				if (((Vector2)(ref val)).sqrMagnitude > 0.02f)
				{
					__instance.movementInput = Vector2.ClampMagnitude(val, 1f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(NavigationContainerHandler), "LateUpdate")]
	internal static class NavigationDeselectPatch
	{
		private static readonly MethodInfo ClearOldFrames = AccessTools.Method(typeof(NavigationContainerHandler), "ClearOldFrames", (Type[])null, (Type[])null);

		[HarmonyPrefix]
		private static bool Prefix(NavigationContainerHandler __instance)
		{
			if (!Plugin.VrEnabled)
			{
				return true;
			}
			ClearOldFrames?.Invoke(__instance, null);
			EventSystem current = EventSystem.current;
			if ((Object)(object)current != (Object)null && (Object)(object)current.currentSelectedGameObject != (Object)null && (Object)(object)current.currentSelectedGameObject.GetComponent<TMP_InputField>() == (Object)null)
			{
				current.SetSelectedGameObject((GameObject)null);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterItems))]
	internal static class OneHandedHoldPatch
	{
		public static bool Enabled = true;

		private static readonly MethodInfo GetPosRight = AccessTools.Method(typeof(CharacterItems), "GetItemPosRightWorld", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetRotRight = AccessTools.Method(typeof(CharacterItems), "GetItemRotRightWorld", (Type[])null, (Type[])null);

		[HarmonyPatch("AttachItem")]
		[HarmonyPrefix]
		private static bool AttachItemPrefix(CharacterItems __instance, Item item)
		{
			//IL_0061: 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)
			if (!ShouldApply(__instance) || (Object)(object)item == (Object)null || GetPosRight == null || GetRotRight == null)
			{
				return true;
			}
			Rigidbody bodypartRig = __instance.character.GetBodypartRig((BodypartType)10);
			if ((Object)(object)bodypartRig == (Object)null)
			{
				return true;
			}
			((Component)bodypartRig).transform.position = (Vector3)GetPosRight.Invoke(__instance, new object[1] { item });
			((Component)bodypartRig).transform.rotation = (Quaternion)GetRotRight.Invoke(__instance, new object[1] { item });
			if ((Object)(object)item.rig != (Object)null)
			{
				((Joint)((Component)bodypartRig).gameObject.AddComponent<FixedJoint>()).connectedBody = item.rig;
			}
			return false;
		}

		[HarmonyPatch("UnAttachItem")]
		[HarmonyPrefix]
		private static bool UnAttachItemPrefix(CharacterItems __instance)
		{
			if (!ShouldApply(__instance))
			{
				return true;
			}
			DestroyHandJoint(__instance, (BodypartType)7);
			DestroyHandJoint(__instance, (BodypartType)10);
			return false;
		}

		private static void DestroyHandJoint(CharacterItems items, BodypartType part)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody bodypartRig = items.character.GetBodypartRig(part);
			FixedJoint val = default(FixedJoint);
			if (!((Object)(object)bodypartRig == (Object)null) && ((Component)bodypartRig).gameObject.TryGetComponent<FixedJoint>(ref val))
			{
				Object.Destroy((Object)(object)val);
			}
		}

		private static bool ShouldApply(CharacterItems items)
		{
			if (!Enabled || (Object)(object)items.character == (Object)null)
			{
				return false;
			}
			Character character = items.character;
			if ((Object)(object)character == (Object)(object)Character.localCharacter && (Object)(object)VRHands.Right != (Object)null)
			{
				return true;
			}
			return VRNetworking.IsActiveRemote(character);
		}
	}
	internal static class PeakAssets
	{
		private static AssetBundle bundle;

		public static Sprite Reticle { get; private set; }

		public static GameObject Controller { get; private set; }

		public static Texture2D Vignette { get; private set; }

		public static Shader MirrorView { get; private set; }

		public static Sprite EmoteButton { get; private set; }

		public static Sprite Logo { get; private set; }

		public static Sprite AboutButton { get; private set; }

		public static Sprite TPose { get; private set; }

		public static void Load()
		{
			if (!((Object)(object)bundle != (Object)null))
			{
				string text = Path.Combine(Path.GetDirectoryName(Plugin.Config.AssemblyPath), "peakvr");
				bundle = AssetBundle.LoadFromFile(text);
				if ((Object)(object)bundle == (Object)null)
				{
					Plugin.Log.LogError((object)("[PeakVR] Failed to load asset bundle at " + text));
					return;
				}
				Reticle = bundle.LoadAsset<Sprite>("reticlevr");
				Controller = bundle.LoadAsset<GameObject>("UniversalControllerWithAnchors") ?? bundle.LoadAsset<GameObject>("UniversalController");
				Vignette = bundle.LoadAsset<Texture2D>("vignette");
				MirrorView = bundle.LoadAsset<Shader>("XRMirrorView");
				EmoteButton = bundle.LoadAsset<Sprite>("ButtonEmote");
				Logo = bundle.LoadAsset<Sprite>("Logo");
				AboutButton = bundle.LoadAsset<Sprite>("SmallVRButton");
				TPose = bundle.LoadAsset<Sprite>("TPoseWhite");
				Plugin.Log.LogInfo((object)$"[PeakVR] Bundle loaded (reticle={(Object)(object)Reticle != (Object)null}, controller={(Object)(object)Controller != (Object)null}, vignette={(Object)(object)Vignette != (Object)null}, mirror={(Object)(object)MirrorView != (Object)null})");
				Plugin.Log.LogInfo((object)$"[PeakVR] Sprites (emote={(Object)(object)EmoteButton != (Object)null}, logo={(Object)(object)Logo != (Object)null}, about={(Object)(object)AboutButton != (Object)null}, tpose={(Object)(object)TPose != (Object)null})");
			}
		}
	}
	[HarmonyPatch(typeof(PointPinger), "TryGetPingHit")]
	internal static class PingRedirectPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(ref bool __result, out RaycastHit hit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			hit = default(RaycastHit);
			if (!Plugin.VrEnabled || !VRAim.TryRight(out var origin, out var direction))
			{
				return true;
			}
			LayerMask mask = HelperFunctions.GetMask((LayerType)1);
			__result = Physics.Raycast(origin, direction, ref hit, 2000f, LayerMask.op_Implicit(mask));
			return false;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.andrey04o.PeakVR", "PeakVR", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private int mirrorFrame;

		private bool anyKeyBound;

		public const string Id = "com.andrey04o.PeakVR";

		internal static ManualLogSource Log { get; private set; } = null;

		public static Config Config { get; private set; }

		public static bool VrEnabled { get; private set; } = true;

		public static bool DebugButtons { get; private set; }

		public static string Name => "PeakVR";

		public static string Version => "1.0.0";

		private void Awake()
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			Application.runInBackground = true;
			typeof(InputSystem).GetMethod("PerformDefaultPluginInitialization", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, null);
			ButtonFallbackComposite.Initialize();
			IntegerFallbackComposite.Initialize();
			QuaternionFallbackComposite.Initialize();
			Vector3FallbackComposite.Initialize();
			SectorInteraction.Initialize();
			Log = ((BaseUnityPlugin)this).Logger;
			Logger.SetSource(((BaseUnityPlugin)this).Logger);
			Config = new Config(((BaseUnityPlugin)this).Info.Location, ((BaseUnityPlugin)this).Config);
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			bool flag = commandLineArgs.Contains<string>("--disable-vr", StringComparer.OrdinalIgnoreCase);
			DebugButtons = commandLineArgs.Contains<string>("-vr-debugbuttons", StringComparer.OrdinalIgnoreCase);
			VRNetworking.CreateReceiver();
			PeakAssets.Load();
			if (flag)
			{
				VrEnabled = false;
				ApplyRemoteOnlyPatches();
				Log.LogWarning((object)"[PeakVR] VR disabled by the '--disable-vr' command line flag — running in flat (non-VR) mode; only remote-VR-render patches applied.");
				Log.LogInfo((object)("Plugin " + Name + " is loaded (VR disabled)!"));
				return;
			}
			if (!PreloadRuntimeDependencies())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because required runtime dependencies could not be loaded!");
				return;
			}
			if (!InitializeVR())
			{
				VrEnabled = false;
				ApplyRemoteOnlyPatches();
				Log.LogWarning((object)"[PeakVR] VR failed to initialize (no headset or OpenXR runtime?) — running in flat (non-VR) mode; only remote-VR-render patches applied.");
				Log.LogInfo((object)("Plugin " + Name + " is loaded (VR unavailable)!"));
				return;
			}
			VRRender.DisableXRVisibilityMesh();
			PeakAssets.Load();
			XRMirror.Setup();
			VRControls.Init();
			new Harmony("com.andrey04o.PeakVR").PatchAll(typeof(Plugin).Assembly);
			VRArmIKPatch.LoadArmScaleFromConfig();
			try
			{
				VRCalibration.Register();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[PeakVR] Calibration menu unavailable (PEAKLib.UI missing?): " + ex.Message));
			}
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private void Update()
		{
			if (DebugButtons && Keyboard.current != null)
			{
				HandleDebugKeys();
			}
			if (VrEnabled)
			{
				TryBindAnyKey();
				mirrorFrame++;
				if (mirrorFrame % 300 == 0)
				{
					XRMirror.Assert();
				}
			}
		}

		private void TryBindAnyKey()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (anyKeyBound)
			{
				return;
			}
			InputActionAsset actions = InputSystem.actions;
			if ((Object)(object)actions == (Object)null)
			{
				return;
			}
			InputAction val = actions.FindAction("AnyKey", false);
			if (val == null)
			{
				return;
			}
			anyKeyBound = true;
			try
			{
				bool enabled = actions.enabled;
				if (enabled)
				{
					actions.Disable();
				}
				InputActionSetupExtensions.AddBinding(val, "<XRController>{RightHand}/triggerPressed", (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val, "<XRController>{LeftHand}/triggerPressed", (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val, "<XRController>{RightHand}/primaryButton", (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val, "<XRController>{RightHand}/secondaryButton", (string)null, (string)null, (string)null);
				if (enabled)
				{
					actions.Enable();
				}
				Log.LogInfo((object)"[PeakVR] AnyKey bound to VR buttons (credits skip)");
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[PeakVR] AnyKey bind failed: " + ex.Message));
			}
		}

		private static void HandleDebugKeys()
		{
			Keyboard current = Keyboard.current;
			if (((ButtonControl)current.f1Key).wasPressedThisFrame)
			{
				DumpCanvases();
			}
			if (((ButtonControl)current.f2Key).wasPressedThisFrame)
			{
				UrpDiagnostics.Dump();
			}
			if (((ButtonControl)current.f3Key).wasPressedThisFrame)
			{
				UrpDiagnostics.CycleTestMode();
			}
			if (((ButtonControl)current.lKey).wasPressedThisFrame)
			{
				RenderDiagnostics.Toggle();
			}
			if (((ButtonControl)current.f4Key).wasPressedThisFrame)
			{
				UIOverlay.SetLogging(!UIOverlay.Logging);
			}
			if (((ButtonControl)current.f9Key).wasPressedThisFrame)
			{
				float num = VRStereoCulling.Margin - 0.1f;
				VRStereoCulling.Margin = ((num < 1f) ? 1f : num);
				Log.LogInfo((object)$"[PeakVR] StereoCulling Margin = {VRStereoCulling.Margin:F2}");
			}
			if (((ButtonControl)current.f10Key).wasPressedThisFrame)
			{
				VRStereoCulling.Margin += 0.1f;
				Log.LogInfo((object)$"[PeakVR] StereoCulling Margin = {VRStereoCulling.Margin:F2}");
			}
			if (((ButtonControl)current.f11Key).wasPressedThisFrame)
			{
				VRStereoCulling.DisableOcclusion = !VRStereoCulling.DisableOcclusion;
				Log.LogInfo((object)("[PeakVR] Occlusion culling " + (VRStereoCulling.DisableOcclusion ? "DISABLED" : "ENABLED")));
			}
			if (((ButtonControl)current.f12Key).wasPressedThisFrame && (Object)(object)MainCamera.instance != (Object)null)
			{
				RenderDiagnostics.LogLookedAt(MainCamera.instance.cam);
			}
		}

		private static void DumpCanvases()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Log.LogInfo((object)"[PeakVR][Canvas] ===== active canvases =====");
			Canvas[] array = Object.FindObjectsByType<Canvas>((FindObjectsSortMode)0);
			foreach (Canvas val in array)
			{
				Log.LogInfo((object)$"[PeakVR][Canvas] mode={val.renderMode} sort={val.sortingOrder} enabled={((Behaviour)val).isActiveAndEnabled} path={CanvasPath(((Component)val).transform)}");
			}
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Log.LogInfo((object)"[PeakVR][HUD] ===== hud elements =====");
			Log.LogInfo((object)("[PeakVR][HUD] staminaGroup=" + CanvasPath(((Object)(object)instance.staminaCanvasGroup != (Object)null) ? ((Component)instance.staminaCanvasGroup).transform : null)));
			Log.LogInfo((object)("[PeakVR][HUD] bar=" + CanvasPath(((Object)(object)instance.bar != (Object)null) ? ((Component)instance.bar).transform : null)));
			if (instance.items != null)
			{
				for (int j = 0; j < instance.items.Length; j++)
				{
					Log.LogInfo((object)$"[PeakVR][HUD] item[{j}]={CanvasPath(((Object)(object)instance.items[j] != (Object)null) ? ((Component)instance.items[j]).transform : null)}");
				}
			}
			Log.LogInfo((object)("[PeakVR][HUD] backpack=" + CanvasPath(((Object)(object)instance.backpack != (Object)null) ? ((Component)instance.backpack).transform : null)));
			Log.LogInfo((object)("[PeakVR][HUD] temporaryItem=" + CanvasPath(((Object)(object)instance.temporaryItem != (Object)null) ? ((Component)instance.temporaryItem).transform : null)));
		}

		private static string CanvasPath(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return "<null>";
			}
			string text = ((Object)t).name;
			while ((Object)(object)t.parent != (Object)null)
			{
				t = t.parent;
				text = ((Object)t).name + "/" + text;
			}
			return text;
		}

		private static void ApplyRemoteOnlyPatches()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("com.andrey04o.PeakVR");
			val.CreateClassProcessor(typeof(RemoteIKPatch)).Patch();
			val.CreateClassProcessor(typeof(OneHandedHoldPatch)).Patch();
			val.CreateClassProcessor(typeof(AboutButtonPatch)).Patch();
		}

		private bool PreloadRuntimeDependencies()
		{
			try
			{
				string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "RuntimeDeps");
				HashSet<string> loaded = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				string versionSpecificDeps = GetVersionSpecificDeps(text);
				if (versionSpecificDeps != null)
				{
					PreloadFromFolder(versionSpecificDeps, loaded);
				}
				PreloadFromFolder(text, loaded);
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Unexpected error occured while preloading runtime dependencies (incorrect folder structure?): " + ex.Message));
				return false;
			}
			return true;
		}

		private string GetVersionSpecificDeps(string deps)
		{
			string unityVersion = Application.unityVersion;
			string text = (unityVersion.StartsWith("6000.") ? ("6." + unityVersion.Substring("6000.".Length)) : unityVersion);
			string text2 = Path.Combine(deps, text);
			if (Directory.Exists(text2))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Unity " + unityVersion + ": using version-specific RuntimeDeps folder '" + text + "'"));
				return text2;
			}
			return null;
		}

		private void PreloadFromFolder(string folder, HashSet<string> loaded)
		{
			string[] files = Directory.GetFiles(folder, "*.dll");
			foreach (string path in files)
			{
				string fileName = Path.GetFileName(path);
				bool flag = ((fileName == "UnityOpenXR.dll" || fileName == "openxr_loader.dll") ? true : false);
				if (!flag && loaded.Add(fileName))
				{
					((BaseUnityPlugin)this).Logger.LogDebug((object)("Preloading '" + fileName + "'..."));
					try
					{
						Assembly.LoadFile(path);
					}
					catch (Exception ex)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to preload '" + fileName + "': " + ex.Message));
					}
				}
			}
		}

		private static bool InitializeVR()
		{
			Logger.LogInfo("Loading VR...");
			if (!OpenXR.Loader.InitializeXR())
			{
				Logger.LogError("Failed to start in VR Mode! Only Non-VR features are available!");
				Logger.LogWarning("You may ignore the previous error if you are intending to play without VR");
				return false;
			}
			if (OpenXR.GetActiveRuntimeName(out string name) && OpenXR.GetActiveRuntimeVersion(out var major, out var minor, out var patch))
			{
				Logger.LogInfo($"OpenXR runtime being used: {name} ({major}.{minor}.{patch})");
			}
			else
			{
				Logger.LogError("Could not get OpenXR runtime info?");
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterAnimations), "ConfigureIK")]
	internal static class RemoteIKPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAnimations __instance)
		{
			Character character = __instance.character;
			if ((Object)(object)character == (Object)null || (Object)(object)character == (Object)(object)Character.localCharacter)
			{
				return true;
			}
			return !VRNetworking.IsActiveRemote(character);
		}
	}
	internal static class RenderDiagnostics
	{
		private struct BigLod
		{
			public LODGroup group;

			public float[] thresholds;

			public Vector3 localRef;

			public float worldSize;

			public int lastLevel;
		}

		public static bool Enabled = true;

		private static readonly List<BigLod> bigLods = new List<BigLod>();

		private static readonly HashSet<LODGroup> tracked = new HashSet<LODGroup>();

		private static float nextScan;

		private static int cursor;

		private const float LodBias = 2.5f;

		private const float ScanInterval = 3f;

		private const int SpreadFrames = 4;

		public static void ApplyLodBias()
		{
			float lodBias = QualitySettings.lodBias;
			QualitySettings.lodBias = Mathf.Max(lodBias, 2.5f);
			QualitySettings.maximumLODLevel = 0;
			Plugin.Log.LogInfo((object)$"[PeakVR] lodBias {lodBias} -> {QualitySettings.lodBias}");
		}

		public static void ScheduleScan()
		{
			tracked.Clear();
			bigLods.Clear();
			nextScan = 0f;
		}

		public static void Tick(Camera cam)
		{
			if (Enabled)
			{
				if (Time.time >= nextScan)
				{
					nextScan = Time.time + 3f;
					Rescan();
				}
				ForceLods(cam);
			}
		}

		public static void Toggle()
		{
			Enabled = !Enabled;
			if (!Enabled)
			{
				foreach (BigLod bigLod in bigLods)
				{
					if ((Object)(object)bigLod.group != (Object)null)
					{
						bigLod.group.ForceLOD(-1);
					}
					else
					{
						ScheduleScan();
					}
				}
			}
			Plugin.Log.LogInfo((object)("[PeakVR] LOD forcing " + (Enabled ? "ENABLED" : "DISABLED (automatic per-eye LOD)")));
		}

		private static void Rescan()
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0158: 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)
			for (int num = bigLods.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)bigLods[num].group == (Object)null)
				{
					bigLods.RemoveAt(num);
				}
			}
			tracked.RemoveWhere((LODGroup g) => (Object)(object)g == (Object)null);
			LODGroup[] array = Object.FindObjectsByType<LODGroup>((FindObjectsSortMode)0);
			int num2 = 0;
			LODGroup[] array2 = array;
			foreach (LODGroup val in array2)
			{
				if ((Object)(object)val == (Object)null || !tracked.Add(val))
				{
					continue;
				}
				val.fadeMode = (LODFadeMode)0;
				val.animateCrossFading = false;
				LOD[] lODs = val.GetLODs();
				if (lODs.Length != 0)
				{
					float[] array3 = new float[lODs.Length];
					for (int num4 = 0; num4 < lODs.Length; num4++)
					{
						array3[num4] = lODs[num4].screenRelativeTransitionHeight;
					}
					Vector3 lossyScale = ((Component)val).transform.lossyScale;
					float num5 = Mathf.Max(new float[3]
					{
						Mathf.Abs(lossyScale.x),
						Mathf.Abs(lossyScale.y),
						Mathf.Abs(lossyScale.z)
					});
					bigLods.Add(new BigLod
					{
						group = val,
						thresholds = array3,
						localRef = val.localReferencePoint,
						worldSize = val.size * num5,
						lastLevel = -2
					});
					num2++;
				}
			}
			if (num2 > 0)
			{
				Plugin.Log.LogInfo((object)$"[PeakVR] LOD scan: +{num2} new (driving {bigLods.Count})");
			}
		}

		public static void LogLookedAt(Camera cam)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cam == (Object)null)
			{
				return;
			}
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(((Component)cam).transform.position, ((Component)cam).transform.forward, ref val, 60f, -1, (QueryTriggerInteraction)1))
			{
				Plugin.Log.LogInfo((object)"[PeakVR][LODdbg] no raycast hit");
				return;
			}
			Plugin.Log.LogInfo((object)$"[PeakVR][LODdbg] hit path='{Path(((Component)((RaycastHit)(ref val)).collider).transform)}' dist={((RaycastHit)(ref val)).distance:F1}");
			LODGroup componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<LODGroup>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				Plugin.Log.LogInfo((object)"[PeakVR][LODdbg]   NO LODGroup in parents of the hit object");
				return;
			}
			LogGroup(componentInParent, cam, "HIT");
			LODGroup[] componentsInChildren = ((Component)((Component)componentInParent).transform).GetComponentsInChildren<LODGroup>(true);
			foreach (LODGroup val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)(object)componentInParent)
				{
					LogGroup(val2, cam, "child");
				}
			}
		}

		private static void LogGroup(LODGroup g, Camera cam, string tag)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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)
			if ((Object)(object)g == (Object)null)
			{
				return;
			}
			LOD[] lODs = g.GetLODs();
			string text = "";
			for (int i = 0; i < lODs.Length; i++)
			{
				text += $"[L{i}:{lODs[i].renderers.Length}r@{lODs[i].screenRelativeTransitionHeight:F3}]";
			}
			Vector3 lossyScale = ((Component)g).transform.lossyScale;
			float num = Mathf.Max(new float[3]
			{
				Mathf.Abs(lossyScale.x),
				Mathf.Abs(lossyScale.y),
				Mathf.Abs(lossyScale.z)
			});
			float num2 = g.size * num;
			float num3 = Mathf.Tan(MathF.PI / 180f * cam.fieldOfView * 0.5f);
			float num4 = Vector3.Distance(((Component)cam).transform.position, ((Component)g).transform.TransformPoint(g.localReferencePoint));
			float num5 = ((num4 > 0.001f && num3 > 0f) ? (num2 * QualitySettings.lodBias / (2f * num4 * num3)) : (-1f));
			int num6 = -1;
			for (int j = 0; j < lODs.Length; j++)
			{
				if (num5 >= lODs[j].screenRelativeTransitionHeight)
				{
					num6 = j;
					break;
				}
			}
			Plugin.Log.LogInfo((object)($"[PeakVR][LODdbg]   [{tag}] '{((Object)g).name}' lods={lODs.Length} tracked={tracked.Contains(g)} enabled={g.enabled} " + $"fade={g.fadeMode} size={g.size:F2} dist={num4:F1} relH={num5:F3} ourLevel={num6} {text}"));
		}

		private static string Path(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null && num++ < 6)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static void ForceLods(Camera cam)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			int count = bigLods.Count;
			if ((Object)(object)cam == (Object)null || count == 0)
			{
				return;
			}
			float num = Mathf.Tan(MathF.PI / 180f * cam.fieldOfView * 0.5f);
			if (num <= 0f)
			{
				return;
			}
			float lodBias = QualitySettings.lodBias;
			Vector3 position = ((Component)cam).transform.position;
			int num2 = Mathf.CeilToInt((float)count / 4f);
			for (int i = 0; i < num2; i++)
			{
				if (cursor >= count)
				{
					cursor = 0;
				}
				int index = cursor++;
				BigLod value = bigLods[index];
				if ((Object)(object)value.group == (Object)null || !value.group.enabled || !((Component)value.group).gameObject.activeInHierarchy || value.thresholds.Length == 0)
				{
					continue;
				}
				float num3 = Vector3.Distance(position, ((Component)value.group).transform.TransformPoint(value.localRef));
				if (num3 <= 0.001f)
				{
					continue;
				}
				float num4 = value.worldSize * lodBias / (2f * num3 * num);
				int num5 = value.thresholds.Length - 1;
				for (int j = 0; j < value.thresholds.Length; j++)
				{
					if (num4 >= value.thresholds[j])
					{
						num5 = j;
						break;
					}
				}
				if (num5 != value.lastLevel)
				{
					value.group.ForceLOD(num5);
					value.lastLevel = num5;
					bigLods[index] = value;
				}
			}
		}
	}
	internal static class ShootableAim
	{
		public static bool RollEnabled = true;

		public static Vector3 RotationOffset = new Vector3(5f, 0f, -45f);

		public static bool IsShootableHeld()
		{
			Character localCharacter = Character.localCharacter;
			Item val = (((Object)(object)localCharacter != (Object)null) ? localCharacter.data.currentItem : null);
			if ((Object)(object)val != (Object)null)
			{
				return val.UIData.isShootable;
			}
			return false;
		}
	}
	internal static class UIOverlay
	{
		private static readonly int ZTestUI = Shader.PropertyToID("unity_GUIZTestMode");

		private static readonly int ZTestTMP = Shader.PropertyToID("_ZTestMode");

		private const int Always = 8;

		private const int DefaultQueue = 3000;

		private const int ForegroundQueue = 3005;

		public const int HandQueue = 4000;

		public const int ReticleQueue = 4200;

		private static readonly Dictionary<Graphic, Material> Cache = new Dictionary<Graphic, Material>();

		public static bool Logging;

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

		public static void SetLogging(bool on)
		{
			Logging = on;
			if (on)
			{
				Logged.Clear();
			}
			Plugin.Log.LogInfo((object)("[PeakVR][UIOrder] logging " + (on ? "ON" : "OFF")));
		}

		public static void MakeAlwaysVisible(Canvas canvas, bool foreground)
		{
			Apply(canvas, foreground ? 3005 : 3000);
		}

		public static void MakeAlwaysVisible(Canvas canvas, int baseQueue)
		{
			Apply(canvas, baseQueue);
		}

		public static void MakeTopmost(Graphic graphic, int queue)
		{
			if (!((Object)(object)graphic == (Object)null))
			{
				Material material = GetMaterial(graphic);
				if (!((Object)(object)material == (Object)null))
				{
					material.SetInt(ZTestUI, 8);
					material.SetInt(ZTestTMP, 8);
					material.renderQueue = queue;
				}
			}
		}

		private static void Apply(Canvas canvas, int baseQueue)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			bool flag = baseQueue != 3000;
			bool flag2 = Logging && Logged.Add(canvas);
			if (flag2)
			{
				Plugin.Log.LogInfo((object)$"[PeakVR][UIOrder] ===== {((Object)canvas).name} base={baseQueue} sorting={canvas.sortingOrder} mode={canvas.renderMode} =====");
			}
			Graphic[] componentsInChildren = ((Component)canvas).GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Graphic val = componentsInChildren[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material material = GetMaterial(val);
				if (!((Object)(object)material == (Object)null))
				{
					material.SetInt(ZTestUI, 8);
					material.SetInt(ZTestTMP, 8);
					if (flag)
					{
						material.renderQueue = baseQueue;
					}
					if (flag2)
					{
						Plugin.Log.LogInfo((object)$"[PeakVR][UIOrder] [{i,3}] q={material.renderQueue} stencil={(InStencilMask(val) ? 1 : 0)} rect={(InRectMask(val) ? 1 : 0)} {((object)val).GetType().Name} :: {Path(((Component)val).transform)}");
					}
				}
			}
		}

		private static Material GetMaterial(Graphic g)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (Cache.TryGetValue(g, out Material value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			TMP_Text val = (TMP_Text)(object)((g is TMP_Text) ? g : null);
			Material val2;
			if (val != null)
			{
				val2 = val.fontMaterial;
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
			}
			else
			{
				Material val3 = (((Object)(object)g.material != (Object)null) ? g.material : g.defaultMaterial);
				if ((Object)(object)val3 == (Object)null)
				{
					return null;
				}
				val2 = (g.material = new Material(val3));
			}
			Cache[g] = val2;
			return val2;
		}

		private static bool InStencilMask(Graphic g)
		{
			Mask componentInParent = ((Component)g).GetComponentInParent<Mask>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return ((Behaviour)componentInParent).enabled;
			}
			return false;
		}

		private static bool InRectMask(Graphic g)
		{
			RectMask2D componentInParent = ((Component)g).GetComponentInParent<RectMask2D>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return ((Behaviour)componentInParent).enabled;
			}
			return false;
		}

		private static string Path(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null && num++ < 8)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}
	}
	internal static class UrpDiagnostics
	{
		private const BindingFlags Any = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static bool dumped;

		private static int testMode;

		private static float baseRenderScale = -1f;

		public static void DumpOnce()
		{
			if (!dumped)
			{
				dumped = true;
				Dump();
			}
		}

		public static void Dump()
		{
			//IL_00a4: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ManualLogSource log = Plugin.Log;
				log.LogInfo((object)"[PeakVR][URP] ===== render settings dump =====");
				log.LogInfo((object)("[PeakVR][URP] unity=" + Application.unityVersion));
				RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
				log.LogInfo((object)("[PeakVR][URP] pipeline=" + (((Object)(object)currentRenderPipeline != (Object)null) ? (((Object)currentRenderPipeline).name + " (" + ((object)currentRenderPipeline).GetType().Name + ")") : "<null>")));
				log.LogInfo((object)($"[PeakVR][URP] quality: lodBias={QualitySettings.lodBias} maxLOD={QualitySettings.maximumLODLevel} " + $"pixelLights={QualitySettings.pixelLightCount} aa={QualitySettings.antiAliasing} shadows={QualitySettings.shadows} " + $"shadowDist={QualitySettings.shadowDistance} softParticles={QualitySettings.softParticles}"));
				log.LogInfo((object)($"[PeakVR][URP] lighting: ambientMode={RenderSettings.ambientMode} ambientIntensity={RenderSettings.ambientIntensity:F2} " + $"ambient={RenderSettings.ambientLight} fog={RenderSettings.fog} reflIntensity={RenderSettings.reflectionIntensity:F2}"));
				if ((Object)(object)currentRenderPipeline != (Object)null)
				{
					DumpProps(currentRenderPipeline, "asset", new string[14]
					{
						"supportsHDR", "msaaSampleCount", "renderScale", "upscalingFilter", "shadowDistance", "supportsMainLightShadows", "supportsAdditionalLightShadows", "supportsSoftShadows", "mainLightRenderingMode", "additionalLightsRenderingMode",
						"maxAdditionalLightsCount", "colorGradingMode", "colorGradingLutSize", "useSRPBatcher"
					});
					DumpRenderers(currentRenderPipeline);
				}
				DumpVolumes();
				log.LogInfo((object)"[PeakVR][URP] ===== end dump =====");
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"[PeakVR][URP] dump failed: {arg}");
			}
		}

		private static void DumpRenderers(object asset)
		{
			if (!(asset.GetType().GetField("m_RendererDataList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(asset) is Array array))
			{
				Plugin.Log.LogInfo((object)"[PeakVR][URP] (no m_RendererDataList field)");
				return;
			}
			for (int i = 0; i < array.Length; i++)
			{
				object value = array.GetValue(i);
				if (value == null)
				{
					continue;
				}
				object obj = ((value is Object) ? value : null);
				string arg = ((obj != null) ? ((Object)obj).name : null) ?? value.GetType().Name;
				Plugin.Log.LogInfo((object)($"[PeakVR][URP] renderer[{i}] '{arg}' type={value.GetType().Name} " + string.Format("renderingMode={0} depthPriming={1}", Member(value, "renderingMode"), Member(value, "depthPrimingMode"))));
				if (!(value.GetType().GetProperty("rendererFeatures", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(value) is IEnumerable enumerable))
				{
					continue;
				}
				foreach (object item in enumerable)
				{
					if (item == null)
					{
						Plugin.Log.LogInfo((object)"[PeakVR][URP]    feature=<null>");
						continue;
					}
					object obj2 = ((item is Object) ? item : null);
					string arg2 = ((obj2 != null) ? ((Object)obj2).name : null) ?? item.GetType().Name;
					Plugin.Log.LogInfo((object)string.Format("[PeakVR][URP]    feature '{0}' type={1} active={2}", arg2, item.GetType().Name, Member(item, "isActive")));
					string text = item.GetType().Name.ToLowerInvariant();
					if (text.Contains("occlusion") || text.Contains("ssao") || text.Contains("hbao") || text.Contains("gtao"))
					{
						DumpFields(Member(item, "m_Settings") ?? item, "settings");
					}
				}
			}
		}

		private static void DumpVolumes()
		{
			Volume[] array = Object.FindObjectsByType<Volume>((FindObjectsSortMode)0);
			Plugin.Log.LogInfo((object)$"[PeakVR][URP] volumes={array.Length} (active overrides per volume):");
			Volume[] array2 = array;
			foreach (Volume val in array2)
			{
				if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled || (Object)(object)val.profile == (Object)null)
				{
					continue;
				}
				List<string> list = new List<string>();
				foreach (VolumeComponent component in val.profile.components)
				{
					if ((Object)(object)component != (Object)null && component.active)
					{
						list.Add(((object)component).GetType().Name);
					}
				}
				if (list.Count != 0)
				{
					Plugin.Log.LogInfo((object)string.Format("[PeakVR][URP]   '{0}' global={1} pri={2} weight={3:F2} -> {4}", ((Object)val).name, val.isGlobal, val.priority, val.weight, string.Join(", ", list)));
				}
			}
		}

		private static void DumpProps(object obj, string tag, string[] names)
		{
			StringBuilder stringBuilder = new StringBuilder("[PeakVR][URP] " + tag + ":");
			foreach (string text in names)
			{
				object obj2 = Member(obj, text);
				if (obj2 != null)
				{
					stringBuilder.Append($" {text}={obj2}");
				}
			}
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}

		private static void DumpFields(object obj, string tag)
		{
			if (obj == null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder("[PeakVR][URP]       " + tag + ":");
			FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				object arg = null;
				try
				{
					arg = fieldInfo.GetValue(obj);
				}
				catch
				{
				}
				stringBuilder.Append($" {fieldInfo.Name}={arg}");
			}
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}

		public static void CycleTestMode()
		{
			testMode = (testMode + 1) % 4;
			SetFeatureActive("HBAO", testMode == 0);
			SetFeatureActive("EdgeDetection", testMode <= 1);
			SetRenderScaleOriginal(testMode <= 2);
			Plugin.Log.LogInfo((object)($"[PeakVR][URP] test mode {testMode}: " + "HBAO=" + ((testMode == 0) ? "on" : "OFF") + " EdgeDetection=" + ((testMode <= 1) ? "on" : "OFF") + " renderScale=" + ((testMode <= 2) ? "orig" : "1.0")));
		}

		public static void SetFeatureActive(string nameContains, bool active)
		{
			RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
			if ((Object)(object)currentRenderPipeline == (Object)null || !(((object)currentRenderPipeline).GetType().GetField("m_RendererDataList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(currentRenderPipeline) is Array array))
			{
				return;
			}
			foreach (object item in array)
			{
				if (item == null || !(item.GetType().GetProperty("rendererFeatures", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(item) is IEnumerable enumerable))
				{
					continue;
				}
				foreach (object item2 in enumerable)
				{
					if (item2 == null)
					{
						continue;
					}
					object obj = ((item2 is Object) ? item2 : null);
					string text = ((obj != null) ? ((Object)obj).name : null) ?? item2.GetType().Name;
					if (text.IndexOf(nameContains, StringComparison.OrdinalIgnoreCase) >= 0 || item2.GetType().Name.IndexOf(nameContains, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						MethodInfo method = item2.GetType().GetMethod("SetActive", new Type[1] { typeof(bool) });
						if (method != null)
						{
							method.Invoke(item2, new object[1] { active });
						}
						else
						{
							item2.GetType().GetProperty("isActive", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(item2, active);
						}
					}
				}
			}
		}

		private static void SetRenderScaleOriginal(bool original)
		{
			RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
			PropertyInfo propertyInfo = ((object)currentRenderPipeline)?.GetType().GetProperty("renderScale", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(propertyInfo == null) && propertyInfo.CanWrite)
			{
				if (baseRenderScale < 0f)
				{
					baseRenderScale = (float)propertyInfo.GetValue(currentRenderPipeline);
				}
				propertyInfo.SetValue(currentRenderPipeline, original ? baseRenderScale : 1f);
			}
		}

		private static object Member(object obj, string name)
		{
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanRead)
			{
				try
				{
					return property.GetValue(obj);
				}
				catch
				{
				}
			}
			FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					return field.GetValue(obj);
				}
				catch
				{
				}
			}
			return null;
		}
	}
	internal static class VRAboutPanel
	{
		private const string GithubUrl = "https://github.com/Andrey04o/PeakVR";

		private const string ItchUrl = "https://andrey04o.itch.io/";

		private static PeakCustomPage page;

		public static void Open()
		{
			try
			{
				if ((Object)(object)page == (Object)null)
				{
					page = BuildPage();
				}
				((MenuWindow)page).Open();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[PeakVR] About panel unavailable (PEAKLib.UI missing?): " + ex.Message));
			}
		}

		private static PeakCustomPage BuildPage()
		{
			//IL_0082: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			PeakCustomPage page = MenuAPI.CreatePageWithBackground("About PeakVR");
			page.SelectOnOpen = false;
			page.CloseOnUICancel = true;
			page.CloseOnPause = true;
			if ((Object)(object)PeakAssets.Logo != (Object)null)
			{
				Picture(page, PeakAssets.Logo, new Vector2(0f, 320f), 150f);
			}
			else
			{
				Label(page, "PeakVR", 320f, 62f, Color.white);
			}
			Label(page, "Version " + Plugin.Version, 248f, 28f, new Color(0.7f, 0.7f, 0.72f));
			Label(page, "Created by Andrey04o", 188f, 34f, Color.white);
			Label(page, "Forked from LCVR by DaXcess", 150f, 24f, new Color(0.8f, 0.8f, 0.82f));
			LinkButton(page, "GitHub   —   github.com/Andrey04o/PeakVR", 70f, "https://github.com/Andrey04o/PeakVR");
			LinkButton(page, "My other games   —   andrey04o.itch.io", -20f, "https://andrey04o.itch.io/");
			Label(page, "Links open in your desktop web browser.", -80f, 22f, new Color(0.6f, 0.6f, 0.62f));
			PeakButton val = MenuAPI.CreateButton("Close");
			ElementExtensions.ParentTo<PeakButton>(val, ((Component)page).transform);
			Place(((PeakElement)val).RectTransform, new Vector2(0f, -165f), new Vector2(320f, 72f));
			val.OnClick((UnityAction)delegate
			{
				((MenuWindow)page).Close();
			});
			Label(page, "Used Assets", -240f, 28f, Color.white);
			Label(page, "VR controller FBX model — Unity VR Template", -288f, 22f, new Color(0.72f, 0.72f, 0.74f));
			return page;
		}

		private static void LinkButton(PeakCustomPage page, string text, float y, string url)
		{
			//IL_002d: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			PeakButton val = MenuAPI.CreateButton(text);
			ElementExtensions.ParentTo<PeakButton>(val, ((Component)page).transform);
			Place(((PeakElement)val).RectTransform, new Vector2(0f, y), new Vector2(820f, 74f));
			val.OnClick((UnityAction)delegate
			{
				Application.OpenURL(url);
			});
		}

		private static void Picture(PeakCustomPage page, Sprite sprite, Vector2 pos, float height)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0067: 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_0091: 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_00a6: 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)
			GameObject val = new GameObject("Picture", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(((Component)page).transform, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			Rect rect = sprite.rect;
			float num;
			if (!(((Rect)(ref rect)).height > 0f))
			{
				num = 1f;
			}
			else
			{
				rect = sprite.rect;
				float width = ((Rect)(ref rect)).width;
				rect = sprite.rect;
				num = width / ((Rect)(ref rect)).height;
			}
			float num2 = num;
			Place(val.GetComponent<RectTransform>(), pos, new Vector2(height * num2, height));
		}

		private static void Label(PeakCustomPage page, string text, float y, float size, Color color)
		{
			//IL_0015: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			PeakText val = MenuAPI.CreateText(text);
			ElementExtensions.ParentTo<PeakText>(val, ((Component)page).transform);
			val.SetColor(color);
			TextMeshProUGUI textMesh = val.TextMesh;
			((TMP_Text)textMesh).enableAutoSizing = false;
			((TMP_Text)textMesh).fontSize = size;
			((TMP_Text)textMesh).alignment = (TextAlignmentOptions)514;
			((TMP_Text)textMesh).enableWordWrapping = true;
			((Graphic)textMesh).raycastTarget = false;
			Place(((PeakElement)val).RectTransform, new Vector2(0f, y), new Vector2(1500f, 200f));
		}

		private static void Place(RectTransform rt, Vector2 pos, Vector2 size)
		{
			//IL_0013: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			rt.anchorMax = val;
			rt.anchorMin = val;
			rt.pivot = new Vector2(0.5f, 0.5f);
			rt.sizeDelta = size;
			rt.anchoredPosition = pos;
		}
	}
	internal static class VRAim
	{
		public static bool TryRight(out Vector3 origin, out Vector3 direction)
		{
			return TryHand(VRHands.Right, (BodypartType)10, out origin, out direction);
		}

		public static bool TryLeft(out Vector3 origin, out Vector3 direction)
		{
			return TryHand(VRHands.Left, (BodypartType)7, out origin, out direction);
		}

		private static bool TryHand(Transform controller, BodypartType palm, out Vector3 origin, out Vector3 direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			origin = default(Vector3);
			direction = default(Vector3);
			if ((Object)(object)controller == (Object)null)
			{
				return false;
			}
			direction = controller.forward;
			origin = controller.position;
			if (VRControllerVisibility.Hidden)
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null)
				{
					Rigidbody bodypartRig = localCharacter.GetBodypartRig(palm);
					if ((Object)(object)bodypartRig != (Object)null)
					{
						origin = ((Component)bodypartRig).transform.position;
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterAnimations))]
	internal static class VRArmIKPatch
	{
		public static Quaternion HandRotationOffset = Quaternion.Euler(-90f, 180f, 0f);

		public static float ArmScale = 1.089f;

		public static bool ElbowClampEnabled = true;

		private static readonly Vector3 ShoulderOffsetLeft = new Vector3(-0.18f, -0.2f, 0f);

		private static readonly Vector3 ShoulderOffsetRight = new Vector3(0.18f, -0.2f, 0f);

		private static readonly Vector3 ElbowSeedLocal = new Vector3(0f, -0.7f, -0.5f);

		private const float ElbowHintDistance = 0.3f;

		private const float HandInfluence = 0.35f;

		public const float MinElbowAngle = 40f;

		public static void LoadArmScaleFromConfig()
		{
			if (Plugin.Config != null)
			{
				ArmScale = Plugin.Config.ArmSpanScale.Value;
			}
		}

		public static void ApplyArmScale(float scale)
		{
			ArmScale = scale;
			if (Plugin.Config != null)
			{
				Plugin.Config.ArmSpanScale.Value = scale;
				Plugin.Config.File.Save();
			}
		}

		[HarmonyPatch("HandleIK")]
		[HarmonyPostfix]
		private static void HandleIKPostfix(CharacterAnimations __instance)
		{
			if (ShouldDrive(__instance, out Character c))
			{
				c.refs.ikRig.weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)c.refs.ikLeft).weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)c.refs.ikRight).weight = 1f;
			}
		}

		[HarmonyPatch("ConfigureIK")]
		[HarmonyPostfix]
		private static void ConfigureIKPostfix(CharacterAnimations __instance)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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)
			//IL_0065: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00b5: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0117: 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_0194: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldDrive(__instance, out Character c))
			{
				return;
			}
			CharacterRefs refs = c.refs;
			if (!((Object)(object)((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikLeft).data)).root == (Object)null) && !((Object)(object)((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikRight).data)).root == (Object)null))
			{
				Transform transform = ((Component)MainCamera.instance.cam).transform;
				Vector3 val = transform.rotation * ShoulderOffsetLeft;
				Vector3 val2 = transform.rotation * ShoulderOffsetRight;
				Vector3 val3 = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikLeft).data)).root.position + ArmScale * (VRHands.Left.position - transform.position - val);
				Vector3 val4 = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikRight).data)).root.position + ArmScale * (VRHands.Right.position - transform.position - val2);
				if (ElbowClampEnabled)
				{
					val3 = ClampMinElbowBend(refs.ikLeft, val3);
					val4 = ClampMinElbowBend(refs.ikRight, val4);
				}
				refs.IKHandTargetLeft.position = val3;
				refs.IKHandTargetRight.position = val4;
				refs.IKHandTargetLeft.rotation = VRHands.Left.rotation * HandRotationOffset;
				Quaternion val5 = VRHands.Right.rotation * HandRotationOffset;
				if (ShootableAim.RollEnabled && ShootableAim.IsShootableHeld())
				{
					val5 *= Quaternion.Euler(ShootableAim.RotationOffset);
				}
				refs.IKHandTargetRight.rotation = val5;
				SetElbowHint(refs.ikLeft, val3, VRHands.Left.rotation);
				SetElbowHint(refs.ikRight, val4, VRHands.Right.rotation);
				refs.ikRig.weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikLeft).weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikRight).weight = 1f;
			}
		}

		private static Vector3 ClampMinElbowBend(TwoBoneIKConstraint ik, Vector3 target)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			Transform root = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).root;
			Transform mid = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).mid;
			Transform tip = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).tip;
			if ((Object)(object)root == (Object)null || (Object)(object)mid == (Object)null || (Object)(object)tip == (Object)null)
			{
				return target;
			}
			float num = Vector3.Distance(root.position, mid.position);
			float num2 = Vector3.Distance(mid.position, tip.position);
			if (num < 0.0001f || num2 < 0.0001f)
			{
				return target;
			}
			float num3 = MinReachDistance(num, num2);
			Vector3 val = target - root.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude >= num3 || magnitude < 0.0001f)
			{
				return target;
			}
			return root.position + val * (num3 / magnitude);
		}

		public static float MinReachDistance(float upper, float fore)
		{
			float num = Mathf.Cos(0.6981317f);
			return Mathf.Sqrt(Mathf.Max(0f, upper * upper + fore * fore - 2f * upper * fore * num));
		}

		private static void SetElbowHint(TwoBoneIKConstraint ik, Vector3 handPos, Quaternion ctrlRot)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ac: 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_00bd: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Transform hint = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).hint;
			if ((Object)(object)hint == (Object)null)
			{
				return;
			}
			Vector3 position = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).root.position;
			Vector3 val = handPos - position;
			if (!(((Vector3)(ref val)).sqrMagnitude < 0.0001f))
			{
				((Vector3)(ref val)).Normalize();
				Vector3 val2 = Vector3.ProjectOnPlane(Vector3.down, val);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					val2 = Vector3.ProjectOnPlane(Vector3.back, val);
				}
				Vector3 val3 = Vector3.ProjectOnPlane(ctrlRot * ElbowSeedLocal, val);
				if (((Vector3)(ref val3)).sqrMagnitude < 0.0001f)
				{
					val3 = val2;
				}
				Vector3 val4 = Vector3.Slerp(((Vector3)(ref val2)).normalized, ((Vector3)(ref val3)).normalized, 0.35f);
				hint.position = (position + handPos) * 0.5f + ((Vector3)(ref val4)).normalized * 0.3f;
			}
		}

		private static bool ShouldDrive(CharacterAnimations anim, out Character c)
		{
			c = Character.localCharacter;
			if ((Object)(object)c == (Object)null || (Object)(object)VRHands.Left == (Object)null || (Object)(object)VRHands.Right == (Object)null)
			{
				return false;
			}
			if (c.data.fullyPassedOut)
			{
				return false;
			}
			if ((Object)(object)c.refs.animations != (Object)(object)anim)
			{
				return false;
			}
			if ((Object)(object)c.refs.IKHandTargetLeft == (Object)null || (Object)(object)c.refs.ikRig == (Object)null || (Object)(object)c.refs.ikLeft == (Object)null || (Object)(object)c.refs.ikRight == (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	internal static class VRCalibration
	{
		private class Runner : MonoBehaviour
		{
			public PeakCustomPage Page;

			public PeakText Readout;

			public PeakText Current;

			public PeakText Status;

			private Transform left;

			private Transform right;

			private bool prevBoth;

			private void Update()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Page == (Object)null || !((MenuWindow)Page).isOpen)
				{
					prevBoth = false;
					return;
				}
				if (!TryControllers())
				{
					Readout.SetText("Controllers not tracked.");
					prevBoth = false;
					return;
				}
				float num = Vector3.Distance(left.position, right.position);
				float num2 = VirtualArmSpan();
				float num3 = Mathf.Clamp(num2 / Mathf.Max(num, 0.05f), 0.6f, 1.8f);
				Readout.SetText($"Wingspan: {num:0.00} m      New Arm Scale: {num3:0.000}");
				Current.SetText($"Current Arm Scale: {VRArmIKPatch.ArmScale:0.000}");
				bool flag = VRControls.LeftTrigger != null && VRControls.RightTrigger != null && VRControls.LeftTrigger.IsPressed() && VRControls.RightTrigger.IsPressed();
				if (flag && !prevBoth)
				{
					VRArmIKPatch.ApplyArmScale(num3);
					Status.SetText($"Saved!   Arm Scale = {num3:0.000}");
				}
				prevBoth = flag;
			}

			private bool TryControllers()
			{
				if ((Object)(object)left == (Object)null)
				{
					left = (((Object)(object)VRHands.Left != (Object)null) ? VRHands.Left : Find("PeakVR Left Hand"));
				}
				if ((Object)(object)right == (Object)null)
				{
					right = (((Object)(object)VRHands.Right != (Object)null) ? VRHands.Right : Find("PeakVR Right Hand"));
				}
				if ((Object)(object)left != (Object)null)
				{
					return (Object)(object)right != (Object)null;
				}
				return false;
			}

			private static Transform Find(string name)
			{
				GameObject val = GameObject.Find(name);
				if (!((Object)(object)val != (Object)null))
				{
					return null;
				}
				return val.transform;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static BuilderDelegate <0>__BuildPauseEntry;
		}

		private const float DefaultArmScale = 1.089f;

		private const float MinScale = 0.6f;

		private const float MaxScale = 1.8f;

		private static PeakCustomPage page;

		public static void Register()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__BuildPauseEntry;
			if (obj == null)
			{
				BuilderDelegate val = BuildPauseEntry;
				<>O.<0>__BuildPauseEntry = val;
				obj = (object)val;
			}
			MenuAPI.AddToPauseMenu((BuilderDelegate)obj);
			Plugin.Log.LogInfo((object)"[PeakVR] Calibration menu registered (pause menu)");
		}

		private static void BuildPauseEntry(Transform parent)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			PauseMenuMainPage pauseMain = ((Component)parent).GetComponent<PauseMenuMainPage>();
			PeakMenuButton val = MenuAPI.CreatePauseMenuButton("VR Calibration");
			if ((Object)(object)pauseMain != (Object)null && (Object)(object)pauseMain.resumeButton != (Object)null)
			{
				Transform transform = ((Component)pauseMain.resumeButton).transform;
				ElementExtensions.ParentTo<PeakMenuButton>(val, transform.parent);
				((Component)val).transform.SetSiblingIndex(transform.GetSiblingIndex() + 1);
			}
			else
			{
				ElementExtensions.ParentTo<PeakMenuButton>(val, parent);
			}
			val.OnClick((UnityAction)delegate
			{
				Open();
				if ((Object)(object)pauseMain != (Object)null && (Object)(object)pauseMain.resumeButton != (Object)null)
				{
					((UnityEvent)pauseMain.resumeButton.onClick).Invoke();
				}
			});
		}

		public static void Open()
		{
			try
			{
				if ((Object)(object)page == (Object)null)
				{
					page = BuildPage();
				}
				((MenuWindow)page).Open();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[PeakVR] Calibration page unavailable (PEAKLib.UI missing?): " + ex.Message));
			}
		}

		private static PeakCustomPage BuildPage()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_012d: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			PeakCustomPage page = MenuAPI.CreatePageWithBackground("VR Calibration");
			page.SelectOnOpen = false;
			page.CloseOnUICancel = true;
			page.CloseOnPause = true;
			Label(page, "VR Arm Calibration", 400f, 54f, Color.white);
			Label(page, "Stand up straight in a T-pose: arms straight out to your sides,\ncontrollers level with your shoulders.", 315f, 30f, new Color(0.85f, 0.85f, 0.85f));
			Label(page, "Then squeeze BOTH TRIGGERS at once to save.", 245f, 32f, new Color(1f, 0.85f, 0.3f));
			if ((Object)(object)PeakAssets.TPose != (Object)null)
			{
				Picture(page, PeakAssets.TPose, new Vector2(0f, 45f), 360f);
			}
			PeakText readout = Label(page, "", -175f, 32f, Color.white);
			PeakText current = Label(page, "", -235f, 26f, new Color(0.7f, 0.8f, 1f));
			PeakText status = Label(page, "", -290f, 30f, new Color(0.4f, 1f, 0.5f));
			PeakButton val = MenuAPI.CreateButton("Reset to Default");
			ElementExtensions.ParentTo<PeakButton>(val, ((Component)page).transform);
			Place(((PeakElement)val).RectTransform, new Vector2(-180f, -390f), new Vector2(320f, 72f));
			val.OnClick((UnityAction)delegate
			{
				VRArmIKPatch.ApplyArmScale(1.089f);
				status.SetText("Reset to default.");
			});
			PeakButton val2 = MenuAPI.CreateButton("Close");
			ElementExtensions.ParentTo<PeakButton>(val2, ((Component)page).transform);
			Place(((PeakElement)val2).RectTransform, new Vector2(180f, -390f), new Vector2(320f, 72f));
			val2.OnClick((UnityAction)delegate
			{
				((MenuWindow)page).Close();
			});
			Runner runner = ((Component)page).gameObject.AddComponent<Runner>();
			runner.Page = page;
			runner.Readout = readout;
			runner.Current = current;
			runner.Status = status;
			return page;
		}

		private static PeakText Label(PeakCustomPage page, string text, float y, float size, Color color)
		{
			//IL_0015: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			PeakText val = MenuAPI.CreateText(text);
			ElementExtensions.ParentTo<PeakText>(val, ((Component)page).transform);
			val.SetColor(color);
			TextMeshProUGUI textMesh = val.TextMesh;
			((TMP_Text)textMesh).enableAutoSizing = false;
			((TMP_Text)textMesh).fontSize = size;
			((TMP_Text)textMesh).alignment = (TextAlignmentOptions)514;
			((TMP_Text)textMesh).enableWordWrapping = true;
			((Graphic)textMesh).raycastTarget = false;
			Place(((PeakElement)val).RectTransform, new Vector2(0f, y), new Vector2(1500f, 220f));
			return val;
		}

		private static void Picture(PeakCustomPage page, Sprite sprite, Vector2 pos, float height)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0067: 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_0091: 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_00a6: 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)
			GameObject val = new GameObject("Picture", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(((Component)page).transform, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			Rect rect = sprite.rect;
			float num;
			if (!(((Rect)(ref rect)).height > 0f))
			{
				num = 1f;
			}
			else
			{
				rect = sprite.rect;
				float width = ((Rect)(ref rect)).width;
				rect = sprite.rect;
				num = width / ((Rect)(ref rect)).height;
			}
			float num2 = num;
			Place(val.GetComponent<RectTransform>(), pos, new Vector2(height * num2, height));
		}

		private static void Place(RectTransform rt, Vector2 pos, Vector2 size)
		{
			//IL_0013: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			rt.anchorMax = val;
			rt.anchorMin = val;
			rt.pivot = new Vector2(0.5f, 0.5f);
			rt.sizeDelta = size;
			rt.anchoredPosition = pos;
		}

		private static float MeasureVirtualArmSpan()
		{
			//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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || localCharacter.refs == null || (Object)(object)localCharacter.refs.ikLeft == (Object)null || (Object)(object)localCharacter.refs.ikRight == (Object)null)
			{
				return 0f;
			}
			TwoBoneIKConstraintData data = ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)localCharacter.refs.ikLeft).data;
			TwoBoneIKConstraintData data2 = ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)localCharacter.refs.ikRight).data;
			if ((Object)(object)((TwoBoneIKConstraintData)(ref data)).root == (Object)null || (Object)(object)((TwoBoneIKConstraintData)(ref data)).mid == (Object)null || (Object)(object)((TwoBoneIKConstraintData)(ref data)).tip == (Object)null || (Object)(object)((TwoBoneIKConstraintData)(ref data2)).root == (Object)null || (Object)(object)((TwoBoneIKConstraintData)(ref data2)).mid == (Object)null || (Object)(object)((TwoBoneIKConstraintData)(ref data2)).tip == (Object)null)
			{
				return 0f;
			}
			float num = Vector3.Distance(((TwoBoneIKConstraintData)(ref data)).root.position, ((TwoBoneIKConstraintData)(ref data)).mid.position) + Vector3.Distance(((TwoBoneIKConstraintData)(ref data)).mid.position, ((TwoBoneIKConstraintData)(ref data)).tip.position);
			float num2 = Vector3.Distance(((TwoBoneIKConstraintData)(ref data2)).root.position, ((TwoBoneIKConstraintData)(ref data2)).mid.position) + Vector3.Distance(((TwoBoneIKConstraintData)(ref data2)).mid.position, ((TwoBoneIKConstraintData)(ref data2)).tip.position);
			float num3 = Vector3.Distance(((TwoBoneIKConstraintData)(ref data)).root.position, ((TwoBoneIKConstraintData)(ref data2)).root.position);
			return num + num2 + num3;
		}

		private static float VirtualArmSpan()
		{
			float num = MeasureVirtualArmSpan();
			if (num > 0.1f)
			{
				if (Plugin.Config != null)
				{
					Plugin.Config.VirtualArmSpan.Value = num;
				}
				return num;
			}
			if (Plugin.Config == null)
			{
				return 1.851f;
			}
			return Plugin.Config.VirtualArmSpan.Value;
		}
	}
	[DefaultExecutionOrder(1250)]
	internal class VRControllerHud : MonoBehaviour
	{
		private struct CellTarget
		{
			public Collider collider;

			public Transform cell;

			public byte slot;
		}

		private const float Scale = 0.0007f;

		private const float ItemSpacing = 90f;

		private const int HudLayer = 3;

		private const float PointerMaxDistance = 1.5f;

		private const float HoverScale = 1.14f;

		private static readonly Vector3 LeftPos = new Vector3(0f, 0.03f, -0.06f);

		private static readonly Vector3 RightPos = new Vector3(0f, 0.03f, -0.06f);

		private static readonly Vector3 LeftEuler = new Vector3(0f, 90f, 90f);

		private static readonly Vector3 RightEuler = new Vector3(0f, -90f, -90f);

		internal static Canvas LeftHudCanvas;

		private Canvas left;

		private Canvas right;

		private bool moved;

		private readonly List<CellTarget> targets = new List<CellTarget>();

		private LineRenderer pointer;

		private Material pointerMat;

		private Transform hoveredCell;

		public static bool LeftTriggerConsumed { get; private set; }

		private void LateUpdate()
		{
			LeftTriggerConsumed = false;
			if (!Plugin.VrEnabled || (Object)(object)VRHands.Left == (Object)null || (Object)(object)VRHands.Right == (Object)null)
			{
				return;
			}
			GUIManager instance = GUIManager.instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.staminaCanvasGroup == (Object)null) && instance.items != null && instance.items.Length != 0)
			{
				if (!moved || (Object)(object)((Component)instance.staminaCanvasGroup).transform.parent != (Object)(object)((Component)left).transform)
				{
					MoveHud(instance);
				}
				UpdateBackface();
				UpdateSelection();
			}
		}

		private void MoveHud(GUIManager gui)
		{
			//IL_001d: 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_00d9: 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)
			EnsureCanvases();
			ClearTargets();
			Center(((Component)gui.staminaCanvasGroup).transform, left, Vector2.zero);
			float num = (float)(-(gui.items.Length - 1)) * 90f * 0.5f;
			for (int i = 0; i < gui.items.Length; i++)
			{
				if ((Object)(object)gui.items[i] != (Object)null)
				{
					Center(((Component)gui.items[i]).transform, right, new Vector2(num + (float)i * 90f, 0f));
					RegisterCell(((Component)gui.items[i]).transform, (byte)i);
				}
			}
			if ((Object)(object)gui.backpack != (Object)null)
			{
				Center(((Component)gui.backpack).transform, right, new Vector2(num + (float)gui.items.Length * 90f, 0f));
				RegisterCell(((Component)gui.backpack).transform, 3);
			}
			if ((Object)(object)gui.temporaryItem != (Object)null)
			{
				Center(((Component)gui.temporaryItem).transform, right, new Vector2(num - 90f, 0f));
				RegisterCell(((Component)gui.temporaryItem).transform, 250);
			}
			UIOverlay.MakeAlwaysVisible(left, 4000);
			UIOverlay.MakeAlwaysVisible(right, 4000);
			HideInputPrompts(left);
			HideInputPrompts(right);
			VRLayers.HideFromMirror(((Component)left).gameObject, 3, 7);
			VRLayers.HideFromMirror(((Component)right).gameObject, 3, 7);
			moved = true;
			Plugin.Log.LogInfo((object)"[PeakVR] HUD moved onto controllers");
		}

		private static void HideInputPrompts(Canvas canvas)
		{
			if (!((Object)(object)canvas == (Object)null))
			{
				InLineInputPrompts[] componentsInChildren = ((Component)canvas).GetComponentsInChildren<InLineInputPrompts>(true);
				foreach (InLineInputPrompts val in componentsInChildren)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private void UpdateBackface()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)MainCamera.instance == (Object)null))
			{
				Vector3 position = ((Component)MainCamera.instance.cam).transform.position;
				SetVisible(left, position);
				SetVisible(right, position);
			}
		}

		private static void SetVisible(Canvas canvas, Vector3 camPos)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)canvas == (Object)null))
			{
				bool flag = Vector3.Dot(((Component)canvas).transform.forward, camPos - ((Component)canvas).transform.position) < 0f;
				if (((Behaviour)canvas).enabled != flag)
				{
					((Behaviour)canvas).enabled = flag;
				}
			}
		}

		private void UpdateSelection()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			EnsurePointer();
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)right != (Object)null) || !((Behaviour)right).enabled || !((Object)(object)VRPointer.Canvas == (Object)null) || !((Object)(object)localCharacter != (Object)null) || localCharacter.data.fullyPassedOut)
			{
				SetHover(null);
				if ((Object)(object)pointer != (Object)null)
				{
					((Renderer)pointer).enabled = false;
				}
				return;
			}
			if ((Object)(object)VRHands.Left == (Object)null)
			{
				SetHover(null);
				((Renderer)pointer).enabled = false;
				return;
			}
			Vector3 position = VRHands.Left.position;
			Vector3 forward = VRHands.Left.forward;
			RaycastHit val = default(RaycastHit);
			bool flag = Physics.Raycast(position, forward, ref val, 1.5f, 8, (QueryTriggerInteraction)2);
			Transform val2 = null;
			byte slot = 0;
			if (flag)
			{
				foreach (CellTarget target in targets)
				{
					if ((Object)(object)target.collider == (Object)(object)((RaycastHit)(ref val)).collider)
					{
						val2 = target.cell;
						slot = target.slot;
						break;
					}
				}
			}
			bool flag2 = (Object)(object)val2 != (Object)null;
			bool flag3 = VRLine.ShouldShow(Plugin.Config.HudLine.Value, flag2);
			((Renderer)pointer).enabled = flag3;
			if (flag3)
			{
				pointer.SetPosition(0, position);
				pointer.SetPosition(1, flag2 ? ((RaycastHit)(ref val)).point : (position + forward * 1.5f));
				SetPointerColor(flag2);
			}
			SetHover(val2);
			if (flag2)
			{
				LeftTriggerConsumed = true;
				if (VRControls.LeftTrigger != null && VRControls.LeftTrigger.WasPressedThisFrame())
				{
					SelectSlot(slot);
				}
			}
		}

		private void SetHover(Transform cell)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)hoveredCell == (Object)(object)cell))
			{
				if ((Object)(object)hoveredCell != (Object)null)
				{
					hoveredCell.localScale = Vector3.one;
				}
				hoveredCell = cell;
				if ((Object)(object)hoveredCell != (Object)null)
				{
					hoveredCell.localScale = Vector3.one * 1.14f;
				}
			}
		}

		private static void SelectSlot(byte slot)
		{
			//IL_0061: 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)
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && localCharacter.refs != null && !((Object)(object)localCharacter.refs.items == (Object)null))
			{
				CharacterItems items = localCharacter.refs.items;
				if (items.currentSelectedSlot.IsSome && items.currentSelectedSlot.Value == slot)
				{
					items.EquipSlot(Optionable<byte>.None);
				}
				else
				{
					items.EquipSlot(Optionable<byte>.Some(slot));
				}
				if (slot == 3 && (Object)(object)localCharacter.data != (Object)null && (Object)(object)localCharacter.data.carriedPlayer != (Object)null && (Object)(object)localCharacter.refs.carriying != (Object)null)
				{
					localCharacter.refs.carriying.Drop(localCharacter.data.carriedPlayer);
				}
			}
		}

		private void RegisterCell(Transform cell, byte slot)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_001e: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cell == (Object)null))
			{
				RectTransform val = (RectTransform)(object)((cell is RectTransform) ? cell : null);
				? val2;
				if (val == null)
				{
					val2 = new Vector2(80f, 80f);
				}
				else
				{
					Rect rect = val.rect;
					val2 = ((Rect)(ref rect)).size;
				}
				Vector2 val3 = (Vector2)val2;
				if (val3.x < 1f)
				{
					val3.x = 80f;
				}
				if (val3.y < 1f)
				{
					val3.y = 80f;
				}
				GameObject val4 = new GameObject("PeakVR HudCollider")
				{
					layer = 3
				};
				val4.transform.SetParent(cell, false);
				val4.transform.localPosition = Vector3.zero;
				val4.transform.localRotation = Quaternion.identity;
				val4.transform.localScale = Vector3.one;
				BoxCollider val5 = val4.AddComponent<BoxCollider>();
				((Collider)val5).isTrigger = true;
				val5.size = new Vector3(val3.x, val3.y, 40f);
				targets.Add(new CellTarget
				{
					collider = (Collider)(object)val5,
					cell = cell,
					slot = slot
				});
			}
		}

		private void ClearTargets()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			foreach (CellTarget target in targets)
			{
				if ((Object)(object)target.cell != (Object)null)
				{
					target.cell.localScale = Vector3.one;
				}
				if ((Object)(object)target.collider != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)target.collider).gameObject);
				}
			}
			targets.Clear();
			hoveredCell = null;
		}

		private void EnsurePointer()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (!((Object)(object)pointer != (Object)null))
			{
				GameObject val = new GameObject("PeakVR HudPointer")
				{
					layer = VRLayers.UI
				};
				val.transform.SetParent(VRHands.Left, false);
				pointer = val.AddComponent<LineRenderer>();
				pointer.useWorldSpace = true;
				pointer.widthMultiplier = 0.004f;
				pointer.numCapVertices = 4;
				pointer.positionCount = 2;
				Shader val2 = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
				pointerMat = new Material(val2);
				((Renderer)pointer).material = pointerMat;
				((Renderer)pointer).enabled = false;
			}
		}

		private void SetPointerColor(bool hover)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			Color val = (Color)(hover ? VRLine.CharacterColor() : new Color(0.9f, 0.9f, 0.95f));
			if (pointerMat.HasProperty("_BaseColor"))
			{
				pointerMat.SetColor("_BaseColor", val);
			}
			else
			{
				pointerMat.color = val;
			}
		}

		private void EnsureCanvases()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)left == (Object)null)
			{
				left = MakeCanvas("PeakVR LeftHUD", VRHands.Left, "LeftHUDAnchor", LeftPos, LeftEuler);
				LeftHudCanvas = left;
			}
			if ((Object)(object)right == (Object)null)
			{
				right = MakeCanvas("PeakVR RightHUD", VRHands.Right, "RightHUDAnchor", RightPos, RightEuler);
			}
		}

		private static Canvas MakeCanvas(string name, Transform hand, string anchorName, Vector3 fallbackPos, Vector3 fallbackEuler)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			Transform val2 = FindAnchor(hand, anchorName);
			if ((Object)(object)val2 != (Object)null)
			{
				val.transform.SetParent(val2, false);
				val.transform.localPosition = Vector3.zero;
				val.transform.localRotation = Quaternion.identity;
			}
			else
			{
				val.transform.SetParent(hand, false);
				val.transform.localPosition = fallbackPos;
				val.transform.localRotation = Quaternion.Euler(fallbackEuler);
			}
			val.transform.localScale = Vector3.one * 0.0007f;
			Canvas val3 = val.AddComponent<Canvas>();
			val3.renderMode = (RenderMode)2;
			val3.worldCamera = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			RectTransform val4 = (RectTransform)((Component)val3).transform;
			val4.sizeDelta = new Vector2(500f, 220f);
			return val3;
		}

		private static Transform FindAnchor(Transform hand, string anchorName)
		{
			Transform[] componentsInChildren = ((Component)hand).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == anchorName || ((Object)val).name == "HUDAnchor")
				{
					return val;
				}
			}
			return null;
		}

		private static void Center(Transform t, Canvas canvas, Vector2 pos)
		{
			//IL_002b: 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_0032: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			t.SetParent(((Component)canvas).transform, false);
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			if (val != null)
			{
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0.5f, 0.5f);
				val.pivot = val2;
				Vector2 anchorMin = (val.anchorMax = val2);
				val.anchorMin = anchorMin;
				val.anchoredPosition = pos;
				((Transform)val).localScale = Vector3.one;
				((Transform)val).localRotation = Quaternion.identity;
			}
		}
	}
	internal static class VRControllers
	{
		private static Material controllerMat;

		public static void CreateLasers(Transform rig)
		{
			if (!((Object)(object)GameObject.Find("PeakVR Left Hand") != (Object)null))
			{
				CreateHand(rig, "LeftHand", "PeakVR Left Hand");
				CreateHand(rig, "RightHand", "PeakVR Right Hand");
			}
		}

		private static void CreateHand(Transform rig, string hand, string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(rig, false);
			InputAction val2 = new InputAction(hand + " Position", (InputActionType)0, "<XRController>{" + hand + "}/pointer/position", (string)null, (string)null, "Vector3");
			InputAction val3 = new InputAction(hand + " Rotation", (InputActionType)0, "<XRController>{" + hand + "}/pointer/rotation", (string)null, (string)null, "Quaternion");
			val2.Enable();
			val3.Enable();
			TrackedPoseDriver val4 = val.AddComponent<TrackedPoseDriver>();
			val4.trackingType = (TrackingType)0;
			val4.updateType = (UpdateType)0;
			val4.positionInput = new InputActionProperty(val2);
			val4.rotationInput = new InputActionProperty(val3);
			LineRenderer val5 = val.AddComponent<LineRenderer>();
			val5.useWorldSpace = false;
			val5.widthMultiplier = 0.005f;
			val5.numCapVertices = 4;
			val5.positionCount = 2;
			val5.SetPosition(0, Vector3.zero);
			val5.SetPosition(1, Vector3.forward * 5f);
			Color startColor = (val5.endColor = Color.cyan);
			val5.startColor = startColor;
			((Renderer)val5).material = CreateLaserMaterial();
			InputAction val6 = new InputAction(hand + " Trigger", (InputActionType)1, "<XRController>{" + hand + "}/triggerPressed", (string)null, (string)null, (string)null);
			val6.Enable();
			VRLaser vRLaser = val.AddComponent<VRLaser>();
			vRLaser.line = val5;
			vRLaser.trigger = val6;
			if ((Object)(object)PeakAssets.Controller != (Object)null)
			{
				GameObject val7 = Object.Instantiate<GameObject>(PeakAssets.Controller, val.transform);
				val7.transform.localPosition = Vector3.zero;
				val7.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
				if (hand == "RightHand")
				{
					val7.transform.localScale = new Vector3(-1f, 1f, 1f);
				}
				if (controllerMat == null)
				{
					controllerMat = new Material(Shader.Find("Universal Render Pipeline/Lit"))
					{
						color = new Color(0.12f, 0.12f, 0.13f)
					};
				}
				Renderer[] componentsInChildren = val7.GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val8 in array)
				{
					val8.sharedMaterial = controllerMat;
				}
				Plugin.Log.LogInfo((object)$"[PeakVR] {name} model: renderers={componentsInChildren.Length}, active={val7.activeInHierarchy}");
			}
			Plugin.Log.LogInfo((object)("[PeakVR] Created " + name));
		}

		private static Material CreateLaserMaterial()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0040: 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)
			Shader val = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
			Material val2 = new Material(val);
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", Color.cyan);
			}
			else
			{
				val2.color = Color.cyan;
			}
			return val2;
		}
	}
	internal static class VRControllerVisibility
	{
		private static readonly List<Renderer> renderers = new List<Renderer>();

		private static bool? applied;

		public static bool Hidden
		{
			get
			{
				if (Plugin.Config != null)
				{
					return Plugin.Config.HideControllers.Value;
				}
				return false;
			}
		}

		public static void Register(GameObject model)
		{
			if ((Object)(object)model == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = model.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					renderers.Add(val);
				}
			}
			applied = null;
			Tick();
		}

		public static void Tick()
		{
			bool hidden = Hidden;
			if (applied == hidden)
			{
				return;
			}
			applied = hidden;
			for (int num = renderers.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)renderers[num] == (Object)null)
				{
					renderers.RemoveAt(num);
				}
				else
				{
					renderers[num].enabled = !hidden;
				}
			}
		}
	}
	internal static class VRControls
	{
		public static InputAction MoveStick { get; private set; }

		public static InputAction TurnStick { get; private set; }

		public static InputAction LeftGrip { get; private set; }

		public static InputAction RightGrip { get; private set; }

		public static InputAction LeftTrigger { get; private set; }

		public static InputAction RightTrigger { get; private set; }

		public static InputAction LeftPrimary { get; private set; }

		public static InputAction RightPrimary { get; private set; }

		public static InputAction RightSecondary { get; private set; }

		public static InputAction Pause { get; private set; }

		public static InputAction Sprint { get; private set; }

		public static InputAction Stash { get; private set; }

		public static void Init()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			MoveStick = new InputAction("VR Move", (InputActionType)0, "<XRController>{LeftHand}/thumbstick", (string)null, (string)null, "Vector2");
			TurnStick = new InputAction("VR Turn", (InputActionType)0, "<XRController>{RightHand}/thumbstick", (string)null, (string)null, "Vector2");
			LeftGrip = Button("VR LeftGrip", "<XRController>{LeftHand}/gripPressed");
			RightGrip = Button("VR RightGrip", "<XRController>{RightHand}/gripPressed");
			LeftTrigger = Button("VR LeftTrigger", "<XRController>{LeftHand}/triggerPressed");
			RightTrigger = Button("VR RightTrigger", "<XRController>{RightHand}/triggerPressed");
			LeftPrimary = Button("VR LeftPrimary", "<XRController>{LeftHand}/primaryButton");
			RightPrimary = Button("VR RightPrimary", "<XRController>{RightHand}/primaryButton");
			RightSecondary = Button("VR RightSecondary", "<XRController>{RightHand}/secondaryButton");
			Pause = Button("VR Pause", "<XRController>{LeftHand}/secondaryButton");
			Sprint = new InputAction("VR Sprint", (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(Sprint, "<XRController>{LeftHand}/thumbstickClicked", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(Sprint, "<XRController>{LeftHand}/thumbstickpressed", (string)null, (string)null, (string)null);
			Stash = new InputAction("VR Stash", (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(Stash, "<XRController>{RightHand}/thumbstickClicked", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(Stash, "<XRController>{RightHand}/thumbstickpressed", (string)null, (string)null, (string)null);
			MoveStick.Enable();
			TurnStick.Enable();
			LeftGrip.Enable();
			RightGrip.Enable();
			LeftTrigger.Enable();
			RightTrigger.Enable();
			LeftPrimary.Enable();
			RightPrimary.Enable();
			RightSecondary.Enable();
			Pause.Enable();
			Sprint.Enable();
			Stash.Enable();
		}

		private static InputAction Button(string name, string binding)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return new InputAction(name, (InputActionType)1, binding, (string)null, (string)null, (string)null);
		}
	}
	internal static class VRCutscene
	{
		public static bool Active;

		public static Camera[] Cameras;

		public static RenderTexture Sink;

		public static Transform CurrentTransform()
		{
			if (Cameras == null)
			{
				return null;
			}
			Transform result = null;
			Camera[] cameras = Cameras;
			foreach (Camera val in cameras)
			{
				if (!((Object)(object)val == (Object)null))
				{
					result = ((Component)val).transform;
					if (((Behaviour)val).isActiveAndEnabled)
					{
						return ((Component)val).transform;
					}
				}
			}
			return result;
		}
	}
	[HarmonyPatch(typeof(PeakHandler), "EndCutscene")]
	internal static class EndCutsceneVRPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PeakHandler __instance)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if (!Plugin.VrEnabled || (Object)(object)__instance.endCutscene == (Object)null)
			{
				return;
			}
			if ((Object)(object)MainCamera.instance != (Object)null)
			{
				((Component)MainCamera.instance).gameObject.SetActive(true);
			}
			Camera[] componentsInChildren = __instance.endCutscene.GetComponentsInChildren<Camera>(true);
			if (componentsInChildren.Length != 0)
			{
				if ((Object)(object)VRCutscene.Sink == (Object)null)
				{
					VRCutscene.Sink = new RenderTexture(1, 1, 0)
					{
						name = "PeakVR CutsceneSink"
					};
				}
				Camera[] array = componentsInChildren;
				foreach (Camera val in array)
				{
					val.stereoTargetEye = (StereoTargetEyeMask)0;
					val.targetTexture = VRCutscene.Sink;
				}
				if ((Object)(object)MainCamera.instance != (Object)null)
				{
					MainCamera.instance.cam.cullingMask = componentsInChildren[0].cullingMask;
				}
				VRCutscene.Cameras = componentsInChildren;
				VRCutscene.Active = true;
				Plugin.Log.LogInfo((object)$"[PeakVR] EndCutscene: following {componentsInChildren.Length} cutscene camera(s), rendering to sink");
			}
		}
	}
	[DefaultExecutionOrder(1260)]
	internal class VREmoteWheel : MonoBehaviour
	{
		private const int EmoteLayer = 7;

		private const float MaxDistance = 1.5f;

		private const float HoverScale = 1.15f;

		private RectTransform button;

		private Collider buttonCollider;

		private LineRenderer line;

		private Material lineMat;

		public static bool EmoteActive { get; private set; }

		public static bool RightTriggerConsumed { get; private set; }

		private void LateUpdate()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			RightTriggerConsumed = false;
			if (!Plugin.VrEnabled || (Object)(object)VRHands.Right == (Object)null)
			{
				return;
			}
			EnsureButton();
			if ((Object)(object)buttonCollider == (Object)null)
			{
				return;
			}
			if (EmoteActive)
			{
				RightTriggerConsumed = true;
				((Transform)button).localScale = Vector3.one;
				HideLine();
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null || localCharacter.data.fullyPassedOut || (VRControls.RightTrigger != null && VRControls.RightTrigger.WasPressedThisFrame()))
				{
					EmoteActive = false;
				}
				return;
			}
			if (!((Object)(object)VRControllerHud.LeftHudCanvas != (Object)null) || !((Behaviour)VRControllerHud.LeftHudCanvas).enabled || !((Object)(object)VRPointer.Canvas == (Object)null) || !((Object)(object)Character.localCharacter != (Object)null) || Character.localCharacter.data.fullyPassedOut)
			{
				((Transform)button).localScale = Vector3.one;
				HideLine();
				return;
			}
			RaycastHit hit = default(RaycastHit);
			bool flag = Physics.Raycast(VRHands.Right.position, VRHands.Right.forward, ref hit, 1.5f, 128, (QueryTriggerInteraction)2);
			((Transform)button).localScale = (flag ? (Vector3.one * 1.15f) : Vector3.one);
			UpdateLine(flag, hit);
			if (flag)
			{
				RightTriggerConsumed = true;
				if (VRControls.RightTrigger != null && VRControls.RightTrigger.WasPressedThisFrame())
				{
					EmoteActive = true;
				}
			}
		}

		private void UpdateLine(bool hovering, RaycastHit hit)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0096: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			EnsureLine();
			bool flag = VRLine.ShouldShow(Plugin.Config.HudLine.Value, hovering);
			((Renderer)line).enabled = flag;
			if (flag)
			{
				Vector3 position = VRHands.Right.position;
				Vector3 forward = VRHands.Right.forward;
				line.SetPosition(0, position);
				line.SetPosition(1, hovering ? ((RaycastHit)(ref hit)).point : (position + forward * 1.5f));
				Color val = (Color)(hovering ? VRLine.CharacterColor() : new Color(0.9f, 0.9f, 0.95f));
				if (lineMat.HasProperty("_BaseColor"))
				{
					lineMat.SetColor("_BaseColor", val);
				}
				else
				{
					lineMat.color = val;
				}
			}
		}

		private void HideLine()
		{
			if ((Object)(object)line != (Object)null)
			{
				((Renderer)line).enabled = false;
			}
		}

		private void EnsureLine()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (!((Object)(object)line != (Object)null))
			{
				GameObject val = new GameObject("PeakVR EmoteLine")
				{
					layer = VRLayers.UI
				};
				val.transform.SetParent(VRHands.Right, false);
				line = val.AddComponent<LineRenderer>();
				line.useWorldSpace = true;
				line.widthMultiplier = 0.004f;
				line.numCapVertices = 4;
				line.positionCount = 2;
				Shader val2 = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
				lineMat = new Material(val2);
				((Renderer)line).material = lineMat;
				((Renderer)line).enabled = false;
			}
		}

		private void EnsureButton()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0059: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00f2: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a4: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button != (Object)null || (Object)(object)VRControllerHud.LeftHudCanvas == (Object)null)
			{
				return;
			}
			GameObject val = new GameObject("PeakVR EmoteButton");
			button = val.AddComponent<RectTransform>();
			((Transform)button).SetParent(((Component)VRControllerHud.LeftHudCanvas).transform, false);
			button.sizeDelta = new Vector2(150f, 150f);
			button.anchoredPosition = new Vector2(0f, -170f);
			Image val2 = val.AddComponent<Image>();
			if ((Object)(object)PeakAssets.EmoteButton != (Object)null)
			{
				val2.sprite = PeakAssets.EmoteButton;
				((Graphic)val2).color = Color.white;
				val2.preserveAspect = true;
			}
			else
			{
				((Graphic)val2).color = new Color(1f, 0.78f, 0.2f);
				GameObject val3 = new GameObject("Label");
				RectTransform val4 = val3.AddComponent<RectTransform>();
				((Transform)val4).SetParent((Transform)(object)button, false);
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = Vector2.zero;
				val4.offsetMax = Vector2.zero;
				TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val5).text = "EMOTE";
				((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
				((Graphic)val5).color = Color.black;
				((TMP_Text)val5).fontSize = 42f;
				TextMeshProUGUI val6 = Object.FindObjectOfType<TextMeshProUGUI>();
				if ((Object)(object)val6 != (Object)null && (Object)(object)val6 != (Object)(object)val5 && (Object)(object)((TMP_Text)val6).font != (Object)null)
				{
					((TMP_Text)val5).font = ((TMP_Text)val6).font;
				}
			}
			GameObject val7 = new GameObject("EmoteCollider")
			{
				layer = 7
			};
			val7.transform.SetParent((Transform)(object)button, false);
			val7.transform.localPosition = Vector3.zero;
			val7.transform.localRotation = Quaternion.identity;
			val7.transform.localScale = Vector3.one;
			BoxCollider val8 = val7.AddComponent<BoxCollider>();
			((Collider)val8).isTrigger = true;
			val8.size = new Vector3(150f, 150f, 40f);
			buttonCollider = (Collider)(object)val8;
			UIOverlay.MakeAlwaysVisible(VRControllerHud.LeftHudCanvas, 4000);
			VRLayers.HideFromMirror(val, 7);
			Plugin.Log.LogInfo((object)"[PeakVR] Emote button created on left wrist canvas");
		}
	}
	internal static class VRHands
	{
		private static Material handMat;

		private static Material laserMat;

		private static VRLaser leftLaser;

		private static VRLaser rightLaser;

		private static LineRenderer interactRay;

		private static Material interactRayMat;

		private static bool menuPointersOn;

		public static Transform Left { get; private set; }

		public static Transform Right { get; private set; }

		public static void Create(Transform rig)
		{
			if (!((Object)(object)Left != (Object)null))
			{
				Left = CreateHand(rig, "LeftHand", "PeakVR IG Left Hand", out leftLaser);
				Right = CreateHand(rig, "RightHand", "PeakVR IG Right Hand", out rightLaser);
				interactRay = CreateInteractRay(Right);
			}
		}

		public static void SetPointersActive(bool on)
		{
			menuPointersOn = on;
			if (!((Object)(object)leftLaser == (Object)null) && !((Object)(object)rightLaser == (Object)null))
			{
				((Behaviour)leftLaser).enabled = on;
				((Renderer)leftLaser.line).enabled = on;
				((Behaviour)rightLaser).enabled = on;
				((Renderer)rightLaser.line).enabled = on;
				if (on && (Object)(object)interactRay != (Object)null)
				{
					((Renderer)interactRay).enabled = false;
				}
			}
		}

		public static void SetInteractRay(bool show, Vector3 origin, Vector3 end, Color color)
		{
			//IL_0041: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)interactRay == (Object)null)
			{
				return;
			}
			if (!show || menuPointersOn)
			{
				if (((Renderer)interactRay).enabled)
				{
					((Renderer)interactRay).enabled = false;
				}
				return;
			}
			((Renderer)interactRay).enabled = true;
			interactRay.SetPosition(0, origin);
			interactRay.SetPosition(1, end);
			if (interactRayMat.HasProperty("_BaseColor"))
			{
				interactRayMat.SetColor("_BaseColor", color);
			}
			else
			{
				interactRayMat.color = color;
			}
		}

		private static LineRenderer CreateInteractRay(Transform hand)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			GameObject val = new GameObject("PeakVR Interact Ray")
			{
				layer = VRLayers.UI
			};
			val.transform.SetParent(hand, false);
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			val2.useWorldSpace = true;
			val2.widthMultiplier = 0.004f;
			val2.numCapVertices = 4;
			val2.positionCount = 2;
			Color startColor = (val2.endColor = Color.white);
			val2.startColor = startColor;
			Shader val3 = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
			interactRayMat = new Material(val3);
			((Renderer)val2).material = interactRayMat;
			((Renderer)val2).enabled = false;
			return val2;
		}

		private static Transform CreateHand(Transform rig, string hand, string name, out VRLaser laser)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(rig, false);
			InputAction val2 = new InputAction(hand + " HandPos", (InputActionType)0, "<XRController>{" + hand + "}/pointer/position", (string)null, (string)null, "Vector3");
			InputAction val3 = new InputAction(hand + " HandRot", (InputActionType)0, "<XRController>{" + hand + "}/pointer/rotation", (string)null, (string)null, "Quaternion");
			val2.Enable();
			val3.Enable();
			TrackedPoseDriver val4 = val.AddComponent<TrackedPoseDriver>();
			val4.trackingType = (TrackingType)0;
			val4.updateType = (UpdateType)0;
			val4.positionInput = new InputActionProperty(val2);
			val4.rotationInput = new InputActionProperty(val3);
			LineRenderer val5 = val.AddComponent<LineRenderer>();
			val5.useWorldSpace = false;
			val5.widthMultiplier = 0.005f;
			val5.numCapVertices = 4;
			val5.positionCount = 2;
			val5.SetPosition(0, Vector3.zero);
			val5.SetPosition(1, Vector3.forward * 5f);
			Color startColor = (val5.endColor = Color.cyan);
			val5.startColor = startColor;
			((Renderer)val5).material = CreateLaserMaterial();
			((Renderer)val5).enabled = false;
			InputAction val6 = new InputAction(hand + " PointerTrigger", (InputActionType)1, "<XRController>{" + hand + "}/triggerPressed", (string)null, (string)null, (string)null);
			val6.Enable();
			laser = val.AddComponent<VRLaser>();
			laser.line = val5;
			laser.trigger = val6;
			((Behaviour)laser).enabled = false;
			val.layer = VRLayers.UI;
			if ((Object)(object)PeakAssets.Controller != (Object)null)
			{
				GameObject val7 = Object.Instantiate<GameObject>(PeakAssets.Controller, val.transform);
				val7.transform.localPosition = Vector3.zero;
				val7.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
				if (handMat == null)
				{
					handMat = new Material(Shader.Find("Universal Render Pipeline/Lit"))
					{
						color = new Color(0.12f, 0.12f, 0.13f)
					};
				}
				Renderer[] componentsInChildren = val7.GetComponentsInChildren<Renderer>();
				foreach (Renderer val8 in componentsInChildren)
				{
					val8.sharedMaterial = handMat;
				}
				VRControllerVisibility.Register(val7);
			}
			Plugin.Log.LogInfo((object)("[PeakVR] Created in-game " + name));
			return val.transform;
		}

		private static Material CreateLaserMaterial()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)laserMat != (Object)null)
			{
				return laserMat;
			}
			Shader val = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
			laserMat = new Material(val);
			if (laserMat.HasProperty("_BaseColor"))
			{
				laserMat.SetColor("_BaseColor", Color.cyan);
			}
			else
			{
				laserMat.color = Color.cyan;
			}
			return laserMat;
		}
	}
	[DefaultExecutionOrder(1000)]
	internal class VRHeadRig : MonoBehaviour
	{
		public static float HandScale = 1f;

		private const float SnapThreshold = 0.7f;

		private const float SnapReleaseThreshold = 0.3f;

		private const float SmoothDeadzone = 0.15f;

		private const float StickDeadzone = 0.1f;

		private const float ForceMultiplier = 8f;

		private const float MaxGap = 0.75f;

		private const float MinGap = 0.02f;

		private const float RecenterSpeed = 2f;

		private const float MoveDeadzone = 0.12f;

		private const float WalkInputGain = 0.6f;

		private const float MaxWalkInput = 0.5f;

		private const float CrouchRatio = 0.65f;

		private const float CrouchExitRatio = 0.72f;

		private const float RecalibRate = 0.3f;

		private const float FreeRadius = 0.1f;

		private const float ClampDown = 0.8f;

		private const float ClampUp = 0.4f;

		private const float RefRate = 2.5f;

		private const float CrouchCenter = 0.1f;

		private const float CenterLerpRate = 4f;

		public static bool RoomMoving;

		public static Vector2 RoomInput;

		public static bool Crouching;

		private static bool recalibrateRequested;

		private Camera cam;

		private TrackedPoseDriver headDriver;

		private Vector3 hmdOffset;

		private float turnYaw;

		private bool snapReady = true;

		private Vector2 originOffset;

		private Vector2 prevAnchor;

		private bool hasPrev;

		private Vector2 prevHmdRawXZ;

		private bool physInit;

		private Vector2 physVel;

		private float hmdRef;

		private float standingHmdY;

		private float crouchCenter;

		private bool heightCalibrated;

		private bool resetHeight;

		private const float SpecDistance = 3f;

		private const float SpecHeight = 1.5f;

		public static void RequestRecalibrate()
		{
			recalibrateRequested = true;
		}

		private void Awake()
		{
			cam = ((Component)this).GetComponentInChildren<Camera>();
			VRCutscene.Active = false;
		}

		private void Update()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cam != (Object)null)
			{
				hmdOffset = ((Component)cam).transform.localPosition;
			}
			RenderDiagnostics.Tick(cam);
			VRControllerVisibility.Tick();
			HandleTurn();
			if (Keyboard.current != null && ((ButtonControl)Keyboard.current.f5Key).wasPressedThisFrame)
			{
				resetHeight = true;
			}
			if (recalibrateRequested)
			{
				recalibrateRequested = false;
				resetHeight = true;
			}
		}

		private void HandleTurn()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (VRControls.TurnStick == null)
			{
				return;
			}
			float x = VRControls.TurnStick.ReadValue<Vector2>().x;
			float num = turnYaw;
			if (Plugin.Config.SmoothTurn.Value)
			{
				if (Mathf.Abs(x) > 0.15f)
				{
					turnYaw += x * Plugin.Config.SmoothTurnSpeed.Value * Time.deltaTime;
				}
			}
			else if (snapReady && Mathf.Abs(x) > 0.7f)
			{
				turnYaw += Mathf.Sign(x) * Plugin.Config.SnapTurnAngle.Value;
				snapReady = false;
			}
			else if (Mathf.Abs(x) < 0.3f)
			{
				snapReady = true;
			}
			if (turnYaw != num)
			{
				PivotAroundHead(num, turnYaw);
			}
		}

		private void PivotAroundHead(float oldYaw, float newYaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = hmdOffset * HandScale;
			Vector3 val2 = Quaternion.Euler(0f, oldYaw, 0f) * val;
			Vector3 val3 = Quaternion.Euler(0f, newYaw, 0f) * val;
			originOffset.x -= val3.x - val2.x;
			originOffset.y -= val3.z - val2.z;
		}

		private void LateUpdate()
		{
			//IL_0062: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00dd: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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)
			if (VRCutscene.Active)
			{
				Transform val = VRCutscene.CurrentTransform();
				if (!((Object)(object)val == (Object)null))
				{
					HandleCutscene(val);
					return;
				}
				VRCutscene.Active = false;
			}
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)cam == (Object)null))
			{
				if (localCharacter.data.fullyPassedOut)
				{
					HandleSpectator(localCharacter);
					return;
				}
				((Component)this).transform.localScale = Vector3.one * HandScale;
				((Component)this).transform.rotation = Quaternion.Euler(0f, turnYaw, 0f);
				Vector3 cameraPos = localCharacter.GetCameraPos(0f);
				Vector3 val2 = ((Component)this).transform.rotation * (hmdOffset * HandScale);
				Vector2 anchorXZ = default(Vector2);
				((Vector2)(ref anchorXZ))..ctor(cameraPos.x, cameraPos.z);
				UpdatePhysVel();
				CompensateOrigin(anchorXZ, new Vector2(val2.x, val2.z));
				((Component)this).transform.position = new Vector3(cameraPos.x + originOffset.x, ComputeRigY(cameraPos), cameraPos.z + originOffset.y);
				RoomScale(localCharacter, new Vector2(val2.x, val2.z));
				HandleCrouch();
			}
		}

		private void HandleCutscene(Transform cutsceneCam)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cam == (Object)null))
			{
				if ((Object)(object)headDriver == (Object)null)
				{
					headDriver = ((Component)cam).GetComponent<TrackedPoseDriver>();
				}
				if ((Object)(object)headDriver != (Object)null && !((Behaviour)headDriver).enabled)
				{
					((Behaviour)headDriver).enabled = true;
				}
				((Component)this).transform.localScale = Vector3.one * HandScale;
				((Component)this).transform.SetPositionAndRotation(cutsceneCam.position, cutsceneCam.rotation);
			}
		}

		private void HandleSpectator(Character character)
		{
			//IL_0063: 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_0068: 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_007e: 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_00b4: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)headDriver == (Object)null && (Object)(object)cam != (Object)null)
			{
				headDriver = ((Component)cam).GetComponent<TrackedPoseDriver>();
			}
			if ((Object)(object)headDriver != (Object)null && !((Behaviour)headDriver).enabled)
			{
				((Behaviour)headDriver).enabled = true;
			}
			Vector3 val = (VRSpectator.HasTarget ? VRSpectator.Pivot : character.GetSpectatePosition());
			Quaternion val2 = Quaternion.Euler(0f, turnYaw, 0f);
			float num = ((character.data.spectateZoom > 0.1f) ? character.data.spectateZoom : 3f);
			((Component)this).transform.localScale = Vector3.one * HandScale;
			((Component)this).transform.rotation = val2;
			((Component)this).transform.position = val + val2 * new Vector3(0f, 1.5f, 0f - num);
		}

		private float ComputeRigY(Vector3 anchor)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			if (!heightCalibrated || resetHeight)
			{
				standingHmdY = hmdOffset.y;
				hmdRef = hmdOffset.y;
				heightCalibrated = true;
				resetHeight = false;
			}
			else
			{
				float num = hmdOffset.y - hmdRef;
				if (num > 0.1f)
				{
					hmdRef = Mathf.Lerp(hmdRef, hmdOffset.y - 0.1f, 2.5f * Time.deltaTime);
				}
				else if (num < -0.1f)
				{
					hmdRef = Mathf.Lerp(hmdRef, hmdOffset.y + 0.1f, 2.5f * Time.deltaTime);
				}
			}
			crouchCenter = Mathf.Lerp(crouchCenter, Crouching ? (-0.1f) : 0f, 4f * Time.deltaTime);
			float num2 = Mathf.Clamp(hmdOffset.y - hmdRef, -0.8f, 0.4f);
			return anchor.y + crouchCenter + num2 - hmdOffset.y;
		}

		private void HandleCrouch()
		{
			if (heightCalibrated && !(standingHmdY < 0.1f))
			{
				float num = hmdOffset.y / standingHmdY;
				if (num < 0.65f)
				{
					Crouching = true;
				}
				else if (num > 0.72f)
				{
					Crouching = false;
				}
				if (!Crouching && num > 0.72f)
				{
					standingHmdY = Mathf.Lerp(standingHmdY, hmdOffset.y, 0.3f * Time.deltaTime);
				}
			}
		}

		private void UpdatePhysVel()
		{
			//IL_002d: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(hmdOffset.x, hmdOffset.z);
			physVel = (physInit ? ((val - prevHmdRawXZ) / Mathf.Max(Time.deltaTime, 0.0001f)) : Vector2.zero);
			prevHmdRawXZ = val;
			physInit = true;
		}

		private void ComputeWalkInput(Character character)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_007f: 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_008e: 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)
			//IL_0095: 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_00a6: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!(((Vector2)(ref physVel)).magnitude < 0.12f))
			{
				Vector3 val = ((Component)this).transform.rotation * new Vector3(physVel.x, 0f, physVel.y);
				Vector3 lookDirection = character.data.lookDirection;
				lookDirection.y = 0f;
				if (!(((Vector3)(ref lookDirection)).sqrMagnitude < 0.0001f))
				{
					((Vector3)(ref lookDirection)).Normalize();
					Vector3 val2 = default(Vector3);
					((Vector3)(ref val2))..ctor(lookDirection.z, 0f, 0f - lookDirection.x);
					Vector2 val3 = default(Vector2);
					((Vector2)(ref val3))..ctor(Vector3.Dot(val, val2), Vector3.Dot(val, lookDirection));
					RoomInput = Vector2.ClampMagnitude(val3 * 0.6f, 0.5f);
				}
			}
		}

		private void CompensateOrigin(Vector2 anchorXZ, Vector2 hmdXZ)
		{
			//IL_0023: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0084: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			if (!hasPrev)
			{
				prevAnchor = anchorXZ;
				originOffset = -hmdXZ;
				hasPrev = true;
				return;
			}
			Vector2 val = anchorXZ - prevAnchor;
			prevAnchor = anchorXZ;
			Vector2 val2 = anchorXZ + originOffset + hmdXZ;
			if (Vector2.Distance(anchorXZ + new Vector2(val.x, 0f), val2) < Vector2.Distance(anchorXZ, val2))
			{
				originOffset.x -= val.x;
			}
			if (Vector2.Distance(anchorXZ + new Vector2(0f, val.y), val2) < Vector2.Distance(anchorXZ, val2))
			{
				originOffset.y -= val.y;
			}
		}

		private void RoomScale(Character character, Vector2 hmdXZ)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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)
			RoomMoving = false;
			RoomInput = Vector2.zero;
			Vector2 val = originOffset + hmdXZ;
			float magnitude = ((Vector2)(ref val)).magnitude;
			float num;
			if (VRControls.MoveStick == null)
			{
				num = 0f;
			}
			else
			{
				Vector2 val2 = VRControls.MoveStick.ReadValue<Vector2>();
				num = ((Vector2)(ref val2)).magnitude;
			}
			float num2 = num;
			if (num2 > 0.1f)
			{
				originOffset = Vector2.MoveTowards(originOffset, originOffset - val, 2f * Time.deltaTime);
				ComputeWalkInput(character);
			}
			else if (!(magnitude < 0.02f))
			{
				if (magnitude > 0.75f)
				{
					originOffset -= val;
				}
				else if (!((Object)(object)VRPointer.Canvas != (Object)null) && character.data.isGrounded)
				{
					float num3 = (((Object)(object)character.refs.movement != (Object)null) ? character.refs.movement.movementForce : 10f);
					character.AddForce(new Vector3(val.x, 0f, val.y) * (num3 * 8f), 1f, 1f);
					RoomMoving = true;
				}
			}
		}
	}
	[DefaultExecutionOrder(2000)]
	internal class VRHeadRoll : MonoBehaviour
	{
		public static float LocalRoll;

		private Camera cam;

		private Quaternion hmdLocalRot = Quaternion.identity;

		private void Awake()
		{
			cam = ((Component)this).GetComponentInChildren<Camera>();
		}

		private void Update()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cam != (Object)null)
			{
				hmdLocalRot = ((Component)cam).transform.localRotation;
			}
		}

		private void LateUpdate()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = hmdLocalRot * Vector3.forward;
			Vector3 val2 = hmdLocalRot * Vector3.up;
			Vector3 val3 = Vector3.ProjectOnPlane(Vector3.up, val);
			if (((Vector3)(ref val3)).sqrMagnitude < 0.0001f)
			{
				return;
			}
			((Vector3)(ref val3)).Normalize();
			float num = (LocalRoll = Vector3.SignedAngle(val3, val2, val));
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)localCharacter.refs.head == (Object)null) && !((Object)(object)VRPointer.Canvas != (Object)null) && !localCharacter.data.fullyPassedOut)
			{
				Vector3 lookDirection = localCharacter.data.lookDirection;
				if (!(((Vector3)(ref lookDirection)).sqrMagnitude < 0.0001f))
				{
					((Vector3)(ref lookDirection)).Normalize();
					Transform transform = ((Component)localCharacter.refs.head).transform;
					transform.rotation = Quaternion.AngleAxis(num, lookDirection) * transform.rotation;
				}
			}
		}
	}
	[DefaultExecutionOrder(1200)]
	internal class VRInteractPrompt : MonoBehaviour
	{
		private const float Scale = 0.0013f;

		private const float ForwardOffset = 0.05f;

		private const float UpOffset = 0.07f;

		private Canvas canvas;

		private RectTransform canvasRt;

		private Transform interactName;

		private Transform interactPrompts;

		private Transform progress;

		private UI_UseItemProgress progressComp;

		private void LateUpdate()
		{
			//IL_0092: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)VRHands.Right == (Object)null)
			{
				return;
			}
			GUIManager instance = GUIManager.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				if ((Object)(object)instance.reticleDefault != (Object)null && instance.reticleDefault.activeSelf)
				{
					instance.reticleDefault.SetActive(false);
				}
				EnsureCanvas();
				if ((Object)(object)progressComp == (Object)null)
				{
					progressComp = Object.FindObjectOfType<UI_UseItemProgress>(true);
				}
				Adopt(ref progress, ((Object)(object)progressComp != (Object)null) ? ((Component)progressComp).transform : null, new Vector2(0f, 155f));
				Adopt(ref interactName, ((Object)(object)instance.interactName != (Object)null) ? instance.interactName.transform : null, new Vector2(0f, 70f));
				Adopt(ref interactPrompts, PromptContainer(instance), new Vector2(0f, -70f));
				PlaceCanvas();
			}
		}

		private void EnsureCanvas()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0089: 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)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)canvas != (Object)null))
			{
				GameObject val = new GameObject("PeakVR Interact Prompt");
				canvas = val.AddComponent<Canvas>();
				canvas.renderMode = (RenderMode)2;
				canvas.worldCamera = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
				canvas.sortingOrder = 50;
				canvasRt = (RectTransform)val.transform;
				canvasRt.sizeDelta = new Vector2(500f, 400f);
				((Transform)canvasRt).localScale = Vector3.one * 0.0013f;
			}
		}

		private void Adopt(ref Transform held, Transform target, Vector2 anchoredPos)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			if ((Object)(object)target.parent != (Object)(object)canvasRt)
			{
				target.SetParent((Transform)(object)canvasRt, false);
				RectTransform val = (RectTransform)(object)((target is RectTransform) ? target : null);
				if (val != null)
				{
					Vector2 val2 = default(Vector2);
					((Vector2)(ref val2))..ctor(0.5f, 0.5f);
					val.pivot = val2;
					Vector2 anchorMin = (val.anchorMax = val2);
					val.anchorMin = anchorMin;
					val.anchoredPosition = anchoredPos;
				}
			}
			held = target;
		}

		private static Transform PromptContainer(GUIManager gui)
		{
			if ((Object)(object)gui.interactPromptPrimary != (Object)null && (Object)(object)gui.interactPromptPrimary.transform.parent != (Object)null)
			{
				return gui.interactPromptPrimary.transform.parent;
			}
			return null;
		}

		private void PlaceCanvas()
		{
			//IL_0037: 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_0046: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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)
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if (!((Object)(object)val == (Object)null))
			{
				Transform right = VRHands.Right;
				Transform transform = ((Component)val).transform;
				Vector3 val2 = right.position + Vector3.up * 0.07f + right.forward * 0.05f;
				((Transform)canvasRt).position = val2;
				Vector3 val3 = val2 - transform.position;
				if (((Vector3)(ref val3)).sqrMagnitude < 0.0001f)
				{
					val3 = transform.forward;
				}
				((Transform)canvasRt).rotation = Quaternion.LookRotation(((Vector3)(ref val3)).normalized, Vector3.up);
			}
		}
	}
	[DefaultExecutionOrder(1500)]
	internal class VRItemAim : MonoBehaviour
	{
		private const float MaxDist = 80f;

		private const float ReticlePadding = 0.03f;

		private const float ReticleAngularScale = 0.022f;

		private LineRenderer line;

		private Material lineMat;

		private SpriteRenderer reticle;

		private bool reticleSpriteSet;

		private void Awake()
		{
			CreateLine();
			CreateReticle();
		}

		private void Update()
		{
			//IL_0026: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				if (((ButtonControl)current.f9Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(-5f, 0f, 0f));
				}
				else if (((ButtonControl)current.f10Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(5f, 0f, 0f));
				}
				else if (((ButtonControl)current.f11Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(0f, -5f, 0f));
				}
				else if (((ButtonControl)current.f12Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(0f, 5f, 0f));
				}
				else if (((ButtonControl)current.f2Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(0f, 0f, -5f));
				}
				else if (((ButtonControl)current.f3Key).wasPressedThisFrame)
				{
					AdjustOffset(new Vector3(0f, 0f, 5f));
				}
			}
		}

		private static void AdjustOffset(Vector3 delta)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			ShootableAim.RotationOffset += delta;
			Plugin.Log.LogInfo((object)$"[PeakVR] Item rotation offset = {ShootableAim.RotationOffset}");
		}

		private void LateUpdate()
		{
			//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_0081: 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_0088: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00f1: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			Item val = (((Object)(object)localCharacter != (Object)null) ? localCharacter.data.currentItem : null);
			bool flag = (Object)(object)val != (Object)null && val.UIData.isShootable;
			if (!ItemAim.Enabled || (Object)(object)VRHands.Right == (Object)null || (Object)(object)VRPointer.Canvas != (Object)null || (Object)(object)val == (Object)null || (!flag && !IsPlacementItem(val)))
			{
				Hide();
				return;
			}
			if (flag)
			{
				HideGameReticle();
			}
			Ray middleScreenRay = ItemAim.GetMiddleScreenRay();
			LayerMask val2 = HelperExtensions.ToLayerMask((LayerType)1);
			RaycastHit val4 = default(RaycastHit);
			Vector3 val3 = (Physics.Raycast(middleScreenRay, ref val4, 80f, LayerMask.op_Implicit(val2), (QueryTriggerInteraction)1) ? ((RaycastHit)(ref val4)).point : (((Ray)(ref middleScreenRay)).origin + ((Ray)(ref middleScreenRay)).direction * 80f));
			((Renderer)line).enabled = true;
			line.SetPosition(0, ((Ray)(ref middleScreenRay)).origin);
			line.SetPosition(1, val3);
			if (flag && val.CanUsePrimary() && TryGetReachHit(val, out var hit))
			{
				EnsureReticleSprite();
				Transform val5 = (((Object)(object)MainCamera.instance != (Object)null) ? ((Component)MainCamera.instance.cam).transform : null);
				float num = (((Object)(object)val5 != (Object)null) ? Vector3.Distance(val5.position, ((RaycastHit)(ref hit)).point) : 1f);
				((Component)reticle).gameObject.SetActive(true);
				((Component)reticle).transform.position = ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * 0.03f;
				((Component)reticle).transform.rotation = (((Object)(object)val5 != (Object)null) ? val5.rotation : Quaternion.LookRotation(((RaycastHit)(ref hit)).normal));
				((Component)reticle).transform.localScale = Vector3.one * (0.022f * num);
			}
			else
			{
				((Component)reticle).gameObject.SetActive(false);
			}
		}

		private static bool TryGetReachHit(Item item, out RaycastHit hit)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			RopeShooter componentInChildren = ((Component)item).GetComponentInChildren<RopeShooter>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren.WillAttach(ref hit);
			}
			VineShooter componentInChildren2 = ((Component)item).GetComponentInChildren<VineShooter>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				return componentInChildren2.WillAttach(ref hit);
			}
			Ray middleScreenRay = ItemAim.GetMiddleScreenRay();
			return Physics.Raycast(middleScreenRay, ref hit, 80f, LayerMask.op_Implicit(HelperExtensions.ToLayerMask((LayerType)1)), (QueryTriggerInteraction)1);
		}

		private void Hide()
		{
			if ((Object)(object)line != (Object)null && ((Renderer)line).enabled)
			{
				((Renderer)line).enabled = false;
			}
			if ((Object)(object)reticle != (Object)null && ((Component)reticle).gameObject.activeSelf)
			{
				((Component)reticle).gameObject.SetActive(false);
			}
		}

		private static void HideGameReticle()
		{
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.reticleShoot != (Object)null && instance.reticleShoot.activeSelf)
			{
				instance.reticleShoot.SetActive(false);
			}
		}

		private void EnsureReticleSprite()
		{
			if (reticleSpriteSet)
			{
				return;
			}
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.reticleShoot != (Object)null)
			{
				Image componentInChildren = instance.reticleShoot.GetComponentInChildren<Image>(true);
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.sprite != (Object)null)
				{
					reticle.sprite = componentInChildren.sprite;
					reticleSpriteSet = true;
					return;
				}
			}
			if ((Object)(object)PeakAssets.Reticle != (Object)null)
			{
				reticle.sprite = PeakAssets.Reticle;
				reticleSpriteSet = true;
			}
		}

		private static bool IsPlacementItem(Item item)
		{
			if (!((Object)(object)((Component)item).GetComponentInChildren<Constructable>() != (Object)null) && !((Object)(object)((Component)item).GetComponentInChildren<ClimbingSpikeComponent>() != (Object)null))
			{
				return (Object)(object)((Component)item).GetComponentInChildren<RopeTier>() != (Object)null;
			}
			return true;
		}

		private void CreateLine()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00bd: 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)
			GameObject val = new GameObject("PeakVR ItemAim Line");
			val.transform.SetParent(((Component)this).transform, false);
			line = val.AddComponent<LineRenderer>();
			line.useWorldSpace = true;
			line.widthMultiplier = 0.006f;
			line.numCapVertices = 4;
			line.positionCount = 2;
			line.textureMode = (LineTextureMode)0;
			Shader val2 = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
			lineMat = new Material(val2);
			if (lineMat.HasProperty("_BaseColor"))
			{
				lineMat.SetColor("_BaseColor", Color.white);
			}
			else
			{
				lineMat.color = Color.white;
			}
			((Renderer)line).material = lineMat;
			((Renderer)line).enabled = false;
		}

		private void CreateReticle()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("PeakVR ItemAim Reticle");
			val.transform.SetParent(((Component)this).transform, false);
			reticle = val.AddComponent<SpriteRenderer>();
			((Component)reticle).gameObject.SetActive(false);
		}
	}
	internal class VRLaser : MonoBehaviour
	{
		public LineRenderer line;

		public InputAction trigger;

		private const float MaxDistance = 8f;

		private const float ReticlePixels = 36f;

		private GameObject hovered;

		private GameObject pressTarget;

		private GameObject dragTarget;

		private bool dragging;

		private bool wasPressed;

		private Vector2 pressScreenPos;

		private RaycastResult pressRaycast;

		private Image reticle;

		private Canvas reticleCanvas;

		private readonly List<RaycastResult> results = new List<RaycastResult>();

		private readonly List<TrackedDeviceGraphicRaycaster> raycasters = new List<TrackedDeviceGraphicRaycaster>();

		private void OnDisable()
		{
			if ((Object)(object)reticle != (Object)null)
			{
				((Component)reticle).gameObject.SetActive(false);
			}
		}

		private void Update()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: 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_019e: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: 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_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			Canvas canvas = VRPointer.Canvas;
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			EnsureReticle(canvas);
			GatherRaycasters(canvas);
			Vector3 position = ((Component)this).transform.position;
			Vector3 forward = ((Component)this).transform.forward;
			Vector3 hitPoint;
			bool flag = TryGetPanelHit(canvas, position, forward, out hitPoint);
			line.SetPosition(1, flag ? ((Component)this).transform.InverseTransformPoint(hitPoint) : (Vector3.forward * 5f));
			UpdateReticle(canvas, flag, hitPoint);
			TrackedDeviceEventData val = new TrackedDeviceEventData(EventSystem.current)
			{
				layerMask = LayerMask.op_Implicit(-1),
				rayPoints = new List<Vector3>
				{
					position,
					position + forward * 8f
				},
				button = (InputButton)0
			};
			RaycastResult hit;
			bool flag2 = RaycastTopmost(val, out hit);
			GameObject val2 = (flag2 ? ((RaycastResult)(ref hit)).gameObject : null);
			((PointerEventData)val).pointerCurrentRaycast = hit;
			((PointerEventData)val).position = (flag2 ? hit.screenPosition : pressScreenPos);
			GameObject val3 = (((Object)(object)val2 != (Object)null) ? ExecuteEvents.GetEventHandler<IPointerEnterHandler>(val2) : null);
			if ((Object)(object)val3 != (Object)(object)hovered)
			{
				if ((Object)(object)hovered != (Object)null)
				{
					ExecuteEvents.Execute<IPointerExitHandler>(hovered, (BaseEventData)(object)val, ExecuteEvents.pointerExitHandler);
				}
				hovered = val3;
				if ((Object)(object)hovered != (Object)null)
				{
					ExecuteEvents.Execute<IPointerEnterHandler>(hovered, (BaseEventData)(object)val, ExecuteEvents.pointerEnterHandler);
				}
			}
			bool flag3 = trigger.IsPressed();
			if (flag3 && !wasPressed)
			{
				pressScreenPos = ((PointerEventData)val).position;
				pressRaycast = hit;
				((PointerEventData)val).pressPosition = pressScreenPos;
				((PointerEventData)val).pointerPressRaycast = hit;
				pressTarget = (((Object)(object)val2 != (Object)null) ? ExecuteEvents.GetEventHandler<IPointerClickHandler>(val2) : null);
				dragTarget = (((Object)(object)val2 != (Object)null) ? ExecuteEvents.GetEventHandler<IDragHandler>(val2) : null);
				dragging = false;
				((PointerEventData)val).pointerPress = pressTarget;
				((PointerEventData)val).pointerDrag = dragTarget;
				((PointerEventData)val).useDragThreshold = true;
				if ((Object)(object)pressTarget != (Object)null)
				{
					ExecuteEvents.Execute<IPointerDownHandler>(pressTarget, (BaseEventData)(object)val, ExecuteEvents.pointerDownHandler);
				}
				if ((Object)(object)dragTarget != (Object)null)
				{
					ExecuteEvents.Execute<IInitializePotentialDragHandler>(dragTarget, (BaseEventData)(object)val, ExecuteEvents.initializePotentialDrag);
				}
			}
			else if (flag3 && wasPressed)
			{
				((PointerEventData)val).pressPosition = pressScreenPos;
				((PointerEventData)val).pointerPressRaycast = pressRaycast;
				((PointerEventData)val).pointerPress = pressTarget;
				((PointerEventData)val).pointerDrag = dragTarget;
				((PointerEventData)val).delta = ((PointerEventData)val).position - pressScreenPos;
				if ((Object)(object)dragTarget != (Object)null && !dragging)
				{
					Vector2 val4 = ((PointerEventData)val).position - pressScreenPos;
					float sqrMagnitude = ((Vector2)(ref val4)).sqrMagnitude;
					int pixelDragThreshold = EventSystem.current.pixelDragThreshold;
					if (!((PointerEventData)val).useDragThreshold || sqrMagnitude >= (float)(pixelDragThreshold * pixelDragThreshold))
					{
						dragging = true;
						((PointerEventData)val).dragging = true;
						ExecuteEvents.Execute<IBeginDragHandler>(dragTarget, (BaseEventData)(object)val, ExecuteEvents.beginDragHandler);
					}
				}
				if (dragging && (Object)(object)dragTarget != (Object)null)
				{
					ExecuteEvents.Execute<IDragHandler>(dragTarget, (BaseEventData)(object)val, ExecuteEvents.dragHandler);
				}
			}
			else if (!flag3 && wasPressed)
			{
				((PointerEventData)val).pointerPressRaycast = pressRaycast;
				if (dragging && (Object)(object)dragTarget != (Object)null)
				{
					ExecuteEvents.Execute<IEndDragHandler>(dragTarget, (BaseEventData)(object)val, ExecuteEvents.endDragHandler);
				}
				if ((Object)(object)pressTarget != (Object)null)
				{
					ExecuteEvents.Execute<IPointerUpHandler>(pressTarget, (BaseEventData)(object)val, ExecuteEvents.pointerUpHandler);
				}
				GameObject val5 = (((Object)(object)val2 != (Object)null) ? ExecuteEvents.GetEventHandler<IPointerClickHandler>(val2) : null);
				if (!dragging && (Object)(object)val5 != (Object)null && (Object)(object)val5 == (Object)(object)pressTarget)
				{
					ExecuteEvents.Execute<IPointerClickHandler>(val5, (BaseEventData)(object)val, ExecuteEvents.pointerClickHandler);
				}
				pressTarget = null;
				dragTarget = null;
				dragging = false;
			}
			wasPressed = flag3;
		}

		private bool RaycastTopmost(TrackedDeviceEventData eventData, out RaycastResult hit)
		{
			//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_006c: Unknown result type (might be due to invalid IL or missing references)
			foreach (TrackedDeviceGraphicRaycaster raycaster in raycasters)
			{
				results.Clear();
				((BaseRaycaster)raycaster).Raycast((PointerEventData)(object)eventData, results);
				if (results.Count > 0)
				{
					hit = results[0];
					return true;
				}
			}
			hit = default(RaycastResult);
			return false;
		}

		private void GatherRaycasters(Canvas canvas)
		{
			raycasters.Clear();
			Canvas val = (Canvas)(((Object)(object)canvas.rootCanvas != (Object)null) ? ((object)canvas.rootCanvas) : ((object)canvas));
			Canvas[] componentsInChildren = ((Component)val).GetComponentsInChildren<Canvas>(false);
			foreach (Canvas val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || !((Behaviour)val2).isActiveAndEnabled)
				{
					continue;
				}
				TrackedDeviceGraphicRaycaster val3 = ((Component)val2).GetComponent<TrackedDeviceGraphicRaycaster>();
				if ((Object)(object)val3 == (Object)null)
				{
					if ((Object)(object)val2 != (Object)(object)val && (Object)(object)((Component)val2).GetComponent<GraphicRaycaster>() == (Object)null)
					{
						continue;
					}
					val3 = ((Component)val2).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
				}
				raycasters.Add(val3);
			}
			raycasters.Sort((TrackedDeviceGraphicRaycaster a, TrackedDeviceGraphicRaycaster b) => ((Canvas)((Component)b).GetComponent(typeof(Canvas))).sortingOrder.CompareTo(((Canvas)((Component)a).GetComponent(typeof(Canvas))).sortingOrder));
		}

		private void EnsureReticle(Canvas canvas)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)PeakAssets.Reticle == (Object)null))
			{
				if ((Object)(object)reticle == (Object)null)
				{
					GameObject val = new GameObject("PeakVR Reticle");
					reticle = val.AddComponent<Image>();
					reticle.sprite = PeakAssets.Reticle;
					((Graphic)reticle).raycastTarget = false;
					((Graphic)reticle).rectTransform.sizeDelta = new Vector2(36f, 36f);
					((Component)reticle).gameObject.SetActive(false);
					UIOverlay.MakeTopmost((Graphic)(object)reticle, 4200);
				}
				if ((Object)(object)reticleCanvas != (Object)(object)canvas)
				{
					((Transform)((Graphic)reticle).rectTransform).SetParent(((Component)canvas).transform, false);
					reticleCanvas = canvas;
				}
			}
		}

		private void UpdateReticle(Canvas canvas, bool onPanel, Vector3 hitPoint)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)reticle == (Object)null))
			{
				if (!onPanel)
				{
					((Component)reticle).gameObject.SetActive(false);
					return;
				}
				Vector3 val = ((Component)canvas).transform.InverseTransformPoint(hitPoint);
				((Transform)((Graphic)reticle).rectTransform).localPosition = new Vector3(val.x, val.y, 0f);
				((Transform)((Graphic)reticle).rectTransform).SetAsLastSibling();
				((Component)reticle).gameObject.SetActive(true);
			}
		}

		private bool TryGetPanelHit(Canvas canvas, Vector3 origin, Vector3 dir, out Vector3 hitPoint)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)canvas).transform;
			Plane val2 = default(Plane);
			((Plane)(ref val2))..ctor(-((Transform)val).forward, ((Transform)val).position);
			Ray val3 = default(Ray);
			((Ray)(ref val3))..ctor(origin, dir);
			float num = default(float);
			if (((Plane)(ref val2)).Raycast(val3, ref num))
			{
				hitPoint = ((Ray)(ref val3)).GetPoint(num);
				return true;
			}
			hitPoint = default(Vector3);
			return false;
		}
	}
	internal static class VRLayers
	{
		private static int ui = -2;

		public static int UI
		{
			get
			{
				if (ui == -2)
				{
					ui = LayerMask.NameToLayer("UI");
				}
				return ui;
			}
		}

		public static void HideFromMirror(GameObject root, params int[] preserve)
		{
			if ((Object)(object)root == (Object)null || UI < 0)
			{
				return;
			}
			Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				int layer = ((Component)val).gameObject.layer;
				bool flag = false;
				for (int j = 0; j < preserve.Length; j++)
				{
					if (layer == preserve[j])
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					((Component)val).gameObject.layer = UI;
				}
			}
		}
	}
	public enum LineVisibility
	{
		Always,
		OnInteract,
		Hidden
	}
	internal static class VRLine
	{
		private static readonly Color Fallback = new Color(0.3f, 1f, 0.4f);

		public static Color CharacterColor()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null && localCharacter.refs != null && (Object)(object)localCharacter.refs.customization != (Object)null)
			{
				try
				{
					return localCharacter.refs.customization.PlayerColor;
				}
				catch
				{
				}
			}
			return Fallback;
		}

		public static bool ShouldShow(LineVisibility mode, bool interacting)
		{
			return mode switch
			{
				LineVisibility.Always => true, 
				LineVisibility.OnInteract => interacting, 
				_ => false, 
			};
		}
	}
	[HarmonyPatch(typeof(LoadingScreen), "Awake")]
	internal static class LoadingScreenVRPatch
	{
		[HarmonyPostfix]
		private static void Postfix(LoadingScreen __instance)
		{
			((Component)__instance).gameObject.AddComponent<VRLoadingScreen>();
		}
	}
	[DefaultExecutionOrder(3000)]
	internal class VRLoadingScreen : MonoBehaviour
	{
		private const float Scale = 0.003f;

		private const float Distance = 3f;

		private LoadingScreen loadingScreen;

		private bool converted;

		private void Awake()
		{
			loadingScreen = ((Component)this).GetComponent<LoadingScreen>();
		}

		private void LateUpdate()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00cd: 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_00e3: 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_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_0104: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VrEnabled || (Object)(object)loadingScreen == (Object)null || (Object)(object)loadingScreen.canvas == (Object)null || !((Behaviour)loadingScreen.canvas).enabled)
			{
				return;
			}
			Camera val = Camera.main;
			if ((Object)(object)val == (Object)null && (Object)(object)MainCamera.instance != (Object)null)
			{
				val = MainCamera.instance.cam;
			}
			if (!((Object)(object)val == (Object)null))
			{
				if (!converted)
				{
					loadingScreen.canvas.renderMode = (RenderMode)2;
					loadingScreen.canvas.worldCamera = val;
					UIOverlay.MakeAlwaysVisible(loadingScreen.canvas, foreground: true);
					converted = true;
				}
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)((Component)loadingScreen.canvas).transform;
				((Transform)val2).localScale = Vector3.one * 0.003f;
				((Transform)val2).position = transform.position + transform.forward * 3f;
				((Transform)val2).rotation = transform.rotation;
			}
		}
	}
	[DefaultExecutionOrder(1100)]
	internal class VRMenuManager : MonoBehaviour
	{
		private const float Scale = 0.0022f;

		private const float Distance = 2.5f;

		private const float KioskForward = 0.5f;

		private const float KioskUp = 0.25f;

		private static readonly FieldInfo PauseMenuField = typeof(GUIManager).GetField("pauseMenu", BindingFlags.Instance | BindingFlags.NonPublic);

		private Canvas converted;

		private RenderMode savedMode;

		private bool convertedForeground;

		private void Update()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.instance;
			Canvas val = (((Object)(object)instance != (Object)null) ? instance.hudCanvas : null);
			bool isPauseMenu;
			Canvas val2 = FindActiveCanvas(out isPauseMenu);
			Canvas wheelCanvas = GetWheelCanvas(instance);
			Canvas val3 = (((Object)(object)val2 != (Object)null) ? val2 : wheelCanvas);
			Canvas val4 = (((Object)(object)val2 != (Object)null) ? val2 : (((Object)(object)wheelCanvas != (Object)null && (Object)(object)wheelCanvas != (Object)(object)val) ? wheelCanvas : null));
			if ((Object)(object)val4 != (Object)(object)converted)
			{
				if ((Object)(object)converted != (Object)null)
				{
					converted.renderMode = savedMode;
				}
				converted = val4;
				convertedForeground = (Object)(object)val4 != (Object)null && (Object)(object)val4 == (Object)(object)val2 && isPauseMenu;
				if ((Object)(object)converted != (Object)null)
				{
					ConvertToWorld(converted);
				}
			}
			if ((Object)(object)converted != (Object)null)
			{
				UIOverlay.MakeAlwaysVisible(converted, convertedForeground);
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null && localCharacter.data.fullyPassedOut)
				{
					PlaceInFront(converted);
				}
			}
			if ((Object)(object)val3 != (Object)null)
			{
				EnsureEventSystem();
				VRPointer.Canvas = val3;
				VRPointer.Raycaster = EnsureRaycaster(val3);
				VRHands.SetPointersActive(on: true);
			}
			else
			{
				VRPointer.Canvas = null;
				VRPointer.Raycaster = null;
				VRHands.SetPointersActive(on: false);
			}
		}

		private static Canvas FindActiveCanvas(out bool isPauseMenu)
		{
			isPauseMenu = false;
			if (GUIManager.InPauseMenu && PauseMenuField != null && (Object)(object)GUIManager.instance != (Object)null)
			{
				object? value = PauseMenuField.GetValue(GUIManager.instance);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				if ((Object)(object)val != (Object)null && val.activeInHierarchy)
				{
					Canvas componentInParent = val.GetComponentInParent<Canvas>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						isPauseMenu = true;
						return componentInParent.rootCanvas;
					}
				}
			}
			for (int num = MenuWindow.AllActiveWindows.Count - 1; num >= 0; num--)
			{
				MenuWindow val2 = MenuWindow.AllActiveWindows[num];
				if (!((Object)(object)val2 == (Object)null) && val2.isOpen && !((Object)(object)val2.panel == (Object)null))
				{
					Canvas val3 = val2.panel.GetComponentInParent<Canvas>();
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = val2.panel.GetComponentInChildren<Canvas>(true);
					}
					if ((Object)(object)val3 != (Object)null)
					{
						return val3.rootCanvas;
					}
					Plugin.Log.LogWarning((object)("[PeakVR] " + ((object)val2).GetType().Name + " open but no Canvas found"));
				}
			}
			return null;
		}

		private static GameObject GetWheelObject(GUIManager gui)
		{
			if ((Object)(object)gui == (Object)null || !gui.wheelActive)
			{
				return null;
			}
			if ((Object)(object)gui.backpackWheel != (Object)null && ((Component)gui.backpackWheel).gameObject.activeInHierarchy)
			{
				return ((Component)gui.backpackWheel).gameObject;
			}
			if ((Object)(object)gui.emoteWheel != (Object)null && gui.emoteWheel.activeInHierarchy)
			{
				return gui.emoteWheel;
			}
			return null;
		}

		private static Canvas GetWheelCanvas(GUIManager gui)
		{
			GameObject wheelObject = GetWheelObject(gui);
			if ((Object)(object)wheelObject == (Object)null)
			{
				return null;
			}
			Canvas componentInParent = wheelObject.GetComponentInParent<Canvas>();
			if (!((Object)(object)componentInParent != (Object)null))
			{
				return null;
			}
			return componentInParent.rootCanvas;
		}

		private void ConvertToWorld(Canvas canvas)
		{
			//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)
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if (!((Object)(object)val == (Object)null))
			{
				savedMode = canvas.renderMode;
				canvas.renderMode = (RenderMode)2;
				canvas.worldCamera = val;
				Transform kioskFor = GetKioskFor(canvas);
				if ((Object)(object)kioskFor != (Object)null)
				{
					PlaceAtKiosk(canvas, kioskFor);
				}
				else
				{
					PlaceInFront(canvas);
				}
				Plugin.Log.LogInfo((object)("[PeakVR] Menu -> world space: " + ((Object)canvas).name));
			}
		}

		private static Transform GetKioskFor(Canvas canvas)
		{
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.boardingPass == (Object)null || !((MenuWindow)instance.boardingPass).isOpen || (Object)(object)instance.boardingPass.kiosk == (Object)null)
			{
				return null;
			}
			GameObject panel = ((MenuWindow)instance.boardingPass).panel;
			Canvas val = (((Object)(object)panel != (Object)null) ? panel.GetComponentInParent<Canvas>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val = val.rootCanvas;
			}
			if (!((Object)(object)val == (Object)(object)canvas))
			{
				return null;
			}
			return ((Component)instance.boardingPass.kiosk).transform;
		}

		private static void PlaceAtKiosk(Canvas canvas, Transform kiosk)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0080: 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_008b: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)canvas).transform;
			((Transform)val).localScale = Vector3.one * 0.0022f;
			Vector3 val2 = kiosk.right;
			val2.y = 0f;
			val2 = ((((Vector3)(ref val2)).sqrMagnitude < 0.001f) ? kiosk.right : ((Vector3)(ref val2)).normalized);
			Camera val3 = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if ((Object)(object)val3 != (Object)null)
			{
				Vector3 val4 = ((Component)val3).transform.position - kiosk.position;
				val4.y = 0f;
				if (Vector3.Dot(val2, val4) < 0f)
				{
					val2 = -val2;
				}
			}
			((Transform)val).position = kiosk.position + val2 * 0.5f + Vector3.up * 0.25f;
			((Transform)val).rotation = Quaternion.LookRotation(-val2, Vector3.up);
		}

		private static void PlaceInFront(Canvas canvas)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008f: 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)
			//IL_009f: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if (!((Object)(object)val == (Object)null))
			{
				Transform transform = ((Component)val).transform;
				Vector3 val2 = transform.forward;
				val2.y = 0f;
				val2 = ((((Vector3)(ref val2)).sqrMagnitude < 0.001f) ? transform.forward : ((Vector3)(ref val2)).normalized);
				RectTransform val3 = (RectTransform)((Component)canvas).transform;
				((Transform)val3).localScale = Vector3.one * 0.0022f;
				((Transform)val3).position = transform.position + val2 * 2.5f;
				((Transform)val3).rotation = Quaternion.LookRotation(val2, Vector3.up);
			}
		}

		private static TrackedDeviceGraphicRaycaster EnsureRaycaster(Canvas canvas)
		{
			TrackedDeviceGraphicRaycaster val = ((Component)canvas).GetComponent<TrackedDeviceGraphicRaycaster>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)canvas).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			}
			return val;
		}

		private static void EnsureEventSystem()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				new GameObject("PeakVR EventSystem").AddComponent<EventSystem>();
			}
		}
	}
	[DefaultExecutionOrder(120)]
	internal class VRMenuPopup : MonoBehaviour
	{
		private const float Scale = 0.0025f;

		private const float Distance = 3f;

		private const float Height = 0.4f;

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

		private Canvas active;

		private void LateUpdate()
		{
			if (!Plugin.VrEnabled)
			{
				return;
			}
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)MenuCanvasPatch.MenuCanvas != (Object)null)
			{
				MenuCanvasPatch.MenuCanvas.worldCamera = val;
			}
			Canvas val2 = FindPopup();
			if ((Object)(object)val2 == (Object)null)
			{
				if ((Object)(object)active != (Object)null)
				{
					RestorePointer();
					active = null;
				}
				else if ((Object)(object)VRPointer.Canvas != (Object)(object)MenuCanvasPatch.MenuCanvas)
				{
					RestorePointer();
				}
			}
			else if ((Object)(object)val2 != (Object)(object)active)
			{
				Convert(val2, val);
				active = val2;
			}
			else if ((Object)(object)VRPointer.Canvas != (Object)(object)val2)
			{
				PointAt(val2);
			}
		}

		private static Canvas FindPopup()
		{
			Canvas[] array = Object.FindObjectsByType<Canvas>((FindObjectsSortMode)0);
			foreach (Canvas val in array)
			{
				if (IsPopup(val))
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsPopup(Canvas c)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null || !((Behaviour)c).isActiveAndEnabled)
			{
				return false;
			}
			if ((Object)(object)c == (Object)(object)MenuCanvasPatch.MenuCanvas)
			{
				return false;
			}
			if (((Object)((Component)c).transform.root).name.StartsWith("PeakVR"))
			{
				return false;
			}
			if ((Object)(object)((Component)c).GetComponentInParent<LoadingScreen>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)c).GetComponentInParent<Modal>() != (Object)null)
			{
				return Modal.IsOpen;
			}
			if ((int)c.renderMode != 0)
			{
				return converted.Contains(c);
			}
			return true;
		}

		private static void Convert(Canvas c, Camera cam)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00ba: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			if ((int)c.renderMode != 2)
			{
				c.renderMode = (RenderMode)2;
				c.worldCamera = cam;
				UIOverlay.MakeAlwaysVisible(c, foreground: true);
				converted.Add(c);
			}
			RectTransform val = (RectTransform)((Component)c).transform;
			Canvas menuCanvas = MenuCanvasPatch.MenuCanvas;
			if ((Object)(object)menuCanvas != (Object)null)
			{
				Transform transform = ((Component)menuCanvas).transform;
				((Transform)val).position = transform.position;
				((Transform)val).rotation = transform.rotation;
				((Transform)val).localScale = transform.localScale;
			}
			else
			{
				Transform transform2 = ((Component)cam).transform;
				Vector3 val2 = transform2.forward;
				val2.y = 0f;
				val2 = ((((Vector3)(ref val2)).sqrMagnitude < 0.001f) ? transform2.forward : ((Vector3)(ref val2)).normalized);
				((Transform)val).localScale = Vector3.one * 0.0025f;
				((Transform)val).position = transform2.position + val2 * 3f + Vector3.up * 0.4f;
				((Transform)val).rotation = Quaternion.LookRotation(val2, Vector3.up);
			}
			PointAt(c);
			Plugin.Log.LogInfo((object)("[PeakVR] Menu popup '" + ((Object)((Component)c).transform.root).name + "' -> world space"));
		}

		private static void PointAt(Canvas c)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			TrackedDeviceGraphicRaycaster val = ((Component)c).GetComponent<TrackedDeviceGraphicRaycaster>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)c).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			}
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				new GameObject("PeakVR EventSystem").AddComponent<EventSystem>();
			}
			VRPointer.Canvas = c;
			VRPointer.Raycaster = val;
		}

		private static void RestorePointer()
		{
			VRPointer.Canvas = MenuCanvasPatch.MenuCanvas;
			VRPointer.Raycaster = MenuCanvasPatch.MenuRaycaster;
		}
	}
	[HarmonyPatch(typeof(UIPlayerNames), "UpdateName")]
	internal static class VRNameplatePatch
	{
		private const float Scale = 0.005f;

		private static Canvas worldCanvas;

		[HarmonyPostfix]
		private static void Postfix(UIPlayerNames __instance, int index, Vector3 position, bool visible)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VrEnabled || (Object)(object)MainCamera.instance == (Object)null || index >= __instance.playerNameText.Length)
			{
				return;
			}
			PlayerName val = __instance.playerNameText[index];
			if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeSelf)
			{
				EnsureCanvas();
				if ((Object)(object)((Component)val).transform.parent != (Object)(object)((Component)worldCanvas).transform)
				{
					((Component)val).transform.SetParent(((Component)worldCanvas).transform, false);
					UIOverlay.MakeAlwaysVisible(worldCanvas, foreground: true);
				}
				Transform transform = ((Component)MainCamera.instance.cam).transform;
				((Component)val).transform.position = position;
				((Component)val).transform.rotation = Quaternion.LookRotation(position - transform.position, Vector3.up);
				((Component)val).transform.localScale = Vector3.one * 0.005f;
			}
		}

		private static void EnsureCanvas()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			if (!((Object)(object)worldCanvas != (Object)null))
			{
				GameObject val = new GameObject("PeakVR Nameplates");
				Object.DontDestroyOnLoad((Object)(object)val);
				worldCanvas = val.AddComponent<Canvas>();
				worldCanvas.renderMode = (RenderMode)2;
				worldCanvas.worldCamera = MainCamera.instance.cam;
			}
		}
	}
	[DefaultExecutionOrder(2001)]
	internal class VRNetReceiver : MonoBehaviour
	{
		private class Smooth
		{
			public float headRoll;

			public Vector3 leftPos;

			public Quaternion leftRot;

			public Vector3 rightPos;

			public Quaternion rightRot;

			public bool init;

			public int outlierCount;

			public Vector3 lastOutlierLeft;

			public Quaternion lastHeadOutput;

			public Vector3 lastAxis;

			public float lastRoll;

			public bool rollInit;
		}

		private const float SmoothSpeed = 18f;

		private const float OutlierMax = 5f;

		private const int MaxOutliers = 3;

		private readonly Dictionary<int, Smooth> smoothing = new Dictionary<int, Smooth>();

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

		private void Update()
		{
			VRNetworking.EnsureRegistered();
		}

		private void LateUpdate()
		{
			//IL_019a: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0158: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			if (VRNetworking.Remotes.Count == 0)
			{
				if (smoothing.Count > 0)
				{
					smoothing.Clear();
				}
				return;
			}
			Character localCharacter = Character.localCharacter;
			stale.Clear();
			float num = Time.deltaTime * 18f;
			Character val = default(Character);
			foreach (KeyValuePair<int, VRNetworking.RemotePose> remote in VRNetworking.Remotes)
			{
				VRNetworking.RemotePose value = remote.Value;
				value.sinceReceived += Time.deltaTime;
				VRNetworking.Remotes[remote.Key] = value;
				if (value.sinceReceived > 1f)
				{
					stale.Add(remote.Key);
					continue;
				}
				if (!PlayerHandler.TryGetCharacter(remote.Key, ref val) || (Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)localCharacter || (Object)(object)val.refs.head == (Object)null)
				{
					continue;
				}
				if (!smoothing.TryGetValue(remote.Key, out Smooth value2))
				{
					value2 = new Smooth();
					smoothing[remote.Key] = value2;
				}
				if (!value2.init)
				{
					value2.headRoll = value.headRoll;
					value2.leftPos = value.leftPos;
					value2.leftRot = value.leftRot;
					value2.rightPos = value.rightPos;
					value2.rightRot = value.rightRot;
					value2.init = true;
					goto IL_0301;
				}
				value2.headRoll = Mathf.LerpAngle(value2.headRoll, value.headRoll, num);
				Vector3 val2 = value.leftPos - value2.leftPos;
				if (!(((Vector3)(ref val2)).magnitude > 5f))
				{
					val2 = value.rightPos - value2.rightPos;
					if (!(((Vector3)(ref val2)).magnitude > 5f))
					{
						value2.outlierCount = 0;
						value2.leftPos = Vector3.Lerp(value2.leftPos, value.leftPos, num);
						value2.leftRot = Quaternion.Slerp(value2.leftRot, value.leftRot, num);
						value2.rightPos = Vector3.Lerp(value2.rightPos, value.rightPos, num);
						value2.rightRot = Quaternion.Slerp(value2.rightRot, value.rightRot, num);
						goto IL_0301;
					}
				}
				if (value2.outlierCount > 0)
				{
					val2 = value.leftPos - value2.lastOutlierLeft;
					if (((Vector3)(ref val2)).magnitude < 5f)
					{
						value2.outlierCount++;
						goto IL_0230;
					}
				}
				value2.outlierCount = 1;
				goto IL_0230;
				IL_0230:
				value2.lastOutlierLeft = value.leftPos;
				if (value2.outlierCount >= 3)
				{
					value2.outlierCount = 0;
					value2.leftPos = value.leftPos;
					value2.leftRot = value.leftRot;
					value2.rightPos = value.rightPos;
					value2.rightRot = value.rightRot;
				}
				goto IL_0301;
				IL_0301:
				if (value.hasHands)
				{
					ApplyHands(val, value2);
				}
				ApplyHeadRoll(val, value2);
			}
			foreach (int item in stale)
			{
				VRNetworking.Remotes.Remove(item);
				smoothing.Remove(item);
			}
		}

		private static void ApplyHands(Character character, Smooth s)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			CharacterRefs refs = character.refs;
			if (!((Object)(object)refs.IKHandTargetLeft == (Object)null) && !((Object)(object)refs.IKHandTargetRight == (Object)null) && !((Object)(object)refs.ikRig == (Object)null) && !((Object)(object)refs.ikLeft == (Object)null) && !((Object)(object)refs.ikRight == (Object)null))
			{
				Transform transform = ((Component)character).transform;
				refs.IKHandTargetLeft.position = transform.TransformPoint(s.leftPos);
				refs.IKHandTargetLeft.rotation = transform.rotation * s.leftRot;
				refs.IKHandTargetRight.position = transform.TransformPoint(s.rightPos);
				refs.IKHandTargetRight.rotation = transform.rotation * s.rightRot;
				refs.ikRig.weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikLeft).weight = 1f;
				((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)refs.ikRight).weight = 1f;
			}
		}

		private static void ApplyHeadRoll(Character character, Smooth s)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Vector3 lookDirection = character.data.lookDirection;
			if (!(((Vector3)(ref lookDirection)).sqrMagnitude < 0.0001f))
			{
				((Vector3)(ref lookDirection)).Normalize();
				Transform transform = ((Component)character.refs.head).transform;
				Quaternion val = transform.rotation;
				if (s.rollInit && Quaternion.Angle(transform.rotation, s.lastHeadOutput) < 1f)
				{
					val = Quaternion.AngleAxis(0f - s.lastRoll, s.lastAxis) * transform.rotation;
				}
				Quaternion lastHeadOutput = (transform.rotation = Quaternion.AngleAxis(s.headRoll, lookDirection) * val);
				s.lastHeadOutput = lastHeadOutput;
				s.lastAxis = lookDirection;
				s.lastRoll = s.headRoll;
				s.rollInit = true;
			}
		}
	}
	internal class VRNetSync : MonoBehaviour
	{
		private const float SendInterval = 0.05f;

		private float sinceSend;

		private void Update()
		{
			sinceSend += Time.deltaTime;
			if (!(sinceSend < 0.05f))
			{
				sinceSend = 0f;
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter == (Object)null) && localCharacter.refs != null && !((Object)(object)localCharacter.refs.head == (Object)null) && !((Object)(object)localCharacter.refs.IKHandTargetLeft == (Object)null) && !((Object)(object)localCharacter.refs.IKHandTargetRight == (Object)null))
				{
					VRNetworking.SendPose(localCharacter);
				}
			}
		}
	}
	internal static class VRNetworking
	{
		public struct RemotePose
		{
			public float headRoll;

			public Vector3 leftPos;

			public Quaternion leftRot;

			public Vector3 rightPos;

			public Quaternion rightRot;

			public bool hasHands;

			public float sinceReceived;
		}

		private const byte EventCode = 199;

		public const float StaleTime = 1f;

		private static bool registered;

		private static GameObject receiver;

		private static readonly RaiseEventOptions SendOptionsToOthers = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)0
		};

		public static readonly Dictionary<int, RemotePose> Remotes = new Dictionary<int, RemotePose>();

		public static void CreateReceiver()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)receiver != (Object)null))
			{
				receiver = new GameObject("PeakVR NetReceiver");
				Object.DontDestroyOnLoad((Object)(object)receiver);
				receiver.AddComponent<VRNetReceiver>();
				Plugin.Log.LogInfo((object)"[PeakVR][Net] receiver created (runs on all clients)");
			}
		}

		public static bool EnsureRegistered()
		{
			if (registered)
			{
				return true;
			}
			if (PhotonNetwork.NetworkingClient == null)
			{
				return false;
			}
			PhotonNetwork.NetworkingClient.EventReceived += OnEvent;
			registered = true;
			Plugin.Log.LogInfo((object)"[PeakVR][Net] event handler registered");
			return true;
		}

		public static void SendPose(Character c)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00e9: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.InRoom && PhotonNetwork.CurrentRoom.PlayerCount >= 2 && !((Object)(object)c.refs.IKHandTargetLeft == (Object)null) && !((Object)(object)c.refs.IKHandTargetRight == (Object)null) && !c.data.fullyPassedOut)
			{
				Transform transform = ((Component)c).transform;
				Vector3 val = transform.InverseTransformPoint(c.refs.IKHandTargetLeft.position);
				Quaternion val2 = Quaternion.Inverse(transform.rotation) * c.refs.IKHandTargetLeft.rotation;
				Vector3 val3 = transform.InverseTransformPoint(c.refs.IKHandTargetRight.position);
				Quaternion val4 = Quaternion.Inverse(transform.rotation) * c.refs.IKHandTargetRight.rotation;
				object[] array = new object[5]
				{
					VRHeadRoll.LocalRoll,
					val,
					val2,
					val3,
					val4
				};
				PhotonNetwork.RaiseEvent((byte)199, (object)array, SendOptionsToOthers, SendOptions.SendUnreliable);
			}
		}

		public static bool IsActiveRemote(Character c)
		{
			if ((Object)(object)c == (Object)null || (Object)(object)((MonoBehaviourPun)c).photonView == (Object)null)
			{
				return false;
			}
			if (Remotes.TryGetValue(((MonoBehaviourPun)c).photonView.OwnerActorNr, out var value) && value.hasHands)
			{
				return value.sinceReceived <= 1f;
			}
			return false;
		}

		private static void OnEvent(EventData e)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (e.Code == 199)
			{
				object[] array = (object[])e.CustomData;
				RemotePose value = new RemotePose
				{
					headRoll = (float)array[0],
					leftPos = (Vector3)array[1],
					leftRot = (Quaternion)array[2],
					rightPos = (Vector3)array[3],
					rightRot = (Quaternion)array[4],
					hasHands = true,
					sinceReceived = 0f
				};
				Remotes[e.Sender] = value;
			}
		}
	}
	internal static class VRPointer
	{
		public static Canvas Canvas;

		public static TrackedDeviceGraphicRaycaster Raycaster;
	}
	internal static class VRRender
	{
		private static bool logged;

		private static bool aoDisabled;

		public static void DisableBrokenAO()
		{
			if (Application.unityVersion.StartsWith("6000.0."))
			{
				return;
			}
			try
			{
				UrpDiagnostics.SetFeatureActive("HBAO", active: false);
				if (!aoDisabled)
				{
					aoDisabled = true;
					Plugin.Log.LogInfo((object)("[PeakVR] Disabled HBAO ambient occlusion (broken under Unity " + Application.unityVersion + " / URP 17.3 XR path)"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[PeakVR] Could not disable HBAO: " + ex.Message));
			}
		}

		public static void DisableXRVisibilityMesh()
		{
			try
			{
				PropertyInfo propertyInfo = AccessTools.TypeByName("UnityEngine.Rendering.XRSRPSettings")?.GetProperty("useVisibilityMesh", BindingFlags.Static | BindingFlags.Public);
				if (propertyInfo != null && propertyInfo.CanWrite)
				{
					if ((bool)propertyInfo.GetValue(null))
					{
						propertyInfo.SetValue(null, false);
						Log("[PeakVR] Disabled XR visibility mesh (URP post-processing uses pass 0)");
					}
					return;
				}
				MethodInfo methodInfo = AccessTools.TypeByName("UnityEngine.Rendering.XRSystem")?.GetMethod("SetUseVisibilityMesh", BindingFlags.Static | BindingFlags.NonPublic);
				if (methodInfo != null)
				{
					methodInfo.Invoke(null, new object[1] { false });
					Log("[PeakVR] Disabled XR visibility mesh via XRSystem");
				}
			}
			catch (Exception ex)
			{
				Log("[PeakVR] Could not disable XR visibility mesh: " + ex.Message);
			}
		}

		private static void Log(string message)
		{
			if (!logged)
			{
				logged = true;
				Plugin.Log.LogInfo((object)message);
			}
		}
	}
	[DefaultExecutionOrder(2000)]
	internal class VRShoulderTwist : MonoBehaviour
	{
		private struct ArmState
		{
			public bool has;

			public float prev;

			public float baseline;

			public float smooth;

			public bool applied;

			public Quaternion cleanLocal;

			public Quaternion lastOutputLocal;
		}

		public static bool Enabled = true;

		private const float ExtensionStart = 0.9f;

		private const float Influence = 0.6f;

		private const float MaxTwist = 60f;

		private const float Smoothing = 12f;

		private ArmState right = new ArmState
		{
			baseline = -4.51f,
			prev = -4.51f,
			has = true
		};

		private ArmState left = new ArmState
		{
			baseline = 14.15f,
			prev = 14.15f,
			has = true
		};

		private bool recalibrate;

		private void LateUpdate()
		{
			HandleToggles();
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)VRHands.Left == (Object)null) && !((Object)(object)VRHands.Right == (Object)null) && !localCharacter.data.fullyPassedOut)
			{
				CharacterRefs refs = localCharacter.refs;
				if (refs != null && !((Object)(object)refs.ikLeft == (Object)null) && !((Object)(object)refs.ikRight == (Object)null))
				{
					bool suppress = !Enabled || (Object)(object)VRPointer.Canvas != (Object)null;
					Apply(refs.ikRight, VRHands.Right, suppress, ref right, "R");
					Apply(refs.ikLeft, VRHands.Left, suppress, ref left, "L");
					recalibrate = false;
				}
			}
		}

		private void HandleToggles()
		{
			if (!Plugin.DebugButtons)
			{
				return;
			}
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				if (((ButtonControl)current.f8Key).wasPressedThisFrame)
				{
					Enabled = !Enabled;
					Plugin.Log.LogInfo((object)("[PeakVR][Twist] wrist shoulder-twist " + (Enabled ? "ENABLED" : "DISABLED")));
				}
				if (((ButtonControl)current.f7Key).wasPressedThisFrame)
				{
					VRArmIKPatch.ElbowClampEnabled = !VRArmIKPatch.ElbowClampEnabled;
					Plugin.Log.LogInfo((object)("[PeakVR][Twist] min-elbow clamp " + (VRArmIKPatch.ElbowClampEnabled ? "ENABLED" : "DISABLED")));
				}
				if (((ButtonControl)current.f6Key).wasPressedThisFrame)
				{
					recalibrate = true;
					Plugin.Log.LogInfo((object)"[PeakVR][Twist] recalibrating neutral wrist baseline");
				}
			}
		}

		private void Apply(TwoBoneIKConstraint ik, Transform hand, bool suppress, ref ArmState s, string arm)
		{
			//IL_0065: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_008f: 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)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00c7: 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_00d8: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			Transform root = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).root;
			Transform mid = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).mid;
			Transform tip = ((TwoBoneIKConstraintData)(ref ((RigConstraint<TwoBoneIKConstraintJob, TwoBoneIKConstraintData, TwoBoneIKConstraintJobBinder<TwoBoneIKConstraintData>>)(object)ik).data)).tip;
			if ((Object)(object)root == (Object)null || (Object)(object)mid == (Object)null || (Object)(object)tip == (Object)null)
			{
				return;
			}
			if (!s.applied || Quaternion.Angle(root.localRotation, s.lastOutputLocal) > 0.5f)
			{
				s.cleanLocal = root.localRotation;
			}
			root.localRotation = s.cleanLocal;
			s.applied = false;
			Quaternion val = hand.rotation * VRArmIKPatch.HandRotationOffset;
			Vector3 val2 = tip.position - root.position;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			if (magnitude < 0.0001f)
			{
				return;
			}
			val2 /= magnitude;
			float num = Vector3.Distance(root.position, mid.position) + Vector3.Distance(mid.position, tip.position);
			if (num < 0.0001f)
			{
				return;
			}
			float num2 = Mathf.Clamp01(magnitude / num);
			float num3 = Mathf.InverseLerp(0.9f, 1f, num2);
			float num4 = TwistAngle(val * Quaternion.Inverse(mid.rotation), val2);
			if (s.has)
			{
				while (num4 - s.prev > 180f)
				{
					num4 -= 360f;
				}
				for (; num4 - s.prev < -180f; num4 += 360f)
				{
				}
			}
			else
			{
				s.baseline = num4;
				s.has = true;
				Plugin.Log.LogInfo((object)$"[PeakVR][Twist] {arm} auto baseline = {num4:F2}");
			}
			s.prev = num4;
			if (recalibrate)
			{
				s.baseline = num4;
				Plugin.Log.LogInfo((object)$"[PeakVR][Twist] {arm} neutral baseline = {num4:F2}");
			}
			float num5 = num4 - s.baseline;
			float num6 = Mathf.Clamp(0.6f * num3 * num5, -60f, 60f);
			s.smooth = Mathf.Lerp(s.smooth, num6, Mathf.Clamp01(12f * Time.deltaTime));
			if (!suppress && !(num3 <= 0f))
			{
				Vector3 localPosition = mid.localPosition;
				Vector3 val3;
				if (!(((Vector3)(ref localPosition)).sqrMagnitude > 1E-08f))
				{
					val3 = Vector3.up;
				}
				else
				{
					localPosition = mid.localPosition;
					val3 = ((Vector3)(ref localPosition)).normalized;
				}
				Vector3 val4 = val3;
				root.localRotation = s.cleanLocal * Quaternion.AngleAxis(s.smooth, val4);
				s.lastOutputLocal = root.localRotation;
				s.applied = true;
				tip.rotation = val;
			}
		}

		private static float TwistAngle(Quaternion q, Vector3 axis)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0069: 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)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.Project(new Vector3(q.x, q.y, q.z), axis);
			float num = Mathf.Sqrt(val.x * val.x + val.y * val.y + val.z * val.z + q.w * q.w);
			if (num < 1E-05f)
			{
				return 0f;
			}
			float num2 = q.w / num;
			float num3 = 2f * Mathf.Acos(Mathf.Clamp(num2, -1f, 1f)) * 57.29578f;
			if (Vector3.Dot(val, axis) < 0f)
			{
				num3 = 0f - num3;
			}
			if (num3 > 180f)
			{
				num3 -= 360f;
			}
			else if (num3 < -180f)
			{
				num3 += 360f;
			}
			return num3;
		}
	}
	[HarmonyPatch(typeof(MainCameraMovement), "Spectate")]
	internal static class VRSpectator
	{
		public static Vector3 Pivot;

		public static bool HasTarget;

		[HarmonyPostfix]
		private static void Postfix()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Character specCharacter = MainCameraMovement.specCharacter;
			if ((Object)(object)specCharacter != (Object)null)
			{
				Pivot = specCharacter.GetSpectatePosition();
				HasTarget = true;
			}
			else
			{
				HasTarget = false;
			}
		}
	}
	internal class VRStereoCulling : MonoBehaviour
	{
		public static float Margin = 1.4f;

		public static bool DisableOcclusion = false;

		private Camera cam;

		private int lastFrame = -1;

		private int passIndex;

		private Matrix4x4 sharedCulling;

		private bool haveShared;

		private void Awake()
		{
			cam = ((Component)this).GetComponent<Camera>();
		}

		private void OnEnable()
		{
			RenderPipelineManager.beginCameraRendering += OnBeginCamera;
		}

		private void OnDisable()
		{
			RenderPipelineManager.beginCameraRendering -= OnBeginCamera;
			if ((Object)(object)cam != (Object)null)
			{
				cam.ResetCullingMatrix();
				cam.ResetProjectionMatrix();
			}
		}

		private void OnBeginCamera(ScriptableRenderContext ctx, Camera rendering)
		{
			//IL_0065: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rendering != (Object)(object)cam)
			{
				return;
			}
			cam.useOcclusionCulling = !DisableOcclusion;
			bool flag = Time.frameCount != lastFrame;
			if (flag)
			{
				lastFrame = Time.frameCount;
				passIndex = 0;
			}
			else
			{
				passIndex++;
			}
			StereoscopicEye val = (StereoscopicEye)(passIndex >= 1);
			Matrix4x4 stereoProjectionMatrix = cam.GetStereoProjectionMatrix(val);
			if (stereoProjectionMatrix.m11 != 0f && stereoProjectionMatrix.m00 != 0f)
			{
				cam.projectionMatrix = stereoProjectionMatrix;
				if (flag || !haveShared)
				{
					float num = Mathf.Atan(1f / stereoProjectionMatrix.m11) * 2f * 57.29578f * Margin;
					float num2 = stereoProjectionMatrix.m11 / stereoProjectionMatrix.m00 * Margin;
					Matrix4x4 val2 = Matrix4x4.Perspective(num, num2, cam.nearClipPlane, cam.farClipPlane);
					Matrix4x4 val3 = Matrix4x4.Scale(new Vector3(1f, 1f, -1f)) * ((Component)this).transform.worldToLocalMatrix;
					sharedCulling = val2 * val3;
					haveShared = true;
				}
				cam.cullingMatrix = sharedCulling;
			}
		}
	}
	[HarmonyPatch(typeof(Transitions), "Awake")]
	internal static class VRTransitionPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Transitions __instance)
		{
			if (Plugin.VrEnabled)
			{
				((Component)__instance).gameObject.AddComponent<VRTransition>();
			}
		}
	}
	[DefaultExecutionOrder(1300)]
	internal class VRTransition : MonoBehaviour
	{
		private const float Distance = 1.2f;

		private const float Scale = 0.0035f;

		private Canvas canvas;

		private bool resolved;

		private RenderMode originalMode;

		private bool converted;

		private void Resolve()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			resolved = true;
			CanvasGroup componentInChildren = ((Component)this).GetComponentInChildren<CanvasGroup>(true);
			Canvas val = (((Object)(object)componentInChildren != (Object)null) ? ((Component)componentInChildren).GetComponentInParent<Canvas>() : ((Component)this).GetComponentInParent<Canvas>());
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)((Component)val).GetComponentInParent<GUIManager>() != (Object)null || ((Object)val).name.Contains("HUD") || ((Object)val).name.Contains("GUI"))
				{
					Plugin.Log.LogWarning((object)("[PeakVR] Transition canvas '" + ((Object)val).name + "' looks shared with the HUD — not surfacing in VR"));
					return;
				}
				canvas = val;
				originalMode = val.renderMode;
			}
		}

		private void LateUpdate()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if (!resolved)
			{
				Resolve();
			}
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter != (Object)null) || !((Object)(object)localCharacter.data != (Object)null) || !localCharacter.data.fullyPassedOut)
			{
				if (converted)
				{
					canvas.renderMode = originalMode;
					converted = false;
				}
				return;
			}
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : Camera.main);
			if (!((Object)(object)val == (Object)null))
			{
				if (!converted)
				{
					canvas.renderMode = (RenderMode)2;
					canvas.worldCamera = val;
					UIOverlay.MakeAlwaysVisible(canvas, foreground: true);
					converted = true;
				}
				Transform transform = ((Component)val).transform;
				((Component)canvas).transform.SetPositionAndRotation(transform.position + transform.forward * 1.2f, transform.rotation);
				((Component)canvas).transform.localScale = Vector3.one * 0.0035f;
			}
		}
	}
	[DefaultExecutionOrder(1100)]
	internal class VRTunneling : MonoBehaviour
	{
		private const float Distance = 2f;

		private const float Size = 12f;

		private const int RenderQueue = 4000;

		private const float InTime = 0.3f;

		private const float OutTime = 1f;

		private const float HoldTime = 0.5f;

		private const float MaxAlpha = 1f;

		private const float MinClose = 0f;

		private const float MaxClose = 7f;

		private const float ClearRadius = 0.35f;

		private const float DarkRadius = 0.7f;

		private const float MinSpeed = 0.6f;

		private const float TurnThreshold = 0.5f;

		private const float LogInterval = 0.5f;

		private MeshRenderer rend;

		private Material mat;

		private Texture2D tex;

		private Mesh mesh;

		private readonly Vector2[] uv = (Vector2[])(object)new Vector2[4];

		private float current;

		private float holdTimer;

		private float logTimer;

		private void Start()
		{
			Build();
		}

		private void Build()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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_00e5: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_016d: 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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PeakVR Tunneling");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = Vector3.forward * 2f;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one * 12f;
			int num = LayerMask.NameToLayer("UI");
			if (num >= 0)
			{
				val.layer = num;
			}
			mesh = new Mesh
			{
				name = "PeakVR Tunneling Quad"
			};
			mesh.vertices = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(-0.5f, -0.5f, 0f),
				new Vector3(0.5f, -0.5f, 0f),
				new Vector3(-0.5f, 0.5f, 0f),
				new Vector3(0.5f, 0.5f, 0f)
			};
			mesh.triangles = new int[6] { 0, 2, 1, 2, 3, 1 };
			mesh.colors = (Color[])(object)new Color[4]
			{
				Color.white,
				Color.white,
				Color.white,
				Color.white
			};
			mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 2f);
			mesh.MarkDynamic();
			ApplyUv(1f);
			val.AddComponent<MeshFilter>().sharedMesh = mesh;
			tex = GenerateRadial(256);
			mat = new Material(Shader.Find("UI/Default"))
			{
				mainTexture = (Texture)(object)tex,
				renderQueue = 4000
			};
			mat.SetInt("unity_GUIZTestMode", 8);
			mat.SetColor("_Color", new Color(0f, 0f, 0f, 1f));
			rend = val.AddComponent<MeshRenderer>();
			((Renderer)rend).sharedMaterial = mat;
			((Renderer)rend).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)rend).receiveShadows = false;
			((Renderer)rend).enabled = false;
		}

		private void LateUpdate()
		{
			if ((Object)(object)mat == (Object)null)
			{
				return;
			}
			if ((Object)(object)VRPointer.Canvas != (Object)null)
			{
				current = 0f;
				holdTimer = 0f;
				if (((Renderer)rend).enabled)
				{
					((Renderer)rend).enabled = false;
				}
				return;
			}
			Config config = Plugin.Config;
			float num = (config.MovementTunneling.Value ? MovementTarget() : 0f);
			float deltaTime = Time.deltaTime;
			if (num >= current)
			{
				holdTimer = 0f;
				current = Mathf.MoveTowards(current, num, deltaTime / 0.3f);
			}
			else
			{
				holdTimer += deltaTime;
				if (holdTimer >= 0.5f)
				{
					current = Mathf.MoveTowards(current, num, deltaTime / 1f);
				}
			}
			bool flag = current > 0.002f;
			if (((Renderer)rend).enabled != flag)
			{
				((Renderer)rend).enabled = flag;
			}
			if (flag)
			{
				float num2 = Mathf.Lerp(0f, 7f, Mathf.Clamp01(config.TunnelingStrength.Value));
				ApplyUv(Mathf.Lerp(1f, num2, current));
			}
		}

		private void ApplyUv(float tiling)
		{
			//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_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.5f * (1f - tiling);
			uv[0] = new Vector2(num, num);
			uv[1] = new Vector2(num + tiling, num);
			uv[2] = new Vector2(num, num + tiling);
			uv[3] = new Vector2(num + tiling, num + tiling);
			mesh.uv = uv;
		}

		private float MovementTarget()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null)
			{
				return 0f;
			}
			float magnitude = ((Vector3)(ref localCharacter.data.avarageVelocity)).magnitude;
			logTimer += Time.deltaTime;
			if (logTimer >= 0.5f && magnitude > 0.05f)
			{
				logTimer = 0f;
				Plugin.Log.LogInfo((object)$"[PeakVR][Tunnel] speed={magnitude:F2} current={current:F2}");
			}
			bool flag = Plugin.Config.SmoothTurn.Value && VRControls.TurnStick != null && Mathf.Abs(VRControls.TurnStick.ReadValue<Vector2>().x) > 0.5f;
			if (!(magnitude > 0.6f || flag))
			{
				return 0f;
			}
			return 1f;
		}

		private static Texture2D GenerateRadial(int size)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false, true)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float num = (float)(size - 1) * 0.5f;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num2 = ((float)j - num) / num;
					float num3 = ((float)i - num) / num;
					float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
					float num5 = Mathf.Clamp01((num4 - 0.35f) / 0.35f);
					num5 = num5 * num5 * (3f - 2f * num5);
					array[i * size + j] = new Color32((byte)0, (byte)0, (byte)0, (byte)(num5 * 255f));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			return val;
		}
	}
	internal static class XRMirror
	{
		private const string XRSystemTypeName = "UnityEngine.Experimental.Rendering.XRSystem";

		private const string NativeShaderName = "Hidden/Universal Render Pipeline/XR/XRMirrorView";

		private static FieldInfo materialField;

		private static Material material;

		public static void Setup()
		{
			if (Resolve())
			{
				Assert();
			}
		}

		public static void Assert()
		{
			if (!(materialField == null))
			{
				object? value = materialField.GetValue(null);
				Material val = (Material)((value is Material) ? value : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					material = val;
				}
				else if (!((Object)(object)material == (Object)null))
				{
					materialField.SetValue(null, material);
				}
			}
		}

		private static bool Resolve()
		{
			//IL_00f6: 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_0108: Expected O, but got Unknown
			if (materialField != null && (Object)(object)material != (Object)null)
			{
				return true;
			}
			Shader val = Shader.Find("Hidden/Universal Render Pipeline/XR/XRMirrorView");
			if ((Object)(object)val == (Object)null || !val.isSupported)
			{
				val = PeakAssets.MirrorView;
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[PeakVR] No XR mirror shader available; desktop view stays black");
				return false;
			}
			Type type = (from a in AppDomain.CurrentDomain.GetAssemblies()
				select a.GetType("UnityEngine.Experimental.Rendering.XRSystem", throwOnError: false)).FirstOrDefault((Type t) => t != null);
			if (type == null)
			{
				Plugin.Log.LogError((object)"[PeakVR] Could not find XRSystem type for desktop mirror");
				return false;
			}
			materialField = type.GetField("s_MirrorViewMaterial", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (materialField == null)
			{
				Plugin.Log.LogError((object)"[PeakVR] XRSystem.s_MirrorViewMaterial field not found");
				return false;
			}
			material = new Material(val)
			{
				hideFlags = (HideFlags)61
			};
			Plugin.Log.LogInfo((object)"[PeakVR] Desktop mirror material ready");
			return true;
		}
	}
	internal class XRSessionMonitor : OpenXRFeature
	{
		private static void Log(string msg)
		{
			if (Plugin.Log != null)
			{
				Plugin.Log.LogWarning((object)("[PeakVR][XR] " + msg));
			}
		}

		private static string StateName(int s)
		{
			return s switch
			{
				0 => "Unknown", 
				1 => "Idle", 
				2 => "Ready", 
				3 => "Synchronized", 
				4 => "Visible", 
				5 => "Focused", 
				6 => "Stopping", 
				7 => "LossPending", 
				8 => "Exiting", 
				_ => s.ToString(), 
			};
		}

		public override void OnSessionStateChange(int oldState, int newState)
		{
			Log("state " + StateName(oldState) + " -> " + StateName(newState));
		}

		public override void OnSessionExiting(ulong xrSession)
		{
			Log("OnSessionExiting");
		}

		public override void OnSessionLossPending(ulong xrSession)
		{
			Log("OnSessionLossPending");
		}

		public override void OnInstanceLossPending(ulong xrInstance)
		{
			Log("OnInstanceLossPending");
		}

		public override void OnSessionCreate(ulong xrSession)
		{
			Log("OnSessionCreate");
		}

		public override void OnSessionBegin(ulong xrSession)
		{
			Log("OnSessionBegin");
		}

		public override void OnSessionEnd(ulong xrSession)
		{
			Log("OnSessionEnd");
		}

		public override void OnSessionDestroy(ulong xrSession)
		{
			Log("OnSessionDestroy");
		}

		public override void OnSubsystemStop()
		{
			Log("OnSubsystemStop");
		}

		public override void OnSubsystemStart()
		{
			Log("OnSubsystemStart");
		}

		public override void OnSubsystemDestroy()
		{
			Log("OnSubsystemDestroy");
		}

		public override void OnInstanceDestroy(ulong xrInstance)
		{
			Log("OnInstanceDestroy");
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}