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.Bootstrap;
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 PEAKLib.UI.Elements.Settings;
using Peak;
using PeakVR;
using Photon.Pun;
using Photon.Realtime;
using Steamworks;
using TMPro;
using Unity.Profiling;
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.Utilities;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering.Universal;
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.Settings;
using Zorro.Settings.DebugUI;
using Zorro.Settings.UI;
using Zorro.UI;
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.5.0.0")]
[assembly: AssemblyInformationalVersion("1.5.0+e5f9386847851d7bf3c02e50aad517a7f6c3382a")]
[assembly: AssemblyProduct("com.andrey04o.PeakVR")]
[assembly: AssemblyTitle("PeakVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.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
	{
		private readonly Dictionary<string, ConfigEntry<bool>> keyboardLayouts = new Dictionary<string, ConfigEntry<bool>>();

		private const int CurrentConfigVersion = 2;

		public string AssemblyPath { get; }

		public ConfigFile File { get; }

		public ConfigEntry<bool> StartInVR { get; }

		public ConfigEntry<bool> ModeHotkeyEnabled { get; }

		public ConfigEntry<KeyCode> ModeHotkey { get; }

		public ConfigEntry<string> OpenXRRuntime { get; }

		public ConfigEntry<bool> EnableVerboseLogging { get; }

		public ConfigEntry<bool> ReacquireAudioDevice { get; }

		public ConfigEntry<bool> ModForegroundUI { get; }

		public ConfigEntry<bool> ModUIOnLeftHand { get; }

		public ConfigEntry<bool> LoadingCover { get; }

		public ConfigEntry<bool> FixHazardRendering { get; }

		public ConfigEntry<float> KeyRepeatDelay { get; }

		public ConfigEntry<float> KeyRepeatRate { 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> CameraRoll { get; }

		public ConfigEntry<bool> CopyHeadRotation { get; }

		public ConfigEntry<bool> HideControllers { get; }

		public ConfigEntry<float> MoveDeadzone { get; }

		public ConfigEntry<float> TurnDeadzone { 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<float> LodBias { get; }

		public ConfigEntry<string> SharpenImage { get; }

		public ConfigEntry<bool> ForceDisableHBAO { get; }

		public ConfigEntry<float> FoveationLevel { get; }

		public ConfigEntry<bool> FixPerEyeCulling { get; }

		public ConfigEntry<bool> GpuOcclusionCulling { get; }

		public ConfigEntry<float> FoliageDistance { get; }

		public ConfigEntry<bool> DepthPrepass { get; }

		public ConfigEntry<bool> ForegroundUI { get; }

		public ConfigEntry<bool> ForegroundUIOverGeometry { get; }

		public ConfigEntry<float> FarPlane { get; }

		public ConfigEntry<float> ControllerOffsetX { get; }

		public ConfigEntry<float> ControllerOffsetY { get; }

		public ConfigEntry<float> ControllerOffsetZ { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public ConfigEntry<int> ConfigVersion { get; }

		public bool KeyboardLayoutEnabled(string name)
		{
			if (keyboardLayouts.TryGetValue(name, out ConfigEntry<bool> value))
			{
				return value.Value;
			}
			return false;
		}

		public ConfigEntry<bool> KeyboardLayoutEntry(string name)
		{
			if (!keyboardLayouts.TryGetValue(name, out ConfigEntry<bool> value))
			{
				return null;
			}
			return value;
		}

		public Config(string assemblyPath, ConfigFile file)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Expected O, but got Unknown
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Expected O, but got Unknown
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Expected O, but got Unknown
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Expected O, but got Unknown
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Expected O, but got Unknown
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_059b: Expected O, but got Unknown
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d4: Expected O, but got Unknown
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Expected O, but got Unknown
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b0: Expected O, but got Unknown
			//IL_0709: Unknown result type (might be due to invalid IL or missing references)
			//IL_0713: Expected O, but got Unknown
			//IL_075a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0764: Expected O, but got Unknown
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_078b: Expected O, but got Unknown
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dc: Expected O, but got Unknown
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Expected O, but got Unknown
			//IL_085c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0866: Expected O, but got Unknown
			//IL_08ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Expected O, but got Unknown
			//IL_08e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f0: Expected O, but got Unknown
			//IL_0944: Unknown result type (might be due to invalid IL or missing references)
			//IL_094e: Expected O, but got Unknown
			//IL_09a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b0: Expected O, but got Unknown
			AssemblyPath = assemblyPath;
			File = file;
			StartInVR = file.Bind<bool>("VR", "Start In VR", true, "Start the game in VR. Turn off to launch flat with the mod still loaded. You can also switch mode while the game is running from the VR Settings page.");
			ModeHotkeyEnabled = file.Bind<bool>("VR", "Mode Switch Hotkey", true, "Allow a keyboard key to switch between VR and flat mode while the game is running.");
			ModeHotkey = file.Bind<KeyCode>("VR", "Mode Switch Key", (KeyCode)292, "The key that switches between VR and flat mode.");
			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.");
			ModForegroundUI = file.Bind<bool>("VR", "Other Mods UI In VR", true, "Pull flat screen-space UI created by other mods into VR as a head-locked foreground panel. Turn off to leave it alone (it will then be invisible in the headset).");
			ModUIOnLeftHand = file.Bind<bool>("VR", "sPEAKer UI On Left Hand", true, "Move the sPEAKer music HUD (timer, current song, mixtape name and icon) onto the left wrist instead of leaving it head-locked. Requires the sPEAKer mod.");
			KeyRepeatDelay = file.Bind<float>("VR", "Key Repeat Delay", 0.4f, new ConfigDescription("How long to hold a key on the VR keyboard before it starts repeating, in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1.5f), Array.Empty<object>()));
			KeyRepeatRate = file.Bind<float>("VR", "Key Repeat Rate", 12f, new ConfigDescription("How many characters a held key types per second. Set to 0 to turn key repeat off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
			VRKeyboardLayoutDef[] all = VRKeyboardLayout.All;
			foreach (VRKeyboardLayoutDef vRKeyboardLayoutDef in all)
			{
				keyboardLayouts[vRKeyboardLayoutDef.Name] = file.Bind<bool>("VR", VRKeyboardLanguages.SettingKey(vRKeyboardLayoutDef), vRKeyboardLayoutDef.Name == "US", "Offer the " + vRKeyboardLayoutDef.Display + " layout on the VR keyboard. The Lang key cycles through every layout you enable here.");
			}
			LoadingCover = file.Bind<bool>("VR", "Fullscreen Loading Cover", true, "Fill the whole view with the loading screen's colour while a level loads, instead of showing it as a panel with the world visible around it. Turn this off if you ever end up with a coloured tint over everything after spawning in.");
			ReacquireAudioDevice = file.Bind<bool>("VR", "Reacquire Audio Device", false, "Troubleshooting only. Re-initialises Unity's audio output when the headset session becomes focused so the game re-reads the current Windows default playback device. Only try this if you get NO sound in the headset - the re-initialise can itself silence audio that was working. Does NOT choose a device: set the headset as the Windows default output for that.");
			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>()));
			CameraRoll = file.Bind<bool>("Comfort", "Camera Roll", false, "Roll and tumble the headset view along with the character camera during backflips, falls and ragdolls, matching the flat game. More immersive but can cause motion sickness.");
			CopyHeadRotation = file.Bind<bool>("Special", "Copy Head Rotation", false, "Copy the character's head-bone tilt (the subtle head lean/bob during movement) onto the view. Can be applied to flat players too. Caution: turn it on only if you don't get motion sickness from VR.");
			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" }));
			ControllerOffsetX = file.Bind<float>("VR", "Controller Rotation Offset X", 0f, new ConfigDescription("Tilt of the controllers up or down, in degrees. Both the hands and the aim follow it, so raise it if you hold the controllers angled and the aim points too low.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-90f, 90f), Array.Empty<object>()));
			ControllerOffsetX.SettingChanged += delegate
			{
				VRHands.ApplyRotationOffset();
			};
			ControllerOffsetY = file.Bind<float>("VR", "Controller Rotation Offset Y", 0f, new ConfigDescription("Turn of the controllers left or right, in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-90f, 90f), Array.Empty<object>()));
			ControllerOffsetY.SettingChanged += delegate
			{
				VRHands.ApplyRotationOffset();
			};
			ControllerOffsetZ = file.Bind<float>("VR", "Controller Rotation Offset Z", 0f, new ConfigDescription("Roll of the controllers, in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-90f, 90f), Array.Empty<object>()));
			ControllerOffsetZ.SettingChanged += delegate
			{
				VRHands.ApplyRotationOffset();
			};
			MoveDeadzone = file.Bind<float>("VR", "Move Stick Deadzone", 0.15f, new ConfigDescription("How far the left stick has to be pushed before it counts as input. Raise it if a worn stick drifts and walks you around on its own; lower it for finer control. Past the deadzone the full speed range is still available.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.6f), Array.Empty<object>()));
			TurnDeadzone = file.Bind<float>("VR", "Turn Stick Deadzone", 0.15f, new ConfigDescription("How far the right stick has to be pushed before it counts as input. Raise it if a worn stick drifts and turns the view, scrolls the inventory or moves menu sliders on its own.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.6f), Array.Empty<object>()));
			LodBias = file.Bind<float>("VR Graphics", "LOD Bias", 2.5f, new ConfigDescription("Level-of-detail bias in VR. Higher keeps distant objects detailed; lower boosts performance. Applies immediately.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			LodBias.SettingChanged += delegate
			{
				RenderDiagnostics.ApplyLodBias();
			};
			SharpenImage = file.Bind<string>("VR Graphics", "Make Image Sharper", "Enable", new ConfigDescription("Sharpen the VR image: disables temporal anti-aliasing (TAA) and MSAA and uses a spatial (Linear) upscaler. TAA in particular blurs the image in a VR headset. Disable to keep the game's own graphics settings.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Enable", "Disable" }), Array.Empty<object>()));
			SharpenImage.SettingChanged += delegate
			{
				VRRender.ApplySharpening();
			};
			FixHazardRendering = file.Bind<bool>("VR Graphics", "Fix Hazard Rendering", true, "Some hazard props - the arms the spiked balls swing on - are invisible in VR because of the layer they sit on. This moves the purely visual parts of them onto the default layer so they draw. Only objects with no collider are touched, so nothing about damage or collision changes.");
			ForceDisableHBAO = file.Bind<bool>("VR Graphics", "Force Disable HBAO", true, new ConfigDescription("Disable HBAO ambient occlusion, which renders wrong per-eye in VR on PEAK's Unity 6.3 (URP 17.3) and costs performance. On by default; turn off to keep the game's ambient occlusion.", (AcceptableValueBase)null, Array.Empty<object>()));
			ForceDisableHBAO.SettingChanged += delegate
			{
				VRRender.ApplyHBAO();
			};
			FarPlane = file.Bind<float>("VR Graphics", "Far Plane Culling Distance", 3000f, new ConfigDescription("How far away the game still draws things, in metres. Lower values cull distant scenery and gain performance; too low and far islands or mountain tops pop out of view.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(500f, 20000f), Array.Empty<object>()));
			FarPlane.SettingChanged += delegate
			{
				VRRender.ApplyFarPlane();
			};
			DepthPrepass = file.Bind<bool>("VR Graphics", "Depth Prepass", true, new ConfigDescription("Draw scene depth first so hidden pixels are skipped instead of shaded. Grass and leaves are alpha-clipped, which normally defeats that optimisation, and they are the most expensive thing on screen in VR - this can nearly double the framerate with no visual change. Takes effect on restart.", (AcceptableValueBase)null, Array.Empty<object>()));
			ForegroundUI = file.Bind<bool>("VR Graphics", "Foreground UI", true, new ConfigDescription("Draw the VR interface in its own render pass after everything else, so world glass, rain and fog can never cover the wrist HUD, menus or the stamina bar. Replaces the old render-order workaround, which could not win against transparent scenery.", (AcceptableValueBase)null, Array.Empty<object>()));
			ForegroundUI.SettingChanged += delegate
			{
				PeakVR.ForegroundUI.Apply();
			};
			ForegroundUIOverGeometry = file.Bind<bool>("VR Graphics", "Foreground UI Over Geometry", true, new ConfigDescription("Let the foreground interface draw over solid objects too, instead of being hidden behind walls and terrain. Only applies when Foreground UI is on.", (AcceptableValueBase)null, Array.Empty<object>()));
			ForegroundUIOverGeometry.SettingChanged += delegate
			{
				PeakVR.ForegroundUI.ApplyDepthMode();
			};
			FoliageDistance = file.Bind<float>("VR Graphics", "Foliage Draw Distance", 0f, new ConfigDescription("Hide grass, leaves and bushes further away than this many metres. Foliage is the most expensive thing on screen in VR - hundreds of separate alpha-clipped draws, each one rendered twice, once per eye. 0 disables the limit and draws everything.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 300f), Array.Empty<object>()));
			FixPerEyeCulling = file.Bind<bool>("VR Graphics", "Fix Per-Eye Object Culling", true, new ConfigDescription("URP's GPU Resident Drawer culls small meshes per view, so in VR an object can vanish in one eye only (coconuts, lights, elevator pings). Turning this on stops that cull and costs no measurable performance. Changing it mid-game can freeze the desktop mirror until restart.", (AcceptableValueBase)null, Array.Empty<object>()));
			FixPerEyeCulling.SettingChanged += delegate
			{
				UrpDiagnostics.ApplySmallMeshCulling();
			};
			GpuOcclusionCulling = file.Bind<bool>("VR Graphics", "GPU Occlusion Culling", false, new ConfigDescription("Let the GPU skip objects hidden behind other objects, using the previous frame's depth. Measured no framerate gain in PEAK, which is limited by the processor rather than the graphics card, so leave it off unless you want to experiment. Takes effect on restart.", (AcceptableValueBase)null, Array.Empty<object>()));
			FoveationLevel = file.Bind<float>("VR Graphics", "Foveated Rendering", 0f, new ConfigDescription("Render the periphery at lower detail to save GPU. Seems like it don't work.0 = off, 1 = strongest.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FoveationLevel.SettingChanged += delegate
			{
				VRFoveation.Apply();
			};
			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);
			};
			ConfigVersion = file.Bind<int>("Internal", "ConfigVersion", 0, new ConfigDescription("FOR INTERNAL USE ONLY, DO NOT EDIT", (AcceptableValueBase)null, new object[1] { "Hidden" }));
			Migrate(file);
		}

		private void Migrate(ConfigFile file)
		{
			int value = ConfigVersion.Value;
			if (value < 2)
			{
				if (value < 1 && SharpenImage.Value != "Enable")
				{
					SharpenImage.Value = "Enable";
					Plugin.Log.LogInfo((object)"[PeakVR] Config update: turned on \"Make Image Sharper\" (it is now on by default)");
				}
				ConfigVersion.Value = 2;
				file.Save();
				Plugin.Log.LogInfo((object)$"[PeakVR] Config migrated {value} -> {2}");
			}
		}
	}
	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 ShutdownXR()
			{
				if ((Object)(object)xrManagerSettings == (Object)null)
				{
					return false;
				}
				if (!xrManagerSettings.isInitializationComplete)
				{
					return true;
				}
				xrManagerSettings.StopSubsystems();
				xrManagerSettings.DeinitializeLoader();
				return true;
			}

			public static bool RestartXR()
			{
				return InitializeXR();
			}

			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;
				OpenXRSettings.Instance.optimizeBufferDiscards = true;
				try
				{
					PropertyInfo property = typeof(OpenXRSettings).GetProperty("foveatedRenderingApi");
					if (property != null && property.CanWrite)
					{
						string[] names = Enum.GetNames(property.PropertyType);
						foreach (string text in names)
						{
							if (text.IndexOf("SRP", StringComparison.OrdinalIgnoreCase) >= 0)
							{
								property.SetValue(OpenXRSettings.Instance, Enum.Parse(property.PropertyType, text));
								Logger.LogInfo((object)("Foveation backend set to " + text));
								break;
							}
						}
					}
				}
				catch (Exception ex)
				{
					Logger.LogWarning((object)("Could not set SRP foveation API: " + ex.Message));
				}
				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
					};
					EnableFoveationFeature();
				}
			}

			private static void EnableFoveationFeature()
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				try
				{
					Type type = null;
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly in assemblies)
					{
						Type[] types;
						try
						{
							types = assembly.GetTypes();
						}
						catch
						{
							continue;
						}
						Type[] array = types;
						foreach (Type type2 in array)
						{
							if (!type2.IsAbstract && typeof(OpenXRFeature).IsAssignableFrom(type2) && type2.Name.IndexOf("Foveat", StringComparison.OrdinalIgnoreCase) >= 0)
							{
								type = type2;
								break;
							}
						}
						if (type != null)
						{
							break;
						}
					}
					if (type == null)
					{
						Logger.LogWarning((object)"OpenXR Foveated Rendering feature type not found");
						return;
					}
					OpenXRFeature val = (OpenXRFeature)ScriptableObject.CreateInstance(type);
					val.enabled = true;
					List<OpenXRFeature> list = new List<OpenXRFeature>(OpenXRSettings.Instance.features) { val };
					OpenXRSettings.Instance.features = list.ToArray();
					Logger.LogInfo((object)("Enabled OpenXR Foveated Rendering feature: " + type.Name));
				}
				catch (Exception ex)
				{
					Logger.LogWarning((object)("Could not enable OpenXR foveation feature: " + ex.Message));
				}
			}
		}

		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 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)");
			}
		}
	}
	internal static class BinocularRig
	{
		private static bool loaded;

		public static bool HasRig { get; private set; }

		public static Vector3 ScopePos { get; private set; }

		public static Quaternion ScopeRot { get; private set; } = Quaternion.identity;

		public static Vector3 ScopeScale { get; private set; } = Vector3.one;

		public static Vector3 GripPos { get; private set; }

		public static Quaternion GripRot { get; private set; } = Quaternion.identity;

		public static void Load()
		{
			//IL_0063: 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_0079: 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_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_00b3: 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)
			if (loaded)
			{
				return;
			}
			loaded = true;
			GameObject binocularsRig = PeakAssets.BinocularsRig;
			if (!((Object)(object)binocularsRig == (Object)null))
			{
				Transform val = binocularsRig.transform.Find("Scope");
				Transform val2 = binocularsRig.transform.Find("Grip");
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogWarning((object)"[PeakVR] BinocularsRig needs child transforms named 'Scope' and 'Grip'");
					return;
				}
				ScopePos = val.localPosition;
				ScopeRot = val.localRotation;
				ScopeScale = val.localScale;
				GripPos = val2.localPosition;
				GripRot = val2.localRotation;
				HasRig = true;
				Plugin.Log.LogInfo((object)$"[PeakVR] Binoculars rig: scope pos={ScopePos} scale={ScopeScale} grip pos={GripPos}");
			}
		}

		public static void ApplyHold(Transform item, Transform hand)
		{
			//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)
			if (!((Object)(object)hand == (Object)null))
			{
				ApplyHold(item, hand.position, hand.rotation);
			}
		}

		public static void ApplyHold(Transform item, Vector3 handPos, Quaternion handRot)
		{
			//IL_0011: 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_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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null) && HasRig)
			{
				Quaternion val = handRot * Quaternion.Inverse(GripRot);
				item.SetPositionAndRotation(handPos - val * GripPos, val);
			}
		}

		public static Quaternion ControllerRotationFromIkTarget(Quaternion ikRotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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)
			return ikRotation * Quaternion.Inverse(VRArmIKPatch.HandRotationOffset);
		}
	}
	[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;

		private static readonly VRRestore Reparented = new VRRestore();

		[HarmonyPrefix]
		private static bool Prefix(CameraQuad __instance)
		{
			//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_0037: 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_006e: 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_00ca: 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)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VrEnabled)
			{
				return true;
			}
			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)
			{
				Reparented.Record(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;
		}

		public static void Restore()
		{
			Reparented.RestoreAll();
		}
	}
	internal static class ForegroundUI
	{
		private const BindingFlags Any = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly List<ScriptableRendererData> Stripped = new List<ScriptableRendererData>();

		private static readonly List<LayerMask> SavedOpaque = new List<LayerMask>();

		private static readonly List<LayerMask> SavedTransparent = new List<LayerMask>();

		private static ForegroundUIPass pass;

		private static bool hooked;

		public static bool Active { get; private set; }

		public static void Apply()
		{
			if (!Plugin.VrEnabled)
			{
				return;
			}
			bool flag = Plugin.Config == null || Plugin.Config.ForegroundUI.Value;
			if (flag != Active)
			{
				if (flag)
				{
					Enable();
				}
				else
				{
					Disable();
				}
			}
		}

		private static void Enable()
		{
			//IL_0020: 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_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_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_00a9: 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_00cf: 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_014f: 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)
			int uI = VRLayers.UI;
			if (uI < 0)
			{
				Plugin.Log.LogWarning((object)"[PeakVR][ForegroundUI] no UI layer; not enabling");
				return;
			}
			LayerMask layers = LayerMask.op_Implicit(1 << uI);
			foreach (ScriptableRendererData rendererDatum in GetRendererData())
			{
				PropertyInfo property = ((object)rendererDatum).GetType().GetProperty("opaqueLayerMask");
				PropertyInfo property2 = ((object)rendererDatum).GetType().GetProperty("transparentLayerMask");
				if (!(property == null) && !(property2 == null))
				{
					LayerMask item = (LayerMask)property.GetValue(rendererDatum);
					LayerMask item2 = (LayerMask)property2.GetValue(rendererDatum);
					Stripped.Add(rendererDatum);
					SavedOpaque.Add(item);
					SavedTransparent.Add(item2);
					property.SetValue(rendererDatum, LayerMask.op_Implicit(((LayerMask)(ref item)).value & ~((LayerMask)(ref layers)).value));
					property2.SetValue(rendererDatum, LayerMask.op_Implicit(((LayerMask)(ref item2)).value & ~((LayerMask)(ref layers)).value));
					rendererDatum.SetDirty();
				}
			}
			if (Stripped.Count == 0)
			{
				Plugin.Log.LogWarning((object)"[PeakVR][ForegroundUI] no renderer data found; not enabling");
				return;
			}
			if (pass == null)
			{
				pass = new ForegroundUIPass();
			}
			pass.Layers = layers;
			pass.ClearDepth = Plugin.Config == null || Plugin.Config.ForegroundUIOverGeometry.Value;
			if (!hooked)
			{
				RenderPipelineManager.beginCameraRendering += OnBeginCamera;
				hooked = true;
			}
			Active = true;
			Plugin.Log.LogInfo((object)$"[PeakVR][ForegroundUI] enabled (layer {uI}, {Stripped.Count} renderer data)");
		}

		private static void Disable()
		{
			//IL_0036: 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)
			for (int i = 0; i < Stripped.Count; i++)
			{
				ScriptableRendererData val = Stripped[i];
				if (!((Object)(object)val == (Object)null))
				{
					((object)val).GetType().GetProperty("opaqueLayerMask")?.SetValue(val, SavedOpaque[i]);
					((object)val).GetType().GetProperty("transparentLayerMask")?.SetValue(val, SavedTransparent[i]);
					val.SetDirty();
				}
			}
			Stripped.Clear();
			SavedOpaque.Clear();
			SavedTransparent.Clear();
			if (hooked)
			{
				RenderPipelineManager.beginCameraRendering -= OnBeginCamera;
				hooked = false;
			}
			Active = false;
			Plugin.Log.LogInfo((object)"[PeakVR][ForegroundUI] disabled");
		}

		public static void Shutdown()
		{
			if (Active)
			{
				Disable();
			}
		}

		public static void ApplyDepthMode()
		{
			if (pass != null)
			{
				pass.ClearDepth = Plugin.Config == null || Plugin.Config.ForegroundUIOverGeometry.Value;
			}
		}

		private static void OnBeginCamera(ScriptableRenderContext context, Camera camera)
		{
			long start = VRProfile.Begin();
			OnBeginCameraBody(camera);
			VRProfile.End(5, start);
		}

		private static void OnBeginCameraBody(Camera camera)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if (Active && (int)camera.cameraType == 1)
			{
				UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(camera);
				if (!((Object)(object)universalAdditionalCameraData == (Object)null) && universalAdditionalCameraData.scriptableRenderer != null)
				{
					universalAdditionalCameraData.scriptableRenderer.EnqueuePass((ScriptableRenderPass)(object)pass);
				}
			}
		}

		public static void LogUiLayerRenderers()
		{
			int uI = VRLayers.UI;
			if (uI < 0)
			{
				return;
			}
			int num = 0;
			Renderer[] array = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
			foreach (Renderer val in array)
			{
				if (((Component)val).gameObject.layer == uI && !IsOurs(((Component)val).transform) && num++ < 30)
				{
					Plugin.Log.LogInfo((object)("[PeakVR][ForegroundUI] game renderer on UI layer: " + Path(((Component)val).transform) + " (" + ((object)val).GetType().Name + ")"));
				}
			}
			Plugin.Log.LogInfo((object)$"[PeakVR][ForegroundUI] {num} non-PeakVR renderers on the UI layer");
		}

		private static bool IsOurs(Transform t)
		{
			while ((Object)(object)t != (Object)null)
			{
				if (((Object)t).name.StartsWith("PeakVR"))
				{
					return true;
				}
				t = t.parent;
			}
			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++ < 6)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static IEnumerable<ScriptableRendererData> GetRendererData()
		{
			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 ScriptableRendererData[] array))
			{
				yield break;
			}
			ScriptableRendererData[] array2 = array;
			foreach (ScriptableRendererData val in array2)
			{
				if ((Object)(object)val != (Object)null)
				{
					yield return val;
				}
			}
		}
	}
	internal class ForegroundUIPass : ScriptableRenderPass
	{
		private class PassData
		{
			public RendererListHandle List;

			public bool ClearDepth;
		}

		private static readonly ShaderTagId[] Tags = (ShaderTagId[])(object)new ShaderTagId[3]
		{
			new ShaderTagId("SRPDefaultUnlit"),
			new ShaderTagId("UniversalForward"),
			new ShaderTagId("UniversalForwardOnly")
		};

		public LayerMask Layers = LayerMask.op_Implicit(32);

		public bool ClearDepth = true;

		private bool warnedBackBuffer;

		public ForegroundUIPass()
		{
			//IL_0003: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			((ScriptableRenderPass)this).renderPassEvent = (RenderPassEvent)600;
			((ScriptableRenderPass)this).profilingSampler = new ProfilingSampler("PeakVR Foreground UI");
		}

		public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
		{
			//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_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)
			//IL_008d: 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_00cd: 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_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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			UniversalResourceData val = frameData.Get<UniversalResourceData>();
			UniversalRenderingData val2 = frameData.Get<UniversalRenderingData>();
			UniversalCameraData val3 = frameData.Get<UniversalCameraData>();
			if (val.isActiveTargetBackBuffer)
			{
				if (!warnedBackBuffer)
				{
					warnedBackBuffer = true;
					Plugin.Log.LogWarning((object)("[PeakVR][ForegroundUI] active target is the back buffer on '" + ((Object)val3.camera).name + "'; pass skipped"));
				}
				return;
			}
			SortingSettings val4 = default(SortingSettings);
			((SortingSettings)(ref val4))..ctor(val3.camera);
			((SortingSettings)(ref val4)).criteria = (SortingCriteria)119;
			SortingSettings val5 = val4;
			DrawingSettings val6 = default(DrawingSettings);
			((DrawingSettings)(ref val6))..ctor(Tags[0], val5);
			for (int i = 1; i < Tags.Length; i++)
			{
				((DrawingSettings)(ref val6)).SetShaderPassName(i, Tags[i]);
			}
			((DrawingSettings)(ref val6)).perObjectData = (PerObjectData)0;
			((DrawingSettings)(ref val6)).enableDynamicBatching = false;
			((DrawingSettings)(ref val6)).enableInstancing = false;
			FilteringSettings val7 = default(FilteringSettings);
			((FilteringSettings)(ref val7))..ctor((RenderQueueRange?)RenderQueueRange.all, LayerMask.op_Implicit(Layers), uint.MaxValue, 0);
			RendererListParams val8 = default(RendererListParams);
			((RendererListParams)(ref val8))..ctor(val2.cullResults, val6, val7);
			PassData passData = default(PassData);
			IRasterRenderGraphBuilder val9 = renderGraph.AddRasterRenderPass<PassData>("PeakVR Foreground UI", ref passData, ((ScriptableRenderPass)this).profilingSampler, "./src/PeakVR/ForegroundUIPass.cs", 66);
			try
			{
				passData.List = renderGraph.CreateRendererList(ref val8);
				passData.ClearDepth = ClearDepth;
				((IBaseRenderGraphBuilder)val9).UseRendererList(ref passData.List);
				((IRenderAttachmentRenderGraphBuilder)val9).SetRenderAttachment(val.activeColorTexture, 0, (AccessFlags)2);
				((IRenderAttachmentRenderGraphBuilder)val9).SetRenderAttachmentDepth(val.activeDepthTexture, (AccessFlags)3);
				((IBaseRenderGraphBuilder)val9).AllowPassCulling(false);
				((IBaseRenderGraphBuilder)val9).AllowGlobalStateModification(true);
				val9.SetRenderFunc<PassData>((BaseRenderFunc<PassData, RasterGraphContext>)delegate(PassData d, RasterGraphContext context)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: 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_0015: 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_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_000a: 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_000d: Unknown result type (might be due to invalid IL or missing references)
					RTClearFlags val10 = (RTClearFlags)4;
					if (d.ClearDepth)
					{
						val10 = (RTClearFlags)(val10 | 2);
					}
					context.cmd.ClearRenderTarget(val10, Color.clear, 1f, 0u);
					context.cmd.DrawRendererList(RendererListHandle.op_Implicit(d.List));
				});
			}
			finally
			{
				((IDisposable)val9)?.Dispose();
			}
		}
	}
	[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_0069: 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_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_0084: 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_0098: 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_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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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)
			if (!Plugin.VrEnabled)
			{
				return true;
			}
			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;

		private const float MinHitDistance = 0.0001f;

		private static IInteractible hitTarget;

		private static Vector3 hitPoint;

		private static int hitFrame = -1;

		[HarmonyPostfix]
		private static void Postfix(Interaction __instance, ref IInteractible interactableResult)
		{
			//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_007d: 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_0087: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00cf: 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_00d2: 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_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_00ab: 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_00f7: 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_00b7: 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_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_010a: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VrEnabled || (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, origin, 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, Vector3 origin, out Vector3 center)
		{
			//IL_0001: 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_0038: 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_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_00b5: 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_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_0073: 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)
			center = default(Vector3);
			Component val = (Component)(object)((interactable is Component) ? interactable : null);
			if (val == null || (Object)(object)val == (Object)null)
			{
				return false;
			}
			Vector3 val2 = ((hitFrame == Time.frameCount && hitTarget == interactable) ? hitPoint : origin);
			Collider val3 = null;
			float num = float.MaxValue;
			Collider[] componentsInChildren = val.GetComponentsInChildren<Collider>();
			Bounds bounds;
			foreach (Collider val4 in componentsInChildren)
			{
				if (!((Object)(object)val4 == (Object)null) && val4.enabled)
				{
					bounds = val4.bounds;
					float num2 = ((Bounds)(ref bounds)).SqrDistance(val2);
					if (!(num2 >= num))
					{
						num = num2;
						val3 = val4;
					}
				}
			}
			Vector3 val5;
			if (!((Object)(object)val3 != (Object)null))
			{
				val5 = val.transform.position;
			}
			else
			{
				bounds = val3.bounds;
				val5 = ((Bounds)(ref bounds)).center;
			}
			center = val5;
			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_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_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_0081: 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_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_00f7: 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_0101: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_0145: 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_014b: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: 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)
			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;
			Vector3 point = Vector3.zero;
			bool valid = false;
			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;
					point = ((RaycastHit)(ref h)).point;
					valid = ((RaycastHit)(ref h)).distance > 0.0001f;
				}
			}
			if (val != null)
			{
				Remember(val, point, valid);
				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;
						point = ((RaycastHit)(ref h2)).point;
						valid = ((RaycastHit)(ref h2)).distance > 0.0001f;
					}
				}
			}
			if (val != null)
			{
				Remember(val, point, valid);
			}
			return val;
		}

		private static void Remember(IInteractible target, Vector3 point, bool valid)
		{
			//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)
			if (!valid)
			{
				hitFrame = -1;
				return;
			}
			hitTarget = target;
			hitPoint = point;
			hitFrame = Time.frameCount;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "CameraLook")]
	internal static class HeadLookPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance)
		{
			//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_004d: 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_0057: 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_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_0069: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.VrEnabled)
			{
				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))
				{
					Vector3 val = Quaternion.Inverse(VRHeadRig.ViewTilt) * ((Component)MainCamera.instance.cam).transform.forward;
					localCharacter.data.lookValues = Vector2.op_Implicit(HelperFunctions.DirectionToLook(val));
					localCharacter.RecalculateLookDirections();
				}
			}
		}
	}
	[HarmonyPatch(typeof(MainCameraMovement), "CharacterCam")]
	internal static class HeadRotationCopyPatch
	{
		private static Quaternion smoothed = Quaternion.identity;

		private const float SmoothSpeed = 12f;

		[HarmonyPostfix]
		private static void Postfix(MainCameraMovement __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_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_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)
			//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_00a8: 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_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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.VrEnabled || Plugin.Config == null || !Plugin.Config.CopyHeadRotation.Value)
			{
				smoothed = Quaternion.identity;
				return;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return;
			}
			Rigidbody bodypartRig = localCharacter.GetBodypartRig((BodypartType)4);
			Camera val = (((Object)(object)MainCamera.instance != (Object)null) ? MainCamera.instance.cam : null);
			if (!((Object)(object)bodypartRig == (Object)null) && !((Object)(object)val == (Object)null))
			{
				Vector3 lookDirection = localCharacter.data.lookDirection;
				if (!(((Vector3)(ref lookDirection)).sqrMagnitude < 0.0001f))
				{
					Quaternion val2 = ((Component)bodypartRig).transform.rotation * Quaternion.Inverse(Quaternion.LookRotation(lookDirection));
					smoothed = Quaternion.Slerp(smoothed, val2, Mathf.Clamp01(Time.deltaTime * 12f));
					((Component)val).transform.rotation = smoothed * ((Component)val).transform.rotation;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Bodypart), "SaveAnimationData")]
	internal static class HeadTiltPatch
	{
		private class NeckState
		{
			public ConfigurableJointMotion angularX;

			public ConfigurableJointMotion angularY;

			public ConfigurableJointMotion angularZ;

			public RotationDriveMode driveMode;

			public JointDrive slerpDrive;

			public readonly List<(Collider head, Collider body)> uncoupled = new List<(Collider, Collider)>();
		}

		private const float MinRoll = 0.05f;

		private const float NeckSpring = 3000f;

		private const float NeckDamper = 120f;

		private const float NeckMaxForce = 10000f;

		private static readonly Dictionary<Bodypart, NeckState> widened = new Dictionary<Bodypart, NeckState>();

		private static readonly Dictionary<Character, Bodypart> heads = new Dictionary<Character, Bodypart>();

		public static void RestoreFor(Character character)
		{
			if ((Object)(object)character != (Object)null && heads.TryGetValue(character, out Bodypart value) && (Object)(object)value != (Object)n